Update amrex maintainers (#41122)

https://slurm.schedmd.com/faq.html#acronym

lib/spack/docs/build_settings.rst

@@ -99,547 +99,3 @@ while `py-numpy` still needs an older version:
 
 Up to Spack v0.20 ``duplicates:strategy:none`` was the default (and only) behavior. From Spack v0.21 the
 default behavior is ``duplicates:strategy:minimal``.
-
-.. _build-settings:
-
-================================
-Package Settings (packages.yaml)
-================================
-
-Spack allows you to customize how your software is built through the
-``packages.yaml`` file.  Using it, you can make Spack prefer particular
-implementations of virtual dependencies (e.g., MPI or BLAS/LAPACK),
-or you can make it prefer to build with particular compilers.  You can
-also tell Spack to use *external* software installations already
-present on your system.
-
-At a high level, the ``packages.yaml`` file is structured like this:
-
-.. code-block:: yaml
-
-   packages:
-     package1:
-       # settings for package1
-     package2:
-       # settings for package2
-     # ...
-     all:
-       # settings that apply to all packages.
-
-So you can either set build preferences specifically for *one* package,
-or you can specify that certain settings should apply to *all* packages.
-The types of settings you can customize are described in detail below.
-
-Spack's build defaults are in the default
-``etc/spack/defaults/packages.yaml`` file.  You can override them in
-``~/.spack/packages.yaml`` or ``etc/spack/packages.yaml``. For more
-details on how this works, see :ref:`configuration-scopes`.
-
-.. _sec-external-packages:
-
------------------
-External Packages
------------------
-
-Spack can be configured to use externally-installed
-packages rather than building its own packages. This may be desirable
-if machines ship with system packages, such as a customized MPI
-that should be used instead of Spack building its own MPI.
-
-External packages are configured through the ``packages.yaml`` file.
-Here's an example of an external configuration:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       externals:
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.4.3
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
-         prefix: /opt/openmpi-1.4.3-debug
-       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.6.5-intel
-
-This example lists three installations of OpenMPI, one built with GCC,
-one built with GCC and debug information, and another built with Intel.
-If Spack is asked to build a package that uses one of these MPIs as a
-dependency, it will use the pre-installed OpenMPI in
-the given directory. Note that the specified path is the top-level
-install prefix, not the ``bin`` subdirectory.
-
-``packages.yaml`` can also be used to specify modules to load instead
-of the installation prefixes.  The following example says that module
-``CMake/3.7.2`` provides cmake version 3.7.2.
-
-.. code-block:: yaml
-
-   cmake:
-     externals:
-     - spec: cmake@3.7.2
-       modules:
-       - CMake/3.7.2
-
-Each ``packages.yaml`` begins with a ``packages:`` attribute, followed
-by a list of package names.  To specify externals, add an ``externals:``
-attribute under the package name, which lists externals.
-Each external should specify a ``spec:`` string that should be as
-well-defined as reasonably possible.  If a
-package lacks a spec component, such as missing a compiler or
-package version, then Spack will guess the missing component based
-on its most-favored packages, and it may guess incorrectly.
-
-Each package version and compiler listed in an external should
-have entries in Spack's packages and compiler configuration, even
-though the package and compiler may not ever be built.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Prevent packages from being built from sources
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Adding an external spec in ``packages.yaml`` allows Spack to use an external location,
-but it does not prevent Spack from building packages from sources. In the above example,
-Spack might choose for many valid reasons to start building and linking with the
-latest version of OpenMPI rather than continue using the pre-installed OpenMPI versions.
-
-To prevent this, the ``packages.yaml`` configuration also allows packages
-to be flagged as non-buildable.  The previous example could be modified to
-be:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       externals:
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.4.3
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
-         prefix: /opt/openmpi-1.4.3-debug
-       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.6.5-intel
-       buildable: False
-
-The addition of the ``buildable`` flag tells Spack that it should never build
-its own version of OpenMPI from sources, and it will instead always rely on a pre-built
-OpenMPI.
-
-.. note::
-
-   If ``concretizer:reuse`` is on (see :ref:`concretizer-options` for more information on that flag)
-   pre-built specs include specs already available from a local store, an upstream store, a registered
-   buildcache or specs marked as externals in ``packages.yaml``. If ``concretizer:reuse`` is off, only
-   external specs in ``packages.yaml`` are included in the list of pre-built specs.
-
-If an external module is specified as not buildable, then Spack will load the
-external module into the build environment which can be used for linking.
-
-The ``buildable`` does not need to be paired with external packages.
-It could also be used alone to forbid packages that may be
-buggy or otherwise undesirable.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Non-buildable virtual packages
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Virtual packages in Spack can also be specified as not buildable, and
-external implementations can be provided. In the example above,
-OpenMPI is configured as not buildable, but Spack will often prefer
-other MPI implementations over the externally available OpenMPI. Spack
-can be configured with every MPI provider not buildable individually,
-but more conveniently:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       buildable: False
-     openmpi:
-       externals:
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.4.3
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
-         prefix: /opt/openmpi-1.4.3-debug
-       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.6.5-intel
-
-Spack can then use any of the listed external implementations of MPI
-to satisfy a dependency, and will choose depending on the compiler and
-architecture.
-
-In cases where the concretizer is configured to reuse specs, and other ``mpi`` providers
-(available via stores or buildcaches) are not wanted, Spack can be configured to require
-specs matching only the available externals:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       buildable: False
-       require:
-       - one_of: [
-           "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64",
-           "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug",
-           "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
-         ]
-     openmpi:
-       externals:
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.4.3
-       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
-         prefix: /opt/openmpi-1.4.3-debug
-       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
-         prefix: /opt/openmpi-1.6.5-intel
-
-This configuration prevents any spec using MPI and originating from stores or buildcaches to be reused,
-unless it matches the requirements under ``packages:mpi:require``. For more information on requirements see
-:ref:`package-requirements`.
-
-.. _cmd-spack-external-find:
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Automatically Find External Packages
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-You can run the :ref:`spack external find <spack-external-find>` command
-to search for system-provided packages and add them to ``packages.yaml``.
-After running this command your ``packages.yaml`` may include new entries:
-
-.. code-block:: yaml
-
-   packages:
-     cmake:
-       externals:
-       - spec: cmake@3.17.2
-         prefix: /usr
-
-Generally this is useful for detecting a small set of commonly-used packages;
-for now this is generally limited to finding build-only dependencies.
-Specific limitations include:
-
-* Packages are not discoverable by default: For a package to be
-  discoverable with ``spack external find``, it needs to add special
-  logic. See :ref:`here <make-package-findable>` for more details.
-* The logic does not search through module files, it can only detect
-  packages with executables defined in ``PATH``; you can help Spack locate
-  externals which use module files by loading any associated modules for
-  packages that you want Spack to know about before running
-  ``spack external find``.
-* Spack does not overwrite existing entries in the package configuration:
-  If there is an external defined for a spec at any configuration scope,
-  then Spack will not add a new external entry (``spack config blame packages``
-  can help locate all external entries).
-
-.. _package-requirements:
-
---------------------
-Package Requirements
---------------------
-
-Spack can be configured to always use certain compilers, package
-versions, and variants during concretization through package
-requirements.
-
-Package requirements are useful when you find yourself repeatedly
-specifying the same constraints on the command line, and wish that
-Spack respects these constraints whether you mention them explicitly
-or not. Another use case is specifying constraints that should apply
-to all root specs in an environment, without having to repeat the
-constraint everywhere.
-
-Apart from that, requirements config is more flexible than constraints
-on the command line, because it can specify constraints on packages
-*when they occur* as a dependency. In contrast, on the command line it
-is not possible to specify constraints on dependencies while also keeping
-those dependencies optional.
-
-^^^^^^^^^^^^^^^^^^^
-Requirements syntax
-^^^^^^^^^^^^^^^^^^^
-
-The package requirements configuration is specified in ``packages.yaml``,
-keyed by package name and expressed using the Spec syntax. In the simplest
-case you can specify attributes that you always want the package to have
-by providing a single spec string to ``require``:
-
-.. code-block:: yaml
-
-   packages:
-     libfabric:
-       require: "@1.13.2"
-
-In the above example, ``libfabric`` will always build with version 1.13.2. If you
-need to compose multiple configuration scopes ``require`` accepts a list of
-strings:
-
-.. code-block:: yaml
-
-   packages:
-     libfabric:
-       require:
-       - "@1.13.2"
-       - "%gcc"
-
-In this case ``libfabric`` will always build with version 1.13.2 **and** using GCC
-as a compiler.
-
-For more complex use cases, require accepts also a list of objects. These objects
-must have either a ``any_of`` or a ``one_of`` field, containing a list of spec strings,
-and they can optionally have a ``when`` and a ``message`` attribute:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       require:
-       - any_of: ["@4.1.5", "%gcc"]
-         message: "in this example only 4.1.5 can build with other compilers"
-
-``any_of`` is a list of specs. One of those specs must be satisfied
-and it is also allowed for the concretized spec to match more than one.
-In the above example, that means you could build ``openmpi@4.1.5%gcc``,
-``openmpi@4.1.5%clang`` or ``openmpi@3.9%gcc``, but
-not ``openmpi@3.9%clang``.
-
-If a custom message is provided, and the requirement is not satisfiable,
-Spack will print the custom error message:
-
-.. code-block:: console
-
-   $ spack spec openmpi@3.9%clang
-   ==> Error: in this example only 4.1.5 can build with other compilers
-
-We could express a similar requirement using the ``when`` attribute:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       require:
-       - any_of: ["%gcc"]
-         when: "@:4.1.4"
-         message: "in this example only 4.1.5 can build with other compilers"
-
-In the example above, if the version turns out to be 4.1.4 or less, we require the compiler to be GCC.
-For readability, Spack also allows a ``spec`` key accepting a string when there is only a single
-constraint:
-
-.. code-block:: yaml
-
-   packages:
-     openmpi:
-       require:
-       - spec: "%gcc"
-         when: "@:4.1.4"
-         message: "in this example only 4.1.5 can build with other compilers"
-
-This code snippet and the one before it are semantically equivalent.
-
-Finally, instead of ``any_of`` you can use ``one_of`` which also takes a list of specs. The final
-concretized spec must match one and only one of them:
-
-.. code-block:: yaml
-
-   packages:
-     mpich:
-       require:
-       - one_of: ["+cuda", "+rocm"]
-
-In the example above, that means you could build ``mpich+cuda`` or ``mpich+rocm`` but not ``mpich+cuda+rocm``.
-
-.. note::
-
-   For ``any_of`` and ``one_of``, the order of specs indicates a
-   preference: items that appear earlier in the list are preferred
-   (note that these preferences can be ignored in favor of others).
-
-.. note::
-
-   When using a conditional requirement, Spack is allowed to actively avoid the triggering
-   condition (the ``when=...`` spec) if that leads to a concrete spec with better scores in
-   the optimization criteria. To check the current optimization criteria and their
-   priorities you can run ``spack solve zlib``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Setting default requirements
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-You can also set default requirements for all packages under ``all``
-like this:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       require: '%clang'
-
-which means every spec will be required to use ``clang`` as a compiler.
-
-Note that in this case ``all`` represents a *default set of requirements* -
-if there are specific package requirements, then the default requirements
-under ``all`` are disregarded. For example, with a configuration like this:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       require: '%clang'
-     cmake:
-       require: '%gcc'
-
-Spack requires ``cmake`` to use ``gcc`` and all other nodes (including ``cmake``
-dependencies) to use ``clang``.
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Setting requirements on virtual specs
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-A requirement on a virtual spec applies whenever that virtual is present in the DAG.
-This can be useful for fixing which virtual provider you want to use:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       require: 'mvapich2 %gcc'
-
-With the configuration above the only allowed ``mpi`` provider is ``mvapich2 %gcc``.
-
-Requirements on the virtual spec and on the specific provider are both applied, if
-present. For instance with a configuration like:
-
-.. code-block:: yaml
-
-   packages:
-     mpi:
-       require: 'mvapich2 %gcc'
-     mvapich2:
-       require: '~cuda'
-
-you will use ``mvapich2~cuda %gcc`` as an ``mpi`` provider.
-
-.. _package-preferences:
-
--------------------
-Package Preferences
--------------------
-
-In some cases package requirements can be too strong, and package
-preferences are the better option. Package preferences do not impose
-constraints on packages for particular versions or variants values,
-they rather only set defaults. The concretizer is free to change
-them if it must, due to other constraints, and also prefers reusing
-installed packages over building new ones that are a better match for
-preferences.
-
-Most package preferences (``compilers``, ``target`` and ``providers``)
-can only be set globally under the ``all`` section of ``packages.yaml``:
-
-.. code-block:: yaml
-
-   packages:
-     all:
-       compiler: [gcc@12.2.0, clang@12:, oneapi@2023:]
-       target: [x86_64_v3]
-       providers:
-         mpi: [mvapich2, mpich, openmpi]
-
-These preferences override Spack's default and effectively reorder priorities
-when looking for the best compiler, target or virtual package provider. Each
-preference takes an ordered list of spec constraints, with earlier entries in
-the list being preferred over later entries.
-
-In the example above all packages prefer to be compiled with ``gcc@12.2.0``,
-to target the ``x86_64_v3`` microarchitecture and to use ``mvapich2`` if they
-depend on ``mpi``.
-
-The ``variants`` and ``version`` preferences can be set under
-package specific sections of the ``packages.yaml`` file:
-
-.. code-block:: yaml
-
-   packages:
-     opencv:
-       variants: +debug
-     gperftools:
-       version: [2.2, 2.4, 2.3]
-
-In this case, the preference for ``opencv`` is to build with debug options, while
-``gperftools`` prefers version 2.2 over 2.4.
-
-Any preference can be overwritten on the command line if explicitly requested.
-
-Preferences cannot overcome explicit constraints, as they only set a preferred
-ordering among homogeneous attribute values. Going back to the example, if
-``gperftools@2.3:`` was requested, then Spack will install version 2.4
-since the most preferred version 2.2 is prohibited by the version constraint.
-
-.. _package_permissions:
-
--------------------
-Package Permissions
--------------------
-
-Spack can be configured to assign permissions to the files installed
-by a package.
-
-In the ``packages.yaml`` file under ``permissions``, the attributes
-``read``, ``write``, and ``group`` control the package
-permissions. These attributes can be set per-package, or for all
-packages under ``all``. If permissions are set under ``all`` and for a
-specific package, the package-specific settings take precedence.
-
-The ``read`` and ``write`` attributes take one of ``user``, ``group``,
-and ``world``.
-
-.. code-block:: yaml
-
-  packages:
-    all:
-      permissions:
-        write: group
-        group: spack
-    my_app:
-      permissions:
-        read: group
-        group: my_team
-
-The permissions settings describe the broadest level of access to
-installations of the specified packages. The execute permissions of
-the file are set to the same level as read permissions for those files
-that are executable. The default setting for ``read`` is ``world``,
-and for ``write`` is ``user``. In the example above, installations of
-``my_app`` will be installed with user and group permissions but no
-world permissions, and owned by the group ``my_team``. All other
-packages will be installed with user and group write privileges, and
-world read privileges. Those packages will be owned by the group
-``spack``.
-
-The ``group`` attribute assigns a Unix-style group to a package. All
-files installed by the package will be owned by the assigned group,
-and the sticky group bit will be set on the install prefix and all
-directories inside the install prefix. This will ensure that even
-manually placed files within the install prefix are owned by the
-assigned group. If no group is assigned, Spack will allow the OS
-default behavior to go as expected.
-
-----------------------------
-Assigning Package Attributes
-----------------------------
-
-You can assign class-level attributes in the configuration:
-
-.. code-block:: yaml
-
-  packages:
-    mpileaks:
-      # Override existing attributes
-      url: http://www.somewhereelse.com/mpileaks-1.0.tar.gz
-      # ... or add new ones
-      x: 1
-
-Attributes set this way will be accessible to any method executed
-in the package.py file (e.g. the ``install()`` method). Values for these
-attributes may be any value parseable by yaml.
-
-These can only be applied to specific packages, not "all" or
-virtual packages.

lib/spack/docs/build_systems/intelpackage.rst

@@ -392,7 +392,7 @@ See section
 :ref:`Configuration Scopes <configuration-scopes>`
 for an explanation about the different files
 and section
-:ref:`Build customization <build-settings>`
+:ref:`Build customization <packages-config>`
 for specifics and examples for ``packages.yaml`` files.
 
 .. If your system administrator did not provide modules for pre-installed Intel

lib/spack/docs/configuration.rst

@@ -17,7 +17,7 @@ case you want to skip directly to specific docs:
 * :ref:`config.yaml <config-yaml>`
 * :ref:`mirrors.yaml <mirrors>`
 * :ref:`modules.yaml <modules>`
-* :ref:`packages.yaml <build-settings>`
+* :ref:`packages.yaml <packages-config>`
 * :ref:`repos.yaml <repositories>`
 
 You can also add any of these as inline configuration in the YAML

lib/spack/docs/index.rst

@@ -70,7 +70,7 @@ or refer to the full manual below.
 
    configuration
    config_yaml
-   bootstrapping
+   packages_yaml
    build_settings
    environments
    containers
@@ -78,6 +78,7 @@ or refer to the full manual below.
    module_file_support
    repositories
    binary_caches
+   bootstrapping
    command_index
    chain
    extensions

lib/spack/docs/packages_yaml.rst

@@ -0,0 +1,549 @@
+.. 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)
+
+
+.. _packages-config:
+
+================================
+Package Settings (packages.yaml)
+================================
+
+Spack allows you to customize how your software is built through the
+``packages.yaml`` file.  Using it, you can make Spack prefer particular
+implementations of virtual dependencies (e.g., MPI or BLAS/LAPACK),
+or you can make it prefer to build with particular compilers.  You can
+also tell Spack to use *external* software installations already
+present on your system.
+
+At a high level, the ``packages.yaml`` file is structured like this:
+
+.. code-block:: yaml
+
+   packages:
+     package1:
+       # settings for package1
+     package2:
+       # settings for package2
+     # ...
+     all:
+       # settings that apply to all packages.
+
+So you can either set build preferences specifically for *one* package,
+or you can specify that certain settings should apply to *all* packages.
+The types of settings you can customize are described in detail below.
+
+Spack's build defaults are in the default
+``etc/spack/defaults/packages.yaml`` file.  You can override them in
+``~/.spack/packages.yaml`` or ``etc/spack/packages.yaml``. For more
+details on how this works, see :ref:`configuration-scopes`.
+
+.. _sec-external-packages:
+
+-----------------
+External Packages
+-----------------
+
+Spack can be configured to use externally-installed
+packages rather than building its own packages. This may be desirable
+if machines ship with system packages, such as a customized MPI
+that should be used instead of Spack building its own MPI.
+
+External packages are configured through the ``packages.yaml`` file.
+Here's an example of an external configuration:
+
+.. code-block:: yaml
+
+   packages:
+     openmpi:
+       externals:
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.4.3
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
+         prefix: /opt/openmpi-1.4.3-debug
+       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.6.5-intel
+
+This example lists three installations of OpenMPI, one built with GCC,
+one built with GCC and debug information, and another built with Intel.
+If Spack is asked to build a package that uses one of these MPIs as a
+dependency, it will use the pre-installed OpenMPI in
+the given directory. Note that the specified path is the top-level
+install prefix, not the ``bin`` subdirectory.
+
+``packages.yaml`` can also be used to specify modules to load instead
+of the installation prefixes.  The following example says that module
+``CMake/3.7.2`` provides cmake version 3.7.2.
+
+.. code-block:: yaml
+
+   cmake:
+     externals:
+     - spec: cmake@3.7.2
+       modules:
+       - CMake/3.7.2
+
+Each ``packages.yaml`` begins with a ``packages:`` attribute, followed
+by a list of package names.  To specify externals, add an ``externals:``
+attribute under the package name, which lists externals.
+Each external should specify a ``spec:`` string that should be as
+well-defined as reasonably possible.  If a
+package lacks a spec component, such as missing a compiler or
+package version, then Spack will guess the missing component based
+on its most-favored packages, and it may guess incorrectly.
+
+Each package version and compiler listed in an external should
+have entries in Spack's packages and compiler configuration, even
+though the package and compiler may not ever be built.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Prevent packages from being built from sources
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Adding an external spec in ``packages.yaml`` allows Spack to use an external location,
+but it does not prevent Spack from building packages from sources. In the above example,
+Spack might choose for many valid reasons to start building and linking with the
+latest version of OpenMPI rather than continue using the pre-installed OpenMPI versions.
+
+To prevent this, the ``packages.yaml`` configuration also allows packages
+to be flagged as non-buildable.  The previous example could be modified to
+be:
+
+.. code-block:: yaml
+
+   packages:
+     openmpi:
+       externals:
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.4.3
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
+         prefix: /opt/openmpi-1.4.3-debug
+       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.6.5-intel
+       buildable: False
+
+The addition of the ``buildable`` flag tells Spack that it should never build
+its own version of OpenMPI from sources, and it will instead always rely on a pre-built
+OpenMPI.
+
+.. note::
+
+   If ``concretizer:reuse`` is on (see :ref:`concretizer-options` for more information on that flag)
+   pre-built specs include specs already available from a local store, an upstream store, a registered
+   buildcache or specs marked as externals in ``packages.yaml``. If ``concretizer:reuse`` is off, only
+   external specs in ``packages.yaml`` are included in the list of pre-built specs.
+
+If an external module is specified as not buildable, then Spack will load the
+external module into the build environment which can be used for linking.
+
+The ``buildable`` does not need to be paired with external packages.
+It could also be used alone to forbid packages that may be
+buggy or otherwise undesirable.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Non-buildable virtual packages
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Virtual packages in Spack can also be specified as not buildable, and
+external implementations can be provided. In the example above,
+OpenMPI is configured as not buildable, but Spack will often prefer
+other MPI implementations over the externally available OpenMPI. Spack
+can be configured with every MPI provider not buildable individually,
+but more conveniently:
+
+.. code-block:: yaml
+
+   packages:
+     mpi:
+       buildable: False
+     openmpi:
+       externals:
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.4.3
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
+         prefix: /opt/openmpi-1.4.3-debug
+       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.6.5-intel
+
+Spack can then use any of the listed external implementations of MPI
+to satisfy a dependency, and will choose depending on the compiler and
+architecture.
+
+In cases where the concretizer is configured to reuse specs, and other ``mpi`` providers
+(available via stores or buildcaches) are not wanted, Spack can be configured to require
+specs matching only the available externals:
+
+.. code-block:: yaml
+
+   packages:
+     mpi:
+       buildable: False
+       require:
+       - one_of: [
+           "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64",
+           "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug",
+           "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
+         ]
+     openmpi:
+       externals:
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.4.3
+       - spec: "openmpi@1.4.3%gcc@4.4.7 arch=linux-debian7-x86_64+debug"
+         prefix: /opt/openmpi-1.4.3-debug
+       - spec: "openmpi@1.6.5%intel@10.1 arch=linux-debian7-x86_64"
+         prefix: /opt/openmpi-1.6.5-intel
+
+This configuration prevents any spec using MPI and originating from stores or buildcaches to be reused,
+unless it matches the requirements under ``packages:mpi:require``. For more information on requirements see
+:ref:`package-requirements`.
+
+.. _cmd-spack-external-find:
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Automatically Find External Packages
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You can run the :ref:`spack external find <spack-external-find>` command
+to search for system-provided packages and add them to ``packages.yaml``.
+After running this command your ``packages.yaml`` may include new entries:
+
+.. code-block:: yaml
+
+   packages:
+     cmake:
+       externals:
+       - spec: cmake@3.17.2
+         prefix: /usr
+
+Generally this is useful for detecting a small set of commonly-used packages;
+for now this is generally limited to finding build-only dependencies.
+Specific limitations include:
+
+* Packages are not discoverable by default: For a package to be
+  discoverable with ``spack external find``, it needs to add special
+  logic. See :ref:`here <make-package-findable>` for more details.
+* The logic does not search through module files, it can only detect
+  packages with executables defined in ``PATH``; you can help Spack locate
+  externals which use module files by loading any associated modules for
+  packages that you want Spack to know about before running
+  ``spack external find``.
+* Spack does not overwrite existing entries in the package configuration:
+  If there is an external defined for a spec at any configuration scope,
+  then Spack will not add a new external entry (``spack config blame packages``
+  can help locate all external entries).
+
+.. _package-requirements:
+
+--------------------
+Package Requirements
+--------------------
+
+Spack can be configured to always use certain compilers, package
+versions, and variants during concretization through package
+requirements.
+
+Package requirements are useful when you find yourself repeatedly
+specifying the same constraints on the command line, and wish that
+Spack respects these constraints whether you mention them explicitly
+or not. Another use case is specifying constraints that should apply
+to all root specs in an environment, without having to repeat the
+constraint everywhere.
+
+Apart from that, requirements config is more flexible than constraints
+on the command line, because it can specify constraints on packages
+*when they occur* as a dependency. In contrast, on the command line it
+is not possible to specify constraints on dependencies while also keeping
+those dependencies optional.
+
+^^^^^^^^^^^^^^^^^^^
+Requirements syntax
+^^^^^^^^^^^^^^^^^^^
+
+The package requirements configuration is specified in ``packages.yaml``,
+keyed by package name and expressed using the Spec syntax. In the simplest
+case you can specify attributes that you always want the package to have
+by providing a single spec string to ``require``:
+
+.. code-block:: yaml
+
+   packages:
+     libfabric:
+       require: "@1.13.2"
+
+In the above example, ``libfabric`` will always build with version 1.13.2. If you
+need to compose multiple configuration scopes ``require`` accepts a list of
+strings:
+
+.. code-block:: yaml
+
+   packages:
+     libfabric:
+       require:
+       - "@1.13.2"
+       - "%gcc"
+
+In this case ``libfabric`` will always build with version 1.13.2 **and** using GCC
+as a compiler.
+
+For more complex use cases, require accepts also a list of objects. These objects
+must have either a ``any_of`` or a ``one_of`` field, containing a list of spec strings,
+and they can optionally have a ``when`` and a ``message`` attribute:
+
+.. code-block:: yaml
+
+   packages:
+     openmpi:
+       require:
+       - any_of: ["@4.1.5", "%gcc"]
+         message: "in this example only 4.1.5 can build with other compilers"
+
+``any_of`` is a list of specs. One of those specs must be satisfied
+and it is also allowed for the concretized spec to match more than one.
+In the above example, that means you could build ``openmpi@4.1.5%gcc``,
+``openmpi@4.1.5%clang`` or ``openmpi@3.9%gcc``, but
+not ``openmpi@3.9%clang``.
+
+If a custom message is provided, and the requirement is not satisfiable,
+Spack will print the custom error message:
+
+.. code-block:: console
+
+   $ spack spec openmpi@3.9%clang
+   ==> Error: in this example only 4.1.5 can build with other compilers
+
+We could express a similar requirement using the ``when`` attribute:
+
+.. code-block:: yaml
+
+   packages:
+     openmpi:
+       require:
+       - any_of: ["%gcc"]
+         when: "@:4.1.4"
+         message: "in this example only 4.1.5 can build with other compilers"
+
+In the example above, if the version turns out to be 4.1.4 or less, we require the compiler to be GCC.
+For readability, Spack also allows a ``spec`` key accepting a string when there is only a single
+constraint:
+
+.. code-block:: yaml
+
+   packages:
+     openmpi:
+       require:
+       - spec: "%gcc"
+         when: "@:4.1.4"
+         message: "in this example only 4.1.5 can build with other compilers"
+
+This code snippet and the one before it are semantically equivalent.
+
+Finally, instead of ``any_of`` you can use ``one_of`` which also takes a list of specs. The final
+concretized spec must match one and only one of them:
+
+.. code-block:: yaml
+
+   packages:
+     mpich:
+       require:
+       - one_of: ["+cuda", "+rocm"]
+
+In the example above, that means you could build ``mpich+cuda`` or ``mpich+rocm`` but not ``mpich+cuda+rocm``.
+
+.. note::
+
+   For ``any_of`` and ``one_of``, the order of specs indicates a
+   preference: items that appear earlier in the list are preferred
+   (note that these preferences can be ignored in favor of others).
+
+.. note::
+
+   When using a conditional requirement, Spack is allowed to actively avoid the triggering
+   condition (the ``when=...`` spec) if that leads to a concrete spec with better scores in
+   the optimization criteria. To check the current optimization criteria and their
+   priorities you can run ``spack solve zlib``.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Setting default requirements
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You can also set default requirements for all packages under ``all``
+like this:
+
+.. code-block:: yaml
+
+   packages:
+     all:
+       require: '%clang'
+
+which means every spec will be required to use ``clang`` as a compiler.
+
+Note that in this case ``all`` represents a *default set of requirements* -
+if there are specific package requirements, then the default requirements
+under ``all`` are disregarded. For example, with a configuration like this:
+
+.. code-block:: yaml
+
+   packages:
+     all:
+       require: '%clang'
+     cmake:
+       require: '%gcc'
+
+Spack requires ``cmake`` to use ``gcc`` and all other nodes (including ``cmake``
+dependencies) to use ``clang``.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Setting requirements on virtual specs
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A requirement on a virtual spec applies whenever that virtual is present in the DAG.
+This can be useful for fixing which virtual provider you want to use:
+
+.. code-block:: yaml
+
+   packages:
+     mpi:
+       require: 'mvapich2 %gcc'
+
+With the configuration above the only allowed ``mpi`` provider is ``mvapich2 %gcc``.
+
+Requirements on the virtual spec and on the specific provider are both applied, if
+present. For instance with a configuration like:
+
+.. code-block:: yaml
+
+   packages:
+     mpi:
+       require: 'mvapich2 %gcc'
+     mvapich2:
+       require: '~cuda'
+
+you will use ``mvapich2~cuda %gcc`` as an ``mpi`` provider.
+
+.. _package-preferences:
+
+-------------------
+Package Preferences
+-------------------
+
+In some cases package requirements can be too strong, and package
+preferences are the better option. Package preferences do not impose
+constraints on packages for particular versions or variants values,
+they rather only set defaults. The concretizer is free to change
+them if it must, due to other constraints, and also prefers reusing
+installed packages over building new ones that are a better match for
+preferences.
+
+Most package preferences (``compilers``, ``target`` and ``providers``)
+can only be set globally under the ``all`` section of ``packages.yaml``:
+
+.. code-block:: yaml
+
+   packages:
+     all:
+       compiler: [gcc@12.2.0, clang@12:, oneapi@2023:]
+       target: [x86_64_v3]
+       providers:
+         mpi: [mvapich2, mpich, openmpi]
+
+These preferences override Spack's default and effectively reorder priorities
+when looking for the best compiler, target or virtual package provider. Each
+preference takes an ordered list of spec constraints, with earlier entries in
+the list being preferred over later entries.
+
+In the example above all packages prefer to be compiled with ``gcc@12.2.0``,
+to target the ``x86_64_v3`` microarchitecture and to use ``mvapich2`` if they
+depend on ``mpi``.
+
+The ``variants`` and ``version`` preferences can be set under
+package specific sections of the ``packages.yaml`` file:
+
+.. code-block:: yaml
+
+   packages:
+     opencv:
+       variants: +debug
+     gperftools:
+       version: [2.2, 2.4, 2.3]
+
+In this case, the preference for ``opencv`` is to build with debug options, while
+``gperftools`` prefers version 2.2 over 2.4.
+
+Any preference can be overwritten on the command line if explicitly requested.
+
+Preferences cannot overcome explicit constraints, as they only set a preferred
+ordering among homogeneous attribute values. Going back to the example, if
+``gperftools@2.3:`` was requested, then Spack will install version 2.4
+since the most preferred version 2.2 is prohibited by the version constraint.
+
+.. _package_permissions:
+
+-------------------
+Package Permissions
+-------------------
+
+Spack can be configured to assign permissions to the files installed
+by a package.
+
+In the ``packages.yaml`` file under ``permissions``, the attributes
+``read``, ``write``, and ``group`` control the package
+permissions. These attributes can be set per-package, or for all
+packages under ``all``. If permissions are set under ``all`` and for a
+specific package, the package-specific settings take precedence.
+
+The ``read`` and ``write`` attributes take one of ``user``, ``group``,
+and ``world``.
+
+.. code-block:: yaml
+
+  packages:
+    all:
+      permissions:
+        write: group
+        group: spack
+    my_app:
+      permissions:
+        read: group
+        group: my_team
+
+The permissions settings describe the broadest level of access to
+installations of the specified packages. The execute permissions of
+the file are set to the same level as read permissions for those files
+that are executable. The default setting for ``read`` is ``world``,
+and for ``write`` is ``user``. In the example above, installations of
+``my_app`` will be installed with user and group permissions but no
+world permissions, and owned by the group ``my_team``. All other
+packages will be installed with user and group write privileges, and
+world read privileges. Those packages will be owned by the group
+``spack``.
+
+The ``group`` attribute assigns a Unix-style group to a package. All
+files installed by the package will be owned by the assigned group,
+and the sticky group bit will be set on the install prefix and all
+directories inside the install prefix. This will ensure that even
+manually placed files within the install prefix are owned by the
+assigned group. If no group is assigned, Spack will allow the OS
+default behavior to go as expected.
+
+----------------------------
+Assigning Package Attributes
+----------------------------
+
+You can assign class-level attributes in the configuration:
+
+.. code-block:: yaml
+
+  packages:
+    mpileaks:
+      # Override existing attributes
+      url: http://www.somewhereelse.com/mpileaks-1.0.tar.gz
+      # ... or add new ones
+      x: 1
+
+Attributes set this way will be accessible to any method executed
+in the package.py file (e.g. the ``install()`` method). Values for these
+attributes may be any value parseable by yaml.
+
+These can only be applied to specific packages, not "all" or
+virtual packages.

lib/spack/docs/packaging_guide.rst

@@ -2337,7 +2337,7 @@ window while a batch job is running ``spack install`` on the same or
 overlapping dependencies without any process trying to re-do the work of
 another.
 
-For example, if you are using SLURM, you could launch an installation
+For example, if you are using Slurm, you could launch an installation
 of ``mpich`` using the following command:
 
 .. code-block:: console

lib/spack/docs/requirements.txt

@@ -5,7 +5,7 @@ sphinx-rtd-theme==1.3.0
 python-levenshtein==0.23.0
 docutils==0.18.1
 pygments==2.16.1
-urllib3==2.0.7
+urllib3==2.1.0
 pytest==7.4.3
 isort==5.12.0
 black==23.11.0

lib/spack/spack/audit.py

@@ -40,6 +40,7 @@ def _search_duplicate_compilers(error_cls):
 import collections.abc
 import glob
 import inspect
+import io
 import itertools
 import pathlib
 import pickle
@@ -54,6 +55,7 @@ def _search_duplicate_compilers(error_cls):
 import spack.repo
 import spack.spec
 import spack.util.crypto
+import spack.util.spack_yaml as syaml
 import spack.variant
 
 #: Map an audit tag to a list of callables implementing checks
@@ -250,6 +252,40 @@ def _search_duplicate_specs_in_externals(error_cls):
     return errors
 
 
+@config_packages
+def _deprecated_preferences(error_cls):
+    """Search package preferences deprecated in v0.21 (and slated for removal in v0.22)"""
+    # TODO (v0.22): remove this audit as the attributes will not be allowed in config
+    errors = []
+    packages_yaml = spack.config.CONFIG.get_config("packages")
+
+    def make_error(attribute_name, config_data, summary):
+        s = io.StringIO()
+        s.write("Occurring in the following file:\n")
+        dict_view = syaml.syaml_dict((k, v) for k, v in config_data.items() if k == attribute_name)
+        syaml.dump_config(dict_view, stream=s, blame=True)
+        return error_cls(summary=summary, details=[s.getvalue()])
+
+    if "all" in packages_yaml and "version" in packages_yaml["all"]:
+        summary = "Using the deprecated 'version' attribute under 'packages:all'"
+        errors.append(make_error("version", packages_yaml["all"], summary))
+
+    for package_name in packages_yaml:
+        if package_name == "all":
+            continue
+
+        package_conf = packages_yaml[package_name]
+        for attribute in ("compiler", "providers", "target"):
+            if attribute not in package_conf:
+                continue
+            summary = (
+                f"Using the deprecated '{attribute}' attribute " f"under 'packages:{package_name}'"
+            )
+            errors.append(make_error(attribute, package_conf, summary))
+
+    return errors
+
+
 #: Sanity checks on package directives
 package_directives = AuditClass(
     group="packages",
@@ -776,7 +812,7 @@ def _version_constraints_are_satisfiable_by_some_version_in_repo(pkgs, error_cls
                 )
             except Exception:
                 summary = (
-                    "{0}: dependency on {1} cannot be satisfied " "by known versions of {1.name}"
+                    "{0}: dependency on {1} cannot be satisfied by known versions of {1.name}"
                 ).format(pkg_name, s)
                 details = ["happening in " + filename]
                 if dependency_pkg_cls is not None:
@@ -818,6 +854,53 @@ def _analyze_variants_in_directive(pkg, constraint, directive, error_cls):
     return errors
 
 
+@package_directives
+def _named_specs_in_when_arguments(pkgs, error_cls):
+    """Reports named specs in the 'when=' attribute of a directive.
+
+    Note that 'conflicts' is the only directive allowing that.
+    """
+    errors = []
+    for pkg_name in pkgs:
+        pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)
+
+        def _extracts_errors(triggers, summary):
+            _errors = []
+            for trigger in list(triggers):
+                when_spec = spack.spec.Spec(trigger)
+                if when_spec.name is not None and when_spec.name != pkg_name:
+                    details = [f"using '{trigger}', should be '^{trigger}'"]
+                    _errors.append(error_cls(summary=summary, details=details))
+            return _errors
+
+        for dname, triggers in pkg_cls.dependencies.items():
+            summary = f"{pkg_name}: wrong 'when=' condition for the '{dname}' dependency"
+            errors.extend(_extracts_errors(triggers, summary))
+
+        for vname, (variant, triggers) in pkg_cls.variants.items():
+            summary = f"{pkg_name}: wrong 'when=' condition for the '{vname}' variant"
+            errors.extend(_extracts_errors(triggers, summary))
+
+        for provided, triggers in pkg_cls.provided.items():
+            summary = f"{pkg_name}: wrong 'when=' condition for the '{provided}' virtual"
+            errors.extend(_extracts_errors(triggers, summary))
+
+        for _, triggers in pkg_cls.requirements.items():
+            triggers = [when_spec for when_spec, _, _ in triggers]
+            summary = f"{pkg_name}: wrong 'when=' condition in 'requires' directive"
+            errors.extend(_extracts_errors(triggers, summary))
+
+        triggers = list(pkg_cls.patches)
+        summary = f"{pkg_name}: wrong 'when=' condition in 'patch' directives"
+        errors.extend(_extracts_errors(triggers, summary))
+
+        triggers = list(pkg_cls.resources)
+        summary = f"{pkg_name}: wrong 'when=' condition in 'resource' directives"
+        errors.extend(_extracts_errors(triggers, summary))
+
+    return llnl.util.lang.dedupe(errors)
+
+
 #: Sanity checks on package directives
 external_detection = AuditClass(
     group="externals",

lib/spack/spack/cmd/audit.py

@@ -2,6 +2,8 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import warnings
+
 import llnl.util.tty as tty
 import llnl.util.tty.colify
 import llnl.util.tty.color as cl
@@ -52,8 +54,10 @@ def setup_parser(subparser):
 
 
 def configs(parser, args):
-    reports = spack.audit.run_group(args.subcommand)
-    _process_reports(reports)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        reports = spack.audit.run_group(args.subcommand)
+        _process_reports(reports)
 
 
 def packages(parser, args):

lib/spack/spack/modules/common.py

@@ -62,7 +62,7 @@
 
 #: config section for this file
 def configuration(module_set_name):
-    config_path = "modules:%s" % module_set_name
+    config_path = f"modules:{module_set_name}"
     return spack.config.get(config_path, {})
 
 
@@ -96,10 +96,10 @@ def _check_tokens_are_valid(format_string, message):
     named_tokens = re.findall(r"{(\w*)}", format_string)
     invalid_tokens = [x for x in named_tokens if x.lower() not in _valid_tokens]
     if invalid_tokens:
-        msg = message
-        msg += " [{0}]. ".format(", ".join(invalid_tokens))
-        msg += 'Did you check your "modules.yaml" configuration?'
-        raise RuntimeError(msg)
+        raise RuntimeError(
+            f"{message} [{', '.join(invalid_tokens)}]. "
+            f"Did you check your 'modules.yaml' configuration?"
+        )
 
 
 def update_dictionary_extending_lists(target, update):
@@ -219,7 +219,7 @@ def root_path(name, module_set_name):
     """
     defaults = {"lmod": "$spack/share/spack/lmod", "tcl": "$spack/share/spack/modules"}
     # Root folders where the various module files should be written
-    roots = spack.config.get("modules:%s:roots" % module_set_name, {})
+    roots = spack.config.get(f"modules:{module_set_name}:roots", {})
 
     # Merge config values into the defaults so we prefer configured values
     roots = spack.config.merge_yaml(defaults, roots)
@@ -262,7 +262,7 @@ def read_module_index(root):
     index_path = os.path.join(root, "module-index.yaml")
     if not os.path.exists(index_path):
         return {}
-    with open(index_path, "r") as index_file:
+    with open(index_path) as index_file:
         return _read_module_index(index_file)
 
 
@@ -310,21 +310,21 @@ def upstream_module(self, spec, module_type):
         if db_for_spec in self.upstream_dbs:
             db_index = self.upstream_dbs.index(db_for_spec)
         elif db_for_spec:
-            raise spack.error.SpackError("Unexpected: {0} is installed locally".format(spec))
+            raise spack.error.SpackError(f"Unexpected: {spec} is installed locally")
         else:
-            raise spack.error.SpackError("Unexpected: no install DB found for {0}".format(spec))
+            raise spack.error.SpackError(f"Unexpected: no install DB found for {spec}")
         module_index = self.module_indices[db_index]
         module_type_index = module_index.get(module_type, {})
         if not module_type_index:
             tty.debug(
-                "No {0} modules associated with the Spack instance where"
-                " {1} is installed".format(module_type, spec)
+                f"No {module_type} modules associated with the Spack instance "
+                f"where {spec} is installed"
             )
             return None
         if spec.dag_hash() in module_type_index:
             return module_type_index[spec.dag_hash()]
         else:
-            tty.debug("No module is available for upstream package {0}".format(spec))
+            tty.debug(f"No module is available for upstream package {spec}")
             return None
 
 
@@ -603,7 +603,7 @@ def filename(self):
         # Just the name of the file
         filename = self.use_name
         if self.extension:
-            filename = "{0}.{1}".format(self.use_name, self.extension)
+            filename = f"{self.use_name}.{self.extension}"
         # Architecture sub-folder
         arch_folder_conf = spack.config.get("modules:%s:arch_folder" % self.conf.name, True)
         if arch_folder_conf:
@@ -671,7 +671,7 @@ def configure_options(self):
             return msg
 
         if os.path.exists(pkg.install_configure_args_path):
-            with open(pkg.install_configure_args_path, "r") as args_file:
+            with open(pkg.install_configure_args_path) as args_file:
                 return spack.util.path.padding_filter(args_file.read())
 
         # Returning a false-like value makes the default templates skip
@@ -886,7 +886,7 @@ def _get_template(self):
         # 2. template specified in a package directly
         # 3. default template (must be defined, check in __init__)
         module_system_name = str(self.module.__name__).split(".")[-1]
-        package_attribute = "{0}_template".format(module_system_name)
+        package_attribute = f"{module_system_name}_template"
         choices = [
             self.conf.template,
             getattr(self.spec.package, package_attribute, None),
@@ -952,7 +952,7 @@ def write(self, overwrite=False):
 
         # Attribute from package
         module_name = str(self.module.__name__).split(".")[-1]
-        attr_name = "{0}_context".format(module_name)
+        attr_name = f"{module_name}_context"
         pkg_update = getattr(self.spec.package, attr_name, {})
         context.update(pkg_update)
 
@@ -1002,7 +1002,7 @@ def update_module_hiddenness(self, remove=False):
 
         if modulerc_exists:
             # retrieve modulerc content
-            with open(modulerc_path, "r") as f:
+            with open(modulerc_path) as f:
                 content = f.readlines()
                 content = "".join(content).split("\n")
                 # remove last empty item if any

lib/spack/spack/schema/packages.py

@@ -69,6 +69,8 @@
     "patternProperties": {r"\w+": {}},
 }
 
+REQUIREMENT_URL = "https://spack.readthedocs.io/en/latest/packages_yaml.html#package-requirements"
+
 #: Properties for inclusion in other schemas
 properties = {
     "packages": {
@@ -117,7 +119,7 @@
                     "properties": ["version"],
                     "message": "setting version preferences in the 'all' section of packages.yaml "
                     "is deprecated and will be removed in v0.22\n\n\tThese preferences "
-                    "will be ignored by Spack. You can set them only in package specific sections "
+                    "will be ignored by Spack. You can set them only in package-specific sections "
                     "of the same file.\n",
                     "error": False,
                 },
@@ -162,10 +164,14 @@
                 },
                 "deprecatedProperties": {
                     "properties": ["target", "compiler", "providers"],
-                    "message": "setting compiler, target or provider preferences in a package "
-                    "specific section of packages.yaml is deprecated, and will be removed in "
-                    "v0.22.\n\n\tThese preferences will be ignored by Spack. You "
-                    "can set them only in the 'all' section of the same file.\n",
+                    "message": "setting 'compiler:', 'target:' or 'provider:' preferences in "
+                    "a package-specific section of packages.yaml is deprecated, and will be "
+                    "removed in v0.22.\n\n\tThese preferences will be ignored by Spack, and "
+                    "can be set only in the 'all' section of the same file. "
+                    "You can run:\n\n\t\t$ spack audit configs\n\n\tto get better diagnostics, "
+                    "including files:lines where the deprecated attributes are used.\n\n"
+                    "\tUse requirements to enforce conditions on specific packages: "
+                    f"{REQUIREMENT_URL}\n",
                     "error": False,
                 },
             }

lib/spack/spack/solver/asp.py

@@ -713,7 +713,7 @@ def _get_cause_tree(
         (condition_id, set_id) in which the latter idea means that the condition represented by
         the former held in the condition set represented by the latter.
         """
-        seen = set(seen) | set(cause)
+        seen.add(cause)
         parents = [c for e, c in condition_causes if e == cause and c not in seen]
         local = "required because %s " % conditions[cause[0]]
 
@@ -812,7 +812,14 @@ def on_model(model):
         errors = sorted(
             [(int(priority), msg, args) for priority, msg, *args in error_args], reverse=True
         )
-        msg = self.message(errors)
+        try:
+            msg = self.message(errors)
+        except Exception as e:
+            msg = (
+                f"unexpected error during concretization [{str(e)}]. "
+                f"Please report a bug at https://github.com/spack/spack/issues"
+            )
+            raise spack.error.SpackError(msg)
         raise UnsatisfiableSpecError(msg)
 
 

lib/spack/spack/test/cmd/env.py

@@ -53,6 +53,7 @@
 stage = SpackCommand("stage")
 uninstall = SpackCommand("uninstall")
 find = SpackCommand("find")
+module = SpackCommand("module")
 
 sep = os.sep
 
@@ -1105,13 +1106,14 @@ def test_multi_env_remove(mutable_mock_env_path, monkeypatch, answer):
         assert all(e in env("list") for e in environments)
 
 
-def test_env_loads(install_mockery, mock_fetch):
+def test_env_loads(install_mockery, mock_fetch, mock_modules_root):
     env("create", "test")
 
     with ev.read("test"):
         add("mpileaks")
         concretize()
         install("--fake")
+        module("tcl", "refresh", "-y")
 
     with ev.read("test"):
         env("loads")

lib/spack/spack/test/conftest.py

@@ -6,6 +6,7 @@
 import collections
 import datetime
 import errno
+import functools
 import inspect
 import itertools
 import json
@@ -1967,3 +1968,14 @@ def __exit__(self, *args):
             pass
 
     monkeypatch.setattr(spack.cmd.buildcache, "_make_pool", MockPool)
+
+
+def _root_path(x, y, *, path):
+    return path
+
+
+@pytest.fixture
+def mock_modules_root(tmp_path, monkeypatch):
+    """Sets the modules root to a temporary directory, to avoid polluting configuration scopes."""
+    fn = functools.partial(_root_path, path=str(tmp_path))
+    monkeypatch.setattr(spack.modules.common, "root_path", fn)

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

@@ -14,12 +14,7 @@
 #   ~/.spack/modules.yaml
 # -------------------------------------------------------------------------
 modules:
-  default:
-    enable:
-      - tcl
-    roots:
-      tcl: $user_cache_path/tcl
-      lmod: $user_cache_path/lmod
+  default: {}
   prefix_inspections:
     bin:
       - PATH

lib/spack/spack/test/llnl/util/lock.py

@@ -18,7 +18,7 @@
     mpirun -n 7 spack test lock
 
 And it will test locking correctness among MPI processes.  Ideally, you
-want the MPI processes to span across multiple nodes, so, e.g., for SLURM
+want the MPI processes to span across multiple nodes, so, e.g., for Slurm
 you might do this::
 
     srun -N 7 -n 7 -m cyclic spack test lock

lib/spack/spack/test/modules/common.py

@@ -17,7 +17,10 @@
 from spack.modules.common import UpstreamModuleIndex
 from spack.spec import Spec
 
-pytestmark = pytest.mark.not_on_windows("does not run on windows")
+pytestmark = [
+    pytest.mark.not_on_windows("does not run on windows"),
+    pytest.mark.usefixtures("mock_modules_root"),
+]
 
 
 def test_update_dictionary_extending_list():
@@ -174,6 +177,7 @@ def test_load_installed_package_not_in_repo(install_mockery, mock_fetch, monkeyp
     """Test that installed packages that have been removed are still loadable"""
     spec = Spec("trivial-install-test-package").concretized()
     spec.package.do_install()
+    spack.modules.module_types["tcl"](spec, "default", True).write()
 
     def find_nothing(*args):
         raise spack.repo.UnknownPackageError("Repo package access is disabled for test")

lib/spack/spack/test/modules/conftest.py

@@ -2,6 +2,8 @@
 # Spack Project Developers. See the top-level COPYRIGHT file for details.
 #
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
+import pathlib
+
 import pytest
 
 import spack.config
@@ -13,26 +15,15 @@
 
 @pytest.fixture()
 def modulefile_content(request):
-    """Returns a function that generates the content of a module file
-    as a list of lines.
-    """
-
+    """Returns a function that generates the content of a module file as a list of lines."""
     writer_cls = getattr(request.module, "writer_cls")
 
     def _impl(spec_str, module_set_name="default", explicit=True):
-        # Write the module file
-        spec = spack.spec.Spec(spec_str)
-        spec.concretize()
+        spec = spack.spec.Spec(spec_str).concretized()
         generator = writer_cls(spec, module_set_name, explicit)
         generator.write(overwrite=True)
-
-        # Get its filename
-        filename = generator.layout.filename
-
-        # Retrieve the content
-        with open(filename) as f:
-            content = f.readlines()
-            content = "".join(content).split("\n")
+        written_module = pathlib.Path(generator.layout.filename)
+        content = written_module.read_text().splitlines()
         generator.remove()
         return content
 
@@ -40,27 +31,21 @@ def _impl(spec_str, module_set_name="default", explicit=True):
 
 
 @pytest.fixture()
-def factory(request):
-    """Function that, given a spec string, returns an instance of the writer
-    and the corresponding spec.
-    """
-
-    # Class of the module file writer
+def factory(request, mock_modules_root):
+    """Given a spec string, returns an instance of the writer and the corresponding spec."""
     writer_cls = getattr(request.module, "writer_cls")
 
     def _mock(spec_string, module_set_name="default", explicit=True):
-        spec = spack.spec.Spec(spec_string)
-        spec.concretize()
+        spec = spack.spec.Spec(spec_string).concretized()
         return writer_cls(spec, module_set_name, explicit), spec
 
     return _mock
 
 
 @pytest.fixture()
-def mock_module_filename(monkeypatch, tmpdir):
-    filename = str(tmpdir.join("module"))
+def mock_module_filename(monkeypatch, tmp_path):
+    filename = tmp_path / "module"
     # Set for both module types so we can test both
-    monkeypatch.setattr(spack.modules.lmod.LmodFileLayout, "filename", filename)
-    monkeypatch.setattr(spack.modules.tcl.TclFileLayout, "filename", filename)
-
-    yield filename
+    monkeypatch.setattr(spack.modules.lmod.LmodFileLayout, "filename", str(filename))
+    monkeypatch.setattr(spack.modules.tcl.TclFileLayout, "filename", str(filename))
+    yield str(filename)

lib/spack/spack/test/modules/lmod.py

@@ -21,7 +21,10 @@
 #: Class of the writer tested in this module
 writer_cls = spack.modules.lmod.LmodModulefileWriter
 
-pytestmark = pytest.mark.not_on_windows("does not run on windows")
+pytestmark = [
+    pytest.mark.not_on_windows("does not run on windows"),
+    pytest.mark.usefixtures("mock_modules_root"),
+]
 
 
 @pytest.fixture(params=["clang@=12.0.0", "gcc@=10.2.1"])

lib/spack/spack/test/modules/tcl.py

@@ -18,7 +18,10 @@
 #: Class of the writer tested in this module
 writer_cls = spack.modules.tcl.TclModulefileWriter
 
-pytestmark = pytest.mark.not_on_windows("does not run on windows")
+pytestmark = [
+    pytest.mark.not_on_windows("does not run on windows"),
+    pytest.mark.usefixtures("mock_modules_root"),
+]
 
 
 @pytest.mark.usefixtures("config", "mock_packages", "mock_module_filename")
@@ -279,7 +282,7 @@ def test_projections_all(self, factory, module_configuration):
         projection = writer.spec.format(writer.conf.projections["all"])
         assert projection in writer.layout.use_name
 
-    def test_invalid_naming_scheme(self, factory, module_configuration, mock_module_filename):
+    def test_invalid_naming_scheme(self, factory, module_configuration):
         """Tests the evaluation of an invalid naming scheme."""
 
         module_configuration("invalid_naming_scheme")
@@ -290,7 +293,7 @@ def test_invalid_naming_scheme(self, factory, module_configuration, mock_module_
         with pytest.raises(RuntimeError):
             writer.layout.use_name
 
-    def test_invalid_token_in_env_name(self, factory, module_configuration, mock_module_filename):
+    def test_invalid_token_in_env_name(self, factory, module_configuration):
         """Tests setting environment variables with an invalid name."""
 
         module_configuration("invalid_token_in_env_var_name")

share/spack/gitlab/cloud_pipelines/configs/ci.yaml

@@ -4,6 +4,7 @@ ci:
   broken-tests-packages:
     - gptune
     - superlu-dist    # srun -n 4 hangs
+    - papyrus
 
   broken-specs-url: "https://dummy.io" # s3://spack-binaries/broken-specs"
 

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

@@ -21,7 +21,7 @@ class Amrex(CMakePackage, CudaPackage, ROCmPackage):
 
     tags = ["ecp", "e4s"]
 
-    maintainers("WeiqunZhang", "asalmgren", "etpalmer63")
+    maintainers("WeiqunZhang", "asalmgren", "atmyers")
 
     version("develop", branch="development")
     version("23.11", sha256="49b9fea10cd2a2b6cb0fedf7eac8f7889eacc68a05ae5ac7c5702bc0eb1b3848")

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

@@ -65,6 +65,13 @@ class Bison(AutotoolsPackage, GNUMirrorPackage):
     patch("nvhpc-3.7.patch", when="@3.7.0:3.7 %nvhpc")
 
     conflicts("%intel@:14", when="@3.4.2:", msg="Intel 14 has immature C11 support")
+    conflicts(
+        "%oneapi",
+        msg=(
+            "bison is likely miscompiled by oneapi compilers, "
+            "see https://github.com/spack/spack/issues/37172"
+        ),
+    )
 
     if sys.platform == "darwin" and macos_version() >= Version("10.13"):
         patch("secure_snprintf.patch", level=0, when="@3.0.4")

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

@@ -44,6 +44,10 @@ class Bzip2(Package, SourcewarePackage):
     if sys.platform != "win32":
         depends_on("diffutils", type="build")
 
+    depends_on("gmake", type="build", when="platform=linux")
+    depends_on("gmake", type="build", when="platform=cray")
+    depends_on("gmake", type="build", when="platform=darwin")
+
     @classmethod
     def determine_version(cls, exe):
         output = Executable(exe)("--help", output=str, error=str)

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

@@ -19,6 +19,8 @@ class Clhep(CMakePackage):
 
     maintainers("drbenmorgan")
 
+    version("2.4.7.1", sha256="1c8304a7772ac6b99195f1300378c6e3ddf4ad07c85d64a04505652abb8a55f9")
+    version("2.4.7.0", sha256="7fa460030bc1a804ea7da8cce7611b93261493bbb66c3cfd3ceec935d7e1b8d3")
     version("2.4.6.4", sha256="49c89330f1903ef707d3c5d79c16a7c5a6f2c90fc290e2034ee3834809489e57")
     version("2.4.6.3", sha256="fcd007f11b10ba4af28d027222b63148d0eb44ff7a082eee353bdf921f9c684a")
     version("2.4.6.2", sha256="aded73e49bac85a5b4e86f64a0ee3d6f3cfe5551b0f7731c78b6d8f9dac6e8dc")

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

@@ -297,6 +297,10 @@ class Cp2k(MakefilePackage, CudaPackage, CMakePackage, ROCmPackage):
         depends_on("dbcsr+cuda", when="+cuda")
         depends_on("dbcsr+rocm", when="+rocm")
 
+    with when("@2022: +rocm"):
+        depends_on("hipblas")
+        depends_on("hipfft")
+
     # CP2K needs compiler specific compilation flags, e.g. optflags
     conflicts("%apple-clang")
     conflicts("%clang")

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

@@ -18,7 +18,7 @@ class Cpr(CMakePackage):
     version("1.9.2", sha256="3bfbffb22c51f322780d10d3ca8f79424190d7ac4b5ad6ad896de08dbd06bf31")
 
     depends_on("curl")
-    depends_on("git", when="build")
+    depends_on("git", type="build")
 
     def cmake_args(self):
         _force = "_FORCE" if self.spec.satisfies("@:1.9") else ""

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

@@ -254,7 +254,8 @@ def setup_run_environment(self, env):
         env.set("DD4HEP", self.prefix.examples)
         env.set("DD4hep_DIR", self.prefix)
         env.set("DD4hep_ROOT", self.prefix)
-        env.prepend_path("LD_LIBRARY_PATH", self.libs.directories[0])
+        if len(self.libs.directories) > 0:
+            env.prepend_path("LD_LIBRARY_PATH", self.libs.directories[0])
 
     def url_for_version(self, version):
         # dd4hep releases are dashes and padded with a leading zero

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

@@ -207,7 +207,7 @@ class Dealii(CMakePackage, CudaPackage):
     depends_on("sundials@:3~pthread", when="@9.0:9.2+sundials")
     depends_on("sundials@5:5.8", when="@9.3:9.3.3+sundials")
     depends_on("sundials@5:", when="@9.3.4:+sundials")
-    depends_on("taskflow", when="@9.6:+taskflow")
+    depends_on("taskflow@3.4:", when="@9.6:+taskflow")
     depends_on("trilinos gotype=int", when="+trilinos@12.18.1:")
     # TODO: next line fixes concretization with trilinos and adol-c
     depends_on("trilinos~exodus", when="@9.0:+adol-c+trilinos")

var/spack/repos/builtin/packages/dla-future/package.py

@@ -16,6 +16,7 @@ class DlaFuture(CMakePackage, CudaPackage, ROCmPackage):
 
     license("BSD-3-Clause")
 
+    version("0.3.0", sha256="9887ac0b466ca03d704a8738bc89e68550ed33509578c576390e98e76b64911b")
     version("0.2.1", sha256="4c2669d58f041304bd618a9d69d9879a42e6366612c2fc932df3894d0326b7fe")
     version("0.2.0", sha256="da73cbd1b88287c86d84b1045a05406b742be924e65c52588bbff200abd81a10")
     version("0.1.0", sha256="f7ffcde22edabb3dc24a624e2888f98829ee526da384cd752b2b271c731ca9b1")
@@ -44,12 +45,12 @@ class DlaFuture(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("cmake@3.22:", type="build")
     depends_on("doxygen", type="build", when="+doc")
     depends_on("mpi")
-    depends_on("blaspp@2022.05.00:")
-    depends_on("lapackpp@2022.05.00:")
 
     depends_on("blas")
     depends_on("lapack")
     depends_on("scalapack", when="+scalapack")
+    depends_on("blaspp@2022.05.00:")
+    depends_on("lapackpp@2022.05.00:")
 
     depends_on("umpire~examples")
     depends_on("umpire~cuda", when="~cuda")
@@ -60,8 +61,9 @@ class DlaFuture(CMakePackage, CudaPackage, ROCmPackage):
 
     depends_on("pika@0.15.1:", when="@0.1")
     depends_on("pika@0.16:", when="@0.2.0")
-    depends_on("pika@0.17:", when="@0.2.1:")
-    depends_on("pika-algorithms@0.1:")
+    depends_on("pika@0.17:", when="@0.2.1")
+    depends_on("pika@0.18:", when="@0.3.0:")
+    depends_on("pika-algorithms@0.1:", when="@:0.2")
     depends_on("pika +mpi")
     depends_on("pika +cuda", when="+cuda")
     depends_on("pika +rocm", when="+rocm")

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

@@ -28,7 +28,8 @@ class Esmf(MakefilePackage):
 
     # Develop is a special name for spack and is always considered the newest version
     version("develop", branch="develop")
-    # generate chksum with spack checksum esmf@x.y.z
+    # generate chksum with 'spack checksum esmf@x.y.z'
+    version("8.6.0", sha256="ed057eaddb158a3cce2afc0712b49353b7038b45b29aee86180f381457c0ebe7")
     version("8.5.0", sha256="acd0b2641587007cc3ca318427f47b9cae5bfd2da8d2a16ea778f637107c29c4")
     version("8.4.2", sha256="969304efa518c7859567fa6e65efd960df2b4f6d72dbf2c3f29e39e4ab5ae594")
     version("8.4.1", sha256="1b54cee91aacaa9df400bd284614cbb0257e175f6f3ec9977a2d991ed8aa1af6")

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

@@ -14,31 +14,15 @@ class Fairmq(CMakePackage):
     maintainers("dennisklein", "ChristianTackeGSI")
 
     version("dev", branch="dev", submodules=True, get_full_repo=True)
-    version(
-        "1.7.0",
-        tag="v1.7.0",
-        commit="d1c99f7e150c1177dc1cab1b2adc16475cade24e",
-        submodules=True,
-        no_cache=True,
-    )
-    version(
-        "1.6.0",
-        tag="v1.6.0",
-        commit="42d27af20fb5cbbbc0b0fdfef1c981d51a8baf87",
-        submodules=True,
-        no_cache=True,
-    )
-    version(
-        "1.5.0",
-        tag="v1.5.0",
-        commit="c8fde17b6a10a467035590fd800bb693f50c4826",
-        submodules=True,
-        no_cache=True,
-    )
-    # no_cache=True is currently needed, because FairMQ's build system
-    # depends on the git metadata, see also
-    # https://github.com/spack/spack/issues/19972
-    # https://github.com/spack/spack/issues/14344
+    with default_args(submodules=True, no_cache=True):
+        # no_cache=True is currently needed, because FairMQ's build system
+        # depends on the git metadata, see also
+        # https://github.com/spack/spack/issues/19972
+        # https://github.com/spack/spack/issues/14344
+        version("1.8.1", tag="v1.8.1", commit="961eca52761a31a0200c567b44e2b2d6d6e50df3")
+        version("1.7.0", tag="v1.7.0", commit="d1c99f7e150c1177dc1cab1b2adc16475cade24e")
+        version("1.6.0", tag="v1.6.0", commit="42d27af20fb5cbbbc0b0fdfef1c981d51a8baf87")
+        version("1.5.0", tag="v1.5.0", commit="c8fde17b6a10a467035590fd800bb693f50c4826")
 
     variant(
         "autobind", default=True, when="@1.7:", description="Override the channel autoBind default"
@@ -61,9 +45,10 @@ class Fairmq(CMakePackage):
 
     generator("make", "ninja", default="ninja")
 
-    depends_on("cmake@3.15:", type="build")
-    depends_on("faircmakemodules", type="build")
-    depends_on("git", type="build")
+    with default_args(type="build"):
+        depends_on("cmake@3.15:")
+        depends_on("faircmakemodules")
+        depends_on("git")
 
     depends_on("boost@1.66: +container+program_options+filesystem+date_time+regex")
     depends_on("fairlogger@1.6: +pretty")
@@ -72,6 +57,7 @@ class Fairmq(CMakePackage):
     def cmake_args(self):
         args = [
             self.define("DISABLE_COLOR", True),
+            self.define("BUILD_TESTING", self.run_tests),
             self.define_from_variant("BUILD_EXAMPLES", "examples"),
             self.define_from_variant("FAIRMQ_CHANNEL_DEFAULT_AUTOBIND", "autobind"),
         ]

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

@@ -30,6 +30,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
 
     maintainers("adamjstewart")
 
+    version("3.8.0", sha256="ec0f78d9dc32352aeac6edc9c3b27a991b91f9dc6f92c452207d84431c58757d")
     version("3.7.3", sha256="e0a6f0c453ea7eb7c09967f50ac49426808fcd8f259dbc9888140eb69d7ffee6")
     version("3.7.2", sha256="40c0068591d2c711c699bbb734319398485ab169116ac28005d8302f80b923ad")
     version("3.7.1", sha256="9297948f0a8ba9e6369cd50e87c7e2442eda95336b94d2b92ef1829d260b9a06")
@@ -90,6 +91,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     version("2.0.0", sha256="91704fafeea2349c5e268dc1e2d03921b3aae64b05ee01d59fdfc1a6b0ffc061")
 
     # Optional dependencies
+    variant("archive", default=False, when="@3.7:", description="Optional for vsi7z VFS driver")
     variant(
         "armadillo",
         default=False,
@@ -137,9 +139,11 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     variant("kdu", default=False, description="Required for JP2KAK and JPIPKAK drivers")
     variant("kea", default=False, description="Required for KEA driver")
     variant("lerc", default=False, when="@2.4:", description="Required for LERC compression")
+    variant("libaec", default=False, when="@3.8:", description="Optional for GRIB driver")
     variant("libcsf", default=False, description="Required for PCRaster driver")
     variant("libkml", default=False, description="Required for LIBKML driver")
     variant("liblzma", default=False, description="Required for Zarr driver")
+    variant("libqb3", default=False, when="@3.6:", description="Required for MRF driver")
     variant(
         "libxml2", default=False, description="Required for XML validation in many OGR drivers"
     )
@@ -190,7 +194,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     )
     variant("pcidsk", default=False, description="Required for PCIDSK driver")
     variant(
-        "pcre", default=False, description="Required for REGEXP operator in drivers using SQLite3"
+        "pcre2", default=False, description="Required for REGEXP operator in drivers using SQLite3"
     )
     variant("pdfium", default=False, when="@2.1:", description="Possible backend for PDF driver")
     variant("png", default=True, description="Required for PNG driver")
@@ -201,7 +205,6 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
         default=False,
         description="Required for PostgreSQL and PostGISRaster drivers",
     )
-    variant("qb3", default=False, when="@3.6:", description="Required for MRF driver")
     variant(
         "qhull",
         default=False,
@@ -262,6 +265,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     depends_on("json-c@0.12.1", when="@:2.2")
 
     # Optional dependencies
+    depends_on("libarchive", when="+archive")
     depends_on("armadillo", when="+armadillo")
     depends_on("blas", when="+armadillo")
     depends_on("lapack", when="+armadillo")
@@ -303,6 +307,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     # depends_on('kakadu', when='+kdu')
     depends_on("kealib", when="+kea")
     depends_on("lerc", when="+lerc")
+    depends_on("libaec", when="+libaec")
     # depends_on('libcsf', when='+libcsf')
     depends_on("libkml@1.3:", when="+libkml")
     depends_on("xz", when="+liblzma")
@@ -330,8 +335,8 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     depends_on("oracle-instant-client", when="+oracle")
     depends_on("parquet-cpp", when="+parquet")
     # depends_on('pcidsk', when='+pcidsk')
-    depends_on("pcre2", when="@3.5:+pcre")
-    depends_on("pcre", when="@:3.4+pcre")
+    depends_on("pcre2", when="@3.5:+pcre2")
+    depends_on("pcre", when="@:3.4+pcre2")
     # depends_on('pdfium', when='+pdfium')
     depends_on("libpng", when="+png")
     # depends_on('podofo', when='+podofo')
@@ -341,7 +346,7 @@ class Gdal(CMakePackage, AutotoolsPackage, PythonExtension):
     depends_on("poppler@:0.71", when="@:2.4 +poppler")
     depends_on("poppler@:21", when="@:3.4.1 +poppler")
     depends_on("postgresql", when="+postgresql")
-    depends_on("qb3", when="+qb3")
+    depends_on("qb3", when="+libqb3")
     depends_on("qhull", when="+qhull")
     depends_on("qhull@2015:", when="@3.5:+qhull")
     depends_on("qhull@:2020.1", when="@:3.3+qhull")
@@ -490,6 +495,7 @@ def cmake_args(self):
             # be necessary.
             self.define("ENABLE_DEFLATE64", "zlib-ng" not in self.spec),
             # Optional dependencies
+            self.define_from_variant("GDAL_USE_ARCHIVE", "archive"),
             self.define_from_variant("GDAL_USE_ARMADILLO", "armadillo"),
             self.define_from_variant("GDAL_USE_ARROW", "arrow"),
             self.define_from_variant("GDAL_USE_BASISU", "basisu"),
@@ -519,9 +525,11 @@ def cmake_args(self):
             self.define_from_variant("GDAL_USE_KDU", "kdu"),
             self.define_from_variant("GDAL_USE_KEA", "kea"),
             self.define_from_variant("GDAL_USE_LERC", "lerc"),
+            self.define_from_variant("GDAL_USE_LIBAEC", "libaec"),
             self.define_from_variant("GDAL_USE_LIBCSF", "libcsf"),
             self.define_from_variant("GDAL_USE_LIBKML", "libkml"),
             self.define_from_variant("GDAL_USE_LIBLZMA", "liblzma"),
+            self.define_from_variant("GDAL_USE_LIBQB3", "libqb3"),
             self.define_from_variant("GDAL_USE_LIBXML2", "libxml2"),
             self.define_from_variant("GDAL_USE_LURATECH", "luratech"),
             self.define_from_variant("GDAL_USE_LZ4", "lz4"),
@@ -541,13 +549,12 @@ def cmake_args(self):
             self.define_from_variant("GDAL_USE_OPENSSL", "openssl"),
             self.define_from_variant("GDAL_USE_ORACLE", "oracle"),
             self.define_from_variant("GDAL_USE_PARQUET", "parquet"),
-            self.define_from_variant("GDAL_USE_PCRE2", "pcre"),
+            self.define_from_variant("GDAL_USE_PCRE2", "pcre2"),
             self.define_from_variant("GDAL_USE_PDFIUM", "pdfium"),
             self.define_from_variant("GDAL_USE_PNG", "png"),
             self.define_from_variant("GDAL_USE_PODOFO", "podofo"),
             self.define_from_variant("GDAL_USE_POPPLER", "poppler"),
             self.define_from_variant("GDAL_USE_POSTGRESQL", "postgresql"),
-            self.define_from_variant("GDAL_USE_LIBQB3", "qb3"),
             self.define_from_variant("GDAL_USE_QHULL", "qhull"),
             self.define_from_variant("GDAL_USE_RASDAMAN", "rasdaman"),
             self.define_from_variant("GDAL_USE_RASTERLITE2", "rasterlite2"),
@@ -669,7 +676,7 @@ def configure_args(self):
             self.with_or_without("crypto", variant="openssl", package="openssl"),
             self.with_or_without("oci", variant="oracle", package="oracle-instant-client"),
             self.with_or_without("pcidsk", package="pcidsk"),
-            self.with_or_without("pcre"),
+            self.with_or_without("pcre", variant="pcre2"),
             self.with_or_without("pdfium", package="pdfium"),
             self.with_or_without("png", package="libpng"),
             self.with_or_without("podofo", package="podofo"),

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

@@ -67,6 +67,8 @@ def configure_args(self):
         return [
             "--with-guile" if self.spec.satisfies("+guile") else "--without-guile",
             "--disable-nls",
+            # configure needs make to enable dependency tracking, disable explicitly
+            "--disable-dependency-tracking",
         ]
 
     def install(self, spec, prefix):

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

@@ -109,6 +109,11 @@ class Hpctoolkit(AutotoolsPackage):
         "python", default=False, description="Support unwinding Python source.", when="@2023.03:"
     )
 
+    with when("@develop build_system=autotools"):
+        depends_on("autoconf", type="build")
+        depends_on("automake", type="build")
+        depends_on("libtool", type="build")
+
     boost_libs = (
         "+atomic +chrono +date_time +filesystem +system +thread +timer"
         " +graph +regex +shared +multithreaded visibility=global"

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

@@ -45,21 +45,21 @@ class Interproscan(Package):
     )
 
     resource(
-        when="5.56-89.0 +databases",
+        when="@5.56-89.0 +databases",
         name="databases",
         url="https://ftp.ebi.ac.uk/pub/databases/interpro/iprscan/5/5.56-89.0/alt/interproscan-data-5.56-89.0.tar.gz",
         sha256="49cd0c69711f9469f3b68857f4581b23ff12765ca2b12893d18e5a9a5cd8032d",
     )
 
     resource(
-        when="5.38-76.0 +databases",
+        when="@5.38-76.0 +databases",
         name="databases",
         url="https://ftp.ebi.ac.uk/pub/databases/interpro/iprscan/5/5.38-76.0/alt/interproscan-data-5.38-76.0.tar.gz",
         sha256="e05e15d701037504f92ecf849c20317e70df28e78ff1945826b3c1e16d9b9cce",
     )
 
     resource(
-        when="5.36-75.0 +databases",
+        when="@5.36-75.0 +databases",
         name="databases",
         url="https://ftp.ebi.ac.uk/pub/databases/interpro/iprscan/5/5.36-75.0/alt/interproscan-data-5.36-75.0.tar.gz",
         sha256="e9b1e6f2d1c20d06661a31a08c973bc8ddf039a4cf1e45ec4443200375e5d6a4",

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

@@ -25,6 +25,8 @@ class Ispc(CMakePackage):
     executables = ["^ispc$"]
 
     version("main", branch="main")
+    version("1.21.1", sha256="99bbb1d1f15bc4433d6a63b5bb35b321af3e3af753c3b28a61850d1748e8a89f")
+    version("1.21.0", sha256="023782f721bfb5893bac24bc2153a8214c916be82c290bf63a3ec6678949b5ef")
     version("1.20.0", sha256="8bd30ded7f96859451ead1cecf6f58ac8e937288fe0e5b98c56f6eba4be370b4")
     version("1.19.0", sha256="c1aeae4bdfb28004a6949394ea1b3daa3fdf12f646e17fcc0614861077dc8b6a")
     version("1.18.1", sha256="fee76d42fc0129f81489b7c2b9143e22a44c281940693c1c13cf1e3dd2ab207f")
@@ -45,15 +47,17 @@ class Ispc(CMakePackage):
     depends_on("tbb", type="link", when="platform=linux @1.20:")
     depends_on("llvm+clang")
     depends_on("llvm libcxx=none", when="platform=darwin")
-    depends_on("llvm@13:15", when="@1.19:")
-    depends_on("llvm@11.0:14.0", when="@1.18")
-    depends_on("llvm@11:14", when="@1.17")
-    depends_on("llvm@:12", when="@:1.16")
-    depends_on("llvm@11:", when="@1.16")
-    depends_on("llvm@10:11", when="@1.15.0:1.15")
-    depends_on("llvm@10.0:10", when="@1.13:1.14")
     depends_on("llvm targets=arm,aarch64", when="target=arm:")
     depends_on("llvm targets=arm,aarch64", when="target=aarch64:")
+    depends_on("llvm@:17", when="@:1.21")
+    depends_on("llvm@:15", when="@:1.20")
+    depends_on("llvm@:14", when="@:1.18")
+    depends_on("llvm@:12", when="@:1.16")
+    depends_on("llvm@:11", when="@:1.15")
+    depends_on("llvm@:10", when="@:1.14")
+    depends_on("llvm@13:", when="@1.19:")
+    depends_on("llvm@11:", when="@1.16:")
+    depends_on("llvm@10:", when="@1.13:")
 
     patch(
         "don-t-assume-that-ncurses-zlib-are-system-libraries.patch",

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

@@ -22,6 +22,7 @@ class Justbuild(Package):
     maintainers("asartori86")
 
     version("master", branch="master")
+    version("1.2.3", tag="v1.2.3", commit="45e9c1c85399f00372ad8b72894979a0002d8f95")
     version("1.2.2", tag="v1.2.2", commit="e1ee04684c34ae30ac3c91b6753e99a81a9dc51c")
     version("1.2.1", tag="v1.2.1", commit="959cd90083d0c783389cd09e187c98322c16469f")
     version("1.1.4", tag="v1.1.4", commit="32e96afd159f2158ca129fd00bf02c273d8e1e48")

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

@@ -209,7 +209,7 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     depends_on("py-protobuf+cpp@3.10.0:4.21.12", type=("build", "run"), when="+pfe")
 
     depends_on("protobuf+shared@3.10.0:3.21.12")
-    depends_on("zlib-api", when="protobuf@3.11.0:")
+    depends_on("zlib-api", when="^protobuf@3.11.0:")
 
     # using cereal@1.3.1 and above requires changing the
     # find_package call to lowercase, so stick with :1.3.0

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

@@ -16,3 +16,30 @@ class Lemon(CMakePackage):
     url = "https://lemon.cs.elte.hu/pub/sources/lemon-1.3.1.tar.gz"
 
     version("1.3.1", sha256="71b7c725f4c0b4a8ccb92eb87b208701586cf7a96156ebd821ca3ed855bad3c8")
+
+    # variant("coin", default=False, description="Enable Coin solver backend") #TODO build fails
+    variant("ilog", default=False, description="Enable ILOG (CPLEX) solver backend")
+    variant("glpk", default=True, description="Enable GLPK solver backend")
+    # soplex not mentioned in docs but shown in cmakecache
+    # variant("soplex", default=False, description="Enable SOPLEX solver backend") #TODO
+
+    depends_on("glpk", when="+glpk")
+    depends_on("cplex", when="+ilog")
+    # depends_on("coinutils", when="+coin")  # just a guess
+    # depends_on("cbc", when="+coin")
+    # depends_on("clp", when="+coin")
+    # depends_on("bzip2", when="+coin")
+    # depends_on("soplex", when="+soplex") # no such package in Spack yet. TODO
+
+    def cmake_args(self):
+        spec = self.spec
+        args = []
+        args.extend(
+            [
+                # f"-DLEMON_ENABLE_COIN={spec.variants['coin'].value}", #TODO
+                f"-DLEMON_ENABLE_ILOG={spec.variants['ilog'].value}",
+                f"-DLEMON_ENABLE_GLPK={spec.variants['glpk'].value}",
+                # f"-DLEMON_ENABLE_SOPLEX={spec.variants['soplex'].value}", #TODO
+            ]
+        )
+        return args

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

@@ -59,7 +59,7 @@ def libs(self):
         return LibraryList(libs)
 
     def autoreconf(self, spec, prefix):
-        Executable("./autogen.sh")()
+        autoreconf("--force", "--install", "--symlink")
 
     def configure_args(self):
         spec = self.spec

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

@@ -32,6 +32,11 @@ class Libffi(AutotoolsPackage):
     patch("clang-powerpc-3.2.1.patch", when="@3.2.1%clang platform=linux")
     # ref.: https://github.com/libffi/libffi/pull/561
     patch("powerpc-3.3.patch", when="@3.3")
+    patch(
+        "https://github.com/libffi/libffi/commit/ce077e5565366171aa1b4438749b0922fce887a4.patch?full_index=1",
+        sha256="070b1f3aa87f2b56f83aff38afc42157e1692bfaa580276ecdbad2048b818ed7",
+        when="@3.4.3:3.4.4",
+    )
 
     @property
     def headers(self):

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

@@ -14,6 +14,7 @@ class Libgcrypt(AutotoolsPackage):
 
     maintainers("alalazo")
 
+    version("1.10.3", sha256="8b0870897ac5ac67ded568dcfadf45969cfa8a6beb0fd60af2a9eadc2a3272aa")
     version("1.10.2", sha256="3b9c02a004b68c256add99701de00b383accccf37177e0d6c58289664cce0c03")
     version("1.10.1", sha256="ef14ae546b0084cd84259f61a55e07a38c3b53afc0f546bffcef2f01baffe9de")
     version("1.10.0", sha256="6a00f5c05caa4c4acc120c46b63857da0d4ff61dc4b4b03933fa8d46013fae81")

var/spack/repos/builtin/packages/libjpeg-turbo/package.py

@@ -59,6 +59,22 @@ class LibjpegTurbo(CMakePackage, AutotoolsPackage):
     variant("shared", default=True, description="Build shared libs")
     variant("static", default=True, description="Build static libs")
     variant("jpeg8", default=False, description="Emulate libjpeg v8 API/ABI")
+    variant(
+        "partial_decoder",
+        default=False,
+        description="add partial_decode_scale functionality required for rocAL",
+    )
+
+    patch(
+        "https://github.com/libjpeg-turbo/libjpeg-turbo/commit/09c71da06a6346dca132db66f26f959f7e4dd5ad.patch?full_index=1",
+        sha256="4d5bdfb5de5b04399144254ea383f5357ab7beb830b398aeb35b65f21dd6b4b0",
+        when="@2.0.6 +partial_decoder",
+    )
+    patch(
+        "https://github.com/libjpeg-turbo/libjpeg-turbo/commit/640d7ee1917fcd3b6a5271aa6cf4576bccc7c5fb.patch?full_index=1",
+        sha256="dc1ec567c2356b652100ecdc28713bbf25f544e46f7d2947f31a2395c362cc48",
+        when="@2.0.6 +partial_decoder",
+    )
 
     # Can use either of these. But in the current version of the package
     # only nasm is used. In order to use yasm an environmental variable

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

@@ -131,6 +131,7 @@ def url_for_version(self, version):
     depends_on("py-pybind11", type="build", when="@:4.0.0")
     depends_on("py-pybind11@2.6:", type="build", when="@4.1.0:")
     depends_on("pkgconfig", type="build", when="@5.3.0:")
+    depends_on("abseil-cpp")
 
     for ver in [
         "3.5.0",

var/spack/repos/builtin/packages/mivisionx/0001-add-half-include-path-5.6.patch

@@ -0,0 +1,13 @@
+diff --git a/rocAL/rocAL/CMakeLists.txt b/rocAL/rocAL/CMakeLists.txt
+index 7ae8cb8..195f387 100644
+--- a/rocAL/rocAL/CMakeLists.txt
++++ b/rocAL/rocAL/CMakeLists.txt
+@@ -122,6 +122,8 @@ if(NOT Threads_FOUND)
+ endif()
+
+ if(${BUILD_ROCAL})
++    find_path(HALF_INCLUDE_DIR half.hpp)
++    include_directories(${HALF_INCLUDE_DIR})
+     # AMD OpenVX & VX_RPP
+     set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} openvx vx_rpp)
+     # AMD RPP

var/spack/repos/builtin/packages/mivisionx/0001-add-half-include-path.patch

@@ -0,0 +1,21 @@
+diff --git a/rocAL/rocAL/CMakeLists.txt b/rocAL/rocAL/CMakeLists.txt
+index bb28810..3c97eab 100644
+--- a/rocAL/rocAL/CMakeLists.txt
++++ b/rocAL/rocAL/CMakeLists.txt
+@@ -39,6 +39,8 @@ find_package(Boost COMPONENTS ${BOOST_COMPONENTS} QUIET)
+ set(THREADS_PREFER_PTHREAD_FLAG ON)
+ find_package(Threads QUIET)
+
++find_path(HALF_INCLUDE_DIR half.hpp)
++
+ if( GPU_SUPPORT AND "${BACKEND}" STREQUAL "HIP")
+     if(NOT DEFINED HIP_PATH)
+         if(NOT DEFINED ENV{HIP_PATH})
+@@ -120,6 +122,7 @@ if(NOT Threads_FOUND)
+ endif()
+
+ if(${BUILD_ROCAL})
++    include_directories(${HALF_INCLUDE_DIR})
+     # AMD OpenVX & RPP
+     include_directories(${AMDRPP_INCLUDE_DIRS})
+     set(LINK_LIBRARY_LIST ${LINK_LIBRARY_LIST} openvx vx_rpp)

var/spack/repos/builtin/packages/mivisionx/0002-add-half-include-path-for-tests.patch

@@ -0,0 +1,62 @@
+diff --git a/model_compiler/python/nnir_to_clib.py b/model_compiler/python/nnir_to_clib.py
+index b688094..26fcfe3 100644
+--- a/model_compiler/python/nnir_to_clib.py
++++ b/model_compiler/python/nnir_to_clib.py
+@@ -151,6 +151,10 @@ if (OPENVX_BACKEND_OPENCL_FOUND)
+     include_directories (${OpenCL_INCLUDE_DIRS} ${OpenCL_INCLUDE_DIRS}/Headers )
+ endif()
+
++find_path(HALF_INCLUDE_DIR half.hpp)
++message(STATUS "HALF_INCLUDE_DIR: ${HALF_INCLUDE_DIR}")
++include_directories(${HALF_INCLUDE_DIR})
++
+ find_package(OpenCV QUIET)
+ include_directories (/opt/rocm/include/mivisionx)
+ include_directories (${PROJECT_SOURCE_DIR}/lib)
+diff --git a/samples/inference/mv_objdetect/CMakeLists.txt b/samples/inference/mv_objdetect/CMakeLists.txt
+index 9b92b84..d82b71e 100644
+--- a/samples/inference/mv_objdetect/CMakeLists.txt
++++ b/samples/inference/mv_objdetect/CMakeLists.txt
+@@ -50,7 +50,10 @@ if (OPENVX_BACKEND_OPENCL_FOUND)
+     include_directories (${OpenCL_INCLUDE_DIRS} ${OpenCL_INCLUDE_DIRS}/Headers )
+ endif()
+
+-include_directories (${ROCM_PATH}/include/mivisionx ${PROJECT_SOURCE_DIR} )
++find_path(HALF_INCLUDE_DIR half.hpp)
++message(STATUS "HALF_INCLUDE_DIR: ${HALF_INCLUDE_DIR}")
++
++include_directories (${ROCM_PATH}/include/mivisionx ${PROJECT_SOURCE_DIR} ${HALF_INCLUDE_DIR} )
+ link_directories    (${ROCM_PATH}/lib ${PROJECT_SOURCE_DIR}/lib)
+ option (USE_POSTPROC  "Use postprocessing module implementation" ON)
+ set(SOURCES mvobjdetect.cpp mvdeploy_api.cpp visualize.cpp)
+diff --git a/utilities/rocAL/rocAL_unittests/CMakeLists.txt b/utilities/rocAL/rocAL_unittests/CMakeLists.txt
+index 6500003..20de035 100644
+--- a/utilities/rocAL/rocAL_unittests/CMakeLists.txt
++++ b/utilities/rocAL/rocAL_unittests/CMakeLists.txt
+@@ -43,9 +43,10 @@ include(GNUInstallDirs)
+
+ list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/../amd_openvx/cmake)
+
++find_path(HALF_INCLUDE_DIR half.hpp)
+ find_package(OpenCV QUIET)
+ find_package(AMDRPP QUIET)
+-include_directories(${ROCM_PATH}/${CMAKE_INSTALL_INCLUDEDIR}/mivisionx/rocal)
++include_directories(${ROCM_PATH}/${CMAKE_INSTALL_INCLUDEDIR}/mivisionx/rocal ${HALF_INCLUDE_DIR})
+ link_directories(${ROCM_PATH}/lib/)
+ file(GLOB My_Source_Files ./*.cpp)
+ add_executable(${PROJECT_NAME} ${My_Source_Files})
+diff --git a/utilities/rocAL/rocAL_video_unittests/CMakeLists.txt b/utilities/rocAL/rocAL_video_unittests/CMakeLists.txt
+index bd64a5b..3aa6172 100644
+--- a/utilities/rocAL/rocAL_video_unittests/CMakeLists.txt
++++ b/utilities/rocAL/rocAL_video_unittests/CMakeLists.txt
+@@ -46,8 +46,8 @@ list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/../amd_openvx/cmake)
+
+ find_package(OpenCV QUIET)
+ find_package(AMDRPP QUIET)
+-
+-include_directories(${ROCM_PATH}/${CMAKE_INSTALL_INCLUDEDIR}/mivisionx/rocal)
++find_path(HALF_INCLUDE_DIR half.hpp)
++include_directories(${ROCM_PATH}/${CMAKE_INSTALL_INCLUDEDIR}/mivisionx/rocal ${HALF_INCLUDE_DIR})
+ link_directories(${ROCM_PATH}/lib/)
+ file(GLOB My_Source_Files ./*.cpp)
+ add_executable(${PROJECT_NAME} ${My_Source_Files})

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

@@ -116,8 +116,19 @@ def url_for_version(self, version):
 
     variant("opencl", default=False, description="Use OPENCL as the backend")
     variant("hip", default=True, description="Use HIP as backend")
+    variant("add_tests", default=False, description="add tests and samples folder")
+    patch("0001-add-half-include-path.patch", when="@5.5")
+    patch("0001-add-half-include-path-5.6.patch", when="@5.6:")
+    patch("0002-add-half-include-path-for-tests.patch", when="@5.5: +add_tests")
+
+    patch(
+        "https://github.com/GPUOpen-ProfessionalCompute-Libraries/MIVisionX/commit/da24882438b91a0ae1feee23206b75c1a1256887.patch?full_index=1",
+        sha256="41caff199224f904ef5dc2cd9c5602d6cfa41eba6af0fcc782942a09dd202ab4",
+        when="@5.6",
+    )
 
     conflicts("+opencl", when="@5.6.0:")
+    conflicts("+add_tests", when="@:5.4")
 
     def patch(self):
         if self.spec.satisfies("@4.2.0"):
@@ -179,6 +190,86 @@ def patch(self):
                 "amd_openvx_extensions/amd_nn/nn_hip/CMakeLists.txt",
                 string=True,
             )
+        if self.spec.satisfies("@5.5.0: + hip"):
+            filter_file(
+                "${ROCM_PATH}/llvm/bin/clang++",
+                "{0}/bin/clang++".format(self.spec["llvm-amdgpu"].prefix),
+                "rocAL/rocAL/rocAL_hip/CMakeLists.txt",
+                string=True,
+            )
+        if self.spec.satisfies("+add_tests"):
+            filter_file(
+                "${ROCM_PATH}/include/mivisionx",
+                "{0}/include/mivisionx".format(self.spec.prefix),
+                "tests/amd_migraphx_tests/mnist/CMakeLists.txt",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/lib",
+                "{0}/lib".format(self.spec.prefix),
+                "tests/amd_migraphx_tests/mnist/CMakeLists.txt",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/include/mivisionx",
+                "{0}/include/mivisionx".format(self.spec.prefix),
+                "tests/amd_migraphx_tests/resnet50/CMakeLists.txt",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/lib",
+                "{0}/lib".format(self.spec.prefix),
+                "tests/amd_migraphx_tests/resnet50/CMakeLists.txt",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/include/mivisionx",
+                "{0}/include/mivisionx".format(self.spec.prefix),
+                "samples/inference/mv_objdetect/CMakeLists.txt",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/lib",
+                "{0}/lib".format(self.spec.prefix),
+                "samples/inference/mv_objdetect/CMakeLists.txt",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/include/mivisionx",
+                "{0}/include/mivisionx".format(self.spec.prefix),
+                "model_compiler/python/nnir_to_clib.py",
+                string=True,
+            )
+            filter_file(
+                "/opt/rocm",
+                "{0}".format(self.spec.prefix),
+                "model_compiler/python/nnir_to_clib.py",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/${CMAKE_INSTALL_INCLUDEDIR}/mivisionx/rocal",
+                "{0}/include/mivisionx/rocal".format(self.spec.prefix),
+                "utilities/rocAL/rocAL_unittests/CMakeLists.txt",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/lib",
+                "{0}/lib".format(self.spec.prefix),
+                "utilities/rocAL/rocAL_unittests/CMakeLists.txt",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/${CMAKE_INSTALL_INCLUDEDIR}/mivisionx/rocal",
+                "{0}/include/mivisionx/rocal".format(self.spec.prefix),
+                "utilities/rocAL/rocAL_video_unittests/CMakeLists.txt",
+                string=True,
+            )
+            filter_file(
+                "${ROCM_PATH}/lib",
+                "{0}/lib".format(self.spec.prefix),
+                "utilities/rocAL/rocAL_video_unittests/CMakeLists.txt",
+                string=True,
+            )
 
     depends_on("cmake@3.5:", type="build")
     depends_on("ffmpeg@:4", type="build", when="@:5.3")
@@ -203,7 +294,17 @@ def patch(self):
     depends_on("miopen-opencl@3.5.0", when="@1.7+opencl")
     depends_on("miopengemm@1.1.6", when="@1.7+opencl")
     depends_on("openssl", when="@4.0.0:")
-    depends_on("libjpeg-turbo", type="build")
+    depends_on("libjpeg-turbo@2.0.6+partial_decoder", type="build")
+    depends_on("rpp", when="@5.5:")
+    depends_on("lmdb", when="@5.5:")
+    depends_on("py-setuptools", when="@5.6:")
+    depends_on("py-wheel", when="@5.6:")
+    depends_on("py-pybind11", when="@5.6:")
+    depends_on("py-google-api-python-client", when="+add_tests")
+    depends_on("py-protobuf@3.20.3", type=("build", "run"), when="+add_tests")
+    depends_on("py-future", when="+add_tests")
+    depends_on("py-numpy", when="+add_tests")
+    depends_on("py-pytz", when="+add_tests")
 
     conflicts("^cmake@3.22:", when="@:5.0.0")
     # need to choose atleast one backend and both cannot be set
@@ -265,11 +366,15 @@ def patch(self):
             depends_on("miopen-hip@" + ver, when="@" + ver)
         for ver in ["5.3.3", "5.4.0", "5.4.3", "5.5.0", "5.5.1", "5.6.0", "5.6.1"]:
             depends_on("migraphx@" + ver, when="@" + ver)
+            depends_on("hip@" + ver, when="@" + ver)
 
     for ver in ["5.5.0", "5.5.1", "5.6.0", "5.6.1"]:
         depends_on("rocm-core@" + ver, when="@" + ver)
         depends_on("python@3.5:", type="build")
 
+    def setup_run_environment(self, env):
+        env.set("MIVISIONX_MODEL_COMPILER_PATH", self.spec.prefix.libexec.mivisionx.model_compiler)
+
     def flag_handler(self, name, flags):
         spec = self.spec
         protobuf = spec["protobuf"].prefix.include
@@ -290,4 +395,24 @@ def cmake_args(self):
             args.append(self.define("HIP_PATH", spec["hip"].prefix))
         if self.spec.satisfies("~hip~opencl"):
             args.append(self.define("BACKEND", "CPU"))
+        if self.spec.satisfies("@5.5:"):
+            args.append(
+                self.define("AMDRPP_LIBRARIES", "{0}/lib/librpp.so".format(spec["rpp"].prefix))
+            )
+            args.append(
+                self.define("AMDRPP_INCLUDE_DIRS", "{0}/include/rpp".format(spec["rpp"].prefix))
+            )
+            args.append(
+                self.define(
+                    "TurboJpeg_LIBRARIES_DIRS", "{0}/lib64".format(spec["libjpeg-turbo"].prefix)
+                )
+            )
+            args.append(self.define("CMAKE_INSTALL_PREFIX_PYTHON", spec.prefix))
         return args
+
+    @run_after("install")
+    def add_tests(self):
+        if self.spec.satisfies("+add_tests"):
+            install_tree("tests", self.spec.prefix.tests)
+            install_tree("samples", self.spec.prefix.samples)
+            install_tree("utilities", self.spec.prefix.utilities)

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

@@ -55,7 +55,7 @@ class Mpich(AutotoolsPackage, CudaPackage, ROCmPackage):
     variant("hydra", default=True, description="Build the hydra process manager")
     variant("romio", default=True, description="Enable ROMIO MPI I/O implementation")
     variant("verbs", default=False, description="Build support for OpenFabrics verbs.")
-    variant("slurm", default=False, description="Enable SLURM support")
+    variant("slurm", default=False, description="Enable Slurm support")
     variant("wrapperrpath", default=True, description="Enable wrapper rpath")
     variant(
         "pmi",

var/spack/repos/builtin/packages/mrtrix3/fix_includes.patch

@@ -0,0 +1,26 @@
+--- ./configure.orig    2023-11-12 14:48:25.802025918 -0800
++++ ./configure 2023-11-12 14:48:56.177057419 -0800
+@@ -571,10 +571,7 @@
+     try:
+       flags = []
+       for flag in shlex.split (execute ([ 'pkg-config' ] + pkg_config_flags.split(), RunError)[1]):
+-        if flag.startswith ('-I'):
+-          flags += [ '-idirafter', flag[2:] ]
+-        else:
+-          flags += [ flag ]
++        flags += [ flag ]
+       return flags
+     except Exception:
+       log('error running "pkg-config ' + pkg_config_flags + '"\n\n')
+@@ -1323,10 +1320,7 @@
+       for entry in qt:
+         if entry[0] != '$' and not entry == '-I.':
+           entry = entry.replace('\"','').replace("'",'')
+-          if entry.startswith('-I'):
+-            qt_cflags += [ '-idirafter', entry[2:] ]
+-          else:
+-            qt_cflags += [ entry ]
++          qt_cflags += [ entry ]
+
+       qt = qt_ldflags + qt_libs
+       qt_ldflags = []

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

@@ -17,21 +17,26 @@ class Mrtrix3(Package):
     git = "https://github.com/MRtrix3/mrtrix3.git"
 
     version(
-        "3.0.3",
-        sha256="6ec7d5a567d8d7338e85575a74565189a26ec8971cbe8fb24a49befbc446542e",
+        "3.0.4",
+        sha256="f1d1aa289cfc3e46e3a8eca93594b23d061c6d50a0cd03727433a7e2cd14f71a",
         preferred=True,
     )
+    version("3.0.3", sha256="6ec7d5a567d8d7338e85575a74565189a26ec8971cbe8fb24a49befbc446542e")
     version("2017-09-25", commit="72aca89e3d38c9d9e0c47104d0fb5bd2cbdb536d")
 
     depends_on("python@2.7:", type=("build", "run"))
     depends_on("py-numpy", type=("build", "run"))
     depends_on("glu")
     depends_on("qt+opengl@4.7:")
-    depends_on("eigen")
+    # MRTrix <= 3.0.3 can't build with eigen >= 3.4 due to conflicting declarations
+    depends_on("eigen@3.3", when="@3.0.3")
+    depends_on("eigen@3.4:", when="@3.0.4:")
     depends_on("zlib-api")
     depends_on("libtiff")
     depends_on("fftw")
 
+    patch("fix_includes.patch", when="@3.0.3:3.0.4")
+
     conflicts("%gcc@7:", when="@2017-09-25")  # MRtrix3/mrtrix3#1041
 
     def install(self, spec, prefix):

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

@@ -16,6 +16,8 @@ class Mumps(Package):
     homepage = "https://graal.ens-lyon.fr/MUMPS/index.php"
     url = "https://graal.ens-lyon.fr/MUMPS/MUMPS_5.5.1.tar.gz"
 
+    maintainers("jcortial-safran")
+
     version("5.5.1", sha256="1abff294fa47ee4cfd50dfd5c595942b72ebfcedce08142a75a99ab35014fa15")
     version("5.5.0", sha256="e54d17c5e42a36c40607a03279e0704d239d71d38503aab68ef3bfe0a9a79c13")
     version("5.4.1", sha256="93034a1a9fe0876307136dcde7e98e9086e199de76f1c47da822e7d4de987fa8")
@@ -223,7 +225,7 @@ def write_makefile_inc(self):
         # As of version 5.2.0, MUMPS is able to take advantage
         # of the GEMMT BLAS extension. MKL and amdblis are the only
         # known BLAS implementation supported.
-        if self.spec["blas"].name in INTEL_MATH_LIBRARIES and self.spec.satifies("@5.2.0:"):
+        if self.spec["blas"].name in INTEL_MATH_LIBRARIES and self.spec.satisfies("@5.2.0:"):
             optf.append("-DGEMMT_AVAILABLE")
 
         if "@5.2.0: ^amdblis@3.0:" in self.spec:

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

@@ -24,6 +24,7 @@ class Openblas(CMakePackage, MakefilePackage):
     libraries = ["libopenblas", "openblas"]
 
     version("develop", branch="develop")
+    version("0.3.25", sha256="4c25cb30c4bb23eddca05d7d0a85997b8db6144f5464ba7f8c09ce91e2f35543")
     version("0.3.24", sha256="ceadc5065da97bd92404cac7254da66cc6eb192679cf1002098688978d4d5132")
     version("0.3.23", sha256="5d9491d07168a5d00116cdc068a40022c3455bf9293c7cb86a65b1054d7e5114")
     version("0.3.22", sha256="7fa9685926ba4f27cfe513adbf9af64d6b6b63f9dcabb37baefad6a65ff347a7")

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

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

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

@@ -595,7 +595,7 @@ class Openmpi(AutotoolsPackage, CudaPackage):
     conflicts(
         "schedulers=slurm ~pmi",
         when="@1.5.4",
-        msg="+pmi is required for openmpi to work with SLURM.",
+        msg="+pmi is required for openmpi to work with Slurm.",
     )
     conflicts(
         "schedulers=loadleveler",

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

@@ -381,6 +381,10 @@ class Openssl(Package):  # Uses Fake Autotools, should subclass Package
     depends_on("ca-certificates-mozilla", type="build", when="certs=mozilla")
     depends_on("nasm", when="platform=windows")
 
+    depends_on("gmake", type="build", when="platform=linux")
+    depends_on("gmake", type="build", when="platform=cray")
+    depends_on("gmake", type="build", when="platform=darwin")
+
     patch(
         "https://github.com/openssl/openssl/commit/f9e578e720bb35228948564192adbe3bc503d5fb.patch?full_index=1",
         sha256="3fdcf2d1e47c34f3a012f23306322c5a35cad55b180c9b6fb34537b55884645c",

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

@@ -16,6 +16,7 @@ class Openvkl(CMakePackage):
 
     # maintainers("github_user1", "github_user2")
 
+    version("2.0.0", sha256="469c3fba254c4fcdd84f8a9763d2e1aaa496dc123b5a9d467cc0a561e284c4e6")
     version("1.3.2", sha256="7704736566bf17497a3e51c067bd575316895fda96eccc682dae4aac7fb07b28")
     version("1.3.1", sha256="c9cefb6c313f2b4c0331e9629931759a6bc204ec00deed6ec0becad1670a1933")
     version("1.3.0", sha256="c6d4d40e6d232839c278b53dee1e7bd3bd239c3ccac33f49b465fc65a0692be9")
@@ -36,6 +37,7 @@ class Openvkl(CMakePackage):
     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("rkcommon@:1.11.0", when="@:1.3.2")
     depends_on("tbb")
 
     def cmake_args(self):

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

@@ -16,6 +16,7 @@ class Ospray(CMakePackage):
 
     # maintainers("aumuell")
 
+    version("3.0.0", sha256="d8d8e632d77171c810c0f38f8d5c8387470ca19b75f5b80ad4d3d12007280288")
     version("2.12.0", sha256="268b16952b2dd44da2a1e40d2065c960bc2442dd09b63ace8b65d3408f596301")
     version("2.11.0", sha256="55974e650d9b78989ee55adb81cffd8c6e39ce5d3cf0a3b3198c522bf36f6e81")
     version("2.10.0", sha256="bd478284f48d2cb775fc41a2855a9d9f5ea16c861abda0f8dc94e02ea7189cb8")
@@ -38,26 +39,31 @@ class Ospray(CMakePackage):
     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("rkcommon@1.12:", when="@3:")
     depends_on("embree@3.12: +ispc")
     depends_on("embree@3.13.1:", when="@2.7.0:")
     depends_on("embree@:3", when="@:2.10")
     depends_on("embree@4:", when="@2.11:")
+    depends_on("embree@4.3:", when="@3:")
     with when("+volumes"):
-        depends_on("openvkl@0.13.0:")
+        depends_on("openvkl@0.13.0:1", when="@2")
         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:")
+        depends_on("openvkl@1.3.2:", when="@2.11:2")
+        depends_on("openvkl@2:", when="@3:")
     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("openimagedenoise@2.1:", when="@3:")
     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("ispc@1.21.1:", when="@3:", type=("build"))
     depends_on("tbb")
 
     depends_on("mpi", when="+mpi")

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

@@ -28,6 +28,9 @@ class Paraview(CMakePackage, CudaPackage, ROCmPackage):
     tags = ["e4s"]
 
     version("master", branch="master", submodules=True)
+    version(
+        "5.12.0-RC1", sha256="892eda2ae72831bbadd846be465d496ada35739779229c604cddd56e018a1aea"
+    )
     version(
         "5.11.2",
         sha256="5c5d2f922f30d91feefc43b4a729015dbb1459f54c938896c123d2ac289c7a1e",
@@ -190,7 +193,7 @@ class Paraview(CMakePackage, CudaPackage, ROCmPackage):
         depends_on("libxt", when="~osmesa platform={}".format(p))
     conflicts("+qt", when="+osmesa")
 
-    depends_on("ospray@2.1:", when="+raytracing")
+    depends_on("ospray@2.1:2", when="+raytracing")
     depends_on("openimagedenoise", when="+raytracing")
     depends_on("ospray +mpi", when="+raytracing +mpi")
 

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

@@ -20,6 +20,7 @@ class Podio(CMakePackage):
     tags = ["hep", "key4hep"]
 
     version("master", branch="master")
+    version("0.17.3", sha256="079517eba9c43d01255ef8acd88468c3ead7bb9d8fed11792e121bb481d54dee")
     version("0.17.2", sha256="5b519335c4e1708f71ed85b3cac8ca81e544cc4572a5c37019ce9fc414c5e74d")
     version("0.17.1", sha256="97d6c5f81d50ee42bf7c01f041af2fd333c806f1bbf0a4828ca961a24cea6bb2")
     version("0.17", sha256="0c19f69970a891459cab227ab009514f1c1ce102b70e8c4b7d204eb6a0c643c1")

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

@@ -17,7 +17,7 @@ class PyAbipy(PythonPackage):
     version("0.2.0", sha256="c72b796ba0f9ea4299eac3085bede092d2652e9e5e8074d3badd19ef7b600792")
 
     variant("gui", default=False, description="Build the GUI")
-    variant("ipython", default=False, when="0.2.0", description="Build IPython support")
+    variant("ipython", default=False, when="@0.2.0", description="Build IPython support")
 
     depends_on("py-setuptools", type="build")
     # in newer pip versions --install-option does not exist

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

@@ -32,7 +32,7 @@ class PyKombu(PythonPackage):
     depends_on("py-amqp@5.0.0:5", when="@5.0.0:5.0.2", type=("build", "run"))
     depends_on("py-amqp@5.0.9:5.0", when="@5.2.3", type=("build", "run"))
     depends_on("py-vine", when="@5.1.0:", type=("build", "run"))
-    depends_on("py-importlib-metadata@0.18:", type=("build", "run"), when="python@:3.7")
-    depends_on("py-cached-property", type=("build", "run"), when="python@:3.7")
+    depends_on("py-importlib-metadata@0.18:", type=("build", "run"), when="^python@:3.7")
+    depends_on("py-cached-property", type=("build", "run"), when="^python@:3.7")
 
     depends_on("py-redis@3.4.1:3,4.0.2:", when="+redis", type=("build", "run"))

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

@@ -15,6 +15,7 @@ class PyLightning(PythonPackage):
 
     maintainers("adamjstewart")
 
+    version("2.1.2", sha256="3b2599a8a719916cb03526e6570356809729680c6cda09391232e2aba0a4ed4b")
     version("2.1.1", sha256="865491940d20a9754eac7494aa18cab893e0c2b31e83743349eeeaf31dfb52db")
     version("2.1.0", sha256="1f78f5995ae7dcffa1edf34320db136902b73a0d1b304404c48ec8be165b3a93")
     version("2.0.9", sha256="2395ece6e29e12064718ff16b8edec5685df7f7095d4fee78edb0a654f5cd7eb")

var/spack/repos/builtin/packages/py-nvidia-dali/package.py

@@ -170,20 +170,20 @@ class PyNvidiaDali(PythonPackage):
         )
 
     cuda120_versions = (
-        "1.27.0-cuda120",
-        "1.26.0-cuda120",
-        "1.25.0-cuda120",
-        "1.24.0-cuda120",
-        "1.23.0-cuda120",
-        "1.22.0-cuda120",
+        "@1.27.0-cuda120",
+        "@1.26.0-cuda120",
+        "@1.25.0-cuda120",
+        "@1.24.0-cuda120",
+        "@1.23.0-cuda120",
+        "@1.22.0-cuda120",
     )
     cuda110_versions = (
-        "1.27.0-cuda110",
-        "1.26.0-cuda110",
-        "1.25.0-cuda110",
-        "1.24.0-cuda110",
-        "1.23.0-cuda110",
-        "1.22.0-cuda110",
+        "@1.27.0-cuda110",
+        "@1.26.0-cuda110",
+        "@1.25.0-cuda110",
+        "@1.24.0-cuda110",
+        "@1.23.0-cuda110",
+        "@1.22.0-cuda110",
     )
 
     for v in cuda120_versions:

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

@@ -18,6 +18,6 @@ class PyPdbfixer(PythonPackage):
     version("1.7", sha256="a0bef3c52a7bbe69a6aea5333f51f3e7d158339be5829aed19b0344bd66d4eea")
 
     depends_on("py-setuptools", type="build")
-    depends_on("openmm@7.1:7.5", type=("build", "run"), when="1.7")
+    depends_on("openmm@7.1:7.5", type=("build", "run"), when="@1.7")
     depends_on("openmm@7.6:", type=("build", "run"), when="@1.8:")
     depends_on("py-numpy", type=("build", "run"))

var/spack/repos/builtin/packages/py-tensorflow-datasets/package.py

@@ -29,5 +29,5 @@ class PyTensorflowDatasets(PythonPackage):
     depends_on("py-tensorflow-metadata", type=("build", "run"))
     depends_on("py-termcolor", type=("build", "run"))
     depends_on("py-tqdm", type=("build", "run"))
-    depends_on("py-typing-extensions", type=("build", "run"), when="python@:3.7")
-    depends_on("py-importlib-resources", type=("build", "run"), when="python@:3.8")
+    depends_on("py-typing-extensions", type=("build", "run"), when="^python@:3.7")
+    depends_on("py-importlib-resources", type=("build", "run"), when="^python@:3.8")

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

@@ -25,6 +25,7 @@ class PyTorch(PythonPackage, CudaPackage, ROCmPackage):
 
     version("main", branch="main")
     version("master", branch="main", deprecated=True)
+    version("2.1.1", tag="v2.1.1", commit="4c55dc50355d5e923642c59ad2a23d6ad54711e7")
     version("2.1.0", tag="v2.1.0", commit="7bcf7da3a268b435777fe87c7794c382f444e86d")
     version("2.0.1", tag="v2.0.1", commit="e9ebda29d87ce0916ab08c06ab26fd3766a870e5")
     version("2.0.0", tag="v2.0.0", commit="c263bd43e8e8502d4726643bc6fd046f0130ac0e")

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

@@ -15,6 +15,7 @@ class PyTorchaudio(PythonPackage):
     submodules = True
 
     version("main", branch="main")
+    version("2.1.1", tag="v2.1.1", commit="db624844f5c95bb7618fe5a5f532bf9b68efeb45")
     version("2.1.0", tag="v2.1.0", commit="6ea1133706801ec6e81bb29142da2e21a8583a0a")
     version("2.0.2", tag="v2.0.2", commit="31de77dad5c89274451b3f5c4bcb630be12787c4")
     version("2.0.1", tag="v2.0.1", commit="3b40834aca41957002dfe074175e900cf8906237")
@@ -56,6 +57,7 @@ class PyTorchaudio(PythonPackage):
     depends_on("sox")
 
     depends_on("py-torch@main", when="@main", type=("build", "link", "run"))
+    depends_on("py-torch@2.1.1", when="@2.1.1", type=("build", "link", "run"))
     depends_on("py-torch@2.1.0", when="@2.1.0", type=("build", "link", "run"))
     depends_on("py-torch@2.0.1", when="@2.0.2", type=("build", "link", "run"))
     depends_on("py-torch@2.0.0", when="@2.0.1", type=("build", "link", "run"))

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

@@ -16,6 +16,7 @@ class PyTorchdata(PythonPackage):
     maintainers("adamjstewart")
 
     version("main", branch="main")
+    version("0.7.1", sha256="1b6589336776ccba19fd3bf435588416105d372f6b85d58a9f2b008286f483bf")
     version("0.7.0", sha256="0b444719c3abc67201ed0fea92ea9c4100e7f36551ba0d19a09446cc11154eb3")
     version("0.6.1", sha256="c596db251c5e6550db3f00e4308ee7112585cca4d6a1c82a433478fd86693257")
     version("0.6.0", sha256="048dea12ee96c0ea1525097959fee811d7b38c2ed05f44a90f35f8961895fb5b")
@@ -38,6 +39,7 @@ class PyTorchdata(PythonPackage):
 
     # https://github.com/pytorch/data#version-compatibility
     depends_on("py-torch@main", when="@main", type=("build", "run"))
+    depends_on("py-torch@2.1.1", when="@0.7.1", type=("build", "run"))
     depends_on("py-torch@2.1.0", when="@0.7.0", type=("build", "run"))
     depends_on("py-torch@2.0.1", when="@0.6.1", type=("build", "run"))
     depends_on("py-torch@2.0.0", when="@0.6.0", type=("build", "run"))

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

@@ -17,6 +17,7 @@ class PyTorchtext(PythonPackage):
     maintainers("adamjstewart")
 
     version("main", branch="main")
+    version("0.16.1", tag="v0.16.1", commit="66671007c84e07386da3c04e5ca403b8a417c8e5")
     version("0.16.0", tag="v0.16.0", commit="4e255c95c76b1ccde4f6650391c0bc30650d6dbe")
     version("0.15.2", tag="v0.15.2", commit="4571036cf66c539e50625218aeb99a288d79f3e1")
     version("0.15.1", tag="v0.15.1", commit="c696895e524c61fd2b8b26916dd006411c5f3ba5")
@@ -58,6 +59,7 @@ class PyTorchtext(PythonPackage):
 
     # https://github.com/pytorch/text#installation
     depends_on("py-torch@main", when="@main", type=("build", "link", "run"))
+    depends_on("py-torch@2.1.1", when="@0.16.1", type=("build", "link", "run"))
     depends_on("py-torch@2.1.0", when="@0.16.0", type=("build", "link", "run"))
     depends_on("py-torch@2.0.1", when="@0.15.2", type=("build", "link", "run"))
     depends_on("py-torch@2.0.0", when="@0.15.1", type=("build", "link", "run"))

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

@@ -17,6 +17,7 @@ class PyTorchvision(PythonPackage):
     maintainers("adamjstewart")
 
     version("main", branch="main")
+    version("0.16.1", sha256="d31fe52e4540750c8d372b0f38f1bfa81d8261193f2c2c06577332831d203c50")
     version("0.16.0", sha256="79b30b082237e3ead21e74587cedf4a4d832f977cf7dfeccfb65f67988b12ceb")
     version("0.15.2", sha256="1efcb80e0a6e42c54f07ee16167839b4d302aeeecc12839cc47c74b06a2c20d4")
     version("0.15.1", sha256="689d23d4ebb0c7e54e8651c89b17155b64341c14ae4444a04ca7dc6f2b6a0a43")
@@ -62,6 +63,7 @@ class PyTorchvision(PythonPackage):
 
     # https://github.com/pytorch/vision#installation
     depends_on("py-torch@main", when="@main", type=("build", "link", "run"))
+    depends_on("py-torch@2.1.1", when="@0.16.1", type=("build", "link", "run"))
     depends_on("py-torch@2.1.0", when="@0.16.0", type=("build", "link", "run"))
     depends_on("py-torch@2.0.1", when="@0.15.2", type=("build", "link", "run"))
     depends_on("py-torch@2.0.0", when="@0.15.1", type=("build", "link", "run"))

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

@@ -4,7 +4,6 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 import os
-import re
 
 from spack.package import *
 
@@ -60,21 +59,20 @@ class R(AutotoolsPackage):
     version("3.1.3", sha256="07e98323935baa38079204bfb9414a029704bb9c0ca5ab317020ae521a377312")
     version("3.1.2", sha256="bcd150afcae0e02f6efb5f35a6ab72432be82e849ec52ce0bb89d8c342a8fa7a")
 
-    variant(
-        "external-lapack", default=False, description="Links to externally installed BLAS/LAPACK"
-    )
     variant("X", default=False, description="Enable X11 support (TCLTK, PNG, JPEG, TIFF, CAIRO)")
     variant("memory_profiling", default=False, description="Enable memory profiling")
     variant("rmath", default=False, description="Build standalone Rmath library")
 
-    depends_on("blas", when="+external-lapack")
-    depends_on("lapack", when="+external-lapack")
+    depends_on("blas")
+    depends_on("lapack")
+
     depends_on("bzip2")
     depends_on("curl+libidn2")
     # R didn't anticipate the celebratory non-breaking major version bump of curl 8.
     depends_on("curl@:7", when="@:4.2")
     depends_on("icu4c")
     depends_on("java")
+    depends_on("libtirpc")
     depends_on("ncurses")
     depends_on("pcre", when="@:3.6.3")
     depends_on("pcre2", when="@4:")
@@ -84,16 +82,18 @@ class R(AutotoolsPackage):
     depends_on("zlib-api")
     depends_on("zlib@1.2.5:", when="^zlib")
     depends_on("texinfo", type="build")
-    depends_on("cairo+X+gobject+pdf", when="+X")
-    depends_on("pango+X", when="+X")
-    depends_on("harfbuzz+graphite2", when="+X")
-    depends_on("jpeg", when="+X")
-    depends_on("libpng", when="+X")
-    depends_on("libtiff", when="+X")
-    depends_on("libx11", when="+X")
-    depends_on("libxmu", when="+X")
-    depends_on("libxt", when="+X")
-    depends_on("tk", when="+X")
+
+    with when("+X"):
+        depends_on("cairo+X+gobject+pdf")
+        depends_on("pango+X")
+        depends_on("harfbuzz+graphite2")
+        depends_on("jpeg")
+        depends_on("libpng")
+        depends_on("libtiff")
+        depends_on("libx11")
+        depends_on("libxmu")
+        depends_on("libxt")
+        depends_on("tk")
 
     patch("zlib.patch", when="@:3.3.2")
 
@@ -126,32 +126,34 @@ def configure_args(self):
         spec = self.spec
         prefix = self.prefix
 
+        extra_rpath = join_path(prefix, "rlib", "R", "lib")
+
+        blas_flags: str = spec["blas"].libs.ld_flags
+        lapack_flags: str = spec["lapack"].libs.ld_flags
+
+        # R uses LAPACK in Fortran, which requires libmkl_gf_* when gfortran is used.
+        # TODO: cleaning this up seem to require both compilers as dependencies and use variants.
+        if spec["lapack"].name in INTEL_MATH_LIBRARIES and "gfortran" in self.compiler.fc:
+            xlp64 = "ilp64" if spec["lapack"].satisfies("+ilp64") else "lp64"
+            blas_flags = blas_flags.replace(f"mkl_intel_{xlp64}", f"mkl_gf_{xlp64}")
+            lapack_flags = lapack_flags.replace(f"mkl_intel_{xlp64}", f"mkl_gf_{xlp64}")
+
         config_args = [
             "--with-internal-tzcode",
             "--libdir={0}".format(join_path(prefix, "rlib")),
             "--enable-R-shlib",
-            "--enable-BLAS-shlib",
             "--enable-R-framework=no",
             "--without-recommended-packages",
-            "LDFLAGS=-L{0} -Wl,-rpath,{0}".format(join_path(prefix, "rlib", "R", "lib")),
+            f"LDFLAGS=-Wl,-rpath,{extra_rpath}",
+            f"--with-blas={blas_flags}",
+            f"--with-lapack={lapack_flags}",
+            # cannot disable docs with a normal configure option
+            "ac_cv_path_PDFLATEX=",
+            "ac_cv_path_PDFTEX=",
+            "ac_cv_path_TEX=",
+            "ac_cv_path_TEXI2DVI=",
         ]
 
-        if "+external-lapack" in spec:
-            if spec["lapack"].name in INTEL_MATH_LIBRARIES and "gfortran" in self.compiler.fc:
-                mkl_re = re.compile(r"(mkl_)intel(_i?lp64\b)")
-                config_args.extend(
-                    [
-                        mkl_re.sub(
-                            r"\g<1>gf\g<2>", "--with-blas={0}".format(spec["blas"].libs.ld_flags)
-                        ),
-                        "--with-lapack",
-                    ]
-                )
-            else:
-                config_args.extend(
-                    ["--with-blas={0}".format(spec["blas"].libs.ld_flags), "--with-lapack"]
-                )
-
         if "+X" in spec:
             config_args.append("--with-cairo")
             config_args.append("--with-jpeglib")

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

@@ -16,6 +16,7 @@ class Rkcommon(CMakePackage):
 
     # maintainers("github_user1",o"github_user2")
 
+    version("1.12.0", sha256="6abb901073811cdbcbe336772e1fcb458d78cab5ad8d5d61de2b57ab83581e80")
     version("1.11.0", sha256="9cfeedaccdefbdcf23c465cb1e6c02057100c4a1a573672dc6cfea5348cedfdd")
     version("1.10.0", sha256="57a33ce499a7fc5a5aaffa39ec7597115cf69ed4ff773546b5b71ff475ee4730")
     version("1.9.0", sha256="b68aa02ef44c9e35c168f826a14802bb5cc6a9d769ba4b64b2c54f347a14aa53")

var/spack/repos/builtin/packages/slurm-drmaa/package.py

@@ -10,7 +10,7 @@ class SlurmDrmaa(AutotoolsPackage):
     """
     DRMAA for Slurm is an implementation of Open Grid Forum DRMAA 1.0 (Distributed
     Resource Management Application API) specification for submission and control of
-    jobs to SLURM.  Using DRMAA, grid applications builders, portal developers and
+    jobs to Slurm.  Using DRMAA, grid applications builders, portal developers and
     ISVs can use the same high-level API to link their software with different
     cluster/resource management systems.
     """

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

@@ -16,6 +16,7 @@ class Taskflow(CMakePackage):
     git = "https://github.com/taskflow/taskflow.git"
 
     version("master", branch="master")
+    version("3.6.0", sha256="5a1cd9cf89f93a97fcace58fd73ed2fc8ee2053bcb43e047acb6bc121c3edf4c")
     version("2.7.0", sha256="bc2227dcabec86abeba1fee56bb357d9d3c0ef0184f7c2275d7008e8758dfc3e")
 
     # Compiler must offer C++14 support

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

@@ -85,9 +85,11 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     maintainers("balay", "luszczek", "balos1", "shuds13", "v-dobrev")
 
     version("develop")
+    version("1.0.0")
     version("0.8.0")
     version("0.7.0", deprecated=True)
 
+    variant("sycl", default=False, sticky=True, description="Enable sycl variant of xsdk packages")
     variant("trilinos", default=True, sticky=True, description="Enable trilinos package build")
     variant("datatransferkit", default=True, description="Enable datatransferkit package build")
     variant("omega-h", default=True, description="Enable omega-h package build")
@@ -107,8 +109,14 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     variant("exago", default=True, description="Enable exago build")
     variant("hiop", default=True, description="Enable hiop build")
     variant("raja", default=(sys.platform != "darwin"), description="Enable raja for hiop, exago")
+    variant("pflotran", default=True, description="Enable pflotran package build")
 
-    xsdk_depends_on("hypre@develop+superlu-dist+shared", when="@develop", cuda_var="cuda")
+    xsdk_depends_on(
+        "hypre@develop+superlu-dist+shared", when="@develop", cuda_var="cuda", rocm_var="rocm"
+    )
+    xsdk_depends_on(
+        "hypre@2.30.0+superlu-dist+shared", when="@1.0.0", cuda_var="cuda", rocm_var="rocm"
+    )
     xsdk_depends_on("hypre@2.26.0+superlu-dist+shared", when="@0.8.0", cuda_var="cuda")
     xsdk_depends_on("hypre@2.23.0+superlu-dist+shared", when="@0.7.0", cuda_var="cuda")
 
@@ -118,6 +126,12 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
         cuda_var="cuda",
         rocm_var="rocm",
     )
+    xsdk_depends_on(
+        "mfem@4.6.0+shared+mpi+superlu-dist+petsc+sundials+examples+miniapps",
+        when="@1.0.0",
+        cuda_var="cuda",
+        rocm_var="rocm",
+    )
     xsdk_depends_on(
         "mfem@4.5.0+shared+mpi+superlu-dist+petsc+sundials+examples+miniapps",
         when="@0.8.0",
@@ -131,16 +145,26 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
         rocm_var="rocm",
     )
 
-    xsdk_depends_on("superlu-dist@develop", when="@develop")
+    xsdk_depends_on("superlu-dist@develop", when="@develop", cuda_var="cuda", rocm_var="rocm")
+    xsdk_depends_on("superlu-dist@8.2.0", when="@1.0.0", cuda_var="cuda", rocm_var="rocm")
     xsdk_depends_on("superlu-dist@8.1.2", when="@0.8.0")
     xsdk_depends_on("superlu-dist@7.1.1", when="@0.7.0")
+
+    xsdk_depends_on("trilinos +superlu-dist", when="@1.0.0: +trilinos ~cuda ~rocm")
     xsdk_depends_on(
-        "trilinos@develop+hypre+superlu-dist+hdf5~mumps+boost"
+        "trilinos@develop+hypre+hdf5~mumps+boost"
         + "~suite-sparse+tpetra+nox+ifpack2+zoltan+zoltan2+amesos2"
         + "~exodus~dtk+intrepid2+shards+stratimikos gotype=int"
         + " cxxstd=14",
         when="@develop +trilinos",
     )
+    xsdk_depends_on(
+        "trilinos@14.4.0+hypre+hdf5~mumps+boost"
+        + "~suite-sparse+tpetra+nox+ifpack2+zoltan+zoltan2+amesos2"
+        + "~exodus~dtk+intrepid2+shards+stratimikos gotype=int"
+        + " cxxstd=17",
+        when="@1.0.0 +trilinos",
+    )
     xsdk_depends_on(
         "trilinos@13.4.1+hypre+superlu-dist+hdf5~mumps+boost"
         + "~suite-sparse+tpetra+nox+ifpack2+zoltan+zoltan2+amesos2"
@@ -157,17 +181,25 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     )
 
     xsdk_depends_on("datatransferkit@master", when="@develop +trilinos +datatransferkit")
+    xsdk_depends_on("datatransferkit@3.1.1", when="@1.0.0 +trilinos +datatransferkit")
     dtk7ver = "3.1-rc2" if sys.platform == "darwin" else "3.1-rc3"
     xsdk_depends_on("datatransferkit@" + dtk7ver, when="@0.8.0 +trilinos +datatransferkit")
     xsdk_depends_on("datatransferkit@" + dtk7ver, when="@0.7.0 +trilinos +datatransferkit")
 
     xsdk_depends_on("petsc +batch", when="@0.7.0: ^cray-mpich")
+    xsdk_depends_on("petsc +sycl +kokkos", when="@1.0.0: +sycl")
     xsdk_depends_on(
         "petsc@main+mpi+hypre+superlu-dist+metis+hdf5~mumps+double~int64",
         when="@develop",
         cuda_var="cuda",
         rocm_var="rocm",
     )
+    xsdk_depends_on(
+        "petsc@3.20.1+mpi+hypre+superlu-dist+metis+hdf5~mumps+double~int64",
+        when="@1.0.0",
+        cuda_var="cuda",
+        rocm_var="rocm",
+    )
     xsdk_depends_on(
         "petsc@3.18.1+mpi+hypre+superlu-dist+metis+hdf5~mumps+double~int64",
         when="@0.8.0",
@@ -184,9 +216,14 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     xsdk_depends_on("dealii ~trilinos", when="~trilinos +dealii")
     xsdk_depends_on(
         "dealii@master~assimp~python~doc~gmsh+petsc+slepc+mpi~int64"
-        + "~netcdf+metis+sundials~ginkgo~symengine~nanoflann~simplex~arborx~cgal",
+        + "~netcdf+metis+sundials~ginkgo~symengine~nanoflann~simplex~arborx~cgal~oce",
         when="@develop +dealii",
     )
+    xsdk_depends_on(
+        "dealii@9.5.1~assimp~python~doc~gmsh+petsc+slepc+mpi~int64"
+        + "~netcdf+metis+sundials~ginkgo~symengine~simplex~arborx~cgal~oce",
+        when="@1.0.0 +dealii",
+    )
     xsdk_depends_on(
         "dealii@9.4.0~assimp~python~doc~gmsh+petsc+slepc+mpi~int64"
         + "~netcdf+metis+sundials~ginkgo~symengine~simplex~arborx~cgal",
@@ -198,22 +235,31 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
         when="@0.7.0 +dealii",
     )
 
-    xsdk_depends_on("pflotran@develop", when="@develop")
-    xsdk_depends_on("pflotran@4.0.1", when="@0.8.0")
-    xsdk_depends_on("pflotran@3.0.2", when="@0.7.0")
+    xsdk_depends_on("pflotran@develop", when="@develop +pflotran")
+    xsdk_depends_on("pflotran@5.0.0", when="@1.0.0 +pflotran")
+    xsdk_depends_on("pflotran@4.0.1", when="@0.8.0 +pflotran")
+    xsdk_depends_on("pflotran@3.0.2", when="@0.7.0 +pflotran")
 
     xsdk_depends_on("alquimia@master", when="@develop +alquimia")
+    xsdk_depends_on("alquimia@1.1.0", when="@1.0.0 +alquimia")
     xsdk_depends_on("alquimia@1.0.10", when="@0.8.0 +alquimia")
     xsdk_depends_on("alquimia@1.0.9", when="@0.7.0 +alquimia")
 
     xsdk_depends_on("sundials +trilinos", when="+trilinos @0.7.0:")
     xsdk_depends_on("sundials +ginkgo", when="+ginkgo @0.8.0:")
+    xsdk_depends_on("sundials +sycl cxxstd=17", when="@1.0.0: +sycl")
     xsdk_depends_on(
         "sundials@develop~int64+hypre+petsc+superlu-dist",
         when="@develop",
         cuda_var=["cuda", "?magma"],
         rocm_var=["rocm", "?magma"],
     )
+    xsdk_depends_on(
+        "sundials@6.6.2~int64+hypre+petsc+superlu-dist",
+        when="@1.0.0",
+        cuda_var=["cuda", "?magma"],
+        rocm_var=["rocm", "?magma"],
+    )
     xsdk_depends_on(
         "sundials@6.4.1~int64+hypre+petsc+superlu-dist",
         when="@0.8.0",
@@ -228,13 +274,16 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     )
 
     xsdk_depends_on("plasma@develop:", when="@develop %gcc@6.0:")
+    xsdk_depends_on("plasma@23.8.2:", when="@1.0.0 %gcc@6.0:")
     xsdk_depends_on("plasma@22.9.29:", when="@0.8.0 %gcc@6.0:")
     xsdk_depends_on("plasma@21.8.29:", when="@0.7.0 %gcc@6.0:")
 
     xsdk_depends_on("magma@master", when="@develop", cuda_var="?cuda", rocm_var="?rocm")
+    xsdk_depends_on("magma@2.7.1", when="@1.0.0", cuda_var="?cuda", rocm_var="?rocm")
     xsdk_depends_on("magma@2.7.0", when="@0.8.0", cuda_var="?cuda", rocm_var="?rocm")
     xsdk_depends_on("magma@2.6.1", when="@0.7.0", cuda_var="?cuda", rocm_var="?rocm")
 
+    xsdk_depends_on("amrex +sycl", when="@1.0.0: +sycl")
     xsdk_depends_on(
         "amrex@develop+sundials", when="@develop %intel", cuda_var="cuda", rocm_var="rocm"
     )
@@ -244,6 +293,9 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     xsdk_depends_on(
         "amrex@develop+sundials", when="@develop %cce", cuda_var="cuda", rocm_var="rocm"
     )
+    xsdk_depends_on("amrex@23.08+sundials", when="@1.0.0 %intel", cuda_var="cuda", rocm_var="rocm")
+    xsdk_depends_on("amrex@23.08+sundials", when="@1.0.0 %gcc", cuda_var="cuda", rocm_var="rocm")
+    xsdk_depends_on("amrex@23.08+sundials", when="@1.0.0 %cce", cuda_var="cuda", rocm_var="rocm")
     xsdk_depends_on("amrex@22.09+sundials", when="@0.8.0 %intel", cuda_var="cuda", rocm_var="rocm")
     xsdk_depends_on("amrex@22.09+sundials", when="@0.8.0 %gcc", cuda_var="cuda", rocm_var="rocm")
     xsdk_depends_on("amrex@22.09+sundials", when="@0.8.0 %cce", cuda_var="cuda", rocm_var="rocm")
@@ -252,32 +304,39 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     xsdk_depends_on("amrex@21.10+sundials", when="@0.7.0 %cce", cuda_var="cuda", rocm_var="rocm")
 
     xsdk_depends_on("slepc@main", when="@develop")
+    xsdk_depends_on("slepc@3.20.0", when="@1.0.0", cuda_var="cuda", rocm_var="rocm")
     xsdk_depends_on("slepc@3.18.1", when="@0.8.0", cuda_var="cuda", rocm_var="rocm")
     xsdk_depends_on("slepc@3.16.0", when="@0.7.0")
 
     xsdk_depends_on("omega-h +trilinos", when="+trilinos +omega-h")
     xsdk_depends_on("omega-h ~trilinos", when="~trilinos +omega-h")
     xsdk_depends_on("omega-h@main", when="@develop +omega-h")
+    xsdk_depends_on("omega-h@scorec.10.6.0", when="@1.0.0 +omega-h")
     xsdk_depends_on("omega-h@9.34.13", when="@0.8.0 +omega-h")
     xsdk_depends_on("omega-h@9.34.1", when="@0.7.0 +omega-h")
 
     xsdk_depends_on("strumpack ~cuda", when="~cuda @0.7.0: +strumpack")
     xsdk_depends_on("strumpack ~slate~openmp", when="~slate @0.8.0: +strumpack")
     xsdk_depends_on("strumpack@master", when="@develop +strumpack", cuda_var=["cuda"])
+    xsdk_depends_on("strumpack@7.2.0", when="@1.0.0 +strumpack", cuda_var=["cuda"])
     xsdk_depends_on("strumpack@7.0.1", when="@0.8.0 +strumpack", cuda_var=["cuda"])
     xsdk_depends_on("strumpack@6.1.0~slate~openmp", when="@0.7.0 +strumpack")
 
     xsdk_depends_on("pumi@master+shared", when="@develop")
+    xsdk_depends_on("pumi@2.2.8+shared", when="@1.0.0")
     xsdk_depends_on("pumi@2.2.7+shared", when="@0.8.0")
     xsdk_depends_on("pumi@2.2.6", when="@0.7.0")
 
     tasmanian_openmp = "~openmp" if sys.platform == "darwin" else "+openmp"
     xsdk_depends_on(
-        "tasmanian@develop+xsdkflags+blas" + tasmanian_openmp,
+        "tasmanian@develop+blas" + tasmanian_openmp,
         when="@develop",
         cuda_var=["cuda", "?magma"],
         rocm_var=["rocm", "?magma"],
     )
+    xsdk_depends_on(
+        "tasmanian@8.0+mpi+blas" + tasmanian_openmp, when="@1.0.0", cuda_var=["cuda", "?magma"]
+    )
     xsdk_depends_on(
         "tasmanian@7.9+xsdkflags+mpi+blas" + tasmanian_openmp,
         when="@0.8.0",
@@ -290,6 +349,8 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     )
 
     xsdk_depends_on("arborx@master", when="@develop +arborx")
+    xsdk_depends_on("arborx+sycl", when="@1.0.0: +arborx +sycl")
+    xsdk_depends_on("arborx@1.4.1", when="@1.0.0 +arborx")
     xsdk_depends_on("arborx@1.2", when="@0.8.0 +arborx")
     xsdk_depends_on("arborx@1.1", when="@0.7.0 +arborx")
 
@@ -302,12 +363,17 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     xsdk_depends_on("phist kernel_lib=tpetra", when="+trilinos +phist")
     xsdk_depends_on("phist kernel_lib=petsc", when="~trilinos +phist")
     xsdk_depends_on("phist@develop ~fortran ~scamac ~openmp ~host ~int64", when="@develop +phist")
+    xsdk_depends_on("phist@1.12.0 ~fortran ~scamac ~openmp ~host ~int64", when="@1.0.0 +phist")
     xsdk_depends_on("phist@1.11.2 ~fortran ~scamac ~openmp ~host ~int64", when="@0.8.0 +phist")
     xsdk_depends_on("phist@1.9.5 ~fortran ~scamac ~openmp ~host ~int64", when="@0.7.0 +phist")
 
+    xsdk_depends_on("ginkgo+sycl", when="@1.0.0: +ginkgo +sycl")
     xsdk_depends_on(
         "ginkgo@develop +mpi ~openmp", when="@develop +ginkgo", cuda_var="cuda", rocm_var="rocm"
     )
+    xsdk_depends_on(
+        "ginkgo@1.7.0 +mpi ~openmp", when="@1.0.0 +ginkgo", cuda_var="cuda", rocm_var="rocm"
+    )
     xsdk_depends_on(
         "ginkgo@1.5.0 +mpi ~openmp", when="@0.8.0 +ginkgo", cuda_var="cuda", rocm_var="rocm"
     )
@@ -317,6 +383,8 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
 
     xsdk_depends_on("py-libensemble@develop+petsc4py", when="@develop +libensemble")
     xsdk_depends_on("py-petsc4py@main", when="@develop +libensemble")
+    xsdk_depends_on("py-libensemble@1.0.0+petsc4py", when="@1.0.0 +libensemble")
+    xsdk_depends_on("py-petsc4py@3.20.1", when="@1.0.0 +libensemble")
     xsdk_depends_on("py-libensemble@0.9.3+petsc4py", when="@0.8.0 +libensemble")
     xsdk_depends_on("py-petsc4py@3.18.1", when="@0.8.0 +libensemble")
     xsdk_depends_on("py-libensemble@0.8.0+petsc4py", when="@0.7.0 +libensemble")
@@ -324,11 +392,13 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
 
     xsdk_depends_on("precice ~petsc", when="+precice ^cray-mpich")
     xsdk_depends_on("precice@develop", when="@develop +precice")
+    xsdk_depends_on("precice@2.5.0", when="@1.0.0 +precice")
     xsdk_depends_on("precice@2.5.0", when="@0.8.0 +precice")
     xsdk_depends_on("precice@2.3.0", when="@0.7.0 +precice")
 
     bfpk_openmp = "~openmp" if sys.platform == "darwin" else "+openmp"
     xsdk_depends_on("butterflypack@master", when="@develop +butterflypack")
+    xsdk_depends_on("butterflypack@2.4.0" + bfpk_openmp, when="@1.0.0 +butterflypack")
     xsdk_depends_on("butterflypack@2.2.2" + bfpk_openmp, when="@0.8.0 +butterflypack")
     xsdk_depends_on("butterflypack@2.0.0", when="@0.7.0 +butterflypack")
 
@@ -338,6 +408,12 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
         cuda_var=["cuda", "?magma"],
         rocm_var=["rocm", "?magma"],
     )
+    xsdk_depends_on(
+        "heffte@2.4.0+fftw",
+        when="@1.0.0 +heffte",
+        cuda_var=["cuda", "?magma"],
+        rocm_var=["rocm", "?magma"],
+    )
     xsdk_depends_on(
         "heffte@2.3.0+fftw",
         when="@0.8.0 +heffte",
@@ -352,15 +428,20 @@ class Xsdk(BundlePackage, CudaPackage, ROCmPackage):
     )
 
     xsdk_depends_on("slate@master", when="@develop +slate", cuda_var="cuda")
+    xsdk_depends_on("slate@2023.08.25", when="@1.0.0 +slate", cuda_var="cuda")
     xsdk_depends_on("slate@2022.07.00", when="@0.8.0 +slate", cuda_var="cuda")
     xsdk_depends_on("slate@2021.05.02", when="@0.7.0 +slate %gcc@6.0:", cuda_var="cuda")
 
     xsdk_depends_on("exago@develop~ipopt~hiop~python", when="@develop +exago ~raja")
     xsdk_depends_on("exago@develop~ipopt+hiop+raja", when="@develop +exago +raja", cuda_var="cuda")
+    xsdk_depends_on("exago@1.6.0~ipopt~hiop~python", when="@1.0.0 +exago ~raja")
+    xsdk_depends_on("exago@1.6.0~ipopt+hiop+raja", when="@1.0.0 +exago +raja", cuda_var="cuda")
     xsdk_depends_on("exago@1.5.0~ipopt~hiop~python", when="@0.8.0 +exago ~raja")
     xsdk_depends_on("exago@1.5.0~ipopt+hiop+raja", when="@0.8.0 +exago +raja", cuda_var="cuda")
 
     xsdk_depends_on("hiop@develop", when="@develop +hiop ~raja")
     xsdk_depends_on("hiop@develop+raja", when="@develop +hiop +raja", cuda_var="cuda")
+    xsdk_depends_on("hiop@1.0.0", when="@1.0.0 +hiop ~raja")
+    xsdk_depends_on("hiop@1.0.0+raja", when="@1.0.0 +hiop +raja", cuda_var="cuda")
     xsdk_depends_on("hiop@0.7.1", when="@0.8.0 +hiop ~raja")
     xsdk_depends_on("hiop@0.7.1+raja", when="@0.8.0 +hiop +raja", cuda_var="cuda")