cairo: add shared and pic variants (#40302)

* wayland: dot is a build dependency

otherwise this build failure happens:
../spack-src/doc/meson.build:5:6: ERROR: Program 'dot' not found or not executable

* wayland: make building of documentation optional

renders several dependencies optional

.github/workflows/bootstrap.yml

@@ -42,8 +42,8 @@ jobs:
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
+          spack bootstrap disable github-actions-v0.5
           spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
           spack external find cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -80,8 +80,8 @@ jobs:
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
+          spack bootstrap disable github-actions-v0.5
           spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
           spack external find cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -145,8 +145,8 @@ jobs:
       - name: Bootstrap clingo
         run: |
           source share/spack/setup-env.sh
+          spack bootstrap disable github-actions-v0.5
           spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
           spack external find cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -163,8 +163,8 @@ jobs:
         run: |
           source share/spack/setup-env.sh
           export PATH=/usr/local/opt/bison@2.7/bin:$PATH
+          spack bootstrap disable github-actions-v0.5
           spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
           spack external find --not-buildable cmake bison
           spack -d solve zlib
           tree ~/.spack/bootstrap/store/
@@ -265,6 +265,7 @@ jobs:
         shell: runuser -u spack-test -- bash {0}
         run: |
           source share/spack/setup-env.sh
+          spack bootstrap disable github-actions-v0.4
           spack bootstrap disable spack-install
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
@@ -302,8 +303,8 @@ jobs:
         run: |
           source share/spack/setup-env.sh
           spack solve zlib
+          spack bootstrap disable github-actions-v0.5
           spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
 
@@ -320,6 +321,7 @@ jobs:
       - name: Bootstrap GnuPG
         run: |
           source share/spack/setup-env.sh
+          spack bootstrap disable github-actions-v0.4
           spack bootstrap disable spack-install
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
@@ -338,8 +340,8 @@ jobs:
         run: |
           source share/spack/setup-env.sh
           spack solve zlib
+          spack bootstrap disable github-actions-v0.5
           spack bootstrap disable github-actions-v0.4
-          spack bootstrap disable github-actions-v0.3
           spack -d gpg list
           tree ~/.spack/bootstrap/store/
 

.github/workflows/style/requirements.txt

@@ -2,6 +2,6 @@ black==23.9.1
 clingo==5.6.2
 flake8==6.1.0
 isort==5.12.0
-mypy==1.5.1
+mypy==1.6.0
 types-six==1.16.21.9
 vermin==1.5.2

.github/workflows/unit_tests.yaml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest]
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12']
         concretizer: ['clingo']
         on_develop:
         - ${{ github.ref == 'refs/heads/develop' }}
@@ -45,6 +45,10 @@ jobs:
           os: ubuntu-latest
           concretizer: 'clingo'
           on_develop: false
+        - python-version: '3.11'
+          os: ubuntu-latest
+          concretizer: 'clingo'
+          on_develop: false
 
     steps:
     - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # @v2
@@ -185,7 +189,7 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        python-version: ["3.10"]
+        python-version: ["3.11"]
     steps:
     - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # @v2
       with:

CITATION.cff

@@ -27,12 +27,53 @@
 # And here's the CITATION.cff format:
 #
 cff-version: 1.2.0
+type: software
 message: "If you are referencing Spack in a publication, please cite the paper below."
+title: "The Spack Package Manager: Bringing Order to HPC Software Chaos"
+abstract: >-
+  Large HPC centers spend considerable time supporting software for thousands of users, but the complexity of HPC software is quickly outpacing the capabilities of existing software management tools.
+  Scientific applications require specific versions of compilers, MPI, and other dependency libraries, so using a single, standard software stack is infeasible.
+  However, managing many configurations is difficult because the configuration space is combinatorial in size.
+  We introduce Spack, a tool used at Lawrence Livermore National Laboratory to manage this complexity.
+  Spack provides a novel, re- cursive specification syntax to invoke parametric builds of packages and dependencies.
+  It allows any number of builds to coexist on the same system, and it ensures that installed packages can find their dependencies, regardless of the environment.
+  We show through real-world use cases that Spack supports diverse and demanding applications, bringing order to HPC software chaos.
 preferred-citation:
+  title: "The Spack Package Manager: Bringing Order to HPC Software Chaos"
   type: conference-paper
-  doi: "10.1145/2807591.2807623"
-  url: "https://github.com/spack/spack"
+  url: "https://tgamblin.github.io/pubs/spack-sc15.pdf"
   authors:
+    - family-names: "Gamblin"
+      given-names: "Todd"
+    - family-names: "LeGendre"
+      given-names: "Matthew"
+    - family-names: "Collette"
+      given-names: "Michael R."
+    - family-names: "Lee"
+      given-names: "Gregory L."
+    - family-names: "Moody"
+      given-names: "Adam"
+    - family-names: "de Supinski"
+      given-names: "Bronis R."
+    - family-names: "Futral"
+      given-names: "Scott"
+  conference:
+    name: "Supercomputing 2015 (SC’15)"
+    city: "Austin"
+    region: "Texas"
+    country: "US"
+    date-start: 2015-11-15
+    date-end: 2015-11-20
+  month: 11
+  year: 2015
+  identifiers:
+    - description: "The concept DOI of the work."
+      type: doi
+      value: 10.1145/2807591.2807623
+    - description: "The DOE Document Release Number of the work"
+      type: other 
+      value: "LLNL-CONF-669890"
+authors:
   - family-names: "Gamblin"
     given-names: "Todd"
   - family-names: "LeGendre"
@@ -47,12 +88,3 @@ preferred-citation:
     given-names: "Bronis R."
   - family-names: "Futral"
     given-names: "Scott"
-  title: "The Spack Package Manager: Bringing Order to HPC Software Chaos"
-  conference:
-    name: "Supercomputing 2015 (SC’15)"
-    city: "Austin"
-    region: "Texas"
-    country: "USA"
-  month: November 15-20
-  year: 2015
-  notes: LLNL-CONF-669890

etc/spack/defaults/bootstrap.yaml

@@ -9,15 +9,15 @@ bootstrap:
   # may not be able to bootstrap all the software that Spack needs,
   # depending on its type.
   sources:
+  - name: 'github-actions-v0.5'
+    metadata: $spack/share/spack/bootstrap/github-actions-v0.5
   - name: 'github-actions-v0.4'
     metadata: $spack/share/spack/bootstrap/github-actions-v0.4
-  - name: 'github-actions-v0.3'
-    metadata: $spack/share/spack/bootstrap/github-actions-v0.3
   - name: 'spack-install'
     metadata: $spack/share/spack/bootstrap/spack-install
   trusted:
     # By default we trust bootstrapping from sources and from binaries
     # produced on Github via the workflow
+    github-actions-v0.5: true
     github-actions-v0.4: true
-    github-actions-v0.3: true
     spack-install: true

lib/spack/docs/containers.rst

@@ -212,18 +212,12 @@ under the ``container`` attribute of environments:
          final:
          - libgomp
 
-       # Extra instructions
-       extra_instructions:
-         final: |
-           RUN echo 'export PS1="\[$(tput bold)\]\[$(tput setaf 1)\][gromacs]\[$(tput setaf 2)\]\u\[$(tput sgr0)\]:\w $ "' >> ~/.bashrc
-
        # Labels for the image
        labels:
          app: "gromacs"
          mpi: "mpich"
 
-A detailed description of the options available can be found in the
-:ref:`container_config_options` section.
+A detailed description of the options available can be found in the :ref:`container_config_options` section.
 
 -------------------
 Setting Base Images
@@ -525,6 +519,13 @@ the example below:
    COPY data /share/myapp/data
    {% endblock %}
 
+The Dockerfile is generated by running:
+
+.. code-block:: console
+
+   $ spack -e /opt/environment containerize
+
+Note that the environment must be active for spack to read the template.
 The recipe that gets generated contains the two extra instruction that we added in our template extension:
 
 .. code-block:: Dockerfile

lib/spack/docs/packaging_guide.rst

@@ -3635,7 +3635,8 @@ regardless of the build system. The arguments for the phase are:
 The arguments ``spec`` and ``prefix`` are passed only for convenience, as they always
 correspond to ``self.spec`` and ``self.spec.prefix`` respectively.
 
-If the ``package.py`` encodes builders explicitly, the signature for a phase changes slightly:
+If the ``package.py`` has build instructions in a separate
+:ref:`builder class <multiple_build_systems>`, the signature for a phase changes slightly:
 
 .. code-block:: python
 
@@ -3645,56 +3646,6 @@ If the ``package.py`` encodes builders explicitly, the signature for a phase cha
 
 In this case the package is passed as the second argument, and ``self`` is the builder instance.
 
-.. _multiple_build_systems:
-
-^^^^^^^^^^^^^^^^^^^^^^
-Multiple build systems
-^^^^^^^^^^^^^^^^^^^^^^
-
-There are cases where a software actively supports two build systems, or changes build systems
-as it evolves, or needs different build systems on different platforms. Spack allows dealing with
-these cases natively, if a recipe is written using builders explicitly.
-
-For instance, software that supports two build systems unconditionally should derive from
-both ``*Package`` base classes, and declare the possible use of multiple build systems using
-a directive:
-
-.. code-block:: python
-
-   class ArpackNg(CMakePackage, AutotoolsPackage):
-
-       build_system("cmake", "autotools", default="cmake")
-
-In this case the software can be built with both ``autotools`` and ``cmake``. Since the package
-supports multiple build systems, it is necessary to declare which one is the default. The ``package.py``
-will likely contain some overriding of default builder methods:
-
-.. code-block:: python
-
-   class CMakeBuilder(spack.build_systems.cmake.CMakeBuilder):
-       def cmake_args(self):
-           pass
-
-   class AutotoolsBuilder(spack.build_systems.autotools.AutotoolsBuilder):
-       def configure_args(self):
-           pass
-
-In more complex cases it might happen that the build system changes according to certain conditions,
-for instance across versions. That can be expressed with conditional variant values:
-
-.. code-block:: python
-
-   class ArpackNg(CMakePackage, AutotoolsPackage):
-
-       build_system(
-           conditional("cmake", when="@0.64:"),
-           conditional("autotools", when="@:0.63"),
-           default="cmake",
-       )
-
-In the example the directive impose a change from ``Autotools`` to ``CMake`` going
-from ``v0.63`` to ``v0.64``.
-
 ^^^^^^^^^^^^^^^^^^
 Mixin base classes
 ^^^^^^^^^^^^^^^^^^
@@ -3741,6 +3692,106 @@ for instance:
 
 In the example above ``Cp2k`` inherits all the conflicts and variants that ``CudaPackage`` defines.
 
+.. _multiple_build_systems:
+
+----------------------
+Multiple build systems
+----------------------
+
+There are cases where a package actively supports two build systems, or changes build systems
+as it evolves, or needs different build systems on different platforms. Spack allows dealing with
+these cases by splitting the build instructions into separate builder classes.
+
+For instance, software that supports two build systems unconditionally should derive from
+both ``*Package`` base classes, and declare the possible use of multiple build systems using
+a directive:
+
+.. code-block:: python
+
+   class Example(CMakePackage, AutotoolsPackage):
+
+       variant("my_feature", default=True)
+
+       build_system("cmake", "autotools", default="cmake")
+
+In this case the software can be built with both ``autotools`` and ``cmake``. Since the package
+supports multiple build systems, it is necessary to declare which one is the default.
+
+Additional build instructions are split into separate builder classes:
+
+.. code-block:: python
+
+   class CMakeBuilder(spack.build_systems.cmake.CMakeBuilder):
+       def cmake_args(self):
+           return [
+               self.define_from_variant("MY_FEATURE", "my_feature")
+           ]
+
+   class AutotoolsBuilder(spack.build_systems.autotools.AutotoolsBuilder):
+       def configure_args(self):
+           return self.with_or_without("my-feature", variant="my_feature")
+
+In this example, ``spack install example +feature build_sytem=cmake``  will
+pick the ``CMakeBuilder`` and invoke ``cmake -DMY_FEATURE:BOOL=ON``.
+
+Similarly, ``spack install example +feature build_system=autotools`` will pick
+the  ``AutotoolsBuilder`` and invoke ``./configure --with-my-feature``.
+
+Dependencies are always specified in the package class. When some dependencies
+depend on the choice of the build system, it is possible to use when conditions as 
+usual:
+
+.. code-block:: python
+
+   class Example(CMakePackage, AutotoolsPackage):
+
+       build_system("cmake", "autotools", default="cmake")
+
+       # Runtime dependencies
+       depends_on("ncurses")
+       depends_on("libxml2")
+
+       # Lowerbounds for cmake only apply when using cmake as the build system
+       with when("build_system=cmake"):
+           depends_on("cmake@3.18:", when="@2.0:", type="build")
+           depends_on("cmake@3:", type="build")
+
+       # Specify extra build dependencies used only in the configure script 
+       with when("build_system=autotools"):
+           depends_on("perl", type="build")
+           depends_on("pkgconfig", type="build")
+
+Very often projects switch from one build system to another, or add support
+for a new build system from a certain version, which means that the choice
+of the build system typically depends on a version range. Those situations can
+be handled by using conditional values in the ``build_system`` directive:
+
+.. code-block:: python
+
+   class Example(CMakePackage, AutotoolsPackage):
+
+       build_system(
+           conditional("cmake", when="@0.64:"),
+           conditional("autotools", when="@:0.63"),
+           default="cmake",
+       )
+
+In the example the directive impose a change from ``Autotools`` to ``CMake`` going
+from ``v0.63`` to ``v0.64``.
+
+The ``build_system`` can be used as an ordinary variant, which also means that it can
+be used in ``depends_on`` statements. This can be useful when a package *requires* that
+its dependency has a CMake config file, meaning that the dependent can only build when the
+dependency is built with CMake, and not Autotools. In that case, you can force the choice
+of the build system in the dependent:
+
+.. code-block:: python
+
+   class Dependent(CMakePackage):
+
+       depends_on("example build_system=cmake")
+
+
 .. _install-environment:
 
 -----------------------

lib/spack/docs/requirements.txt

@@ -2,7 +2,7 @@ sphinx==7.2.6
 sphinxcontrib-programoutput==0.17
 sphinx_design==0.5.0
 sphinx-rtd-theme==1.3.0
-python-levenshtein==0.21.1
+python-levenshtein==0.23.0
 docutils==0.18.1
 pygments==2.16.1
 urllib3==2.0.6
@@ -10,4 +10,4 @@ pytest==7.4.2
 isort==5.12.0
 black==23.9.1
 flake8==6.1.0
-mypy==1.5.1
+mypy==1.6.0

lib/spack/docs/tables/system_prerequisites.csv

@@ -1,9 +1,8 @@
 Name, Supported Versions, Notes, Requirement Reason
-Python, 3.6--3.11, , Interpreter for Spack
+Python, 3.6--3.12, , Interpreter for Spack
 C/C++ Compilers, , , Building software
 make, , , Build software
 patch, , , Build software
-bash, , , Compiler wrappers
 tar, , , Extract/create archives
 gzip, , , Compress/Decompress archives
 unzip, , , Compress/Decompress archives

lib/spack/spack/binary_distribution.py

@@ -913,7 +913,7 @@ def _read_specs_and_push_index(file_list, read_method, cache_prefix, db, temp_di
         index_json_path,
         url_util.join(cache_prefix, "index.json"),
         keep_original=False,
-        extra_args={"ContentType": "application/json"},
+        extra_args={"ContentType": "application/json", "CacheControl": "no-cache"},
     )
 
     # Push the hash
@@ -921,7 +921,7 @@ def _read_specs_and_push_index(file_list, read_method, cache_prefix, db, temp_di
         index_hash_path,
         url_util.join(cache_prefix, "index.json.hash"),
         keep_original=False,
-        extra_args={"ContentType": "text/plain"},
+        extra_args={"ContentType": "text/plain", "CacheControl": "no-cache"},
     )
 
 

lib/spack/spack/bootstrap/core.py

@@ -228,7 +228,7 @@ def _install_and_test(
                 if not abstract_spec.intersects(candidate_spec):
                     continue
 
-                if python_spec is not None and python_spec not in abstract_spec:
+                if python_spec is not None and not abstract_spec.intersects(f"^{python_spec}"):
                     continue
 
                 for _, pkg_hash, pkg_sha256 in item["binaries"]:

lib/spack/spack/build_systems/cmake.py

@@ -142,10 +142,10 @@ def flags_to_build_system_args(self, flags):
         # We specify for each of them.
         if flags["ldflags"]:
             ldflags = " ".join(flags["ldflags"])
-            ld_string = "-DCMAKE_{0}_LINKER_FLAGS={1}"
             # cmake has separate linker arguments for types of builds.
-            for type in ["EXE", "MODULE", "SHARED", "STATIC"]:
-                self.cmake_flag_args.append(ld_string.format(type, ldflags))
+            self.cmake_flag_args.append(f"-DCMAKE_EXE_LINKER_FLAGS={ldflags}")
+            self.cmake_flag_args.append(f"-DCMAKE_MODULE_LINKER_FLAGS={ldflags}")
+            self.cmake_flag_args.append(f"-DCMAKE_SHARED_LINKER_FLAGS={ldflags}")
 
         # CMake has libs options separated by language. Apply ours to each.
         if flags["ldlibs"]:

lib/spack/spack/build_systems/racket.py

@@ -64,7 +64,7 @@ class RacketBuilder(spack.builder.Builder):
 
     @property
     def subdirectory(self):
-        if self.racket_name:
+        if self.pkg.racket_name:
             return "pkgs/{0}".format(self.pkg.racket_name)
         return None
 

lib/spack/spack/cmd/buildcache.py

@@ -268,7 +268,7 @@ def _matching_specs(specs: List[Spec]) -> List[Spec]:
     return [spack.cmd.disambiguate_spec(s, ev.active_environment(), installed=any) for s in specs]
 
 
-def push_fn(args):
+def push_fn(args: argparse.Namespace):
     """create a binary package and push it to a mirror"""
     if args.spec_file:
         tty.warn(
@@ -414,7 +414,7 @@ def preview_fn(args):
     )
 
 
-def check_fn(args):
+def check_fn(args: argparse.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
@@ -429,7 +429,7 @@ def check_fn(args):
     specs = spack.cmd.parse_specs(args.spec or args.spec_file)
 
     if specs:
-        specs = _matching_specs(specs, specs)
+        specs = _matching_specs(specs)
     else:
         specs = spack.cmd.require_active_env("buildcache check").all_specs()
 

lib/spack/spack/cmd/checksum.py

@@ -7,6 +7,7 @@
 import re
 import sys
 
+import llnl.string
 import llnl.util.lang
 from llnl.util import tty
 
@@ -15,6 +16,7 @@
 import spack.spec
 import spack.stage
 import spack.util.crypto
+import spack.util.web as web_util
 from spack.cmd.common import arguments
 from spack.package_base import PackageBase, deprecated_version, preferred_version
 from spack.util.editor import editor
@@ -128,18 +130,38 @@ def checksum(parser, args):
             remote_versions = pkg.fetch_remote_versions(args.jobs)
         url_dict = remote_versions
 
+    # A spidered URL can differ from the package.py *computed* URL, pointing to different tarballs.
+    # For example, GitHub release pages sometimes have multiple tarballs with different shasum:
+    # - releases/download/1.0/<pkg>-1.0.tar.gz (uploaded tarball)
+    # - archive/refs/tags/1.0.tar.gz           (generated tarball)
+    # We wanna ensure that `spack checksum` and `spack install` ultimately use the same URL, so
+    # here we check whether the crawled and computed URLs disagree, and if so, prioritize the
+    # former if that URL exists (just sending a HEAD request that is).
+    url_changed_for_version = set()
+    for version, url in url_dict.items():
+        possible_urls = pkg.all_urls_for_version(version)
+        if url not in possible_urls:
+            for possible_url in possible_urls:
+                if web_util.url_exists(possible_url):
+                    url_dict[version] = possible_url
+                    break
+            else:
+                url_changed_for_version.add(version)
+
     if not url_dict:
         tty.die(f"Could not find any remote versions for {pkg.name}")
-
-    # print an empty line to create a new output section block
-    print()
+    elif len(url_dict) > 1 and not args.batch and sys.stdin.isatty():
+        filtered_url_dict = spack.stage.interactive_version_filter(
+            url_dict, pkg.versions, url_changes=url_changed_for_version
+        )
+        if filtered_url_dict is None:
+            exit(0)
+        url_dict = filtered_url_dict
+    else:
+        tty.info(f"Found {llnl.string.plural(len(url_dict), 'version')} of {pkg.name}")
 
     version_hashes = spack.stage.get_checksums_for_versions(
-        url_dict,
-        pkg.name,
-        keep_stage=args.keep_stage,
-        batch=(args.batch or len(versions) > 0 or len(url_dict) == 1),
-        fetch_options=pkg.fetch_options,
+        url_dict, pkg.name, keep_stage=args.keep_stage, fetch_options=pkg.fetch_options
     )
 
     if args.verify:

lib/spack/spack/cmd/create.py

@@ -5,6 +5,7 @@
 
 import os
 import re
+import sys
 import urllib.parse
 
 import llnl.util.tty as tty
@@ -823,6 +824,11 @@ def get_versions(args, name):
         # Find available versions
         try:
             url_dict = spack.url.find_versions_of_archive(args.url)
+            if len(url_dict) > 1 and not args.batch and sys.stdin.isatty():
+                url_dict_filtered = spack.stage.interactive_version_filter(url_dict)
+                if url_dict_filtered is None:
+                    exit(0)
+                url_dict = url_dict_filtered
         except UndetectableVersionError:
             # Use fake versions
             tty.warn("Couldn't detect version in: {0}".format(args.url))
@@ -834,11 +840,7 @@ def get_versions(args, name):
             url_dict = {version: args.url}
 
         version_hashes = spack.stage.get_checksums_for_versions(
-            url_dict,
-            name,
-            first_stage_function=guesser,
-            keep_stage=args.keep_stage,
-            batch=(args.batch or len(url_dict) == 1),
+            url_dict, name, first_stage_function=guesser, keep_stage=args.keep_stage
         )
 
         versions = get_version_lines(version_hashes, url_dict)

lib/spack/spack/container/writers/__init__.py

@@ -272,13 +272,6 @@ def _os_pkg_manager(self):
             raise spack.error.SpackError(msg)
         return os_pkg_manager
 
-    @tengine.context_property
-    def extra_instructions(self):
-        Extras = namedtuple("Extra", ["build", "final"])
-        extras = self.container_config.get("extra_instructions", {})
-        build, final = extras.get("build", None), extras.get("final", None)
-        return Extras(build=build, final=final)
-
     @tengine.context_property
     def labels(self):
         return self.container_config.get("labels", {})

lib/spack/spack/installer.py

@@ -131,12 +131,12 @@ def set_term_title(self, text: str):
         if not sys.stdout.isatty():
             return
 
-        status = "{0} {1}".format(text, self.get_progress())
-        sys.stdout.write("\033]0;Spack: {0}\007".format(status))
+        status = f"{text} {self.get_progress()}"
+        sys.stdout.write(f"\x1b]0;Spack: {status}\x07")
         sys.stdout.flush()
 
     def get_progress(self) -> str:
-        return "[{0}/{1}]".format(self.pkg_num, self.pkg_count)
+        return f"[{self.pkg_num}/{self.pkg_count}]"
 
 
 class TermStatusLine:
@@ -175,7 +175,7 @@ def clear(self):
 
         # Move the cursor to the beginning of the first "Waiting for" message and clear
         # everything after it.
-        sys.stdout.write("\x1b[%sF\x1b[J" % lines)
+        sys.stdout.write(f"\x1b[{lines}F\x1b[J")
         sys.stdout.flush()
 
 
@@ -220,14 +220,13 @@ def _handle_external_and_upstream(pkg: "spack.package_base.PackageBase", explici
     # consists in module file generation and registration in the DB.
     if pkg.spec.external:
         _process_external_package(pkg, explicit)
-        _print_installed_pkg("{0} (external {1})".format(pkg.prefix, package_id(pkg)))
+        _print_installed_pkg(f"{pkg.prefix} (external {package_id(pkg)})")
         return True
 
     if pkg.spec.installed_upstream:
         tty.verbose(
-            "{0} is installed in an upstream Spack instance at {1}".format(
-                package_id(pkg), pkg.spec.prefix
-            )
+            f"{package_id(pkg)} is installed in an upstream Spack instance at "
+            f"{pkg.spec.prefix}"
         )
         _print_installed_pkg(pkg.prefix)
 
@@ -296,7 +295,7 @@ def _packages_needed_to_bootstrap_compiler(
             package is the bootstrap compiler (``True``) or one of its dependencies
             (``False``).  The list will be empty if there are no compilers.
     """
-    tty.debug("Bootstrapping {0} compiler".format(compiler))
+    tty.debug(f"Bootstrapping {compiler} compiler")
     compilers = spack.compilers.compilers_for_spec(compiler, arch_spec=architecture)
     if compilers:
         return []
@@ -305,9 +304,9 @@ def _packages_needed_to_bootstrap_compiler(
 
     # Set the architecture for the compiler package in a way that allows the
     # concretizer to back off if needed for the older bootstrapping compiler
-    dep.constrain("platform=%s" % str(architecture.platform))
-    dep.constrain("os=%s" % str(architecture.os))
-    dep.constrain("target=%s:" % architecture.target.microarchitecture.family.name)
+    dep.constrain(f"platform={str(architecture.platform)}")
+    dep.constrain(f"os={str(architecture.os)}")
+    dep.constrain(f"target={architecture.target.microarchitecture.family.name}:")
     # concrete CompilerSpec has less info than concrete Spec
     # concretize as Spec to add that information
     dep.concretize()
@@ -340,15 +339,15 @@ def _hms(seconds: int) -> str:
     if m:
         parts.append("%dm" % m)
     if s:
-        parts.append("%.2fs" % s)
+        parts.append(f"{s:.2f}s")
     return " ".join(parts)
 
 
 def _log_prefix(pkg_name) -> str:
     """Prefix of the form "[pid]: [pkg name]: ..." when printing a status update during
     the build."""
-    pid = "{0}: ".format(os.getpid()) if tty.show_pid() else ""
-    return "{0}{1}:".format(pid, pkg_name)
+    pid = f"{os.getpid()}: " if tty.show_pid() else ""
+    return f"{pid}{pkg_name}:"
 
 
 def _print_installed_pkg(message: str) -> None:
@@ -375,9 +374,9 @@ def print_install_test_log(pkg: "spack.package_base.PackageBase") -> None:
 
 
 def _print_timer(pre: str, pkg_id: str, timer: timer.BaseTimer) -> None:
-    phases = ["{}: {}.".format(p.capitalize(), _hms(timer.duration(p))) for p in timer.phases]
-    phases.append("Total: {}".format(_hms(timer.duration())))
-    tty.msg("{0} Successfully installed {1}".format(pre, pkg_id), "  ".join(phases))
+    phases = [f"{p.capitalize()}: {_hms(timer.duration(p))}." for p in timer.phases]
+    phases.append(f"Total: {_hms(timer.duration())}")
+    tty.msg(f"{pre} Successfully installed {pkg_id}", "  ".join(phases))
 
 
 def _install_from_cache(
@@ -402,14 +401,14 @@ def _install_from_cache(
     )
     pkg_id = package_id(pkg)
     if not installed_from_cache:
-        pre = "No binary for {0} found".format(pkg_id)
+        pre = f"No binary for {pkg_id} found"
         if cache_only:
-            tty.die("{0} when cache-only specified".format(pre))
+            tty.die(f"{pre} when cache-only specified")
 
-        tty.msg("{0}: installing from source".format(pre))
+        tty.msg(f"{pre}: installing from source")
         return False
     t.stop()
-    tty.debug("Successfully extracted {0} from binary cache".format(pkg_id))
+    tty.debug(f"Successfully extracted {pkg_id} from binary cache")
 
     _write_timer_json(pkg, t, True)
     _print_timer(pre=_log_prefix(pkg.name), pkg_id=pkg_id, timer=t)
@@ -430,19 +429,19 @@ def _process_external_package(pkg: "spack.package_base.PackageBase", explicit: b
     """
     assert pkg.spec.external, "Expected to post-install/register an external package."
 
-    pre = "{s.name}@{s.version} :".format(s=pkg.spec)
+    pre = f"{pkg.spec.name}@{pkg.spec.version} :"
     spec = pkg.spec
 
     if spec.external_modules:
-        tty.msg("{0} has external module in {1}".format(pre, spec.external_modules))
-        tty.debug("{0} is actually installed in {1}".format(pre, spec.external_path))
+        tty.msg(f"{pre} has external module in {spec.external_modules}")
+        tty.debug(f"{pre} is actually installed in {spec.external_path}")
     else:
-        tty.debug("{0} externally installed in {1}".format(pre, spec.external_path))
+        tty.debug(f"{pre} externally installed in {spec.external_path}")
 
     try:
         # Check if the package was already registered in the DB.
         # If this is the case, then only make explicit if required.
-        tty.debug("{0} already registered in DB".format(pre))
+        tty.debug(f"{pre} already registered in DB")
         record = spack.store.STORE.db.get_record(spec)
         if explicit and not record.explicit:
             spack.store.STORE.db.update_explicit(spec, explicit)
@@ -451,11 +450,11 @@ def _process_external_package(pkg: "spack.package_base.PackageBase", explicit: b
         # If not, register it and generate the module file.
         # For external packages we just need to run
         # post-install hooks to generate module files.
-        tty.debug("{0} generating module file".format(pre))
+        tty.debug(f"{pre} generating module file")
         spack.hooks.post_install(spec, explicit)
 
         # Add to the DB
-        tty.debug("{0} registering into DB".format(pre))
+        tty.debug(f"{pre} registering into DB")
         spack.store.STORE.db.add(spec, None, explicit=explicit)
 
 
@@ -490,7 +489,7 @@ def _process_binary_cache_tarball(
         if download_result is None:
             return False
 
-    tty.msg("Extracting {0} from binary cache".format(package_id(pkg)))
+    tty.msg(f"Extracting {package_id(pkg)} from binary cache")
 
     with timer.measure("install"), spack.util.path.filter_padding():
         binary_distribution.extract_tarball(
@@ -522,7 +521,7 @@ def _try_install_from_binary_cache(
     if not spack.mirror.MirrorCollection(binary=True):
         return False
 
-    tty.debug("Searching for binary cache of {0}".format(package_id(pkg)))
+    tty.debug(f"Searching for binary cache of {package_id(pkg)}")
 
     with timer.measure("search"):
         matches = binary_distribution.get_mirrors_for_spec(pkg.spec, index_only=True)
@@ -590,9 +589,9 @@ def dump_packages(spec: "spack.spec.Spec", path: str) -> None:
                 source_repo = spack.repo.Repo(source_repo_root)
                 source_pkg_dir = source_repo.dirname_for_package_name(node.name)
             except spack.repo.RepoError as err:
-                tty.debug("Failed to create source repo for {0}: {1}".format(node.name, str(err)))
+                tty.debug(f"Failed to create source repo for {node.name}: {str(err)}")
                 source_pkg_dir = None
-                tty.warn("Warning: Couldn't copy in provenance for {0}".format(node.name))
+                tty.warn(f"Warning: Couldn't copy in provenance for {node.name}")
 
         # Create a destination repository
         dest_repo_root = os.path.join(path, node.namespace)
@@ -632,7 +631,7 @@ def install_msg(name: str, pid: int, install_status: InstallStatus) -> str:
 
     Return: Colorized installing message
     """
-    pre = "{0}: ".format(pid) if tty.show_pid() else ""
+    pre = f"{pid}: " if tty.show_pid() else ""
     post = (
         " @*{%s}" % install_status.get_progress()
         if install_status and spack.config.get("config:install_status", True)
@@ -698,7 +697,7 @@ def log(pkg: "spack.package_base.PackageBase") -> None:
             # in the stage tree (not arbitrary files)
             abs_expr = os.path.realpath(glob_expr)
             if os.path.realpath(pkg.stage.path) not in abs_expr:
-                errors.write("[OUTSIDE SOURCE PATH]: {0}\n".format(glob_expr))
+                errors.write(f"[OUTSIDE SOURCE PATH]: {glob_expr}\n")
                 continue
             # Now that we are sure that the path is within the correct
             # folder, make it relative and check for matches
@@ -718,14 +717,14 @@ def log(pkg: "spack.package_base.PackageBase") -> None:
                     # Here try to be conservative, and avoid discarding
                     # the whole install procedure because of copying a
                     # single file failed
-                    errors.write("[FAILED TO ARCHIVE]: {0}".format(f))
+                    errors.write(f"[FAILED TO ARCHIVE]: {f}")
 
         if errors.getvalue():
             error_file = os.path.join(target_dir, "errors.txt")
             fs.mkdirp(target_dir)
             with open(error_file, "w") as err:
                 err.write(errors.getvalue())
-            tty.warn("Errors occurred when archiving files.\n\t" "See: {0}".format(error_file))
+            tty.warn(f"Errors occurred when archiving files.\n\tSee: {error_file}")
 
     dump_packages(pkg.spec, packages_dir)
 
@@ -761,11 +760,11 @@ def __init__(self, pkg: "spack.package_base.PackageBase", install_args: dict):
         """
         # Ensure dealing with a package that has a concrete spec
         if not isinstance(pkg, spack.package_base.PackageBase):
-            raise ValueError("{0} must be a package".format(str(pkg)))
+            raise ValueError(f"{str(pkg)} must be a package")
 
         self.pkg = pkg
         if not self.pkg.spec.concrete:
-            raise ValueError("{0} must have a concrete spec".format(self.pkg.name))
+            raise ValueError(f"{self.pkg.name} must have a concrete spec")
 
         # Cache the package phase options with the explicit package,
         # popping the options to ensure installation of associated
@@ -797,14 +796,14 @@ def __init__(self, pkg: "spack.package_base.PackageBase", install_args: dict):
 
     def __repr__(self) -> str:
         """Returns a formal representation of the build request."""
-        rep = "{0}(".format(self.__class__.__name__)
+        rep = f"{self.__class__.__name__}("
         for attr, value in self.__dict__.items():
-            rep += "{0}={1}, ".format(attr, value.__repr__())
-        return "{0})".format(rep.strip(", "))
+            rep += f"{attr}={value.__repr__()}, "
+        return f"{rep.strip(', ')})"
 
     def __str__(self) -> str:
         """Returns a printable version of the build request."""
-        return "package={0}, install_args={1}".format(self.pkg.name, self.install_args)
+        return f"package={self.pkg.name}, install_args={self.install_args}"
 
     def _add_default_args(self) -> None:
         """Ensure standard install options are set to at least the default."""
@@ -930,18 +929,18 @@ def __init__(
 
         # Ensure dealing with a package that has a concrete spec
         if not isinstance(pkg, spack.package_base.PackageBase):
-            raise ValueError("{0} must be a package".format(str(pkg)))
+            raise ValueError(f"{str(pkg)} must be a package")
 
         self.pkg = pkg
         if not self.pkg.spec.concrete:
-            raise ValueError("{0} must have a concrete spec".format(self.pkg.name))
+            raise ValueError(f"{self.pkg.name} must have a concrete spec")
 
         # The "unique" identifier for the task's package
         self.pkg_id = package_id(self.pkg)
 
         # The explicit build request associated with the package
         if not isinstance(request, BuildRequest):
-            raise ValueError("{0} must have a build request".format(str(pkg)))
+            raise ValueError(f"{str(pkg)} must have a build request")
 
         self.request = request
 
@@ -949,8 +948,9 @@ def __init__(
         # ensure priority queue invariants when tasks are "removed" from the
         # queue.
         if status == STATUS_REMOVED:
-            msg = "Cannot create a build task for {0} with status '{1}'"
-            raise InstallError(msg.format(self.pkg_id, status), pkg=pkg)
+            raise InstallError(
+                f"Cannot create a build task for {self.pkg_id} with status '{status}'", pkg=pkg
+            )
 
         self.status = status
 
@@ -964,9 +964,9 @@ def __init__(
         # to support tracking of parallel, multi-spec, environment installs.
         self.dependents = set(get_dependent_ids(self.pkg.spec))
 
-        tty.debug("Pkg id {0} has the following dependents:".format(self.pkg_id))
+        tty.debug(f"Pkg id {self.pkg_id} has the following dependents:")
         for dep_id in self.dependents:
-            tty.debug("- {0}".format(dep_id))
+            tty.debug(f"- {dep_id}")
 
         # Set of dependencies
         #
@@ -988,9 +988,9 @@ def __init__(
         if not spack.compilers.compilers_for_spec(compiler_spec, arch_spec=arch_spec):
             # The compiler is in the queue, identify it as dependency
             dep = spack.compilers.pkg_spec_for_compiler(compiler_spec)
-            dep.constrain("platform=%s" % str(arch_spec.platform))
-            dep.constrain("os=%s" % str(arch_spec.os))
-            dep.constrain("target=%s:" % arch_spec.target.microarchitecture.family.name)
+            dep.constrain(f"platform={str(arch_spec.platform)}")
+            dep.constrain(f"os={str(arch_spec.os)}")
+            dep.constrain(f"target={arch_spec.target.microarchitecture.family.name}:")
             dep.concretize()
             dep_id = package_id(dep.package)
             self.dependencies.add(dep_id)
@@ -1026,14 +1026,14 @@ def __ne__(self, other):
 
     def __repr__(self) -> str:
         """Returns a formal representation of the build task."""
-        rep = "{0}(".format(self.__class__.__name__)
+        rep = f"{self.__class__.__name__}("
         for attr, value in self.__dict__.items():
-            rep += "{0}={1}, ".format(attr, value.__repr__())
-        return "{0})".format(rep.strip(", "))
+            rep += f"{attr}={value.__repr__()}, "
+        return f"{rep.strip(', ')})"
 
     def __str__(self) -> str:
         """Returns a printable version of the build task."""
-        dependencies = "#dependencies={0}".format(len(self.dependencies))
+        dependencies = f"#dependencies={len(self.dependencies)}"
         return "priority={0}, status={1}, start={2}, {3}".format(
             self.priority, self.status, self.start, dependencies
         )
@@ -1056,7 +1056,7 @@ def add_dependent(self, pkg_id: str) -> None:
             pkg_id:  package identifier of the dependent package
         """
         if pkg_id != self.pkg_id and pkg_id not in self.dependents:
-            tty.debug("Adding {0} as a dependent of {1}".format(pkg_id, self.pkg_id))
+            tty.debug(f"Adding {pkg_id} as a dependent of {self.pkg_id}")
             self.dependents.add(pkg_id)
 
     def flag_installed(self, installed: List[str]) -> None:
@@ -1070,9 +1070,8 @@ def flag_installed(self, installed: List[str]) -> None:
         for pkg_id in now_installed:
             self.uninstalled_deps.remove(pkg_id)
             tty.debug(
-                "{0}: Removed {1} from uninstalled deps list: {2}".format(
-                    self.pkg_id, pkg_id, self.uninstalled_deps
-                ),
+                f"{self.pkg_id}: Removed {pkg_id} from uninstalled deps list: "
+                f"{self.uninstalled_deps}",
                 level=2,
             )
 
@@ -1170,18 +1169,18 @@ def __init__(self, installs: List[Tuple["spack.package_base.PackageBase", dict]]
 
     def __repr__(self) -> str:
         """Returns a formal representation of the package installer."""
-        rep = "{0}(".format(self.__class__.__name__)
+        rep = f"{self.__class__.__name__}("
         for attr, value in self.__dict__.items():
-            rep += "{0}={1}, ".format(attr, value.__repr__())
-        return "{0})".format(rep.strip(", "))
+            rep += f"{attr}={value.__repr__()}, "
+        return f"{rep.strip(', ')})"
 
     def __str__(self) -> str:
         """Returns a printable version of the package installer."""
-        requests = "#requests={0}".format(len(self.build_requests))
-        tasks = "#tasks={0}".format(len(self.build_tasks))
-        failed = "failed ({0}) = {1}".format(len(self.failed), self.failed)
-        installed = "installed ({0}) = {1}".format(len(self.installed), self.installed)
-        return "{0}: {1}; {2}; {3}; {4}".format(self.pid, requests, tasks, installed, failed)
+        requests = f"#requests={len(self.build_requests)}"
+        tasks = f"#tasks={len(self.build_tasks)}"
+        failed = f"failed ({len(self.failed)}) = {self.failed}"
+        installed = f"installed ({len(self.installed)}) = {self.installed}"
+        return f"{self.pid}: {requests}; {tasks}; {installed}; {failed}"
 
     def _add_bootstrap_compilers(
         self,
@@ -1226,9 +1225,7 @@ def _modify_existing_task(self, pkgid: str, attr, value) -> None:
         for i, tup in enumerate(self.build_pq):
             key, task = tup
             if task.pkg_id == pkgid:
-                tty.debug(
-                    "Modifying task for {0} to treat it as a compiler".format(pkgid), level=2
-                )
+                tty.debug(f"Modifying task for {pkgid} to treat it as a compiler", level=2)
                 setattr(task, attr, value)
                 self.build_pq[i] = (key, task)
 
@@ -1293,7 +1290,7 @@ def _check_deps_status(self, request: BuildRequest) -> None:
             # Check for failure since a prefix lock is not required
             if spack.store.STORE.failure_tracker.has_failed(dep):
                 action = "'spack install' the dependency"
-                msg = "{0} is marked as an install failure: {1}".format(dep_id, action)
+                msg = f"{dep_id} is marked as an install failure: {action}"
                 raise InstallError(err.format(request.pkg_id, msg), pkg=dep_pkg)
 
             # Attempt to get a read lock to ensure another process does not
@@ -1301,7 +1298,7 @@ def _check_deps_status(self, request: BuildRequest) -> None:
             # installed
             ltype, lock = self._ensure_locked("read", dep_pkg)
             if lock is None:
-                msg = "{0} is write locked by another process".format(dep_id)
+                msg = f"{dep_id} is write locked by another process"
                 raise InstallError(err.format(request.pkg_id, msg), pkg=request.pkg)
 
             # Flag external and upstream packages as being installed
@@ -1320,7 +1317,7 @@ def _check_deps_status(self, request: BuildRequest) -> None:
                     or rec.installation_time > request.overwrite_time
                 )
             ):
-                tty.debug("Flagging {0} as installed per the database".format(dep_id))
+                tty.debug(f"Flagging {dep_id} as installed per the database")
                 self._flag_installed(dep_pkg)
             else:
                 lock.release_read()
@@ -1356,9 +1353,9 @@ def _prepare_for_install(self, task: BuildTask) -> None:
             # Ensure there is no other installed spec with the same prefix dir
             if spack.store.STORE.db.is_occupied_install_prefix(task.pkg.spec.prefix):
                 raise InstallError(
-                    "Install prefix collision for {0}".format(task.pkg_id),
-                    long_msg="Prefix directory {0} already used by another "
-                    "installed spec.".format(task.pkg.spec.prefix),
+                    f"Install prefix collision for {task.pkg_id}",
+                    long_msg=f"Prefix directory {task.pkg.spec.prefix} already "
+                    "used by another installed spec.",
                     pkg=task.pkg,
                 )
 
@@ -1368,7 +1365,7 @@ def _prepare_for_install(self, task: BuildTask) -> None:
                 if not keep_prefix:
                     task.pkg.remove_prefix()
                 else:
-                    tty.debug("{0} is partially installed".format(task.pkg_id))
+                    tty.debug(f"{task.pkg_id} is partially installed")
 
             # Destroy the stage for a locally installed, non-DIYStage, package
             if restage and task.pkg.stage.managed_by_spack:
@@ -1413,9 +1410,8 @@ def _cleanup_failed(self, pkg_id: str) -> None:
         lock = self.failed.get(pkg_id, None)
         if lock is not None:
             err = "{0} exception when removing failure tracking for {1}: {2}"
-            msg = "Removing failure mark on {0}"
             try:
-                tty.verbose(msg.format(pkg_id))
+                tty.verbose(f"Removing failure mark on {pkg_id}")
                 lock.release_write()
             except Exception as exc:
                 tty.warn(err.format(exc.__class__.__name__, pkg_id, str(exc)))
@@ -1442,19 +1438,19 @@ def _ensure_install_ready(self, pkg: "spack.package_base.PackageBase") -> None:
             pkg: the package being locally installed
         """
         pkg_id = package_id(pkg)
-        pre = "{0} cannot be installed locally:".format(pkg_id)
+        pre = f"{pkg_id} cannot be installed locally:"
 
         # External packages cannot be installed locally.
         if pkg.spec.external:
-            raise ExternalPackageError("{0} {1}".format(pre, "is external"))
+            raise ExternalPackageError(f"{pre} is external")
 
         # Upstream packages cannot be installed locally.
         if pkg.spec.installed_upstream:
-            raise UpstreamPackageError("{0} {1}".format(pre, "is upstream"))
+            raise UpstreamPackageError(f"{pre} is upstream")
 
         # The package must have a prefix lock at this stage.
         if pkg_id not in self.locks:
-            raise InstallLockError("{0} {1}".format(pre, "not locked"))
+            raise InstallLockError(f"{pre} not locked")
 
     def _ensure_locked(
         self, lock_type: str, pkg: "spack.package_base.PackageBase"
@@ -1481,14 +1477,14 @@ def _ensure_locked(
         assert lock_type in [
             "read",
             "write",
-        ], '"{0}" is not a supported package management lock type'.format(lock_type)
+        ], f'"{lock_type}" is not a supported package management lock type'
 
         pkg_id = package_id(pkg)
         ltype, lock = self.locks.get(pkg_id, (lock_type, None))
         if lock and ltype == lock_type:
             return ltype, lock
 
-        desc = "{0} lock".format(lock_type)
+        desc = f"{lock_type} lock"
         msg = "{0} a {1} on {2} with timeout {3}"
         err = "Failed to {0} a {1} for {2} due to {3}: {4}"
 
@@ -1507,11 +1503,7 @@ def _ensure_locked(
                 op = "acquire"
                 lock = spack.store.STORE.prefix_locker.lock(pkg.spec, timeout)
                 if timeout != lock.default_timeout:
-                    tty.warn(
-                        "Expected prefix lock timeout {0}, not {1}".format(
-                            timeout, lock.default_timeout
-                        )
-                    )
+                    tty.warn(f"Expected prefix lock timeout {timeout}, not {lock.default_timeout}")
                 if lock_type == "read":
                     lock.acquire_read()
                 else:
@@ -1536,7 +1528,7 @@ def _ensure_locked(
                 tty.debug(msg.format("Upgrading to", desc, pkg_id, pretty_seconds(timeout or 0)))
                 op = "upgrade to"
                 lock.upgrade_read_to_write(timeout)
-            tty.debug("{0} is now {1} locked".format(pkg_id, lock_type))
+            tty.debug(f"{pkg_id} is now {lock_type} locked")
 
         except (lk.LockDowngradeError, lk.LockTimeoutError) as exc:
             tty.debug(err.format(op, desc, pkg_id, exc.__class__.__name__, str(exc)))
@@ -1561,14 +1553,14 @@ def _add_tasks(self, request: BuildRequest, all_deps):
             all_deps (defaultdict(set)): dictionary of all dependencies and
                 associated dependents
         """
-        tty.debug("Initializing the build queue for {0}".format(request.pkg.name))
+        tty.debug(f"Initializing the build queue for {request.pkg.name}")
 
         # Ensure not attempting to perform an installation when user didn't
         # want to go that far for the requested package.
         try:
             _check_last_phase(request.pkg)
         except BadInstallPhase as err:
-            tty.warn("Installation request refused: {0}".format(str(err)))
+            tty.warn(f"Installation request refused: {str(err)}")
             return
 
         # Skip out early if the spec is not being installed locally (i.e., if
@@ -1719,9 +1711,9 @@ def _install_task(self, task: BuildTask, install_status: InstallStatus) -> None:
             # A StopPhase exception means that do_install was asked to
             # stop early from clients, and is not an error at this point
             spack.hooks.on_install_failure(task.request.pkg.spec)
-            pid = "{0}: ".format(self.pid) if tty.show_pid() else ""
-            tty.debug("{0}{1}".format(pid, str(e)))
-            tty.debug("Package stage directory: {0}".format(pkg.stage.source_path))
+            pid = f"{self.pid}: " if tty.show_pid() else ""
+            tty.debug(f"{pid}{str(e)}")
+            tty.debug(f"Package stage directory: {pkg.stage.source_path}")
 
     def _next_is_pri0(self) -> bool:
         """
@@ -1816,7 +1808,7 @@ def _remove_task(self, pkg_id: str) -> Optional[BuildTask]:
             pkg_id: identifier for the package to be removed
         """
         if pkg_id in self.build_tasks:
-            tty.debug("Removing build task for {0} from list".format(pkg_id))
+            tty.debug(f"Removing build task for {pkg_id} from list")
             task = self.build_tasks.pop(pkg_id)
             task.status = STATUS_REMOVED
             return task
@@ -1832,10 +1824,8 @@ def _requeue_task(self, task: BuildTask, install_status: InstallStatus) -> None:
         """
         if task.status not in [STATUS_INSTALLED, STATUS_INSTALLING]:
             tty.debug(
-                "{0} {1}".format(
-                    install_msg(task.pkg_id, self.pid, install_status),
-                    "in progress by another process",
-                )
+                f"{install_msg(task.pkg_id, self.pid, install_status)} "
+                "in progress by another process"
             )
 
         new_task = task.next_attempt(self.installed)
@@ -1852,7 +1842,7 @@ def _setup_install_dir(self, pkg: "spack.package_base.PackageBase") -> None:
         """
         if not os.path.exists(pkg.spec.prefix):
             path = spack.util.path.debug_padded_filter(pkg.spec.prefix)
-            tty.debug("Creating the installation directory {0}".format(path))
+            tty.debug(f"Creating the installation directory {path}")
             spack.store.STORE.layout.create_install_directory(pkg.spec)
         else:
             # Set the proper group for the prefix
@@ -1888,8 +1878,8 @@ def _update_failed(
             exc: optional exception if associated with the failure
         """
         pkg_id = task.pkg_id
-        err = "" if exc is None else ": {0}".format(str(exc))
-        tty.debug("Flagging {0} as failed{1}".format(pkg_id, err))
+        err = "" if exc is None else f": {str(exc)}"
+        tty.debug(f"Flagging {pkg_id} as failed{err}")
         if mark:
             self.failed[pkg_id] = spack.store.STORE.failure_tracker.mark(task.pkg.spec)
         else:
@@ -1898,14 +1888,14 @@ def _update_failed(
 
         for dep_id in task.dependents:
             if dep_id in self.build_tasks:
-                tty.warn("Skipping build of {0} since {1} failed".format(dep_id, pkg_id))
+                tty.warn(f"Skipping build of {dep_id} since {pkg_id} failed")
                 # Ensure the dependent's uninstalled dependents are
                 # up-to-date and their build tasks removed.
                 dep_task = self.build_tasks[dep_id]
                 self._update_failed(dep_task, mark)
                 self._remove_task(dep_id)
             else:
-                tty.debug("No build task for {0} to skip since {1} failed".format(dep_id, pkg_id))
+                tty.debug(f"No build task for {dep_id} to skip since {pkg_id} failed")
 
     def _update_installed(self, task: BuildTask) -> None:
         """
@@ -1935,23 +1925,21 @@ def _flag_installed(
             # Already determined the package has been installed
             return
 
-        tty.debug("Flagging {0} as installed".format(pkg_id))
+        tty.debug(f"Flagging {pkg_id} as installed")
 
         self.installed.add(pkg_id)
 
         # Update affected dependents
         dependent_ids = dependent_ids or get_dependent_ids(pkg.spec)
         for dep_id in set(dependent_ids):
-            tty.debug("Removing {0} from {1}'s uninstalled dependencies.".format(pkg_id, dep_id))
+            tty.debug(f"Removing {pkg_id} from {dep_id}'s uninstalled dependencies.")
             if dep_id in self.build_tasks:
                 # Ensure the dependent's uninstalled dependencies are
                 # up-to-date.  This will require requeueing the task.
                 dep_task = self.build_tasks[dep_id]
                 self._push_task(dep_task.next_attempt(self.installed))
             else:
-                tty.debug(
-                    "{0} has no build task to update for {1}'s success".format(dep_id, pkg_id)
-                )
+                tty.debug(f"{dep_id} has no build task to update for {pkg_id}'s success")
 
     def _init_queue(self) -> None:
         """Initialize the build queue from the list of build requests."""
@@ -2032,8 +2020,8 @@ def install(self) -> None:
 
             pkg, pkg_id, spec = task.pkg, task.pkg_id, task.pkg.spec
             install_status.next_pkg(pkg)
-            install_status.set_term_title("Processing {0}".format(pkg.name))
-            tty.debug("Processing {0}: task={1}".format(pkg_id, task))
+            install_status.set_term_title(f"Processing {pkg.name}")
+            tty.debug(f"Processing {pkg_id}: task={task}")
             # Ensure that the current spec has NO uninstalled dependencies,
             # which is assumed to be reflected directly in its priority.
             #
@@ -2045,24 +2033,19 @@ def install(self) -> None:
             if task.priority != 0:
                 term_status.clear()
                 tty.error(
-                    "Detected uninstalled dependencies for {0}: {1}".format(
-                        pkg_id, task.uninstalled_deps
-                    )
+                    f"Detected uninstalled dependencies for {pkg_id}: " f"{task.uninstalled_deps}"
                 )
                 left = [dep_id for dep_id in task.uninstalled_deps if dep_id not in self.installed]
                 if not left:
-                    tty.warn(
-                        "{0} does NOT actually have any uninstalled deps" " left".format(pkg_id)
-                    )
+                    tty.warn(f"{pkg_id} does NOT actually have any uninstalled deps left")
                 dep_str = "dependencies" if task.priority > 1 else "dependency"
 
                 # Hook to indicate task failure, but without an exception
                 spack.hooks.on_install_failure(task.request.pkg.spec)
 
                 raise InstallError(
-                    "Cannot proceed with {0}: {1} uninstalled {2}: {3}".format(
-                        pkg_id, task.priority, dep_str, ",".join(task.uninstalled_deps)
-                    ),
+                    f"Cannot proceed with {pkg_id}: {task.priority} uninstalled "
+                    f"{dep_str}: {','.join(task.uninstalled_deps)}",
                     pkg=pkg,
                 )
 
@@ -2079,7 +2062,7 @@ def install(self) -> None:
             # assume using a separate (failed) prefix lock file.
             if pkg_id in self.failed or spack.store.STORE.failure_tracker.has_failed(spec):
                 term_status.clear()
-                tty.warn("{0} failed to install".format(pkg_id))
+                tty.warn(f"{pkg_id} failed to install")
                 self._update_failed(task)
 
                 # Mark that the package failed
@@ -2096,7 +2079,7 @@ def install(self) -> None:
             # another process is likely (un)installing the spec or has
             # determined the spec has already been installed (though the
             # other process may be hung).
-            install_status.set_term_title("Acquiring lock for {0}".format(pkg.name))
+            install_status.set_term_title(f"Acquiring lock for {pkg.name}")
             term_status.add(pkg_id)
             ltype, lock = self._ensure_locked("write", pkg)
             if lock is None:
@@ -2119,7 +2102,7 @@ def install(self) -> None:
                 task.request.overwrite_time = time.time()
 
             # Determine state of installation artifacts and adjust accordingly.
-            install_status.set_term_title("Preparing {0}".format(pkg.name))
+            install_status.set_term_title(f"Preparing {pkg.name}")
             self._prepare_for_install(task)
 
             # Flag an already installed package
@@ -2165,7 +2148,7 @@ def install(self) -> None:
 
             # Proceed with the installation since we have an exclusive write
             # lock on the package.
-            install_status.set_term_title("Installing {0}".format(pkg.name))
+            install_status.set_term_title(f"Installing {pkg.name}")
             try:
                 action = self._install_action(task)
 
@@ -2186,8 +2169,9 @@ def install(self) -> None:
             except KeyboardInterrupt as exc:
                 # The build has been terminated with a Ctrl-C so terminate
                 # regardless of the number of remaining specs.
-                err = "Failed to install {0} due to {1}: {2}"
-                tty.error(err.format(pkg.name, exc.__class__.__name__, str(exc)))
+                tty.error(
+                    f"Failed to install {pkg.name} due to " f"{exc.__class__.__name__}: {str(exc)}"
+                )
                 spack.hooks.on_install_cancel(task.request.pkg.spec)
                 raise
 
@@ -2196,9 +2180,10 @@ def install(self) -> None:
                     raise
 
                 # Checking hash on downloaded binary failed.
-                err = "Failed to install {0} from binary cache due to {1}:"
-                err += " Requeueing to install from source."
-                tty.error(err.format(pkg.name, str(exc)))
+                tty.error(
+                    f"Failed to install {pkg.name} from binary cache due "
+                    f"to {str(exc)}: Requeueing to install from source."
+                )
                 # this overrides a full method, which is ugly.
                 task.use_cache = False  # type: ignore[misc]
                 self._requeue_task(task, install_status)
@@ -2216,13 +2201,12 @@ def install(self) -> None:
                     # lower levels -- skip printing if already printed.
                     # TODO: sort out this and SpackError.print_context()
                     tty.error(
-                        "Failed to install {0} due to {1}: {2}".format(
-                            pkg.name, exc.__class__.__name__, str(exc)
-                        )
+                        f"Failed to install {pkg.name} due to "
+                        f"{exc.__class__.__name__}: {str(exc)}"
                     )
                 # Terminate if requested to do so on the first failure.
                 if self.fail_fast:
-                    raise InstallError("{0}: {1}".format(fail_fast_err, str(exc)), pkg=pkg)
+                    raise InstallError(f"{fail_fast_err}: {str(exc)}", pkg=pkg)
 
                 # Terminate at this point if the single explicit spec has
                 # failed to install.
@@ -2261,17 +2245,17 @@ def install(self) -> None:
 
         if failed_explicits or missing:
             for _, pkg_id, err in failed_explicits:
-                tty.error("{0}: {1}".format(pkg_id, err))
+                tty.error(f"{pkg_id}: {err}")
 
             for _, pkg_id in missing:
-                tty.error("{0}: Package was not installed".format(pkg_id))
+                tty.error(f"{pkg_id}: Package was not installed")
 
             if len(failed_explicits) > 0:
                 pkg = failed_explicits[0][0]
                 ids = [pkg_id for _, pkg_id, _ in failed_explicits]
                 tty.debug(
                     "Associating installation failure with first failed "
-                    "explicit package ({0}) from {1}".format(ids[0], ", ".join(ids))
+                    f"explicit package ({ids[0]}) from {', '.join(ids)}"
                 )
 
             elif len(missing) > 0:
@@ -2279,7 +2263,7 @@ def install(self) -> None:
                 ids = [pkg_id for _, pkg_id in missing]
                 tty.debug(
                     "Associating installation failure with first "
-                    "missing package ({0}) from {1}".format(ids[0], ", ".join(ids))
+                    f"missing package ({ids[0]}) from {', '.join(ids)}"
                 )
 
             raise InstallError(
@@ -2357,7 +2341,7 @@ def run(self) -> bool:
             self.timer.stop("stage")
 
             tty.debug(
-                "{0} Building {1} [{2}]".format(self.pre, self.pkg_id, self.pkg.build_system_class)  # type: ignore[attr-defined] # noqa: E501
+                f"{self.pre} Building {self.pkg_id} [{self.pkg.build_system_class}]"  # type: ignore[attr-defined] # noqa: E501
             )
 
             # get verbosity from do_install() parameter or saved value
@@ -2402,7 +2386,7 @@ def _install_source(self) -> None:
             return
 
         src_target = os.path.join(pkg.spec.prefix, "share", pkg.name, "src")
-        tty.debug("{0} Copying source to {1}".format(self.pre, src_target))
+        tty.debug(f"{self.pre} Copying source to {src_target}")
 
         fs.install_tree(
             pkg.stage.source_path, src_target, allow_broken_symlinks=(sys.platform != "win32")
@@ -2464,8 +2448,7 @@ def _real_install(self) -> None:
                         with logger.force_echo():
                             inner_debug_level = tty.debug_level()
                             tty.set_debug(debug_level)
-                            msg = "{0} Executing phase: '{1}'"
-                            tty.msg(msg.format(self.pre, phase_fn.name))
+                            tty.msg(f"{self.pre} Executing phase: '{phase_fn.name}'")
                             tty.set_debug(inner_debug_level)
 
                         # Catch any errors to report to logging
@@ -2539,12 +2522,9 @@ def install(self):
         except fs.CouldNotRestoreDirectoryBackup as e:
             self.database.remove(self.task.pkg.spec)
             tty.error(
-                "Recovery of install dir of {0} failed due to "
-                "{1}: {2}. The spec is now uninstalled.".format(
-                    self.task.pkg.name,
-                    e.outer_exception.__class__.__name__,
-                    str(e.outer_exception),
-                )
+                f"Recovery of install dir of {self.task.pkg.name} failed due to "
+                f"{e.outer_exception.__class__.__name__}: {str(e.outer_exception)}. "
+                "The spec is now uninstalled."
             )
 
             # Unwrap the actual installation exception.
@@ -2567,7 +2547,7 @@ class BadInstallPhase(InstallError):
     """Raised for an install phase option is not allowed for a package."""
 
     def __init__(self, pkg_name, phase):
-        super().__init__("'{0}' is not a valid phase for package {1}".format(phase, pkg_name))
+        super().__init__(f"'{phase}' is not a valid phase for package {pkg_name}")
 
 
 class ExternalPackageError(InstallError):

lib/spack/spack/parser.py

@@ -73,10 +73,10 @@
 #: Valid name for specs and variants. Here we are not using
 #: the previous "w[\w.-]*" since that would match most
 #: characters that can be part of a word in any language
-IDENTIFIER = r"([a-zA-Z_0-9][a-zA-Z_0-9\-]*)"
-DOTTED_IDENTIFIER = rf"({IDENTIFIER}(\.{IDENTIFIER})+)"
-GIT_HASH = r"([A-Fa-f0-9]{40})"
-GIT_VERSION = rf"((git\.({DOTTED_IDENTIFIER}|{IDENTIFIER}))|({GIT_HASH}))"
+IDENTIFIER = r"(?:[a-zA-Z_0-9][a-zA-Z_0-9\-]*)"
+DOTTED_IDENTIFIER = rf"(?:{IDENTIFIER}(?:\.{IDENTIFIER})+)"
+GIT_HASH = r"(?:[A-Fa-f0-9]{40})"
+GIT_VERSION = rf"(?:(?:git\.(?:{DOTTED_IDENTIFIER}|{IDENTIFIER}))|(?:{GIT_HASH}))"
 
 NAME = r"[a-zA-Z_0-9][a-zA-Z_0-9\-.]*"
 
@@ -85,15 +85,15 @@
 #: A filename starts either with a "." or a "/" or a "{name}/,
 # or on Windows, a drive letter followed by a colon and "\"
 # or "." or {name}\
-WINDOWS_FILENAME = r"(\.|[a-zA-Z0-9-_]*\\|[a-zA-Z]:\\)([a-zA-Z0-9-_\.\\]*)(\.json|\.yaml)"
-UNIX_FILENAME = r"(\.|\/|[a-zA-Z0-9-_]*\/)([a-zA-Z0-9-_\.\/]*)(\.json|\.yaml)"
+WINDOWS_FILENAME = r"(?:\.|[a-zA-Z0-9-_]*\\|[a-zA-Z]:\\)(?:[a-zA-Z0-9-_\.\\]*)(?:\.json|\.yaml)"
+UNIX_FILENAME = r"(?:\.|\/|[a-zA-Z0-9-_]*\/)(?:[a-zA-Z0-9-_\.\/]*)(?:\.json|\.yaml)"
 if not IS_WINDOWS:
     FILENAME = UNIX_FILENAME
 else:
     FILENAME = WINDOWS_FILENAME
 
-VALUE = r"([a-zA-Z_0-9\-+\*.,:=\~\/\\]+)"
-QUOTED_VALUE = r"[\"']+([a-zA-Z_0-9\-+\*.,:=\~\/\\\s]+)[\"']+"
+VALUE = r"(?:[a-zA-Z_0-9\-+\*.,:=\~\/\\]+)"
+QUOTED_VALUE = r"[\"']+(?:[a-zA-Z_0-9\-+\*.,:=\~\/\\\s]+)[\"']+"
 
 VERSION = r"=?([a-zA-Z0-9_][a-zA-Z_0-9\-\.]*\b)"
 VERSION_RANGE = rf"({VERSION}\s*:\s*{VERSION}(?!\s*=)|:\s*{VERSION}(?!\s*=)|{VERSION}\s*:|:)"
@@ -125,34 +125,34 @@ class TokenType(TokenBase):
     """
 
     # Dependency
-    DEPENDENCY = r"(\^)"
+    DEPENDENCY = r"(?:\^)"
     # Version
-    VERSION_HASH_PAIR = rf"(@({GIT_VERSION})=({VERSION}))"
-    VERSION = rf"(@\s*({VERSION_LIST}))"
+    VERSION_HASH_PAIR = rf"(?:@(?:{GIT_VERSION})=(?:{VERSION}))"
+    VERSION = rf"(?:@\s*(?:{VERSION_LIST}))"
     # Variants
-    PROPAGATED_BOOL_VARIANT = rf"((\+\+|~~|--)\s*{NAME})"
-    BOOL_VARIANT = rf"([~+-]\s*{NAME})"
-    PROPAGATED_KEY_VALUE_PAIR = rf"({NAME}\s*==\s*({VALUE}|{QUOTED_VALUE}))"
-    KEY_VALUE_PAIR = rf"({NAME}\s*=\s*({VALUE}|{QUOTED_VALUE}))"
+    PROPAGATED_BOOL_VARIANT = rf"(?:(?:\+\+|~~|--)\s*{NAME})"
+    BOOL_VARIANT = rf"(?:[~+-]\s*{NAME})"
+    PROPAGATED_KEY_VALUE_PAIR = rf"(?:{NAME}\s*==\s*(?:{VALUE}|{QUOTED_VALUE}))"
+    KEY_VALUE_PAIR = rf"(?:{NAME}\s*=\s*(?:{VALUE}|{QUOTED_VALUE}))"
     # Compilers
-    COMPILER_AND_VERSION = rf"(%\s*({NAME})([\s]*)@\s*({VERSION_LIST}))"
-    COMPILER = rf"(%\s*({NAME}))"
+    COMPILER_AND_VERSION = rf"(?:%\s*(?:{NAME})(?:[\s]*)@\s*(?:{VERSION_LIST}))"
+    COMPILER = rf"(?:%\s*(?:{NAME}))"
     # FILENAME
-    FILENAME = rf"({FILENAME})"
+    FILENAME = rf"(?:{FILENAME})"
     # Package name
-    FULLY_QUALIFIED_PACKAGE_NAME = rf"({DOTTED_IDENTIFIER})"
-    UNQUALIFIED_PACKAGE_NAME = rf"({IDENTIFIER})"
+    FULLY_QUALIFIED_PACKAGE_NAME = rf"(?:{DOTTED_IDENTIFIER})"
+    UNQUALIFIED_PACKAGE_NAME = rf"(?:{IDENTIFIER})"
     # DAG hash
-    DAG_HASH = rf"(/({HASH}))"
+    DAG_HASH = rf"(?:/(?:{HASH}))"
     # White spaces
-    WS = r"(\s+)"
+    WS = r"(?:\s+)"
 
 
 class ErrorTokenType(TokenBase):
     """Enum with regexes for error analysis"""
 
     # Unexpected character
-    UNEXPECTED = r"(.[\s]*)"
+    UNEXPECTED = r"(?:.[\s]*)"
 
 
 class Token:

lib/spack/spack/patch.py

@@ -312,21 +312,19 @@ def from_json(cls, stream, repository):
     def to_json(self, stream):
         sjson.dump({"patches": self.index}, stream)
 
-    def patch_for_package(self, sha256, pkg):
+    def patch_for_package(self, sha256: str, pkg):
         """Look up a patch in the index and build a patch object for it.
 
         Arguments:
-            sha256 (str): sha256 hash to look up
+            sha256: sha256 hash to look up
             pkg (spack.package_base.PackageBase): Package object to get patch for.
 
         We build patch objects lazily because building them requires that
-        we have information about the package's location in its repo.
-
-        """
+        we have information about the package's location in its repo."""
         sha_index = self.index.get(sha256)
         if not sha_index:
-            raise NoSuchPatchError(
-                "Couldn't find patch for package %s with sha256: %s" % (pkg.fullname, sha256)
+            raise PatchLookupError(
+                f"Couldn't find patch for package {pkg.fullname} with sha256: {sha256}"
             )
 
         # Find patches for this class or any class it inherits from
@@ -335,8 +333,8 @@ def patch_for_package(self, sha256, pkg):
             if patch_dict:
                 break
         else:
-            raise NoSuchPatchError(
-                "Couldn't find patch for package %s with sha256: %s" % (pkg.fullname, sha256)
+            raise PatchLookupError(
+                f"Couldn't find patch for package {pkg.fullname} with sha256: {sha256}"
             )
 
         # add the sha256 back (we take it out on write to save space,
@@ -405,5 +403,9 @@ class NoSuchPatchError(spack.error.SpackError):
     """Raised when a patch file doesn't exist."""
 
 
+class PatchLookupError(NoSuchPatchError):
+    """Raised when a patch file cannot be located from sha256."""
+
+
 class PatchDirectiveError(spack.error.SpackError):
     """Raised when the wrong arguments are suppled to the patch directive."""

lib/spack/spack/schema/container.py

@@ -68,12 +68,6 @@
         "labels": {"type": "object"},
         # Use a custom template to render the recipe
         "template": {"type": "string", "default": None},
-        # Add a custom extra section at the bottom of a stage
-        "extra_instructions": {
-            "type": "object",
-            "additionalProperties": False,
-            "properties": {"build": {"type": "string"}, "final": {"type": "string"}},
-        },
         # Reserved for properties that are specific to each format
         "singularity": {
             "type": "object",
@@ -89,15 +83,6 @@
         "docker": {"type": "object", "additionalProperties": False, "default": {}},
         "depfile": {"type": "boolean", "default": False},
     },
-    "deprecatedProperties": {
-        "properties": ["extra_instructions"],
-        "message": (
-            "container:extra_instructions has been deprecated and will be removed "
-            "in Spack v0.21. Set container:template appropriately to use custom Jinja2 "
-            "templates instead."
-        ),
-        "error": False,
-    },
 }
 
 properties = {"container": container_schema}

lib/spack/spack/solver/concretize.lp

@@ -923,7 +923,8 @@ pkg_fact(Package, variant_single_value("dev_path"))
 %-----------------------------------------------------------------------------
 
 % if no platform is set, fall back to the default
-:- attr("node_platform", _, Platform), not allowed_platform(Platform).
+error(100, "platform '{0}' is not allowed on the current host", Platform)
+  :- attr("node_platform", _, Platform), not allowed_platform(Platform).
 
 attr("node_platform", PackageNode, Platform)
  :- attr("node", PackageNode),

lib/spack/spack/spec.py

@@ -74,6 +74,7 @@
 import spack.deptypes as dt
 import spack.error
 import spack.hash_types as ht
+import spack.patch
 import spack.paths
 import spack.platforms
 import spack.provider_index
@@ -3671,7 +3672,7 @@ def _autospec(self, spec_like):
             return spec_like
         return Spec(spec_like)
 
-    def intersects(self, other: "Spec", deps: bool = True) -> bool:
+    def intersects(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
         """Return True if there exists at least one concrete spec that matches both
         self and other, otherwise False.
 
@@ -3794,7 +3795,7 @@ def _intersects_dependencies(self, other):
 
         return True
 
-    def satisfies(self, other: "Spec", deps: bool = True) -> bool:
+    def satisfies(self, other: Union[str, "Spec"], deps: bool = True) -> bool:
         """Return True if all concrete specs matching self also match other, otherwise False.
 
         Args:
@@ -3906,7 +3907,15 @@ def patches(self):
                 for sha256 in self.variants["patches"]._patches_in_order_of_appearance:
                     index = spack.repo.PATH.patch_index
                     pkg_cls = spack.repo.PATH.get_pkg_class(self.name)
-                    patch = index.patch_for_package(sha256, pkg_cls)
+                    try:
+                        patch = index.patch_for_package(sha256, pkg_cls)
+                    except spack.patch.PatchLookupError as e:
+                        raise spack.error.SpecError(
+                            f"{e}. This usually means the patch was modified or removed. "
+                            "To fix this, either reconcretize or use the original package "
+                            "repository"
+                        ) from e
+
                     self._patches.append(patch)
 
         return self._patches

lib/spack/spack/stage.py

@@ -7,12 +7,13 @@
 import getpass
 import glob
 import hashlib
+import io
 import os
 import shutil
 import stat
 import sys
 import tempfile
-from typing import Callable, Dict, Iterable, Optional
+from typing import Callable, Dict, Iterable, Optional, Set
 
 import llnl.string
 import llnl.util.lang
@@ -27,6 +28,8 @@
     partition_path,
     remove_linked_tree,
 )
+from llnl.util.tty.colify import colify
+from llnl.util.tty.color import colorize
 
 import spack.caches
 import spack.config
@@ -35,11 +38,14 @@
 import spack.mirror
 import spack.paths
 import spack.spec
+import spack.stage
 import spack.util.lock
 import spack.util.path as sup
 import spack.util.pattern as pattern
 import spack.util.url as url_util
 from spack.util.crypto import bit_length, prefix_bits
+from spack.util.editor import editor, executable
+from spack.version import StandardVersion, VersionList
 
 # The well-known stage source subdirectory name.
 _source_path_subdir = "spack-src"
@@ -860,11 +866,187 @@ def purge():
                     os.remove(stage_path)
 
 
+def interactive_version_filter(
+    url_dict: Dict[StandardVersion, str],
+    known_versions: Iterable[StandardVersion] = (),
+    *,
+    url_changes: Set[StandardVersion] = set(),
+    input: Callable[..., str] = input,
+) -> Optional[Dict[StandardVersion, str]]:
+    """Interactively filter the list of spidered versions.
+
+    Args:
+        url_dict: Dictionary of versions to URLs
+        known_versions: Versions that can be skipped because they are already known
+
+    Returns:
+        Filtered dictionary of versions to URLs or None if the user wants to quit
+    """
+    # Find length of longest string in the list for padding
+    sorted_and_filtered = sorted(url_dict.keys(), reverse=True)
+    version_filter = VersionList([":"])
+    max_len = max(len(str(v)) for v in sorted_and_filtered)
+    orig_url_dict = url_dict  # only copy when using editor to modify
+    print_header = True
+    VERSION_COLOR = spack.spec.VERSION_COLOR
+    while True:
+        if print_header:
+            has_filter = version_filter != VersionList([":"])
+            header = []
+            if len(sorted_and_filtered) == len(orig_url_dict):
+                header.append(
+                    f"Selected {llnl.string.plural(len(sorted_and_filtered), 'version')}"
+                )
+            else:
+                header.append(
+                    f"Selected {len(sorted_and_filtered)} of {len(orig_url_dict)} versions"
+                )
+            if known_versions:
+                num_new = sum(1 for v in sorted_and_filtered if v not in known_versions)
+                header.append(f"{llnl.string.plural(num_new, 'new version')}")
+            if has_filter:
+                header.append(colorize(f"Filtered by {VERSION_COLOR}{version_filter}@."))
+
+            version_with_url = [
+                colorize(
+                    f"{VERSION_COLOR}{str(v):{max_len}}@.  {url_dict[v]}"
+                    f"{'  @K{# NOTE: change of URL}' if v in url_changes else ''}"
+                )
+                for v in sorted_and_filtered
+            ]
+            tty.msg(". ".join(header), *llnl.util.lang.elide_list(version_with_url))
+            print()
+
+        print_header = True
+
+        print("commands:")
+        commands = (
+            "@*b{[c]}hecksum",
+            "@*b{[e]}dit",
+            "@*b{[f]}ilter",
+            "@*b{[a]}sk each",
+            "@*b{[n]}ew only",
+            "@*b{[r]}estart",
+            "@*b{[q]}uit",
+        )
+        colify(list(map(colorize, commands)), indent=2)
+
+        try:
+            command = input(colorize("@*g{command>} ")).strip().lower()
+        except EOFError:
+            print()
+            command = "q"
+
+        if command == "c":
+            break
+        elif command == "e":
+            # Create a temporary file in the stage dir with lines of the form
+            # <version> <url>
+            # which the user can modify. Once the editor is closed, the file is
+            # read back in and the versions to url dict is updated.
+
+            # Create a temporary file by hashing its contents.
+            buffer = io.StringIO()
+            buffer.write("# Edit this file to change the versions and urls to fetch\n")
+            for v in sorted_and_filtered:
+                buffer.write(f"{str(v):{max_len}}  {url_dict[v]}\n")
+            data = buffer.getvalue().encode("utf-8")
+
+            short_hash = hashlib.sha1(data).hexdigest()[:7]
+            filename = f"{spack.stage.stage_prefix}versions-{short_hash}.txt"
+            filepath = os.path.join(spack.stage.get_stage_root(), filename)
+
+            # Write contents
+            with open(filepath, "wb") as f:
+                f.write(data)
+
+            # Open editor
+            editor(filepath, exec_fn=executable)
+
+            # Read back in
+            with open(filepath, "r") as f:
+                orig_url_dict, url_dict = url_dict, {}
+                for line in f:
+                    line = line.strip()
+                    # Skip empty lines and comments
+                    if not line or line.startswith("#"):
+                        continue
+                    try:
+                        version, url = line.split(None, 1)
+                    except ValueError:
+                        tty.warn(f"Couldn't parse: {line}")
+                        continue
+                    try:
+                        url_dict[StandardVersion.from_string(version)] = url
+                    except ValueError:
+                        tty.warn(f"Invalid version: {version}")
+                        continue
+                sorted_and_filtered = sorted(url_dict.keys(), reverse=True)
+
+            os.unlink(filepath)
+        elif command == "f":
+            tty.msg(
+                colorize(
+                    f"Examples filters: {VERSION_COLOR}1.2@. "
+                    f"or {VERSION_COLOR}1.1:1.3@. "
+                    f"or {VERSION_COLOR}=1.2, 1.2.2:@."
+                )
+            )
+            try:
+                # Allow a leading @ version specifier
+                filter_spec = input(colorize("@*g{filter>} ")).strip().lstrip("@")
+            except EOFError:
+                print()
+                continue
+            try:
+                version_filter.intersect(VersionList([filter_spec]))
+            except ValueError:
+                tty.warn(f"Invalid version specifier: {filter_spec}")
+                continue
+            # Apply filter
+            sorted_and_filtered = [v for v in sorted_and_filtered if v.satisfies(version_filter)]
+        elif command == "a":
+            i = 0
+            while i < len(sorted_and_filtered):
+                v = sorted_and_filtered[i]
+                try:
+                    answer = input(f"  {str(v):{max_len}}  {url_dict[v]} [Y/n]? ").strip().lower()
+                except EOFError:
+                    # If ^D, don't fully exit, but go back to the command prompt, now with possibly
+                    # fewer versions
+                    print()
+                    break
+                if answer in ("n", "no"):
+                    del sorted_and_filtered[i]
+                elif answer in ("y", "yes", ""):
+                    i += 1
+            else:
+                # Went over each version, so go to checksumming
+                break
+        elif command == "n":
+            sorted_and_filtered = [v for v in sorted_and_filtered if v not in known_versions]
+        elif command == "r":
+            url_dict = orig_url_dict
+            sorted_and_filtered = sorted(url_dict.keys(), reverse=True)
+            version_filter = VersionList([":"])
+        elif command == "q":
+            try:
+                if input("Really quit [y/N]? ").strip().lower() in ("y", "yes"):
+                    return None
+            except EOFError:
+                print()
+                return None
+        else:
+            tty.warn(f"Ignoring invalid command: {command}")
+            print_header = False
+            continue
+    return {v: url_dict[v] for v in sorted_and_filtered}
+
+
 def get_checksums_for_versions(
     url_by_version: Dict[str, str],
     package_name: str,
     *,
-    batch: bool = False,
     first_stage_function: Optional[Callable[[Stage, str], None]] = None,
     keep_stage: bool = False,
     concurrency: Optional[int] = None,
@@ -890,32 +1072,7 @@ def get_checksums_for_versions(
     Returns:
         A dictionary mapping each version to the corresponding checksum
     """
-    sorted_versions = sorted(url_by_version.keys(), reverse=True)
-
-    # Find length of longest string in the list for padding
-    max_len = max(len(str(v)) for v in sorted_versions)
-    num_ver = len(sorted_versions)
-
-    tty.msg(
-        f"Found {llnl.string.plural(num_ver, 'version')} of {package_name}:",
-        "",
-        *llnl.util.lang.elide_list(
-            ["{0:{1}}  {2}".format(str(v), max_len, url_by_version[v]) for v in sorted_versions]
-        ),
-    )
-    print()
-
-    if batch:
-        archives_to_fetch = len(sorted_versions)
-    else:
-        archives_to_fetch = tty.get_number(
-            "How many would you like to checksum?", default=1, abort="q"
-        )
-
-    if not archives_to_fetch:
-        tty.die("Aborted.")
-
-    versions = sorted_versions[:archives_to_fetch]
+    versions = sorted(url_by_version.keys(), reverse=True)
     search_arguments = [(url_by_version[v], v) for v in versions]
 
     version_hashes, errors = {}, []

lib/spack/spack/test/cmd/bootstrap.py

@@ -169,7 +169,7 @@ def test_remove_and_add_a_source(mutable_config):
     assert not sources
 
     # Add it back and check we restored the initial state
-    _bootstrap("add", "github-actions", "$spack/share/spack/bootstrap/github-actions-v0.3")
+    _bootstrap("add", "github-actions", "$spack/share/spack/bootstrap/github-actions-v0.5")
     sources = spack.bootstrap.core.bootstrapping_sources()
     assert len(sources) == 1
 

lib/spack/spack/test/cmd/checksum.py

@@ -7,12 +7,12 @@
 
 import pytest
 
-import llnl.util.tty as tty
-
 import spack.cmd.checksum
 import spack.repo
 import spack.spec
 from spack.main import SpackCommand
+from spack.stage import interactive_version_filter
+from spack.version import Version
 
 spack_checksum = SpackCommand("checksum")
 
@@ -56,18 +56,134 @@ def test_checksum(arguments, expected, mock_packages, mock_clone_repo, mock_stag
         assert "version(" in output
 
 
-@pytest.mark.not_on_windows("Not supported on Windows (yet)")
-def test_checksum_interactive(mock_packages, mock_fetch, mock_stage, monkeypatch):
-    # TODO: mock_fetch doesn't actually work with stage, working around with ignoring
-    # fail_on_error for now
-    def _get_number(*args, **kwargs):
-        return 1
+def input_from_commands(*commands):
+    """Create a function that returns the next command from a list of inputs for interactive spack
+    checksum. If None is encountered, this is equivalent to EOF / ^D."""
+    commands = iter(commands)
 
-    monkeypatch.setattr(tty, "get_number", _get_number)
+    def _input(prompt):
+        cmd = next(commands)
+        if cmd is None:
+            raise EOFError
+        assert isinstance(cmd, str)
+        return cmd
 
-    output = spack_checksum("preferred-test", fail_on_error=False)
-    assert "version of preferred-test" in output
-    assert "version(" in output
+    return _input
+
+
+def test_checksum_interactive_filter():
+    # Filter effectively by 1:1.0, then checksum.
+    input = input_from_commands("f", "@1:", "f", "@:1.0", "c")
+    assert interactive_version_filter(
+        {
+            Version("1.1"): "https://www.example.com/pkg-1.1.tar.gz",
+            Version("1.0.1"): "https://www.example.com/pkg-1.0.1.tar.gz",
+            Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+            Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+        },
+        input=input,
+    ) == {
+        Version("1.0.1"): "https://www.example.com/pkg-1.0.1.tar.gz",
+        Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+    }
+
+
+def test_checksum_interactive_return_from_filter_prompt():
+    # Enter and then exit filter subcommand.
+    input = input_from_commands("f", None, "c")
+    assert interactive_version_filter(
+        {
+            Version("1.1"): "https://www.example.com/pkg-1.1.tar.gz",
+            Version("1.0.1"): "https://www.example.com/pkg-1.0.1.tar.gz",
+            Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+            Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+        },
+        input=input,
+    ) == {
+        Version("1.1"): "https://www.example.com/pkg-1.1.tar.gz",
+        Version("1.0.1"): "https://www.example.com/pkg-1.0.1.tar.gz",
+        Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+        Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+    }
+
+
+def test_checksum_interactive_quit_returns_none():
+    # Quit after filtering something out (y to confirm quit)
+    input = input_from_commands("f", "@1:", "q", "y")
+    assert (
+        interactive_version_filter(
+            {
+                Version("1.1"): "https://www.example.com/pkg-1.1.tar.gz",
+                Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+                Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+            },
+            input=input,
+        )
+        is None
+    )
+
+
+def test_checksum_interactive_reset_resets():
+    # Filter 1:, then reset, then filter :0, should just given 0.9 (it was filtered out
+    # before reset)
+    input = input_from_commands("f", "@1:", "r", "f", ":0", "c")
+    assert interactive_version_filter(
+        {
+            Version("1.1"): "https://www.example.com/pkg-1.1.tar.gz",
+            Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+            Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+        },
+        input=input,
+    ) == {Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz"}
+
+
+def test_checksum_interactive_ask_each():
+    # Ask each should run on the filtered list. First select 1.x, then select only the second
+    # entry, which is 1.0.1.
+    input = input_from_commands("f", "@1:", "a", "n", "y", "n")
+    assert interactive_version_filter(
+        {
+            Version("1.1"): "https://www.example.com/pkg-1.1.tar.gz",
+            Version("1.0.1"): "https://www.example.com/pkg-1.0.1.tar.gz",
+            Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+            Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+        },
+        input=input,
+    ) == {Version("1.0.1"): "https://www.example.com/pkg-1.0.1.tar.gz"}
+
+
+def test_checksum_interactive_quit_from_ask_each():
+    # Enter ask each mode, select the second item, then quit from submenu, then checksum, which
+    # should still include the last item at which ask each stopped.
+    input = input_from_commands("a", "n", "y", None, "c")
+    assert interactive_version_filter(
+        {
+            Version("1.1"): "https://www.example.com/pkg-1.1.tar.gz",
+            Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+            Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+        },
+        input=input,
+    ) == {
+        Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+        Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+    }
+
+
+def test_checksum_interactive_new_only():
+    # The 1.0 version is known already, and should be dropped on `n`.
+    input = input_from_commands("n", "c")
+    assert interactive_version_filter(
+        {
+            Version("1.1"): "https://www.example.com/pkg-1.1.tar.gz",
+            Version("1.0"): "https://www.example.com/pkg-1.0.tar.gz",
+            Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+        },
+        known_versions=[Version("1.0")],
+        input=input,
+    ) == {
+        Version("1.1"): "https://www.example.com/pkg-1.1.tar.gz",
+        Version("0.9"): "https://www.example.com/pkg-0.9.tar.gz",
+    }
 
 
 def test_checksum_versions(mock_packages, mock_clone_repo, mock_fetch, mock_stage):

lib/spack/spack/test/container/docker.py

@@ -82,23 +82,6 @@ def test_strip_is_set_from_config(minimal_configuration):
     assert writer.strip is False
 
 
-def test_extra_instructions_is_set_from_config(minimal_configuration):
-    writer = writers.create(minimal_configuration)
-    assert writer.extra_instructions == (None, None)
-
-    test_line = "RUN echo Hello world!"
-    e = minimal_configuration["spack"]["container"]
-    e["extra_instructions"] = {}
-    e["extra_instructions"]["build"] = test_line
-    writer = writers.create(minimal_configuration)
-    assert writer.extra_instructions == (test_line, None)
-
-    e["extra_instructions"]["final"] = test_line
-    del e["extra_instructions"]["build"]
-    writer = writers.create(minimal_configuration)
-    assert writer.extra_instructions == (None, test_line)
-
-
 def test_custom_base_images(minimal_configuration):
     """Test setting custom base images from configuration file"""
     minimal_configuration["spack"]["container"]["images"] = {

lib/spack/spack/test/data/config/bootstrap.yaml

@@ -1,5 +1,5 @@
 bootstrap:
   sources:
   - name: 'github-actions'
-    metadata: $spack/share/spack/bootstrap/github-actions-v0.3
+    metadata: $spack/share/spack/bootstrap/github-actions-v0.5
   trusted: {}

lib/spack/spack/test/flag_handlers.py

@@ -121,7 +121,6 @@ def test_ld_flags_cmake(self, temp_env):
             "-DCMAKE_EXE_LINKER_FLAGS=-mthreads",
             "-DCMAKE_MODULE_LINKER_FLAGS=-mthreads",
             "-DCMAKE_SHARED_LINKER_FLAGS=-mthreads",
-            "-DCMAKE_STATIC_LINKER_FLAGS=-mthreads",
         }
 
     def test_ld_libs_cmake(self, temp_env):

lib/spack/spack/url.py

@@ -647,7 +647,7 @@ def find_versions_of_archive(
     list_urls |= additional_list_urls
 
     # Grab some web pages to scrape.
-    pages, links = spack.util.web.spider(list_urls, depth=list_depth, concurrency=concurrency)
+    _, links = spack.util.web.spider(list_urls, depth=list_depth, concurrency=concurrency)
 
     # Scrape them for archive URLs
     regexes = []

lib/spack/spack/user_environment.py

@@ -26,8 +26,8 @@ def prefix_inspections(platform):
         A dictionary mapping subdirectory names to lists of environment
             variables to modify with that directory if it exists.
     """
-    inspections = spack.config.get("modules:prefix_inspections", {})
-    if inspections:
+    inspections = spack.config.get("modules:prefix_inspections")
+    if isinstance(inspections, dict):
         return inspections
 
     inspections = {

lib/spack/spack/util/editor.py

@@ -61,7 +61,7 @@ def executable(exe: str, args: List[str]) -> int:
     return cmd.returncode
 
 
-def editor(*args: List[str], exec_fn: Callable[[str, List[str]], int] = os.execv) -> bool:
+def editor(*args: str, exec_fn: Callable[[str, List[str]], int] = os.execv) -> bool:
     """Invoke the user's editor.
 
     This will try to execute the following, in order:

lib/spack/spack/util/unparse/unparser.py

@@ -938,16 +938,10 @@ def visit_arguments(self, node):
                 self.write(", ")
             self.write("*")
             if node.vararg:
-                if hasattr(node.vararg, "arg"):
-                    self.write(node.vararg.arg)
-                    if node.vararg.annotation:
-                        self.write(": ")
-                        self.dispatch(node.vararg.annotation)
-                else:
-                    self.write(node.vararg)
-                    if getattr(node, "varargannotation", None):
-                        self.write(": ")
-                        self.dispatch(node.varargannotation)
+                self.write(node.vararg.arg)
+                if node.vararg.annotation:
+                    self.write(": ")
+                    self.dispatch(node.vararg.annotation)
 
         # keyword-only arguments
         if getattr(node, "kwonlyargs", False):
@@ -967,16 +961,10 @@ def visit_arguments(self, node):
                 first = False
             else:
                 self.write(", ")
-            if hasattr(node.kwarg, "arg"):
-                self.write("**" + node.kwarg.arg)
-                if node.kwarg.annotation:
-                    self.write(": ")
-                    self.dispatch(node.kwarg.annotation)
-            else:
-                self.write("**" + node.kwarg)
-                if getattr(node, "kwargannotation", None):
-                    self.write(": ")
-                    self.dispatch(node.kwargannotation)
+            self.write("**" + node.kwarg.arg)
+            if node.kwarg.annotation:
+                self.write(": ")
+                self.dispatch(node.kwarg.annotation)
 
     def visit_keyword(self, node):
         if node.arg is None:

lib/spack/spack/util/web.py

@@ -110,19 +110,28 @@ def handle_starttag(self, tag, attrs):
                     self.links.append(val)
 
 
-class IncludeFragmentParser(HTMLParser):
+class ExtractMetadataParser(HTMLParser):
     """This parser takes an HTML page and selects the include-fragments,
-    used on GitHub, https://github.github.io/include-fragment-element."""
+    used on GitHub, https://github.github.io/include-fragment-element,
+    as well as a possible base url."""
 
     def __init__(self):
         super().__init__()
-        self.links = []
+        self.fragments = []
+        self.base_url = None
 
     def handle_starttag(self, tag, attrs):
+        # <include-fragment src="..." />
         if tag == "include-fragment":
             for attr, val in attrs:
                 if attr == "src":
-                    self.links.append(val)
+                    self.fragments.append(val)
+
+        # <base href="..." />
+        elif tag == "base":
+            for attr, val in attrs:
+                if attr == "href":
+                    self.base_url = val
 
 
 def read_from_url(url, accept_content_type=None):
@@ -625,12 +634,15 @@ def _spider(url: urllib.parse.ParseResult, collect_nested: bool, _visited: Set[s
 
         # Parse out the include-fragments in the page
         # https://github.github.io/include-fragment-element
-        include_fragment_parser = IncludeFragmentParser()
-        include_fragment_parser.feed(page)
+        metadata_parser = ExtractMetadataParser()
+        metadata_parser.feed(page)
+
+        # Change of base URL due to <base href="..." /> tag
+        response_url = metadata_parser.base_url or response_url
 
         fragments = set()
-        while include_fragment_parser.links:
-            raw_link = include_fragment_parser.links.pop()
+        while metadata_parser.fragments:
+            raw_link = metadata_parser.fragments.pop()
             abs_link = url_util.join(response_url, raw_link.strip(), resolve_href=True)
 
             try:

share/spack/bootstrap/github-actions-v0.3/clingo.json

@@ -1,268 +0,0 @@
-{
-  "verified": [
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "i5rx6vbyw7cyg3snajcpnuozo7l3lcab",
-          "c55d1c76adb82ac9fbe67725641ef7e4fe1ae11e2e8da0dc93a3efe362549127"
-        ]
-      ],
-      "python": "python@3.10",
-      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "xoxkdgo3n332ewhbh7pz2zuevrjxkrke",
-          "b50e2fba026e85af3f99b3c412b4f0c88ec2fbce15b48eeb75072f1d3737f3cc"
-        ]
-      ],
-      "python": "python@3.5",
-      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "sgmirxbu3bpn4rdpfs6jlyycfrkfxl5i",
-          "b0a574df6f5d59491a685a31a8ed99fb345c850a91df62ef232fbe0cca716ed1"
-        ]
-      ],
-      "python": "python@3.6",
-      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "5hn7hszlizeqq3leqi6lrdmyy5ssv6zs",
-          "36e24bc3bd27b125fdeb30d51d2554e44288877c0ce6df5a878bb4e8a1d5847a"
-        ]
-      ],
-      "python": "python@3.7",
-      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "qk3ecxakadq4naakng6mhdfkwauef3dn",
-          "9d974c0d2b546d18f0ec35e08d5ba114bf2867f7ff7c7ea990b79d019ece6380"
-        ]
-      ],
-      "python": "python@3.8",
-      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "2omdsvzshkn2u3l5vwvwoey4es5cowfu",
-          "cbf72eb932ac847f87b1640f8e70e26f5261967288f7d6db19206ef352e36a88"
-        ]
-      ],
-      "python": "python@3.9",
-      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "ifgzrctoh2ibrmitp6ushrvrnaeqtkr7",
-          "1c609df7351286fe09aa3452fa7ed7fedf903e9fa12cde89b916a0fc4c022949"
-        ]
-      ],
-      "python": "python@3.10",
-      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "esfzjhodgh5be22hvh3trg2ojzrmhzwt",
-          "8d070cdb2a5103cde3e6f873b1eb11d25f60464f3059d8643f943e5c9a9ec76c"
-        ]
-      ],
-      "python": "python@3.6",
-      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "5b4uhkhrvtvdmsnctjx2isrxciy6v2o2",
-          "336b8b1202a8a28a0e34a98e5780ae0e2b2370b342ce67434551009b1a7c8db9"
-        ]
-      ],
-      "python": "python@3.7",
-      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "czapgrrey6llnsu2m4qaamv3so2lybxm",
-          "16bdfe4b08ee8da38f3e2c7d5cc44a38d87696cc2b6de0971a4de25efb8ad8e4"
-        ]
-      ],
-      "python": "python@3.8",
-      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "7za6vsetahbghs4d2qe4ajtf2iyiacwx",
-          "730ae7e6096ec8b83a0fc9464dda62bd6c2fec1f8565bb291f4d1ffe7746703b"
-        ]
-      ],
-      "python": "python@3.9",
-      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "zulnxrmchldtasffqw6qacmgg4y2qumj",
-          "8988325db53c0c650f64372c21571ac85e9ba4577975d14ae7dba8ab7728b5fc"
-        ]
-      ],
-      "python": "python@3.10",
-      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "lx54ebqzwtjpfgch7kagoxkmul56z7fa",
-          "81d64229299e76f9dc81f88d286bc94725e7cbcbb29ad0d66aaeaff73dd6473a"
-        ]
-      ],
-      "python": "python@3.6",
-      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "isu2rjoicl4xzmbl3k2c4bg35gvejkgz",
-          "fcc4b052832cfd327d11f657c2b7715d981b0894ed03bbce18b23a842c7d706d"
-        ]
-      ],
-      "python": "python@3.7",
-      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "ob3k3g2wjy7cw33lfobjar44sqmojyth",
-          "f51fd6256bfd3afc8470614d87df61e5c9dd582fcc70f707ca66ba2b7255da12"
-        ]
-      ],
-      "python": "python@3.8",
-      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "norpsmparkl5dfuzdqj4537o77vjbgsl",
-          "477c041857b60f29ff9d6c7d2982b7eb49a2e02ebbc98af11488c32e2fb24081"
-        ]
-      ],
-      "python": "python@3.9",
-      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "gypv5loj2ml73duq6sr76yg5rj25te2m",
-          "c855d7d32aadec37c41e51f19b83558b32bc0b946a9565dba0e659c6820bd6c3"
-        ]
-      ],
-      "python": "python@2.7+ucs4",
-      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "rjopyx7hum3hqhgsdyw3st7frdfgrv3p",
-          "0e555f9bc99b4e4152939b30b2257f4f353941d152659e716bf6123c0ce11a60"
-        ]
-      ],
-      "python": "python@2.7~ucs4",
-      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "2l45t4kw3cqqwj6vbxhfwhzlo6b3q2p4",
-          "6cb90de5a3d123b7408cfef693a9a78bb69c66abbfed746c1e85aa0acb848d03"
-        ]
-      ],
-      "python": "python@3.10",
-      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "4psiezojm7dexequtbnav77wvgcajigq",
-          "b3fc33b5482357613294becb54968bd74de638abeae69e27c6c4319046a7e352"
-        ]
-      ],
-      "python": "python@3.5",
-      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "dzhvhynye4z7oalowdcy5zt25lej3m2n",
-          "61c5f3e80bcc7acfc65e335f1910762df2cc5ded9d7e1e5977380a24de553dd7"
-        ]
-      ],
-      "python": "python@3.6",
-      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "dtwevigmwgke4g6ee5byktpmzmrp2kvx",
-          "636937244b58611ec2eedb4422a1076fcaf09f3998593befb5a6ff1a74e1d5f7"
-        ]
-      ],
-      "python": "python@3.7",
-      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "shqedxgvjnhiwdcdrvjhbd73jaevv7wt",
-          "b3615b2a94a8a15fddaa74cf4d9f9b3a516467a843cdeab597f72dcf6be5e31d"
-        ]
-      ],
-      "python": "python@3.8",
-      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "clingo-bootstrap",
-          "z6v6zvc6awioeompbvo735b4flr3yuyz",
-          "1389192bd74c1f7059d95c4a41500201cbc2905cbba553678613e0b7e3b96c71"
-        ]
-      ],
-      "python": "python@3.9",
-      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
-    }
-  ]
-}

share/spack/bootstrap/github-actions-v0.3/gnupg.json

@@ -1,204 +0,0 @@
-{
-  "verified": [
-    {
-      "binaries": [
-        [
-          "libiconv",
-          "d6dhoguolmllbzy2h6pnvjm3tti6uy6f",
-          "7fe765a87945991d4e57782ed67c4bf42a10f95582eecd6f57de80a545bde821"
-        ],
-        [
-          "npth",
-          "x6fb7zx6n7mos5knvi6wlnaadd7r2szx",
-          "fd1e5a62107339f45219c32ba20b5e82aa0880c31ac86d1b245d388ca4546990"
-        ],
-        [
-          "zlib",
-          "c5wm3jilx6zsers3sfgdisjqusoza4wr",
-          "7500a717c62736872aa65df4599f797ef67b21086dd6236b4c7712cfffac9bf3"
-        ],
-        [
-          "libassuan",
-          "3qv4bprobfwes37clg764cfipdzjdbto",
-          "d85cd9d2c63a296300d4dcbd667421956df241109daef5e12d3ca63fa241cb14"
-        ],
-        [
-          "libgcrypt",
-          "3y4ubdgxvgpvhxr3bk4l5mkw4gv42n7e",
-          "9dad7c2635344957c4db68378964d3af84ea052d45dbe8ded9a6e6e47211daa8"
-        ],
-        [
-          "libgpg-error",
-          "doido34kfwsvwpj4c4jcocahjb5ltebw",
-          "20e5c238bee91d2a841f0b4bd0358ded59a0bd665d7f251fd9cd42f83e0b283b"
-        ],
-        [
-          "libksba",
-          "mttecm7gzdv544lbzcoahchnboxysrvi",
-          "1c0ae64e828a597e4cf15dd997c66cd677e41f68c63db09b9551480a197052a2"
-        ],
-        [
-          "pinentry",
-          "se7xgv7yf4ywpjnbv7voxgeuuvs77ahb",
-          "2fd13fbee7ca2361dc5dd09708c72d0489611301b60635cb0206bc5b94add884"
-        ],
-        [
-          "gnupg",
-          "yannph34bpaqkhsv5mz2icwhy3epiqxd",
-          "1de8b4e119fa3455d0170466fa0fb8e04957fab740aec32535b4667279312b3f"
-        ]
-      ],
-      "spec": "gnupg@2.3: %apple-clang platform=darwin target=x86_64"
-    },
-    {
-      "binaries": [
-        [
-          "zlib",
-          "t2hjzsyf3txkg64e4bq3nihe26rzzdws",
-          "171e720840a28af50b62141be77bc525e666cffd1fbbe2ee62673214e8b0280f"
-        ],
-        [
-          "libiconv",
-          "yjdji2wj4njz72fyrg46jlz5f5wfbhfr",
-          "94c773c3d0294cf248ec1f3e9862669dfa743fe1a76de580d9425c14c8f7dcd2"
-        ],
-        [
-          "npth",
-          "kx3vzmpysee7jxwsudarthrmyop6hzgc",
-          "f8cc6204fa449ce576d450396ec2cad40a75d5712c1381a61ed1681a54f9c79f"
-        ],
-        [
-          "libassuan",
-          "e5n5l5ftzwxs4ego5furrdbegphb6hxp",
-          "ef0428874aa81bcb9944deed88e1fc639f629fe3d522cab3c281235ae2a53db9"
-        ],
-        [
-          "libgcrypt",
-          "wyncpahrpqsmpk4b7nlhg5ekkjzyjdzs",
-          "2309548c51a17f580f036445b701feb85d2bc552b9c4404418c2f223666cfe3b"
-        ],
-        [
-          "libgpg-error",
-          "vhcdd6jkbiday2seg3rlkbzpf6jzfdx7",
-          "79dd719538d9223d6287c0bba07b981944ab6d3ab11e5060274f1b7c727daf55"
-        ],
-        [
-          "libksba",
-          "azcgpgncynoox3dce45hkz46bp2tb5rr",
-          "15d301f201a5162234261fcfccd579b0ff484131444a0b6f5c0006224bb155d6"
-        ],
-        [
-          "pinentry",
-          "e3z5ekbv4jlsie4qooubcfvsk2sb6t7l",
-          "5fd27b8e47934b06554e84f1374a90a93e71e60a14dbde672a8da414b27b97f4"
-        ],
-        [
-          "gnupg",
-          "i5agfvsmzdokuooaqhlh6vro5giwei2t",
-          "f1bde7a1f0c84c1bbcde5757a96cf7a3e9157c2cfa9907fde799aa8e04c0d51f"
-        ]
-      ],
-      "spec": "gnupg@2.3: %gcc platform=linux target=aarch64"
-    },
-    {
-      "binaries": [
-        [
-          "zlib",
-          "v5rr6ba37tudzfuv2jszwikgcl4wd3cd",
-          "371ad4b277af7b97c7871b9931f2764c97362620c7990c5ad8fdb5c42a1d30dc"
-        ],
-        [
-          "libiconv",
-          "bvcnx2e4bumjcgya4dczdhjb3fhqyass",
-          "65a00b717b3a4ee1b5ab9f84163722bdfea8eb20a2eecc9cf657c0eaac0227e9"
-        ],
-        [
-          "npth",
-          "dkb6ez6a4c3iyrv67llwf5mzmynqdmtj",
-          "4d77351661d0e0130b1c89fb6c6a944aee41d701ef80d056d3fc0178a7f36075"
-        ],
-        [
-          "libassuan",
-          "tuydcxdbb5jfvw3gri7y24b233kgotgd",
-          "d8775e7c1dd252437c6fa0781675b1d2202cfc0c8190e60d248928b6fca8bc9f"
-        ],
-        [
-          "libgcrypt",
-          "kgxmg4eukwx6nn3bdera3j7cf7hxfy6n",
-          "6046523f10ed54be50b0211c27191b3422886984fc0c00aed1a85d1f121c42e6"
-        ],
-        [
-          "libgpg-error",
-          "ewhrwnltlrzkpqyix2vbkf4ruq6b6ea3",
-          "3f3bbbf1a3cb82d39313e39bcbe3dad94a176130fc0e9a8045417d6223fb4f31"
-        ],
-        [
-          "libksba",
-          "onxt5ry2fotgwiognwmhxlgnekuvtviq",
-          "3a4df13f8b880441d1df4b234a4ca01de7601d84a6627185c2b3191a34445d40"
-        ],
-        [
-          "pinentry",
-          "fm3m4rsszzxxakcpssd34jbbe4ihrhac",
-          "73afa46176a7ec8f02d01a2caad3e400dc18c3c8a53f92b88a9aa9e3653db3e6"
-        ],
-        [
-          "gnupg",
-          "gwr65ovh4wbxjgniaoqlbt3yla6rdikj",
-          "7a3f7afe69ca67797a339c04028ca45a9630933020b57cb56e28453197fe8a57"
-        ]
-      ],
-      "spec": "gnupg@2.3: %gcc platform=linux target=ppc64le"
-    },
-    {
-      "binaries": [
-        [
-          "libiconv",
-          "vec3ac6t4ag3lb7ycvisafthqmpci74b",
-          "35d184218e525d8aaea60082fd2d0f1e80449ec32746cceda2ea0ca106e9a095"
-        ],
-        [
-          "npth",
-          "jx3kmy3ilc66rgg5mqtbed5z6qwt3vrd",
-          "74c2c1b087667661da3e24ac83bcecf1bc2d10d69e7678d1fd232875fe295135"
-        ],
-        [
-          "zlib",
-          "wnpbp4pu7xca24goggcy773d2y4pobbd",
-          "bcbd5310e8c5e75cbf33d8155448b212486dc543469d6df7e56dcecb6112ee88"
-        ],
-        [
-          "libassuan",
-          "ynn33wutdtoo2lbjjoizgslintxst2zl",
-          "ac3b060690c6da0c64dcf35da047b84cc81793118fb9ff29b993f3fb9efdc258"
-        ],
-        [
-          "libgcrypt",
-          "zzofcjer43vsxwj27c3rxapjxhsz4hlx",
-          "4b1977d815f657c2d6af540ea4b4ce80838cadcf4ada72a8ba142a7441e571ea"
-        ],
-        [
-          "libgpg-error",
-          "gzr2ucybgks5jquvf4lv7iprxq5vx5le",
-          "a12ecb5cfd083a29d042fd309ebb5ab8fd4ace0b68b27f89b857e9a84d75b5be"
-        ],
-        [
-          "libksba",
-          "hw4u4pam6mp3henpw476axtqaahfdy64",
-          "5424caf98a2d48e0ed0b9134353c242328ebeef6d2b31808d58969165e809b47"
-        ],
-        [
-          "pinentry",
-          "hffsjitsewdgoijwgzvub6vpjwm33ywr",
-          "8ed7504b5b2d13ab7e1f4a0e27a882c33c5a6ebfcb43c51269333c0d6d5e1448"
-        ],
-        [
-          "gnupg",
-          "lge4h2kjgvssyspnvutq6t3q2xual5oc",
-          "6080ce00fcc24185e4051a30f6d52982f86f46eee6d8a2dc4d83ab08d8195be8"
-        ]
-      ],
-      "spec": "gnupg@2.3: %gcc platform=linux target=x86_64"
-    }
-  ]
-}

share/spack/bootstrap/github-actions-v0.5/clingo.json

@@ -0,0 +1,389 @@
+{
+  "verified": [
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "riu2vekwzrloc3fktlf6v7kwv6fja7lp",
+          "7527bc4d2d75671162fe0db3de04c5d3e1e6ab7991dfd85442c302c698febb45"
+        ]
+      ],
+      "python": "python@3.10.13",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "sgf6pgn4ihfcbxutxhevp36n3orfpdkw",
+          "958531adcb449094bca7703f8f08d0f55a18f9a4c0f10a175ae4190d20982891"
+        ]
+      ],
+      "python": "python@3.11.5",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "ie4wlhhnb4snroymbnjksajwvoid6omx",
+          "4af14c3375a211ead3d2b4a31b59683744adcb79b820cc0c6b168ab162a7d983"
+        ]
+      ],
+      "python": "python@3.12.0",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "5ke32podcipzxxwrj6uzm324bxegbwca",
+          "a4106c42ee68d07c3d954ab73fe305ca4204f44d90b58fd91a8f784d9b96e7e3"
+        ]
+      ],
+      "python": "python@3.6",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "scu4cnnf5axmjgozqc7cccpqnj5nc5tj",
+          "54de4ca141b92222c8f1729e9e336c8a71dad9efa641e76438fcfb79bb58fc7f"
+        ]
+      ],
+      "python": "python@3.7.17",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "ajbswc25irhmhbc4qibdcr6ohsvpcdku",
+          "8b9e7af163a4259256eca4b4a1a92b5d95463a5cf467be2a11c64ab536ca5b04"
+        ]
+      ],
+      "python": "python@3.8.18",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "vwkuxa5z4pj7vviwsmrpw2r6kbbqej2p",
+          "a3f10024ff859e15b79ccd06c970a5f0e6ba11b0eae423f096ec9a35863816d2"
+        ]
+      ],
+      "python": "python@3.9.18",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "attdjmyzpfnhoobadw55pgg4hwkyp7zk",
+          "f3258af3a648b47f12285dd3f048b685ed652b2b55b53861ac9913926de0f1c3"
+        ]
+      ],
+      "python": "python@3.10",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "w4vnbsxjgkhsmgwozudzcsqlvccjsec4",
+          "19322c2c951fc80234963ac068c78442df57ac63055325b24a39ab705d27a5b9"
+        ]
+      ],
+      "python": "python@3.11",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "dw7ez2xcx6e5dxo3n4jin7pdbo3ihwtw",
+          "c368edda4b3c8fd767f5f0f098ea416864b088c767dc43135df49cf5f6ef4c93"
+        ]
+      ],
+      "python": "python@3.12",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "audrlxaw3ny3kyjkf6kqywumhokcxh3p",
+          "db2f44966ec104ffe57c0911f0b1e0d3d052753f4c46c30c0890dfb26d547b09"
+        ]
+      ],
+      "python": "python@3.6",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "al7brxvvvhih5nlxvtfkavufqc3pe5t2",
+          "4e09b6d50d42c898e075fd20f7c7eddf91cb80edfd2d1326d26fd779e4d1ffed"
+        ]
+      ],
+      "python": "python@3.7",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "v3ctpkyogl542wjibng6m2h2426spjbb",
+          "d9ceb4f9ca23ef1dcc33872e5410ccfef6ea0360247d3e8faedf1751fb1ae4ca"
+        ]
+      ],
+      "python": "python@3.8",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "zxo5ih5ac6r7lj6miwyx36ot7s6a4dcw",
+          "f8f5e124d0e7bada34ff687a05e80b2fe207ce4d26205dab09b144edb148f05e"
+        ]
+      ],
+      "python": "python@3.9",
+      "spec": "clingo-bootstrap%apple-clang platform=darwin target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "wki4qcy3wzpoxav3auxt2u7yb4sk3xcc",
+          "f5b9251eb51c60a71f7a0359c252f48c1a1121c426e1e6f9181808c626cb5fef"
+        ]
+      ],
+      "python": "python@3.10.13",
+      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "gun6hbksmsecau5wjyrmxodq4hxievzx",
+          "28839ec43db444d6725bde3fcff99adadf61a392d967041fb16f0ffc0afa2f9d"
+        ]
+      ],
+      "python": "python@3.11.5",
+      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "er73owosuqfmmkxvuw3f7sqnvvj6s4xp",
+          "99264d48c290256bf16e202c155bf3f8c88fdbbe9894d901344d0db7258abce3"
+        ]
+      ],
+      "python": "python@3.12.0",
+      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "kv6l7qttuzk7zxkxi5fhff52qso3pj7m",
+          "59aa052e89d3c698fdd35e30ac21a896c8e49bbcc2f589a8f777bd5dafff2af7"
+        ]
+      ],
+      "python": "python@3.6",
+      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "uw5o2z753otspa3lmmy2bdodh5munkir",
+          "7a8b6359ce83463541ff68c221296fe9875adf28ea2b2c1416229750cf4935d2"
+        ]
+      ],
+      "python": "python@3.7.17",
+      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "d63pp2l453bfygh6q7afwdj5mw7lhsns",
+          "425bef3a8605732b2fbe74cdd77ef6a359cbdb62800490bbd05620a57da35b0c"
+        ]
+      ],
+      "python": "python@3.8.18",
+      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "nap44jiznzwlma6n75uxbpznppazs7av",
+          "316d940ca9af8c6b3bc50f8fdaadba02b0e955c4f24345a63a1a6715b01a752c"
+        ]
+      ],
+      "python": "python@3.9.18",
+      "spec": "clingo-bootstrap%gcc platform=linux target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "qhvnw4yowmk2tofg3u7a4uomisktgzw5",
+          "d30ec81385377521dd2d1ac091546cc2dec6a852ad31f35c24c65919f94fbf64"
+        ]
+      ],
+      "python": "python@3.10.13",
+      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "b3y37ryfuhjq6ljbkq7piglsafg5stgw",
+          "3c2f9cca3a6d37685fdf7d7dffb7a0505336c32562715069004631c446e46a7c"
+        ]
+      ],
+      "python": "python@3.11.5",
+      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "dbloojtq5kcfd3pjmj4pislgpzrcvjpn",
+          "f8aeba80e6c106b769adba164702db94e077255fe1a22d6d265ccc3172b4ab1a"
+        ]
+      ],
+      "python": "python@3.12.0",
+      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "gtlngzdb7iggcjmaottob54qi3b24blt",
+          "3efc534ba293ee51156971b8c19a597ebcb237b003c98e3c215a49a88064dfd1"
+        ]
+      ],
+      "python": "python@3.6",
+      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "4ab4wobwa7bvhlkrmhdp2dwgtcq5rpzo",
+          "3dc6539a989701ec1d83d644a79953af912c11fe6046a8d720970faf8e477991"
+        ]
+      ],
+      "python": "python@3.7.17",
+      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "fgout3h4mt4i64xaovqrpcsdy3ly2aml",
+          "ade67f0623e941b16f2dd531270b4863de8befd56a9a47bd87af85345bc8bed6"
+        ]
+      ],
+      "python": "python@3.8.18",
+      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "5fv2q4agg4b4g53f4zhnymrbv6ogiwpy",
+          "18047d48538a770f014cce73756258c1a320d4ac143abef3c5d8bc09dd7a03cc"
+        ]
+      ],
+      "python": "python@3.9.18",
+      "spec": "clingo-bootstrap%gcc platform=linux target=ppc64le"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "smkmkb5xqz4v2f7tl22g4e2ghamglox5",
+          "a850c80c7a48dab506f807cc936b9e54e6f5640fe96543ff58281c046140f112"
+        ]
+      ],
+      "python": "python@3.10.13",
+      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "55qeu52pkt5shpwd7ulugv7wzt5j7vqd",
+          "e5e1a10b3b2d543b1555f5caef9ac1a9ccdcddb36a1278d3bf68bf0e9f490626"
+        ]
+      ],
+      "python": "python@3.11.5",
+      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "zcw5ieomfwwpzpzpabetix2plfqzpvwd",
+          "ed409165109488d13afe8ef12edd3b373ed08967903dc802889523b5d3bccd14"
+        ]
+      ],
+      "python": "python@3.12.0",
+      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "t4yf34cuvquqp5xd66zybmcfyhwbdlsf",
+          "b14e26e86bcfdac98b3a55109996265683f32910d3452e034ddc0d328bf62d67"
+        ]
+      ],
+      "python": "python@3.6",
+      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "grkrpj76lxsxa753uzndwfmrj3pwvyhp",
+          "11a535d4a8a9dbb18c2f995e10bc90b27b6ebc61f7ac2090f15db9b4f9be1a64"
+        ]
+      ],
+      "python": "python@3.7.17",
+      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "zowwoarrf3hvo6i3iereolfujr42iyro",
+          "154d3a725f02c1775644d99a0b74f9e2cdf6736989a264ccfd5d9a8bce77a16b"
+        ]
+      ],
+      "python": "python@3.8.18",
+      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "clingo-bootstrap",
+          "bhqgwuvef354fwuxq7heeighavunpber",
+          "399dec8cb6b8cd1b03737e68ea32e6ed69030b57e5f05d983e8856024143ea78"
+        ]
+      ],
+      "python": "python@3.9.18",
+      "spec": "clingo-bootstrap%gcc platform=linux target=x86_64"
+    }
+  ]
+}

share/spack/bootstrap/github-actions-v0.5/gnupg.json

@@ -0,0 +1,254 @@
+{
+  "verified": [
+    {
+      "binaries": [
+        [
+          "libgpg-error",
+          "stcmj3wdfxrohn2a53ecvsfsxe7rzrn4",
+          "942b0f0918798f0a5f007de0f104d71273e6988165c7a34a874e0846b1aa8977"
+        ],
+        [
+          "libassuan",
+          "z27suzptvelnavipmldx6dcntiwqmguq",
+          "c703d6b534e89e383893913fb3b71b47322726c5e19f69178e4d1a3a42a76426"
+        ],
+        [
+          "libgcrypt",
+          "if4uocx75kk6nc5vwvvuxq4dvaoljxkm",
+          "a2320f8cfc8201d15c0e9e244b824ce3d76542c148f4f0631648987957759f07"
+        ],
+        [
+          "libiconv",
+          "nccvt7adwkq5anilrjspffdzl4hggon5",
+          "e23aa0184eb6661331bc850292fa22579005fd8ed62efd4c0c7a87489d8acaf6"
+        ],
+        [
+          "libksba",
+          "lbfaarmpo2tupbezmqhfjvyspvwepv4r",
+          "96888ed37642a2425e2262a5904b82a38f9eecfb18a900493e32d4ab742f994b"
+        ],
+        [
+          "npth",
+          "yc7h5c7cp7mupstvh5wlujp3xqet3xxq",
+          "3ac8e284878c5a556e38aab706e4303daf0a4d2bbb9fac2644495f8a362f9988"
+        ],
+        [
+          "pinentry",
+          "rlo36pidutbjxxc3atooiwruaptfwmml",
+          "70114fe6c9e8723daa960f1a3dc36ed8b5a6c6f9cc828d43f79b8f59f7363605"
+        ],
+        [
+          "zlib-ng",
+          "hewnrm76ju4qcjaezxole5htrulkij25",
+          "7babbe4d3d6e58631a944472356c07f0f4ad4a0759eaeefcf8584f33cce51ca6"
+        ],
+        [
+          "gnupg",
+          "5cguax2vflgy2cwmt2ikvixtynommlmr",
+          "23fdd223493f441fa2e5f82d7e02837ecfad831fbfa4c27c175b3e294ed977d1"
+        ]
+      ],
+      "spec": "gnupg@2.3: %apple-clang platform=darwin target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "libgpg-error",
+          "7yjoei55i6wxycmzbopyrw7nrquc22ac",
+          "c29cfe32521a4a1e2108c711233964c27ca74ffc7505eea86cb8c047ace5715b"
+        ],
+        [
+          "libassuan",
+          "b4pkkugfhdtitffvlh4o3dexmthr6rmk",
+          "27ee6fc272f011f9ad4f000dc54961cccd67b34d6f24f316ca7faf26673bf98b"
+        ],
+        [
+          "libgcrypt",
+          "uqjmpmpeta3w7c66m4e5jojopngpibvp",
+          "d73fbb6e9327faec75af450d602b663ed6bb65ac9657bd795034a53f6acd32c8"
+        ],
+        [
+          "libiconv",
+          "rfsiwcq6tlw6to42a3uxw7wcmcyk5m6r",
+          "1f0176395130ed8b919538fa4b1cbda9f0ff8b836e51097258efc8cf5e11f753"
+        ],
+        [
+          "libksba",
+          "gsobopcvr2p7d7rpgrbk2ulrnhvrpt6u",
+          "0e404a8353f91918f385db8cf661f53f91ffd805798fcd83fb1168a1f1758fe8"
+        ],
+        [
+          "npth",
+          "gib2edyujm2oymkvu2hllm2yeghttvn3",
+          "e04e579e514cd965baf71b7f160b063bff8b116e991e6931c6919cd5f3270e59"
+        ],
+        [
+          "pinentry",
+          "5ndbckveeaywx77rqmujglfnqwpxu3t6",
+          "0ec02dca08ad2e8b3dd1c71195ed3fe3bb8856b746726708f5e5d450619e1285"
+        ],
+        [
+          "zlib-ng",
+          "fg366ys6nx3hthuiix4xooi6xx4qe5d2",
+          "cc372a21608885182233c7800355c7c0bbaff47ea16e190827a9618b0c4703e2"
+        ],
+        [
+          "gnupg",
+          "2x5ftl46zcnxk6knz5y3nuhyn7zcttk3",
+          "b9481e122e2cb26f69b70505830d0fcc0d200aadbb6c6572339825f17ad1e52d"
+        ]
+      ],
+      "spec": "gnupg@2.3: %apple-clang platform=darwin target=x86_64"
+    },
+    {
+      "binaries": [
+        [
+          "libgpg-error",
+          "b7o5zrguyniw5362eey3peglzhlmig7l",
+          "b4373f2b0a2567b3b87e6bfc934135ce7790432aea58c802139bb5352f24b6a9"
+        ],
+        [
+          "libassuan",
+          "6k2arop3mjwfhe4cwga6a775ud5m4scp",
+          "1e5143d35b0938a206ecf1ecb39b77e732629897d2b936cb8274239770055d90"
+        ],
+        [
+          "libgcrypt",
+          "eh5h3zisjkupzr2pgqarvgs2fm7pun5r",
+          "b57eff265b48d0472243babfd1221c7c16189a4e324ea26e65d1a0a8c1391020"
+        ],
+        [
+          "libiconv",
+          "vgk2zgjeflpnksj3lywuwdzs2nez63qv",
+          "d153953c40c630fd2bf271f3de901d7671f80e8161cf746cb54afbf28d934d03"
+        ],
+        [
+          "libksba",
+          "au3xdl4oyfbxat6dknp3mldid7gupgt5",
+          "f1b1a1a02138109bc41b0b2ba54e689b43f35e2828f58b5de74280ce754fac0b"
+        ],
+        [
+          "npth",
+          "ja7cauk7yhhyj7msnprlirue7cn3jpnj",
+          "cf6fd998a8f92ce1cf34c63db09c77b1891bf8f5915deef03c0cae5492bd691b"
+        ],
+        [
+          "pinentry",
+          "6yo4flozla2tvw3ojkh2atvnfxuqx6ym",
+          "e78826a269109b3d67a54b1d01ff0a93be043dddcb4f52d329770ae1f75313f3"
+        ],
+        [
+          "zlib-ng",
+          "4cgenrt3rcinueq6peyolxhegnryoeem",
+          "918a1e48f823806f1562c95569953a4658b2fbc54a2606a09bcd7e259b62f492"
+        ],
+        [
+          "gnupg",
+          "lrmigjenpqj5fy4ojcs5jy6doktiu4qz",
+          "228ccb475932f7f40a64e9d87dec045931cc57f71b1dfd4b4c3926107222d96c"
+        ]
+      ],
+      "spec": "gnupg@2.3: %gcc platform=linux target=aarch64"
+    },
+    {
+      "binaries": [
+        [
+          "libgpg-error",
+          "km6l24czfhnmlya74nu6cxwufgimyhzz",
+          "23c3b7b487b36b9b03eeebbcc484adc6c8190c1bbcaa458943847148c915c6b2"
+        ],
+        [
+          "libassuan",
+          "crkk525xdgsn2k5s4xqdaxkudz6pjqbm",
+          "ae3048a8059c0709d3efe832de1a8f82594373ba853d4bc2dfa05fb9dbfbc782"
+        ],
+        [
+          "libgcrypt",
+          "4s5lkowqilor35fscjwvtmg4wasdknkc",
+          "62d3d13278d60d0329af1a9649b06591153ff68de4584f57777d13d693c7012e"
+        ],
+        [
+          "libiconv",
+          "kbijqx45l3n64dlhenbuwgqpmf434g2d",
+          "dddf581a14a35b85cb69a8c785dd8e250f41e6de7697e34bb0ab2a942e0c2128"
+        ],
+        [
+          "libksba",
+          "jnll3rfuh6xhgqxbwfnpizammcwloxjc",
+          "6200f2b6150aaf6d0e69771dfd5621582bd99ed0024fe83e7bc777cb66cabb29"
+        ],
+        [
+          "npth",
+          "6j6b4hbkhwkb5gfigysqgn5lpu3i4kw5",
+          "0be0c70f3d9d45c4fe7490d8fdb8d7584de6324c3bfac8d884072409799c9951"
+        ],
+        [
+          "pinentry",
+          "cdpcdd4iah6jot4odehm3xmulw3t3e32",
+          "5b447c770d0f705fbc97564fccdfbb0dfff8b6f8e2b4abbea326a538bc1bff80"
+        ],
+        [
+          "zlib-ng",
+          "ogchs3i5tosoqrtsp3czp2azxvm7icig",
+          "acfa12c4e73560416e1169b37adabfbec5ee9a580a684b23e75d7591d8e39a03"
+        ],
+        [
+          "gnupg",
+          "jwpu2wrofbwylpztltmi257benj2wp6z",
+          "98e2bcb4064ec0830d896938bc1fe5264dac611da71ea546b9ca03349b752041"
+        ]
+      ],
+      "spec": "gnupg@2.3: %gcc platform=linux target=ppc64le"
+    },
+    {
+      "binaries": [
+        [
+          "libgpg-error",
+          "dwcgnnqt364enpf5554dio7kklspmrko",
+          "bfe9b506ccba0cca619133a3d2e05aa23c929749428bf6eecbff0c6985447009"
+        ],
+        [
+          "libassuan",
+          "yl5rfsfuxd6if36h7rap7zbbpbfztkpw",
+          "4343dabbeed0851885992acd7b63fd74cb9d1acc06501a8af934e7e103801a15"
+        ],
+        [
+          "libgcrypt",
+          "ka3t3dq73bkz4bs5ilyz6kymkypgbzxl",
+          "ec1bcc324e9f9d660395e2c586094431361a02196da43fce91be41cca5da9636"
+        ],
+        [
+          "libiconv",
+          "5tog27ephuzc4j6kdxavhjsjm2kd5nu6",
+          "928fab3c32a1ae09651bb8491ee3855ccaf3c57a146ee72a289a073accd3fc8f"
+        ],
+        [
+          "libksba",
+          "4ezfhjkmfc4fr34ozzl5q6b4x6jqqmsw",
+          "3045841c50c19a41beb0f32b4e8a960901397b95e82af3a73817babf35d4cfca"
+        ],
+        [
+          "npth",
+          "bn4zrugdajgpk5dssoeccbl7o2gfgmcp",
+          "ef90ef85a818456afbff709b4a0757a077d69fd3c07d1b7612e1d461d837c46f"
+        ],
+        [
+          "pinentry",
+          "cdwqocmusjomjjavnz6nn764oo54j5xj",
+          "b251047c1cb4be1bb884a7843d4419fae40fdbe5e1d36904e35f5e3fef5e4ced"
+        ],
+        [
+          "zlib-ng",
+          "ozawh46coczjwtlul27msr3swe6pl6l5",
+          "0a397b53d64ac8191a36de8b32c5ced28a4c7a6dbafe9396dd897c55bcf7a168"
+        ],
+        [
+          "gnupg",
+          "jra2dbsvpr5c5gj3ittejusa2mjh2sf5",
+          "054fac6eaad7c862ea4661461d847fb069876eb114209416b015748266f7d166"
+        ]
+      ],
+      "spec": "gnupg@2.3: %gcc platform=linux target=x86_64"
+    }
+  ]
+}

share/spack/bootstrap/github-actions-v0.5/metadata.yaml

@@ -3,6 +3,6 @@ description: |
   Buildcache generated from a public workflow using Github Actions.
   The sha256 checksum of binaries is checked before installation.
 info:
-  url: https://mirror.spack.io/bootstrap/github-actions/v0.3
+  url: https://mirror.spack.io/bootstrap/github-actions/v0.5
   homepage: https://github.com/spack/spack-bootstrap-mirrors
   releases: https://github.com/spack/spack-bootstrap-mirrors/releases

share/spack/bootstrap/github-actions-v0.5/patchelf.json

@@ -4,8 +4,8 @@
       "binaries": [
         [
           "patchelf",
-          "cn4gsqzdnnffk7ynvbcai6wrt5ehqqrl",
-          "8c6a28cbe8133d719be27ded11159f0aa2c97ed1d0881119ae0ebd71f8ccc755"
+          "4txke6ixd2zg2yzg33l3fqnjyassono7",
+          "102800775f789cc293e244899f39a22f0b7a19373305ef0497ca3189223123f3"
         ]
       ],
       "spec": "patchelf@0.13: %gcc platform=linux target=aarch64"
@@ -14,8 +14,8 @@
       "binaries": [
         [
           "patchelf",
-          "mgq6n2heyvcx2ebdpchkbknwwn3u63s6",
-          "1d4ea9167fb8345a178c1352e0377cc37ef2b421935cf2b48fb6fa03a94fca3d"
+          "tnbgxc22uebqsiwrhchf3nieatuqlsrr",
+          "91cf0a9d4750c04575c5ed3bcdefc4754e1cf9d1cd1bf197eb1fe20ccaa869f1"
         ]
       ],
       "spec": "patchelf@0.13: %gcc platform=linux target=ppc64le"
@@ -24,8 +24,8 @@
       "binaries": [
         [
           "patchelf",
-          "htk62k7efo2z22kh6kmhaselru7bfkuc",
-          "833df21b20eaa7999ac4c5779ae26aa90397d9027aebaa686a428589befda693"
+          "afv7arjarb7nzmlh7c5slkfxykybuqce",
+          "73f4bde46b843c96521e3f5c31ab94756491404c1ad6429c9f61dbafbbfa6470"
         ]
       ],
       "spec": "patchelf@0.13: %gcc platform=linux target=x86_64"

share/spack/gitlab/cloud_pipelines/.gitlab-ci.yml

@@ -165,6 +165,10 @@ default:
   extends: [ ".generate-base" ]
   tags: ["spack", "public", "medium", "aarch64"]
 
+.generate-neoverse_v1:
+  extends: [ ".generate-base" ]
+  tags: ["spack", "public", "medium", "aarch64", "graviton3"]
+
 .generate-deprecated:
   extends: [ ".base-job" ]
   stage: generate
@@ -301,27 +305,27 @@ e4s-build:
       job: e4s-generate
 
 ########################################
-# E4S ARM pipeline
+# E4S Neoverse V1 pipeline
 ########################################
-.e4s-arm:
-  extends: [ ".linux_aarch64" ]
+.e4s-neoverse_v1:
+  extends: [ ".linux_neoverse_v1" ]
   variables:
-    SPACK_CI_STACK_NAME: e4s-arm
+    SPACK_CI_STACK_NAME: e4s-neoverse_v1
 
-e4s-arm-generate:
-  extends: [ ".e4s-arm", ".generate-aarch64" ]
+e4s-neoverse_v1-generate:
+  extends: [ ".e4s-neoverse_v1", ".generate-neoverse_v1" ]
   image: ghcr.io/spack/ubuntu20.04-runner-arm64-gcc-11.4:2023.08.01
 
-e4s-arm-build:
-  extends: [ ".e4s-arm", ".build" ]
+e4s-neoverse_v1-build:
+  extends: [ ".e4s-neoverse_v1", ".build" ]
   trigger:
     include:
       - artifact: jobs_scratch_dir/cloud-ci-pipeline.yml
-        job: e4s-arm-generate
+        job: e4s-neoverse_v1-generate
     strategy: depend
   needs:
     - artifacts: True
-      job: e4s-arm-generate
+      job: e4s-neoverse_v1-generate
 
 ########################################
 # E4S ROCm External pipeline

share/spack/gitlab/cloud_pipelines/stacks/e4s-neoverse_v1/spack.yaml

@@ -7,7 +7,7 @@ spack:
 
   packages:
     all:
-      require: '%gcc@11.4.0 target=aarch64'
+      require: '%gcc@11.4.0 target=neoverse_v1'
       providers:
         blas: [openblas]
         mpi: [mpich]
@@ -340,7 +340,7 @@ spack:
   # - tasmanian +cuda cuda_arch=90  # tasmanian: conflicts with cuda@12
   # - upcxx +cuda cuda_arch=90      # upcxx: needs NVIDIA driver
 
-  mirrors: { "mirror": "s3://spack-binaries/develop/e4s-arm" }
+  mirrors: { "mirror": "s3://spack-binaries/develop/e4s-arm-neoverse_v1" }
 
   ci:
     pipeline-gen:
@@ -348,4 +348,4 @@ spack:
         image: "ghcr.io/spack/ubuntu20.04-runner-arm64-gcc-11.4:2023.08.01"
 
   cdash:
-    build-group: E4S ARM
+    build-group: E4S ARM Neoverse V1

share/spack/templates/container/Dockerfile

@@ -39,9 +39,6 @@ RUN find -L {{ paths.view }}/* -type f -exec readlink -f '{}' \; | \
 RUN cd {{ paths.environment }} && \
     spack env activate --sh -d . > activate.sh
 
-{% if extra_instructions.build %}
-{{ extra_instructions.build }}
-{% endif %}
 {% endblock build_stage %}
 {% endif %}
 
@@ -70,10 +67,6 @@ RUN {% if os_package_update %}{{ os_packages_final.update }} \
  && {% endif %}{{ os_packages_final.install }} {{ os_packages_final.list | join | replace('\n', ' ') }} \
  && {{ os_packages_final.clean }}
 {% endif %}
-{% if extra_instructions.final %}
-
-{{ extra_instructions.final }}
-{% endif %}
 {% endblock final_stage %}
 {% for label, value in labels.items() %}
 LABEL "{{ label }}"="{{ value }}"

share/spack/templates/container/singularity.def

@@ -39,9 +39,6 @@ EOF
     grep 'x-executable\|x-archive\|x-sharedlib' | \
     awk -F: '{print $1}' | xargs strip
 {% endif %}
-{% if extra_instructions.build %}
-{{ extra_instructions.build }}
-{% endif %}
 {% endblock build_stage %}
 {% if apps %}
 {% for application, help_text in apps.items() %}
@@ -80,9 +77,6 @@ Stage: final
 {% endif %}
   # Modify the environment without relying on sourcing shell specific files at startup
   cat {{ paths.environment }}/environment_modifications.sh >> $SINGULARITY_ENVIRONMENT
-{% if extra_instructions.final %}
-{{ extra_instructions.final }}
-{% endif %}
 {% endblock final_stage %}
 {% if runscript %}
 

var/spack/repos/builtin/packages/3proxy/package.py

@@ -24,9 +24,7 @@ class _3proxy(MakefilePackage):
     depends_on("m4", type="build")
 
     def build(self, spec, prefix):
-        make("-f", "Makefile.{0}".format(platform.system()))
+        make("-f", f"Makefile.{platform.system()}")
 
     def install(self, spec, prefix):
-        make(
-            "-f", "Makefile.{0}".format(platform.system()), "prefix={0}".format(prefix), "install"
-        )
+        make("-f", f"Makefile.{platform.system()}", f"prefix={prefix}", "install")

var/spack/repos/builtin/packages/7zip/package.py

@@ -75,8 +75,8 @@ def is_64bit(self):
     def build(self, spec, prefix):
         link_type = "1" if "static" in spec.variants["link_type"].value else "0"
         nmake_args = [
-            "PLATFORM=%s" % self.plat_arch,
-            "MY_STATIC_LINK=%s" % link_type,
+            f"PLATFORM={self.plat_arch}",
+            f"MY_STATIC_LINK={link_type}",
             "NEW_COMPILER=1",
         ]
         # 7zips makefile is configured in such as way that if this value is set

var/spack/repos/builtin/packages/abacus/package.py

@@ -65,7 +65,7 @@ def edit(self, spec, prefix):
                 spec["fftw"].prefix,
                 spec["elpa"].prefix,
                 inc_var,
-                "{0}".format(spec["elpa"].version),
+                f"{spec['elpa'].version}",
                 spec["cereal"].prefix,
             )
         )

var/spack/repos/builtin/packages/abduco/package.py

@@ -21,4 +21,4 @@ class Abduco(MakefilePackage):
     version("0.4", sha256="bda3729df116ce41f9a087188d71d934da2693ffb1ebcf33b803055eb478bcbb")
 
     def install(self, spec, prefix):
-        make("PREFIX={0}".format(prefix), "install")
+        make(f"PREFIX={prefix}", "install")

var/spack/repos/builtin/packages/acfl/package.py

@@ -185,8 +185,7 @@ def get_acfl_prefix(spec):
         )
     else:
         return join_path(
-            spec.prefix,
-            "arm-linux-compiler-{0}_{1}".format(spec.version, get_os(spec.version.string)),
+            spec.prefix, f"arm-linux-compiler-{spec.version}_{get_os(spec.version.string)}"
         )
 
 
@@ -238,7 +237,7 @@ class Acfl(Package):
     # Run the installer with the desired install directory
     def install(self, spec, prefix):
         exe = Executable(
-            "./arm-compiler-for-linux_{0}_{1}.sh".format(spec.version, get_os(spec.version.string))
+            f"./arm-compiler-for-linux_{spec.version}_{get_os(spec.version.string)}.sh"
         )
         exe("--accept", "--force", "--install-to", prefix)
 

var/spack/repos/builtin/packages/acts/package.py

@@ -336,15 +336,15 @@ def cmake_args(self):
 
         def cmake_variant(cmake_label, spack_variant):
             enabled = spec.satisfies("+" + spack_variant)
-            return "-DACTS_BUILD_{0}={1}".format(cmake_label, enabled)
+            return f"-DACTS_BUILD_{cmake_label}={enabled}"
 
         def enable_cmake_variant(cmake_label, spack_variant):
             enabled = spec.satisfies(spack_variant)
-            return "-DACTS_ENABLE_{0}={1}".format(cmake_label, enabled)
+            return f"-DACTS_ENABLE_{cmake_label}={enabled}"
 
         def example_cmake_variant(cmake_label, spack_variant, type="BUILD"):
             enabled = spec.satisfies("+examples +" + spack_variant)
-            return "-DACTS_{0}_EXAMPLES_{1}={2}".format(type, cmake_label, enabled)
+            return f"-DACTS_{type}_EXAMPLES_{cmake_label}={enabled}"
 
         def plugin_label(plugin_name):
             if spec.satisfies("@0.33:"):
@@ -400,7 +400,7 @@ def plugin_cmake_variant(plugin_name, spack_variant):
         ]
 
         log_failure_threshold = spec.variants["log_failure_threshold"].value
-        args.append("-DACTS_LOG_FAILURE_THRESHOLD={0}".format(log_failure_threshold))
+        args.append(f"-DACTS_LOG_FAILURE_THRESHOLD={log_failure_threshold}")
         if spec.satisfies("@19.4.0:"):
             args.append("-DACTS_ENABLE_LOG_FAILURE_THRESHOLD=ON")
 
@@ -431,11 +431,11 @@ def plugin_cmake_variant(plugin_name, spack_variant):
         if "+cuda" in spec:
             cuda_arch = spec.variants["cuda_arch"].value
             if cuda_arch != "none":
-                args.append("-DCUDA_FLAGS=-arch=sm_{0}".format(cuda_arch[0]))
+                args.append(f"-DCUDA_FLAGS=-arch=sm_{cuda_arch[0]}")
 
         if "+python" in spec:
             python = spec["python"].command.path
-            args.append("-DPython_EXECUTABLE={0}".format(python))
+            args.append(f"-DPython_EXECUTABLE={python}")
 
         args.append(self.define_from_variant("CMAKE_CXX_STANDARD", "cxxstd"))
 

var/spack/repos/builtin/packages/adiak/package.py

@@ -36,8 +36,8 @@ class Adiak(CMakePackage):
     def cmake_args(self):
         args = []
         if self.spec.satisfies("+mpi"):
-            args.append("-DMPI_CXX_COMPILER=%s" % self.spec["mpi"].mpicxx)
-            args.append("-DMPI_C_COMPILER=%s" % self.spec["mpi"].mpicc)
+            args.append(f"-DMPI_CXX_COMPILER={self.spec['mpi'].mpicxx}")
+            args.append(f"-DMPI_C_COMPILER={self.spec['mpi'].mpicc}")
             args.append("-DENABLE_MPI=ON")
         else:
             args.append("-DENABLE_MPI=OFF")

var/spack/repos/builtin/packages/adios/package.py

@@ -119,7 +119,7 @@ def validate(self, spec):
 
     def with_or_without_hdf5(self, activated):
         if activated:
-            return "--with-phdf5={0}".format(self.spec["hdf5"].prefix)
+            return f"--with-phdf5={self.spec['hdf5'].prefix}"
 
         return "--without-phdf5"
 
@@ -134,7 +134,7 @@ def configure_args(self):
 
         extra_args = [
             # required, otherwise building its python bindings will fail
-            "CFLAGS={0}".format(self.compiler.cc_pic_flag)
+            f"CFLAGS={self.compiler.cc_pic_flag}"
         ]
 
         extra_args += self.enable_or_disable("shared")
@@ -148,7 +148,7 @@ def configure_args(self):
         extra_args += self.with_or_without("infiniband")
 
         if "+zlib" in spec:
-            extra_args.append("--with-zlib={0}".format(spec["zlib-api"].prefix))
+            extra_args.append(f"--with-zlib={spec['zlib-api'].prefix}")
         else:
             extra_args.append("--without-zlib")
 

var/spack/repos/builtin/packages/adios2/package.py

@@ -109,19 +109,19 @@ class Adios2(CMakePackage, CudaPackage):
     depends_on("cmake@3.12.0:", type="build")
 
     for _platform in ["linux", "darwin", "cray"]:
-        depends_on("pkgconfig", type="build", when="platform=%s" % _platform)
+        depends_on("pkgconfig", type="build", when=f"platform={_platform}")
         variant(
             "pic",
             default=False,
             description="Build pic-enabled static libraries",
-            when="platform=%s" % _platform,
+            when=f"platform={_platform}",
         )
         # libffi and libfabric and not currently supported on Windows
         # see Paraview's superbuild handling of libfabric at
         # https://gitlab.kitware.com/paraview/paraview-superbuild/-/blob/master/projects/adios2.cmake#L3
-        depends_on("libffi", when="+sst platform=%s" % _platform)  # optional in DILL
+        depends_on("libffi", when=f"+sst platform={_platform}")  # optional in DILL
         depends_on(
-            "libfabric@1.6.0:", when="+sst platform=%s" % _platform
+            "libfabric@1.6.0:", when=f"+sst platform={_platform}"
         )  # optional in EVPath and SST
         # depends_on('bison', when='+sst')     # optional in FFS, broken package
         # depends_on('flex', when='+sst')      # optional in FFS, depends on BISON
@@ -241,8 +241,8 @@ def cmake_args(self):
             args.extend(["-DCMAKE_Fortran_SUBMODULE_EXT=.smod", "-DCMAKE_Fortran_SUBMODULE_SEP=."])
 
         if "+python" in spec or self.run_tests:
-            args.append("-DPYTHON_EXECUTABLE:FILEPATH=%s" % spec["python"].command.path)
-            args.append("-DPython_EXECUTABLE:FILEPATH=%s" % spec["python"].command.path)
+            args.append(f"-DPYTHON_EXECUTABLE:FILEPATH={spec['python'].command.path}")
+            args.append(f"-DPython_EXECUTABLE:FILEPATH={spec['python'].command.path}")
 
         return args
 

var/spack/repos/builtin/packages/adol-c/package.py

@@ -83,12 +83,12 @@ def configure_args(self):
         configure_args = []
 
         if "+boost" in spec:
-            configure_args.append("--with-boost={0}".format(spec["boost"].prefix))
+            configure_args.append(f"--with-boost={spec['boost'].prefix}")
         else:
             configure_args.append("--with-boost=no")
 
         if "+openmp" in spec:
-            configure_args.append("--with-openmp-flag={0}".format(self.compiler.openmp_flag))
+            configure_args.append(f"--with-openmp-flag={self.compiler.openmp_flag}")
 
         configure_args.extend(
             self.enable_or_disable("advanced-branching", variant="advanced_branching")

var/spack/repos/builtin/packages/apr-util/package.py

@@ -32,6 +32,7 @@ class AprUtil(AutotoolsPackage):
     depends_on("postgresql", when="+pgsql")
     depends_on("sqlite", when="+sqlite")
     depends_on("unixodbc", when="+odbc")
+    depends_on("pkg-config", type="build", when="+crypto ^openssl~shared")
 
     @property
     def libs(self):
@@ -85,6 +86,13 @@ def configure_args(self):
         else:
             args.append("--without-odbc")
 
+        if spec.satisfies("+crypto ^openssl~shared"):
+            # Need pkg-config to get zlib and -ldl flags
+            # (see https://dev.apr.apache.narkive.com/pNnO9F1S/configure-bug-openssl)
+            pkgconf = which("pkg-config")
+            ssl_libs = pkgconf("--libs", "--static", "openssl", output=str)
+            args.append(f"LIBS={ssl_libs}")
+
         return args
 
     def check(self):

var/spack/repos/builtin/packages/botan/package.py

@@ -14,6 +14,7 @@ class Botan(MakefilePackage):
 
     maintainers("aumuell")
 
+    version("3.2.0", sha256="049c847835fcf6ef3a9e206b33de05dd38999c325e247482772a5598d9e5ece3")
     version("3.1.1", sha256="30c84fe919936a98fef5331f246c62aa2c0e4d2085b2d4511207f6a20afa3a6b")
     version("3.1.0", sha256="4e18e755a8bbc6bf96fac916fbf072ecd06740c72a72017c27162e4c0b4725fe")
     version("3.0.0", sha256="5da552e00fa1c047a90c22eb5f0247ec27e7432b68b78e10a7ce0955269ccad7")

var/spack/repos/builtin/packages/c-blosc2/package.py

@@ -17,9 +17,10 @@ class CBlosc2(CMakePackage):
     maintainers("ax3l", "robert-mijakovic")
 
     version("develop", branch="master")
-    # 2.10.1+ adds Blosc2 CMake CONFIG files
+    version("2.10.5", sha256="a88f94bf839c1371aab8207a6a43698ceb92c72f65d0d7fe5b6e59f24c138b4d")
     # 2.10.2+ fixes regressions with external dependencies
     version("2.10.2", sha256="069785bc14c006c7dab40ea0c620bdf3eb8752663fd55c706d145bceabc2a31d")
+    # 2.10.1+ adds Blosc2 CMake CONFIG files
     version("2.10.1", sha256="1dd65be2d76eee205c06e8812cc1360448620eee5e368b25ade4ea310654cd01")
     version("2.10.0", sha256="cb7f7c0c62af78982140ecff21a2f3ca9ce6a0a1c02e314fcdce1a98da0fe231")
     version("2.9.3", sha256="1f36b7d79d973505582b9a804803b640dcc0425af3d5e676070847ac4eb38176")
@@ -38,7 +39,7 @@ class CBlosc2(CMakePackage):
     variant("zlib", default=True, description="support for ZLIB")
     variant("zstd", default=True, description="support for ZSTD")
 
-    depends_on("cmake@2.8.10:", type="build")
+    depends_on("cmake@3.16.3:", type="build")
     depends_on("lizard", when="+lizard")
     depends_on("lz4", when="+lz4")
     depends_on("snappy", when="+snappy")

var/spack/repos/builtin/packages/cairo/package.py

@@ -39,6 +39,8 @@ class Cairo(AutotoolsPackage):
     variant("fc", default=False, description="Enable cairo's Fontconfig font backend feature")
     variant("png", default=False, description="Enable cairo's PNG functions feature")
     variant("svg", default=False, description="Enable cairo's SVN functions feature")
+    variant("shared", default=True, description="Build shared libraries")
+    variant("pic", default=True, description="Enable position-independent code (PIC)")
 
     depends_on("libx11", when="+X")
     depends_on("libxext", when="+X")
@@ -61,6 +63,7 @@ class Cairo(AutotoolsPackage):
 
     conflicts("+png", when="platform=darwin")
     conflicts("+svg", when="platform=darwin")
+    conflicts("+shared~pic")
 
     # patch from https://gitlab.freedesktop.org/cairo/cairo/issues/346
     patch("fontconfig.patch", when="@1.16.0:1.17.2")
@@ -84,6 +87,15 @@ def configure_args(self):
         args.extend(self.enable_or_disable("gobject"))
         args.extend(self.enable_or_disable("ft"))
         args.extend(self.enable_or_disable("fc"))
+        args.extend(self.enable_or_disable("shared"))
+        args.extend(self.with_or_without("pic"))
+
+        if self.spec.satisfies("+ft ^freetype~shared"):
+            pkgconf = which("pkg-config")
+            ldflags = pkgconf("--libs-only-L", "--static", "freetype2", output=str)
+            libs = pkgconf("--libs-only-l", "--static", "freetype2", output=str)
+            args.append(f"LDFLAGS={ldflags}")
+            args.append(f"LIBS={libs}")
 
         return args
 

var/spack/repos/builtin/packages/caliper/package.py

@@ -27,6 +27,7 @@ class Caliper(CMakePackage, CudaPackage, ROCmPackage):
 
     version("master", branch="master")
     version("2.10.0", sha256="14c4fb5edd5e67808d581523b4f8f05ace8549698c0e90d84b53171a77f58565")
+    version("2.9.1", sha256="4771d630de505eff9227e0ec498d0da33ae6f9c34df23cb201b56181b8759e9e")
     version("2.9.0", sha256="507ea74be64a2dfd111b292c24c4f55f459257528ba51a5242313fa50978371f")
     version("2.8.0", sha256="17807b364b5ac4b05997ead41bd173e773f9a26ff573ff2fe61e0e70eab496e4")
     version(
@@ -117,7 +118,10 @@ class Caliper(CMakePackage, CudaPackage, ROCmPackage):
     conflicts("+rocm+cuda")
 
     patch("for_aarch64.patch", when="target=aarch64:")
-    patch("sampler-service-missing-libunwind-include-dir.patch", when="@2.9.0 +libunwind +sampler")
+    patch(
+        "sampler-service-missing-libunwind-include-dir.patch",
+        when="@2.9.0:2.9.1 +libunwind +sampler",
+    )
 
     def cmake_args(self):
         spec = self.spec

var/spack/repos/builtin/packages/catch2/package.py

@@ -19,6 +19,7 @@ class Catch2(CMakePackage):
     version("develop", branch="devel")
 
     # Releases
+    version("3.4.0", sha256="122928b814b75717316c71af69bd2b43387643ba076a6ec16e7882bfb2dfacbb")
     version("3.3.2", sha256="8361907f4d9bff3ae7c1edb027f813659f793053c99b67837a0c0375f065bae2")
     version("3.3.1", sha256="d90351cdc55421f640c553cfc0875a8c834428679444e8062e9187d05b18aace")
     version("3.3.0", sha256="fe2f29a54ca775c2dd04bb97ffb79d398e6210e3caa174348b5cd3b7e4ca887d")
@@ -104,6 +105,11 @@ class Catch2(CMakePackage):
     version("1.3.5", sha256="f15730d81b4173fb860ce3561768de7d41bbefb67dc031d7d1f5ae2c07f0a472")
     version("1.3.0", sha256="245f6ee73e2fea66311afa1da59e5087ddab8b37ce64994ad88506e8af28c6ac")
 
+    variant(
+        "pic", when="@3: ~shared", default=True, description="Build with position-independent code"
+    )
+    variant("shared", when="@3:", default=False, description="Build shared library")
+
     def cmake_args(self):
         spec = self.spec
         args = []
@@ -112,6 +118,10 @@ def cmake_args(self):
             args.append("-DNO_SELFTEST={0}".format("OFF" if self.run_tests else "ON"))
         elif spec.satisfies("@2.1.1:"):
             args.append(self.define("BUILD_TESTING", self.run_tests))
+        if spec.satisfies("@3:"):
+            args.append(self.define_from_variant("CMAKE_POSITION_INDEPENDENT_CODE", "pic"))
+            args.append(self.define_from_variant("BUILD_SHARED_LIBS", "shared"))
+
         return args
 
     @when("@:1.6")

var/spack/repos/builtin/packages/clingo/package.py

@@ -42,6 +42,7 @@ class Clingo(CMakePackage):
     # See https://github.com/potassco/clingo/blob/v5.5.2/INSTALL.md
     depends_on("cmake@3.1:", type="build")
     depends_on("cmake@3.18:", type="build", when="@5.5:")
+    depends_on("py-setuptools", when="@5.6.2:", type="build")
 
     depends_on("doxygen", type="build", when="+docs")
 
@@ -68,6 +69,12 @@ class Clingo(CMakePackage):
     patch("size-t.patch", when="%msvc")
     patch("vs2022.patch", when="%msvc@19.30:")
 
+    # TODO: Simplify this after Spack 0.21 release. The old concretizer has problems with
+    # py-setuptools ^python@3.6, so we only apply the distutils -> setuptools patch for Python 3.12
+    with when("@:5.6.1 ^python@3.12:"):
+        patch("setuptools.patch")
+        depends_on("py-setuptools", type="build")
+
     def patch(self):
         # Doxygen is optional but can't be disabled with a -D, so patch
         # it out if it's really supposed to be disabled

var/spack/repos/builtin/packages/clingo/setuptools.patch

@@ -0,0 +1,14 @@
+diff --git a/cmake/python-site.py b/cmake/python-site.py
+index 1e7fc8ce..95ef827f 100644
+--- a/cmake/python-site.py
++++ b/cmake/python-site.py
+@@ -1,4 +1,7 @@
+-from distutils.sysconfig import get_python_lib, get_config_vars
++try:
++    from setuptools.sysconfig import get_python_lib, get_config_vars
++except ImportError:
++    from distutils.sysconfig import get_python_lib, get_config_vars
+ import sys
+ if sys.argv[1] == "prefix":
+     print(get_python_lib(True, False, sys.argv[2] if len(sys.argv) > 2 else None))
+

var/spack/repos/builtin/packages/cmake/package.py

@@ -27,6 +27,7 @@ class Cmake(Package):
     executables = ["^cmake[0-9]*$"]
 
     version("master", branch="master")
+    version("3.27.7", sha256="08f71a106036bf051f692760ef9558c0577c42ac39e96ba097e7662bd4158d8e")
     version("3.27.6", sha256="ef3056df528569e0e8956f6cf38806879347ac6de6a4ff7e4105dc4578732cfb")
     version("3.27.4", sha256="0a905ca8635ca81aa152e123bdde7e54cbe764fdd9a70d62af44cad8b92967af")
     version("3.27.3", sha256="66afdc0f181461b70b6fedcde9ecc4226c5cd184e7203617c83b7d8e47f49521")

var/spack/repos/builtin/packages/composable-kernel/package.py

@@ -64,9 +64,14 @@ def cmake_args(self):
         ]
         if "auto" not in self.spec.variants["amdgpu_target"]:
             args.append(self.define_from_variant("AMDGPU_TARGETS", "amdgpu_target"))
+        if self.spec.satisfies("@5.6.1:"):
+            args.append(self.define("INSTANCES_ONLY", "ON"))
         return args
 
     def build(self, spec, prefix):
         with working_dir(self.build_directory):
             # only instances is necessary to build and install
-            make("instances")
+            if self.spec.satisfies("@5.6.1:"):
+                make()
+            else:
+                make("instances")

var/spack/repos/builtin/packages/curl/package.py

@@ -26,11 +26,25 @@ class Curl(NMakePackage, AutotoolsPackage):
 
     maintainers("alecbcs")
 
-    version("8.1.2", sha256="b54974d32fd610acace92e3df1f643144015ac65847f0a041fdc17db6f43f243")
-    version("8.0.1", sha256="9b6b1e96b748d04b968786b6bdf407aa5c75ab53a3d37c1c8c81cdb736555ccf")
-    version("7.88.1", sha256="8224b45cce12abde039c12dc0711b7ea85b104b9ad534d6e4c5b4e188a61c907")
+    version("8.4.0", sha256="e5250581a9c032b1b6ed3cf2f9c114c811fc41881069e9892d115cc73f9e88c6")
 
     # Deprecated versions due to CVEs
+    # CVE-2023-38545
+    version(
+        "8.1.2",
+        sha256="b54974d32fd610acace92e3df1f643144015ac65847f0a041fdc17db6f43f243",
+        deprecated=True,
+    )
+    version(
+        "8.0.1",
+        sha256="9b6b1e96b748d04b968786b6bdf407aa5c75ab53a3d37c1c8c81cdb736555ccf",
+        deprecated=True,
+    )
+    version(
+        "7.88.1",
+        sha256="8224b45cce12abde039c12dc0711b7ea85b104b9ad534d6e4c5b4e188a61c907",
+        deprecated=True,
+    )
     # https://nvd.nist.gov/vuln/detail/CVE-2022-43551
     version(
         "7.87.0",

var/spack/repos/builtin/packages/elfutils/package.py

@@ -85,10 +85,10 @@ class Elfutils(AutotoolsPackage, SourcewarePackage):
 
     provides("elf@1")
 
-    # libarchive with iconv doesn't configure.
+    # libarchive with iconv doesn't configure (still broken as of libarchive@3.7.1)
     # see https://github.com/spack/spack/issues/36710
     # and https://github.com/libarchive/libarchive/issues/1819
-    conflicts("^libarchive@3.6.2 +iconv", when="+debuginfod")
+    conflicts("^libarchive +iconv", when="+debuginfod")
 
     # https://sourceware.org/bugzilla/show_bug.cgi?id=24964
     conflicts("%apple-clang")

var/spack/repos/builtin/packages/embree/package.py

@@ -13,6 +13,7 @@ class Embree(CMakePackage):
     url = "https://github.com/embree/embree/archive/v3.7.0.tar.gz"
     maintainers("aumuell")
 
+    version("4.3.0", sha256="baf0a57a45837fc055ba828a139467bce0bc0c6a9a5f2dccb05163d012c12308")
     version("4.2.0", sha256="b0479ce688045d17aa63ce6223c84b1cdb5edbf00d7eda71c06b7e64e21f53a0")
     version("4.1.0", sha256="117efd87d6dddbf7b164edd94b0bc057da69d6422a25366283cded57ed94738b")
     version("4.0.1", sha256="1fa3982fa3531f1b6e81f19e6028ae8a62b466597f150b853440fe35ef7c6c06")

var/spack/repos/builtin/packages/feq-parse/package.py

@@ -16,8 +16,11 @@ class FeqParse(CMakePackage):
 
     maintainers("fluidnumerics-joe")
 
+    version("2.0.3", sha256="a1c42507801adc55a63a9a904807058079d54e002e10f2b29a916b06fc815f80")
     version("2.0.1", sha256="08dd08bd100a0a2eb672a5b2792ad56a337df575c634aac0d7a300d7e484b21c")
     version("1.1.0", sha256="d33a4fd6904939bb70780e8f25f37c1291c4f24fd207feb4ffc0f8d89637d1e3")
     version("1.0.2", sha256="1cd1db7562908ea16fc65dc5268b654405d0b3d9dcfe11f409949c431b48a3e8")
 
     depends_on("cmake@3.0.2:", type="build")
+
+    parallel = False

var/spack/repos/builtin/packages/fftx/package.py

@@ -14,13 +14,14 @@ class Fftx(CMakePackage, CudaPackage, ROCmPackage):
     operations composed of linear operations combined with DFT transforms."""
 
     homepage = "https://spiralgen.com"
-    url = "https://github.com/spiral-software/fftx/archive/refs/tags/1.1.2.tar.gz"
+    url = "https://github.com/spiral-software/fftx/archive/refs/tags/1.1.3.tar.gz"
     git = "https://github.com/spiral-software/fftx.git"
 
     maintainers("spiralgen")
 
     version("develop", branch="develop")
     version("main", branch="main")
+    version("1.1.3", sha256="17ed0baf9c2dcf30c789fdae530e006ae3ff2d2c9006989b1e6348e4ae50cef9")
     version("1.1.2", sha256="b2c4a7791305481af9e1bd358c1215efa4506c91c943cddca3780a1ccbc27810")
     version("1.1.1", sha256="5cbca66ef09eca02ee8f336f58eb45cfac69cfb29cd6eb945852ad74085d8a60")
     version("1.1.0", sha256="a6f95605abc11460bbf51839727a456a31488e27e12a970fc29a1b8c42f4e3b5")

var/spack/repos/builtin/packages/flux-pmix/package.py

@@ -18,10 +18,11 @@ class FluxPmix(AutotoolsPackage):
     maintainers("grondo")
 
     version("main", branch="main")
+    version("0.4.0", sha256="f7f58891fc9d9a97a0399b3ab186f2cae30a75806ba0b4d4c1307f07b3f6d1bc")
     version("0.3.0", sha256="88edb2afaeb6058b56ff915105a36972acc0d83204cff7f4a4d2f65a5dee9d34")
     version("0.2.0", sha256="d09f1fe6ffe54f83be4677e1e727640521d8110090515d94013eba0f58216934")
 
-    depends_on("flux-core@0.49.0:", when="@0.3.0:")
+    depends_on("flux-core@0.49:", when="@0.3:")
     depends_on("flux-core@0.30.0:")
     depends_on("pmix@v4.1.0:")
     depends_on("openmpi")

var/spack/repos/builtin/packages/fpocket/package.py

@@ -3,23 +3,27 @@
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+
 from spack.package import *
 
 
 class Fpocket(MakefilePackage):
-    """fpocket is a very fast open source protein pocket detection algorithm
-    based on Voronoi tessellation."""
+    """The fpocket suite of programs is a very fast open source
+    protein pocket detection algorithm based on Voronoi tessellation."""
 
     homepage = "https://github.com/Discngine/fpocket"
-    version("master", branch="master", git="https://github.com/Discngine/fpocket.git")
+    url = "https://github.com/Discngine/fpocket/archive/refs/tags/4.1.tar.gz"
+
+    version("4.1", "1a2af2d3f2df42de67301996db3b93c7eaff0375f866443c0468dcf4b1750688")
 
     depends_on("netcdf-c")
+    depends_on("netcdf-cxx")
 
     def setup_build_environment(self, env):
         if self.compiler.name == "gcc":
             env.set("CXX", "g++")
 
-    def edit(self):
+    def edit(self, spec, prefix):
         makefile = FileFilter("makefile")
-        makefile.filter("BINDIR .*", "BINDIR = %s/bin" % self.prefix)
-        makefile.filter("MANDIR .*", "MANDIR = %s/man/man8" % self.prefix)
+        makefile.filter("BINDIR .*", f"BINDIR = {prefix}/bin")
+        makefile.filter("MANDIR .*", f"MANDIR = {prefix}/man/man8")

var/spack/repos/builtin/packages/gcc/package.py

@@ -783,6 +783,11 @@ def configure_args(self):
                     "--with-as=" + binutils.join("as"),
                 ]
             )
+        elif spec.satisfies("%apple-clang@15:"):
+            # https://github.com/iains/gcc-darwin-arm64/issues/117
+            # https://github.com/iains/gcc-12-branch/issues/22
+            # https://github.com/iains/gcc-13-branch/issues/8
+            options.append("--with-ld=/Library/Developer/CommandLineTools/usr/bin/ld-classic")
 
         # enable_bootstrap
         if spec.satisfies("+bootstrap"):

var/spack/repos/builtin/packages/gettext/package.py

@@ -19,6 +19,7 @@ class Gettext(AutotoolsPackage, GNUMirrorPackage):
 
     executables = [r"^gettext$"]
 
+    version("0.22.3", sha256="b838228b3f8823a6c1eddf07297197c4db13f7e1b173b9ef93f3f945a63080b6")
     version("0.21.1", sha256="50dbc8f39797950aa2c98e939947c527e5ac9ebd2c1b99dd7b06ba33a6767ae6")
     version("0.21", sha256="d20fcbb537e02dcf1383197ba05bd0734ef7bf5db06bdb241eb69b7d16b73192")
     version("0.20.2", sha256="b22b818e644c37f6e3d1643a1943c32c3a9bff726d601e53047d2682019ceaba")
@@ -33,6 +34,8 @@ class Gettext(AutotoolsPackage, GNUMirrorPackage):
     variant("tar", default=True, description="Enable tar support")
     variant("bzip2", default=True, description="Enable bzip2 support")
     variant("xz", default=True, description="Enable xz support")
+    variant("shared", default=True, description="Build shared libraries")
+    variant("pic", default=True, description="Enable position-independent code (PIC)")
 
     # Optional variants
     variant("libunistring", default=False, description="Use libunistring")
@@ -54,6 +57,8 @@ class Gettext(AutotoolsPackage, GNUMirrorPackage):
     depends_on("libunistring", when="+libunistring")
     # depends_on('cvs')
 
+    conflicts("+shared~pic")
+
     patch("test-verify-parallel-make-check.patch", when="@:0.19.8.1")
     patch("nvhpc-builtin.patch", when="@:0.21.0 %nvhpc")
     patch("nvhpc-export-symbols.patch", when="%nvhpc")
@@ -87,6 +92,8 @@ def configure_args(self):
             "--without-cvs",
         ]
 
+        config_args.extend(self.enable_or_disable("shared"))
+
         if self.spec["iconv"].name == "libc":
             config_args.append("--without-libiconv-prefix")
         elif not is_system_path(self.spec["iconv"].prefix):
@@ -115,12 +122,18 @@ def configure_args(self):
         else:
             config_args.append("--with-included-libunistring")
 
+        config_args.extend(self.with_or_without("pic"))
+
         return config_args
 
     @property
     def libs(self):
-        return find_libraries(
+        # Do not fail if the installed gettext did not yet have the shared variant:
+        shared_variant = self.spec.variants.get("shared")
+        libs = find_libraries(
             ["libasprintf", "libgettextlib", "libgettextpo", "libgettextsrc", "libintl"],
             root=self.prefix,
             recursive=True,
+            shared=True if not shared_variant else shared_variant.value,
         )
+        return libs

var/spack/repos/builtin/packages/git/package.py

@@ -253,8 +253,6 @@ def setup_build_environment(self, env):
                     extlib_bits.append(spec["gettext"].libs.search_flags)
                 extlib_bits.append("-lintl")
                 env.append_flags("EXTLIBS", " ".join(extlib_bits))
-            if not is_system_path(spec["gettext"].prefix):
-                env.append_flags("CFLAGS", spec["gettext"].headers.include_flags)
 
         if not self.spec["curl"].satisfies("libs=shared"):
             curlconfig = which(os.path.join(self.spec["curl"].prefix.bin, "curl-config"))

var/spack/repos/builtin/packages/go/package.py

@@ -39,10 +39,15 @@ class Go(Package):
 
     maintainers("alecbcs")
 
-    version("1.20.6", sha256="62ee5bc6fb55b8bae8f705e0cb8df86d6453626b4ecf93279e2867092e0b7f70")
-    version("1.19.11", sha256="e25c9ab72d811142b7f41ff6da5165fec2d1be5feec3ef2c66bc0bdecb431489")
+    version("1.21.3", sha256="186f2b6f8c8b704e696821b09ab2041a5c1ee13dcbc3156a13adcf75931ee488")
 
     # Deprecated Versions
+    # https://nvd.nist.gov/vuln/detail/CVE-2023-39533
+    version(
+        "1.20.6",
+        sha256="62ee5bc6fb55b8bae8f705e0cb8df86d6453626b4ecf93279e2867092e0b7f70",
+        deprecated=True,
+    )
     # https://nvd.nist.gov/vuln/detail/CVE-2023-29405
     version(
         "1.20.4",
@@ -54,6 +59,11 @@ class Go(Package):
         sha256="e447b498cde50215c4f7619e5124b0fc4e25fb5d16ea47271c47f278e7aa763a",
         deprecated=True,
     )
+    version(
+        "1.19.11",
+        sha256="e25c9ab72d811142b7f41ff6da5165fec2d1be5feec3ef2c66bc0bdecb431489",
+        deprecated=True,
+    )
     version(
         "1.19.9",
         sha256="131190a4697a70c5b1d232df5d3f55a3f9ec0e78e40516196ffb3f09ae6a5744",
@@ -64,7 +74,6 @@ class Go(Package):
         sha256="1d7a67929dccafeaf8a29e55985bc2b789e0499cb1a17100039f084e3238da2f",
         deprecated=True,
     )
-
     # https://nvd.nist.gov/vuln/detail/CVE-2023-24538
     version(
         "1.20.2",
@@ -106,7 +115,7 @@ def build(self, spec, prefix):
         bash = which("bash")
 
         with working_dir("src"):
-            bash("{0}.bash".format("all" if self.run_tests else "make"))
+            bash(f"{'all' if self.run_tests else 'make'}.bash")
 
     def install(self, spec, prefix):
         install_tree(".", prefix)

var/spack/repos/builtin/packages/gsi-ncdiag/package.py

@@ -14,6 +14,7 @@ class GsiNcdiag(CMakePackage):
 
     maintainers("ulmononian")
 
+    version("1.1.2", sha256="085884106be1f8fd94a70292102e9351c0efdf1e619a233831fafcd9ed32cd99")
     version("1.1.1", sha256="26fc10cf448dd62daa1385e38921d338778416342956c478337e6c6d1b20bf8c")
     version("1.1.0", sha256="9195801301209d6f93890944d58ffee4e24a4e35502ab27560a8c440ee53df4c")
     version("1.0.0", sha256="7251d6139c2bc1580db5f7f019e10a4c73d188ddd52ccf21ecc9e39d50a6af51")

var/spack/repos/builtin/packages/krb5/package.py

@@ -35,6 +35,7 @@ class Krb5(AutotoolsPackage):
     depends_on("openssl")
     depends_on("gettext")
     depends_on("findutils", type="build")
+    depends_on("pkgconfig", type="build", when="^openssl~shared")
 
     variant(
         "shared", default=True, description="install shared libraries if True, static if false"
@@ -80,6 +81,11 @@ def configure_args(self):
         if "%gcc@10:" in self.spec:
             args.append("CFLAGS=-fcommon")
 
+        if self.spec["openssl"].satisfies("~shared"):
+            pkgconf = which("pkg-config")
+            ssllibs = pkgconf("--static", "--libs", "openssl", output=str)
+            args.append(f"LDFLAGS={ssllibs}")
+
         return args
 
     def flag_handler(self, name, flags):

var/spack/repos/builtin/packages/libzmq/package.py

@@ -12,12 +12,13 @@ class Libzmq(AutotoolsPackage):
     """The ZMQ networking/concurrency library and core API"""
 
     homepage = "https://zguide.zeromq.org/"
-    url = "https://github.com/zeromq/libzmq/releases/download/v4.3.2/zeromq-4.3.2.tar.gz"
+    url = "https://github.com/zeromq/libzmq/releases/download/v4.3.5/zeromq-4.3.5.tar.gz"
     git = "https://github.com/zeromq/libzmq.git"
 
     maintainers("dennisklein")
 
     version("master", branch="master")
+    version("4.3.5", sha256="6653ef5910f17954861fe72332e68b03ca6e4d9c7160eb3a8de5a5a913bfab43")
     version("4.3.4", sha256="c593001a89f5a85dd2ddf564805deb860e02471171b3f204944857336295c3e5")
     version("4.3.3", sha256="9d9285db37ae942ed0780c016da87060497877af45094ff9e1a1ca736e3875a2")
     version("4.3.2", sha256="ebd7b5c830d6428956b67a0454a7f8cbed1de74b3b01e5c33c5378e22740f763")
@@ -104,19 +105,16 @@ def autoreconf(self, spec, prefix):
     def configure_args(self):
         config_args = []
 
+        config_args.extend(self.with_or_without("docs"))
         config_args.extend(self.enable_or_disable("drafts"))
         config_args.extend(self.enable_or_disable("libbsd"))
+        config_args.extend(self.with_or_without("libsodium"))
         config_args.extend(self.enable_or_disable("libunwind"))
         # the package won't compile with newer compilers because warnings
         # are converted to errors. Hence, disable such conversion.
         # this option was only added in version 4.2.3.
         if self.spec.version >= Version("4.2.3"):
             config_args.append("--disable-Werror")
-
-        if "+libsodium" in self.spec:
-            config_args.append("--with-libsodium=" + self.spec["libsodium"].prefix)
-        if "~docs" in self.spec:
-            config_args.append("--without-docs")
         if "clang" in self.compiler.cc:
             config_args.append("CFLAGS=-Wno-gnu")
             config_args.append("CXXFLAGS=-Wno-gnu")

var/spack/repos/builtin/packages/linaro-forge/package.py

@@ -0,0 +1,134 @@
+# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+import os
+import platform
+import subprocess
+
+from spack.package import *
+
+
+class LinaroForge(Package):
+    """Build reliable and optimized code for the right results on multiple
+    Server and HPC architectures, from the latest compilers and C++ standards
+    to Intel, 64-bit Arm, AMD, OpenPOWER and Nvidia GPU hardware. Linaro Forge
+    combines Linaro DDT, the leading debugger for time-saving high performance
+    application debugging, Linaro MAP, the trusted performance profiler for
+    invaluable optimization advice across native and Python HPC codes, and
+    Linaro Performance Reports for advanced reporting capabilities."""
+
+    homepage = "https://www.linaroforge.com"
+    maintainers("kenche-linaro")
+
+    if platform.machine() in ["aarch64", "arm64"]:
+        version(
+            "23.0.3", sha256="a7e23ef2a187f8e2d6a6692cafb931c9bb614abf58e45ea9c2287191c4c44f02"
+        )
+        version(
+            "23.0.2", sha256="698fda8f7cc05a06909e5dcc50b9956f94135d7b12e84ffb21999a5b45c70c74"
+        )
+        version(
+            "23.0.1", sha256="552e4a3f408ed4eb5f1bfbb83c94530ee8733579c56c3e98050c0ad2d43eb433"
+        )
+        version("23.0", sha256="7ae20bb27d539751d1776d1e09a65dcce821fc6a75f924675439f791261783fb")
+        version(
+            "22.1.4", sha256="4e2af481a37b4c99dba0de6fac75ac945316955fc4170d06e321530adea7ac9f"
+        )
+        version(
+            "21.1.3", sha256="4a4ff7372aad5a31fc9e18b7b6c493691ab37d8d44a3158584e62d1ab82b0eeb"
+        )
+    elif platform.machine() == "ppc64le":
+        version(
+            "23.0.3", sha256="5ff9770f4bc4a2df4bac8a2544a9d6bad9fba2556420fa2e659e5c21e741caf7"
+        )
+        version(
+            "23.0.2", sha256="181b157bdfc8609b49addf63023f920ebb609dbc9a126e9dc26605188b756ff0"
+        )
+        version(
+            "23.0.1", sha256="08cffef2195ea96872d56e827f320eed40aaa82fd3b62d4c661a598fb2fb3a47"
+        )
+        version("23.0", sha256="0962c7e0da0f450cf6daffe1156e1f59e02c9f643df458ec8458527afcde5b4d")
+        version(
+            "22.1.3", sha256="6479c3a4ae6ce6648c37594eb0266161f06d9f89010fca9299855848661dda49"
+        )
+        version(
+            "22.0.4", sha256="f4cb5bcbaa67f9209299fe4653186a2829760b8b16a2883913aa43766375b04c"
+        )
+        version(
+            "21.1.3", sha256="eecbc5686d60994c5468b2d7cd37bebe5d9ac0ba37bd1f98fbfc69b071db541e"
+        )
+    elif platform.machine() == "x86_64":
+        version(
+            "23.0.3", sha256="f2a010b94838f174f057cd89d12d03a89ca946163536eab178dd1ec877cdc27f"
+        )
+        version(
+            "23.0.2", sha256="565f0c073c6c8cbb06c062ca414e3f6ff8c6ca6797b03d247b030a9fbc55a5b1"
+        )
+        version(
+            "23.0.1", sha256="1d681891c0c725363f0f45584c9b79e669d5c9782158453b7d24b4b865d72755"
+        )
+        version("23.0", sha256="f4ab12289c992dd07cb1a15dd985ef4713d1f9c0cf362ec5e9c995cca9b1cf81")
+        version(
+            "22.1.3", sha256="4f8a8b1df6ad712e89c82eedf4bd85b93b57b3c8d5b37d13480ff058fa8f4467"
+        )
+        version(
+            "22.0.4", sha256="a2c8c1da38b9684d7c4656a98b3fc42777b03fd474cd0bf969324804f47587e5"
+        )
+        version(
+            "21.1.3", sha256="03dc82f1d075deb6f08d1e3e6592dc9b630d406c08a1316d89c436b5874f3407"
+        )
+
+    variant(
+        "probe",
+        default=False,
+        description='Detect available PMU counters via "forge-probe" during install',
+    )
+
+    variant("accept-eula", default=False, description="Accept the EULA")
+
+    # forge-probe executes with "/usr/bin/env python"
+    depends_on("python@2.7:", type="build", when="+probe")
+
+    # Licensing
+    license_required = True
+    license_comment = "#"
+    license_files = ["licences/Licence"]
+    license_vars = [
+        "ALLINEA_LICENSE_DIR",
+        "ALLINEA_LICENCE_DIR",
+        "ALLINEA_LICENSE_FILE",
+        "ALLINEA_LICENCE_FILE",
+    ]
+    license_url = "https://docs.linaroforge.com/latest/html/licenceserver/index.html"
+
+    def url_for_version(self, version):
+        pre = "arm" if version < Version("23.0") else "linaro"
+        return f"https://downloads.linaroforge.com/{version}/{pre}-forge-{version}-linux-{platform.machine()}.tar"
+
+    @run_before("install")
+    def abort_without_eula_acceptance(self):
+        install_example = "spack install linaro-forge +accept-eula"
+        license_terms_path = os.path.join(self.stage.source_path, "license_terms")
+        if not self.spec.variants["accept-eula"].value:
+            raise InstallError(
+                "\n\n\nNOTE:\nUse +accept-eula "
+                + "during installation "
+                + "to accept the license terms in:\n"
+                + "  {0}\n".format(os.path.join(license_terms_path, "license_agreement.txt"))
+                + "  {0}\n\n".format(os.path.join(license_terms_path, "supplementary_terms.txt"))
+                + "Example: '{0}'\n".format(install_example)
+            )
+
+    def install(self, spec, prefix):
+        subprocess.call(["./textinstall.sh", "--accept-license", prefix])
+        if spec.satisfies("+probe"):
+            probe = join_path(prefix, "bin", "forge-probe")
+            subprocess.call([probe, "--install", "global"])
+
+    def setup_run_environment(self, env):
+        # Only PATH is needed for Forge.
+        # Adding lib to LD_LIBRARY_PATH can cause conflicts with Forge's internal libs.
+        env.clear()
+        env.prepend_path("PATH", join_path(self.prefix, "bin"))

var/spack/repos/builtin/packages/miopen-hip/package.py

@@ -160,6 +160,7 @@ class MiopenHip(CMakePackage):
         depends_on("nlohmann-json", type="link")
         depends_on("composable-kernel@" + ver, when="@" + ver)
     for ver in ["5.4.0", "5.4.3", "5.5.0"]:
+        depends_on("nlohmann-json", type="link")
         depends_on("rocmlir@" + ver, when="@" + ver)
 
     def setup_build_environment(self, env):
@@ -216,6 +217,7 @@ def cmake_args(self):
         if self.spec.satisfies("@5.5.1:"):
             args.append(self.define("MIOPEN_USE_COMPOSABLEKERNEL", "ON"))
             args.append(self.define("MIOPEN_ENABLE_AI_KERNEL_TUNING", "OFF"))
+            args.append(self.define("MIOPEN_USE_MLIR", "OFF"))
         args.append(
             "-DNLOHMANN_JSON_INCLUDE={0}".format(self.spec["nlohmann-json"].prefix.include)
         )

var/spack/repos/builtin/packages/must/package.py

@@ -19,6 +19,8 @@ class Must(CMakePackage):
 
     maintainers("jgalarowicz", "dmont")
 
+    version("1.9.0", sha256="24998f4ca6bce718d69347de90798600f2385c21266c2d1dd39a87dd8bd1fba4")
+    version("1.8.0", sha256="9754fefd2e4c8cba812f8b56a5dd929bc84aa599b2509305e1eb8518be0a8a39")
     version("1.8.0-rc1", sha256="49fd2487fbd1aa41f4252c7e37efebd3f6ff48218c88e82f34b88d59348fe406")
     version(
         "1.8-preview", sha256="67b4b061db7a893e22a6610e2085072716d11738bc6cc3cb3ffd60d6833e8bad"

var/spack/repos/builtin/packages/nimrod-aai/package.py

@@ -14,13 +14,14 @@ class NimrodAai(CMakePackage):
 
     homepage = "https://gitlab.com/NIMRODteam/nimrod-abstract"
     url = (
-        "https://gitlab.com/NIMRODteam/nimrod-abstract/-/archive/23.6/nimrod-abstract-23.6.tar.gz"
+        "https://gitlab.com/NIMRODteam/nimrod-abstract/-/archive/23.9/nimrod-abstract-23.9.tar.gz"
     )
     git = "https://gitlab.com/NIMRODteam/nimrod-abstract.git"
 
     maintainers("jacobrking")
 
     version("main", branch="main")
+    version("23.9", sha256="212d591c5a5e7a394b56a5cf2f92cc69feafc49dd5f042fa95eeb6441649390b")
     version("23.6", sha256="1794b89a5a64ff2b3c548818b90d17eef85d819ba4f63a76c41a682d5b76c14f")
 
     variant("debug", default=False, description="Whether to enable debug code")
@@ -41,8 +42,9 @@ class NimrodAai(CMakePackage):
     )
 
     depends_on("cmake", type="build")
-    depends_on("hdf5+fortran", type="build")
     depends_on("mpi", when="+mpi")
+    depends_on("hdf5+fortran~mpi", type="build", when="~mpi")
+    depends_on("hdf5+fortran+mpi", type="build", when="+mpi")
 
     def cmake_args(self):
         args = [
@@ -62,3 +64,9 @@ def cmake_args(self):
             ]
             args.append(addl_args)
         return args
+
+    @run_after("build")
+    @on_package_attributes(run_tests=True)
+    def check(self):
+        with working_dir(self.builder.build_directory):
+            ctest("--output-on-failure")

var/spack/repos/builtin/packages/nvhpc/package.py

@@ -21,6 +21,20 @@
 #  - package key must be in the form '{os}-{arch}' where 'os' is in the
 #    format returned by platform.system() and 'arch' by platform.machine()
 _versions = {
+    "23.9": {
+        "Linux-aarch64": (
+            "dd32ae4233438adb71b2b4f8891f04802fdf90f67036ecf18bfde1b6043a03c3",
+            "https://developer.download.nvidia.com/hpc-sdk/23.9/nvhpc_2023_239_Linux_aarch64_cuda_multi.tar.gz",
+        ),
+        "Linux-ppc64le": (
+            "984d61695499db098fd32be8345c1f7d7c637ea3bdb29cef17aad656f16b000f",
+            "https://developer.download.nvidia.com/hpc-sdk/23.9/nvhpc_2023_239_Linux_ppc64le_cuda_multi.tar.gz",
+        ),
+        "Linux-x86_64": (
+            "ecf343ecad2398e21c8d7f24a580b2932348017dfd8ea38c1ef31b37114b2d4b",
+            "https://developer.download.nvidia.com/hpc-sdk/23.9/nvhpc_2023_239_Linux_x86_64_cuda_multi.tar.gz",
+        ),
+    },
     "23.7": {
         "Linux-aarch64": (
             "d3b9b674045e6e17156b298941be4e1e1e7dea6a3c1938f14ad653b180860ff2",

var/spack/repos/builtin/packages/opendatadetector/package.py

@@ -18,6 +18,7 @@ class Opendatadetector(CMakePackage):
     tags = ["hep"]
 
     version("main", branch="main")
+    version("v3.0.0", tag="v3.0.0", commit="e3b1eceae96fd5dddf10223753964c570ee868c9")
     version("v2", tag="v2", commit="7041ae086dff4ee4a8d5b65f5d9559acc6dbec47")
     version("v1", tag="v1", commit="81c43c6511723c13c15327479082d3dcfa1947c7")
 

var/spack/repos/builtin/packages/openimagedenoise/package.py

@@ -17,6 +17,7 @@ class Openimagedenoise(CMakePackage):
 
     # maintainers("github_user1", "github_user2")
 
+    version("2.0.1", sha256="328eeb9809d18e835dca7203224af3748578794784c026940c02eea09c695b90")
     version("1.4.3", sha256="3276e252297ebad67a999298d8f0c30cfb221e166b166ae5c955d88b94ad062a")
     version("1.4.2", sha256="e70d27ce24b41364782376c1b3b4f074f77310ccfe5f8ffec4a13a347e48a0ea")
     version("1.4.1", sha256="9088966685a78adf24b8de075d66e4c0019bd7b2b9d29c6e45aaf35d294e3f6f")

var/spack/repos/builtin/packages/openmm/package.py

@@ -17,6 +17,7 @@ class Openmm(CMakePackage, CudaPackage):
     homepage = "https://openmm.org/"
     url = "https://github.com/openmm/openmm/archive/7.4.1.tar.gz"
 
+    version("8.0.0", sha256="dc63d7b47c8bb7b169c409cfd63d909ed0ce1ae114d37c627bf7a4231acf488e")
     version("7.7.0", sha256="51970779b8dc639ea192e9c61c67f70189aa294575acb915e14be1670a586c25")
     version("7.6.0", sha256="5a99c491ded9ba83ecc3fb1d8d22fca550f45da92e14f64f25378fda0048a89d")
     version("7.5.1", sha256="c88d6946468a2bde2619acb834f57b859b5e114a93093cf562165612e10f4ff7")
@@ -32,7 +33,7 @@ class Openmm(CMakePackage, CudaPackage):
     depends_on("doxygen@:1.9.1", type="build", when="@:7.6.0")
     depends_on("doxygen", type="build", when="@7.7:")
     depends_on("swig", type="build")
-    depends_on("fftw")
+    depends_on("fftw", when="@:7")
     depends_on("py-cython", type="build")
     depends_on("py-numpy", type=("build", "run"))
     depends_on("cuda", when="+cuda", type=("build", "link", "run"))

var/spack/repos/builtin/packages/openvkl/package.py

@@ -16,6 +16,7 @@ class Openvkl(CMakePackage):
 
     # maintainers("github_user1", "github_user2")
 
+    version("1.3.2", sha256="7704736566bf17497a3e51c067bd575316895fda96eccc682dae4aac7fb07b28")
     version("1.3.1", sha256="c9cefb6c313f2b4c0331e9629931759a6bc204ec00deed6ec0becad1670a1933")
     version("1.3.0", sha256="c6d4d40e6d232839c278b53dee1e7bd3bd239c3ccac33f49b465fc65a0692be9")
     version("1.2.0", sha256="dc468c2f0a359aaa946e04a01c2a6634081f7b6ce31b3c212c74bf7b4b0c9ec2")
@@ -24,7 +25,8 @@ class Openvkl(CMakePackage):
     version("1.0.0", sha256="81ccae679bfa2feefc4d4b1ce72bcd242ba34d2618fbb418a1c2a05d640d16b4")
     version("0.13.0", sha256="974608259e3a5d8e29d2dfe81c6b2b1830aadeb9bbdc87127f3a7c8631e9f1bd")
 
-    depends_on("embree@3.13.0:3")
+    depends_on("embree@4", when="@1.3.2:")
+    depends_on("embree@3.13.0:3", when="@:1.3.1")
     depends_on("embree@3.13.1:", when="@1.0.0:")
     depends_on("ispc@1.15.0:", type=("build"))
     depends_on("ispc@1.16.0:", when="@1.0.0:", type=("build"))
@@ -32,10 +34,14 @@ class Openvkl(CMakePackage):
     depends_on("rkcommon@1.6.1:")
     depends_on("rkcommon@1.7.0:", when="@1.0.0:")
     depends_on("rkcommon@1.8.0:", when="@1.1:")
+    depends_on("rkcommon@:1.10.0", when="@:1.3.1")
+    depends_on("rkcommon@1.11.0:", when="@1.3.2:")
     depends_on("tbb")
 
     def cmake_args(self):
         args = [
+            # otherwise, openvkl 1.3.2 tries to install its headers into /openvkl
+            self.define("CMAKE_INSTALL_INCLUDEDIR", f"{self.spec.prefix}/include"),
             self.define("BUILD_BENCHMARKS", False),
             self.define("BUILD_EXAMPLES", False),
             self.define("BUILD_TESTING", False),

var/spack/repos/builtin/packages/ospray/package.py

@@ -16,6 +16,8 @@ class Ospray(CMakePackage):
 
     # maintainers("aumuell")
 
+    version("2.12.0", sha256="268b16952b2dd44da2a1e40d2065c960bc2442dd09b63ace8b65d3408f596301")
+    version("2.11.0", sha256="55974e650d9b78989ee55adb81cffd8c6e39ce5d3cf0a3b3198c522bf36f6e81")
     version("2.10.0", sha256="bd478284f48d2cb775fc41a2855a9d9f5ea16c861abda0f8dc94e02ea7189cb8")
     version("2.9.0", sha256="0145e09c3618fb8152a32d5f5cff819eb065d90975ee4e35400d2db9eb9f6398")
     version("2.8.0", sha256="2dabc75446a0e2e970952d325f930853a51a9b4d1868c8135f05552a4ae04d39")
@@ -27,21 +29,35 @@ class Ospray(CMakePackage):
     variant("denoiser", default=True, description="Enable denoiser image operation")
     variant("glm", default=False, description="Build ospray_cpp GLM tests/tutorial")
     variant("mpi", default=True, description="Enable MPI support")
+    variant("volumes", default=True, description="Enable volumetric rendering with Open VKL")
+
+    conflicts("~volumes", when="@:2.10")
 
     depends_on("rkcommon@1.5:")
     depends_on("rkcommon@1.7:1.9", when="@2.7.0:2.8")
     depends_on("rkcommon@1.9", when="@2.9.0")
     depends_on("rkcommon@1.10:", when="@2.10.0:")
+    depends_on("rkcommon@1.11:", when="@2.11:")
     depends_on("embree@3.12: +ispc")
     depends_on("embree@3.13.1:", when="@2.7.0:")
-    depends_on("openvkl@0.13.0:")
-    depends_on("openvkl@1.0.1:", when="@2.7.0:")
-    depends_on("openvkl@1.2.0:", when="@2.9.0:")
-    depends_on("openvkl@1.3.0:", when="@2.10.0:")
-    depends_on("openimagedenoise@1.2.3:", when="+denoiser")
+    depends_on("embree@:3", when="@:2.10")
+    depends_on("embree@4:", when="@2.11:")
+    with when("+volumes"):
+        depends_on("openvkl@0.13.0:")
+        depends_on("openvkl@1.0.1:", when="@2.7.0:")
+        depends_on("openvkl@1.2.0:", when="@2.9.0:")
+        depends_on("openvkl@1.3.0:", when="@2.10.0:")
+        depends_on("openvkl@1.3.2:", when="@2.11:")
+    with when("+denoiser"):
+        depends_on("openimagedenoise@1.2.3:")
+        depends_on("openimagedenoise@1.3:", when="@2.5:")
+        depends_on("openimagedenoise@:1", when="@:2.11")
+        depends_on("openimagedenoise@2:", when="@2.12:")
     depends_on("ispc@1.14.1:", type=("build"))
     depends_on("ispc@1.16.0:", when="@2.7.0:", type=("build"))
     depends_on("ispc@1.18.0:", when="@2.10.0:", type=("build"))
+    depends_on("ispc@1.19.0:", when="@2.11.0:", type=("build"))
+    depends_on("ispc@1.20.0:", when="@2.12.0:", type=("build"))
     depends_on("tbb")
 
     depends_on("mpi", when="+mpi")
@@ -58,6 +74,10 @@ def cmake_args(self):
             self.define_from_variant("OSPRAY_APPS_ENABLE_GLM", "glm"),
         ]
 
+        # support for volumetric data
+        if self.spec.satisfies("@2.11:"):
+            args.append(self.define_from_variant("OSPRAY_ENABLE_VOLUMES", "volumes"))
+
         # Apps
         enable_apps_arg = "" if self.spec.satisfies("@2.9:") else "ENABLE_"
         args.extend(

var/spack/repos/builtin/packages/paintor/package.py

@@ -0,0 +1,37 @@
+# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+from spack.package import *
+
+
+class Paintor(MakefilePackage):
+    """Probabilistic Annotation integrator. Fast, integrative fine mapping with functional
+    data"""
+
+    homepage = "https://github.com/gkichaev/PAINTOR_V3.0"
+    url = "https://github.com/gkichaev/PAINTOR_V3.0/archive/refs/tags/3.0.tar.gz"
+
+    version("3.0", sha256="cc39d3c334cc6d787e4f04847192c9d0185025a2ca46910bd38901b6679d198f")
+
+    depends_on("nlopt")
+    depends_on("eigen")
+
+    def edit(self, spec, prefix):
+        makefile = FileFilter("Makefile")
+        makefile.filter("CC = g\\+\\+", f"CC = {spack_cxx}")
+        makefile.filter(
+            r"(.*)-I/\$\(curr\)/eigen/Eigen(.*)",
+            r"\1-I{}/eigen3/Eigen\2".format(spec["eigen"].prefix.include),
+        )
+        makefile.filter(r"(.*)-L/\$\{curr}/lib(.*)", r"\1-L{}\2".format(spec["nlopt"].prefix.lib))
+        makefile.filter(
+            r"(.*)-I/\${curr}/include(.*)", r"\1-I{}\2".format(spec["nlopt"].prefix.include)
+        )
+
+    @run_after("install")
+    def mv_binary(self):
+        mkdirp(self.prefix.bin)
+        with working_dir(self.build_directory):
+            install("PAINTOR", self.prefix.bin)

var/spack/repos/builtin/packages/pika/package.py

@@ -17,6 +17,7 @@ class Pika(CMakePackage, CudaPackage, ROCmPackage):
     git = "https://github.com/pika-org/pika.git"
     maintainers("msimberg", "albestro", "teonnik", "aurianer")
 
+    version("0.19.1", sha256="674675abf0dd4c6f5a0b2fa3db944b277ed65c62f654029d938a8cab608a9c1d")
     version("0.19.0", sha256="f45cc16e4e50cbb183ed743bdc8b775d49776ee33c13ea39a650f4230a5744cb")
     version("0.18.0", sha256="f34890e0594eeca6ac57f2b988d0807b502782817e53a7f7043c3f921b08c99f")
     version("0.17.0", sha256="717429fc1bc986d62cbec190a69939e91608122d09d54bda1b028871c9ca9ad4")

var/spack/repos/builtin/packages/procps/package.py

@@ -17,6 +17,7 @@ class Procps(AutotoolsPackage):
     url = "https://gitlab.com/procps-ng/procps/-/archive/v4.0.3/procps-v4.0.3.tar.gz"
 
     version("master", branch="master")
+    version("4.0.4", sha256="3214fab0f817d169f2c117842ba635bafb1cd6090273e311a8b5c6fc393ddb9d")
     version("4.0.3", sha256="14cc21219c45d196772274ea3f194f6d668b6cc667fbde9ee6d8039121b73fa6")
     version("4.0.2", sha256="b03e4b55eaa5661e726acb714e689356d80bc056b09965c2284d039ba8dc21e8")
     version("4.0.1", sha256="1eaff353306aba12816d14881f2b88c7c9d06023825f7224700f0c01f66c65cd")
@@ -35,8 +36,11 @@ class Procps(AutotoolsPackage):
     depends_on("pkgconfig@0.9.0:", type="build")
     depends_on("dejagnu", type="test")
     depends_on("iconv")
-    depends_on("gettext", type="build")
-    depends_on("gettext", when="+nls")
+    depends_on("gettext", type="build")  # required by autogen.sh
+    with when("+nls"):
+        depends_on("gettext")
+        # msgfmt 0.22 gives parsing errors
+        depends_on("gettext@:0.21", when="@:4.0.3")
     depends_on("ncurses")
 
     conflicts("platform=darwin", msg="procps is linux-only")

var/spack/repos/builtin/packages/py-bids-validator/package.py

@@ -12,6 +12,7 @@ class PyBidsValidator(PythonPackage):
     homepage = "https://github.com/bids-standard/bids-validator"
     pypi = "bids-validator/bids-validator-1.7.2.tar.gz"
 
+    version("1.13.1", sha256="7205ce4e68fba172215332c786f1ac1665025b702b6dff2b1e158f00a2df9890")
     version("1.11.0", sha256="408c56748b7cf98cf7c31822f33a8d89c5e6e7db5254c345107e8d527576ff53")
     version("1.9.8", sha256="ff39799bb205f92d6f2c322f0b8eff0d1c0288f4291a0b18fce61afa4dfd7f3e")
     version("1.9.4", sha256="4bf07d375f231a2ad2f450beeb3ef6c54f93194fd993aa5157d57a8fba48ed50")
@@ -19,4 +20,5 @@ class PyBidsValidator(PythonPackage):
     version("1.8.4", sha256="63e7a02c9ddb5505a345e178f4e436b82c35ec0a177d7047b67ea10ea3029a68")
     version("1.7.2", sha256="12398831a3a3a2ed7c67e693cf596610c23dd23e0889bfeae0830bbd1d41e5b9")
 
+    depends_on("python@3.8:", when="@1.12:", type=("build", "run"))
     depends_on("py-setuptools", type="build")

var/spack/repos/builtin/packages/py-cmocean/package.py

@@ -13,8 +13,11 @@ class PyCmocean(PythonPackage):
     homepage = "https://matplotlib.org/cmocean/"
     pypi = "cmocean/cmocean-2.0.tar.gz"
 
+    version("3.0.3", sha256="abaf99383c1a60f52970c86052ae6c14eafa84fc16984488040283c02db77c0b")
     version("2.0", sha256="13eea3c8994d8e303e32a2db0b3e686f6edfb41cb21e7b0e663c2b17eea9b03a")
 
+    depends_on("python@3.8:", when="@3:", type=("build", "run"))
     depends_on("py-setuptools", type="build")
     depends_on("py-matplotlib", type=("build", "run"))
     depends_on("py-numpy", type=("build", "run"))
+    depends_on("py-packaging", when="@3:", type=("build", "run"))

var/spack/repos/builtin/packages/py-cylc-flow/package.py

@@ -0,0 +1,36 @@
+# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+from spack.package import *
+
+
+class PyCylcFlow(PythonPackage):
+    """A workflow engine for cycling systems."""
+
+    homepage = "https://cylc.org"
+    pypi = "cylc-flow/cylc-flow-8.1.4.tar.gz"
+
+    maintainers("LydDeb")
+
+    version("8.2.0", sha256="cbe35e0d72d1ca36f28a4cebe9b9040a3445a74253bc94051a3c906cf179ded0")
+    version("8.1.4", sha256="d1835ac18f6f24f3115c56b2bc821185484e834a86b12fd0033ff7e4dc3c1f63")
+
+    depends_on("py-setuptools@49:66,68:", type=("build", "run"))
+    depends_on("py-aiofiles@0.7", type=("build", "run"), when="@:8.1")
+    depends_on("py-ansimarkup@1.0.0:", type=("build", "run"))
+    depends_on("py-async-timeout@3.0.0:", type=("build", "run"))
+    depends_on("py-colorama@0.4:1", type=("build", "run"))
+    depends_on("py-graphene@2.1:2", type=("build", "run"))
+    depends_on("py-jinja2@3.0", type=("build", "run"))
+    depends_on("py-metomi-isodatetime@3.0", type=("build", "run"))
+    depends_on("py-protobuf@4.21.2:4.21", type=("build", "run"))
+    depends_on("py-psutil@5.6.0:", type=("build", "run"))
+    depends_on("py-pyzmq@22:", type=("build", "run"), when="@8.2:")
+    depends_on("py-pyzmq@22", type=("build", "run"), when="@:8.1")
+    depends_on("py-importlib-metadata", type=("build", "run"), when="^python@:3.7")
+    depends_on("py-urwid@2", type=("build", "run"))
+    depends_on("py-rx", type=("build", "run"))
+    depends_on("py-promise", type=("build", "run"))
+    depends_on("py-tomli@2:", type=("build", "run"), when="^python@:3.10")

var/spack/repos/builtin/packages/py-cylc-rose/package.py

@@ -0,0 +1,23 @@
+# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+from spack.package import *
+
+
+class PyCylcRose(PythonPackage):
+    """A Cylc plugin providing support for the Rose rose-suite.conf file."""
+
+    homepage = "https://cylc.github.io/cylc-doc/latest/html/plugins/cylc-rose.html"
+    pypi = "cylc-rose/cylc-rose-1.3.0.tar.gz"
+
+    maintainers("LydDeb")
+
+    version("1.3.0", sha256="017072b69d7a50fa6d309a911d2428743b07c095f308529b36b1b787ebe7ab88")
+
+    depends_on("py-setuptools", type="build")
+    depends_on("py-metomi-rose@2.1", type=("build", "run"))
+    depends_on("py-cylc-flow@8.2", type=("build", "run"))
+    depends_on("py-metomi-isodatetime", type=("build", "run"))
+    depends_on("py-jinja2", type=("build", "run"))

var/spack/repos/builtin/packages/py-doit/package.py

@@ -0,0 +1,20 @@
+# Copyright 2013-2023 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+from spack.package import *
+
+
+class PyDoit(PythonPackage):
+    """doit - Automation Tool."""
+
+    homepage = "http://pydoit.org/"
+    pypi = "doit/doit-0.36.0.tar.gz"
+
+    version("0.36.0", sha256="71d07ccc9514cb22fe59d98999577665eaab57e16f644d04336ae0b4bae234bc")
+
+    depends_on("python@3.8:", type=("build", "run"))
+    depends_on("py-setuptools", type="build")
+    depends_on("py-cloudpickle", type=("build", "run"))
+    depends_on("py-importlib-metadata@4.4:", type=("build", "run"))

var/spack/repos/builtin/packages/py-horovod/package.py

@@ -225,6 +225,8 @@ class PyHorovod(PythonPackage, CudaPackage):
     conflicts(
         "controllers=gloo", when="@:0.20.0 platform=darwin", msg="Gloo cannot be compiled on MacOS"
     )
+    # FIXME
+    conflicts("^py-torch@2.1:")
 
     # https://github.com/horovod/horovod/pull/1835
     patch("fma.patch", when="@0.19.0:0.19.1")

var/spack/repos/builtin/packages/py-ipycanvas/package.py

@@ -17,9 +17,7 @@ class PyIpycanvas(PythonPackage):
 
     depends_on("python@3.5:", type=("build", "run"))
     depends_on("py-setuptools@40.8:", type="build")
-    # TODO: replace this after concretizer learns how to concretize separate build deps
-    depends_on("py-jupyter-packaging7", type="build")
-    # depends_on('py-jupyter-packaging@0.7.0:0.7', type='build')
+    depends_on("py-jupyter-packaging@0.7", type="build")
     depends_on("py-jupyterlab@3.0:3", type="build")
     depends_on("py-ipywidgets@7.6:", type=("build", "run"))
     depends_on("pil@6:", type=("build", "run"))

var/spack/repos/builtin/packages/py-ipyevents/package.py

@@ -16,8 +16,6 @@ class PyIpyevents(PythonPackage):
 
     depends_on("python@3.6:", type=("build", "run"))
     depends_on("py-setuptools@40.8:", type="build")
-    # TODO: replace this after concretizer learns how to concretize separate build deps
-    depends_on("py-jupyter-packaging7", type="build")
-    # depends_on('py-jupyter-packaging@0.7.0:0.7', type='build')
+    depends_on("py-jupyter-packaging@0.7", type="build")
     depends_on("py-jupyterlab@3.0:3", type="build")
     depends_on("py-ipywidgets@7.6:", type=("build", "run"))

var/spack/repos/builtin/packages/py-ipympl/package.py

@@ -23,8 +23,6 @@ class PyIpympl(PythonPackage):
     depends_on("py-traitlets@:5", type=("build", "run"))
     depends_on("py-ipywidgets@7.6:7", type=("build", "run"))
     depends_on("py-matplotlib@2:3", type=("build", "run"))
-    # TODO: replace this after concretizer learns how to concretize separate build deps
-    depends_on("py-jupyter-packaging7", type="build")
-    # depends_on('py-jupyter-packaging@0.7', type='build')
+    depends_on("py-jupyter-packaging@0.7", type="build")
     depends_on("py-jupyterlab@3", type="build")
     depends_on("yarn", type="build")