add missing test_repo package

Signed-off-by: Gregory Becker <becker33@llnl.gov>

.github/workflows/sync-packages.yaml

@@ -0,0 +1,34 @@
+name: sync with spack/spack-packages
+
+on:
+  push:
+    branches:
+    - develop
+
+jobs:
+  sync:
+    if: github.repository == 'spack/spack'
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout spack/spack
+      run: git clone https://github.com/spack/spack.git
+    - name: Checkout spack/spack-packages
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      with:
+        ssh-key: ${{ secrets.SYNC_PACKAGES_KEY }}
+        path: spack-packages
+        repository: spack/spack-packages
+    - name: Install git-filter-repo
+      run: |
+        curl -LfsO https://raw.githubusercontent.com/newren/git-filter-repo/refs/tags/v2.47.0/git-filter-repo
+        echo "67447413e273fc76809289111748870b6f6072f08b17efe94863a92d810b7d94  git-filter-repo" | sha256sum -c -
+        chmod +x git-filter-repo
+        sudo mv git-filter-repo /usr/local/bin/
+    - name: Sync spack/spack-packages with spack/spack
+      run: |
+        cd spack-packages
+        git-filter-repo --quiet --source ../spack --subdirectory-filter var/spack/repos --refs develop
+    - name: Push
+      run: |
+        cd spack-packages
+        git push git@github.com:spack/spack-packages.git develop:develop --force

lib/spack/docs/binary_caches.rst

@@ -45,10 +45,14 @@ provided binary cache, which can be a local directory or a remote URL.
 Here is an example where a build cache is created in a local directory named
 "spack-cache", to which we push the "ninja" spec:
 
+ninja-1.12.1-vmvycib6vmiofkdqgrblo7zsvp7odwut
+
 .. code-block:: console
 
     $ spack buildcache push ./spack-cache ninja
-    ==> Pushing binary packages to file:///home/spackuser/spack/spack-cache/build_cache
+    ==> Selected 30 specs to push to file:///home/spackuser/spack/spack-cache
+    ...
+    ==> [30/30] Pushed ninja@1.12.1/ngldn2k
 
 Note that ``ninja`` must be installed locally for this to work.
 
@@ -98,9 +102,10 @@ Now you can use list:
 .. code-block:: console
 
     $  spack buildcache list
-    ==> 1 cached build.
-    -- linux-ubuntu20.04-skylake / gcc@9.3.0 ------------------------
-    ninja@1.10.2
+    ==> 24 cached builds.
+    -- linux-ubuntu22.04-sapphirerapids / gcc@12.3.0 ----------------
+    [ ... ]
+    ninja@1.12.1
 
 With ``mymirror`` configured and an index available, Spack will automatically
 use it during concretization and installation. That means that you can expect
@@ -111,17 +116,17 @@ verify by re-installing ninja:
 
     $ spack uninstall ninja
     $ spack install ninja
-    ==> Installing ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz
-    ==> Fetching file:///home/spackuser/spack/spack-cache/build_cache/linux-ubuntu20.04-skylake-gcc-9.3.0-ninja-1.10.2-yxferyhmrjkosgta5ei6b4lqf6bxbscz.spec.json.sig
-    gpg: Signature made Do 12 Jan 2023 16:01:04 CET
-    gpg:                using RSA key 61B82B2B2350E171BD17A1744E3A689061D57BF6
+    [ ... ]
+    ==> Installing ninja-1.12.1-ngldn2kpvb6lqc44oqhhow7fzg7xu7lh [24/24]
+    gpg: Signature made Thu 06 Mar 2025 10:03:38 AM MST
+    gpg:                using RSA key 75BC0528114909C076E2607418010FFAD73C9B07
     gpg: Good signature from "example (GPG created for Spack) <example@example.com>" [ultimate]
-    ==> Fetching file:///home/spackuser/spack/spack-cache/build_cache/linux-ubuntu20.04-skylake/gcc-9.3.0/ninja-1.10.2/linux-ubuntu20.04-skylake-gcc-9.3.0-ninja-1.10.2-yxferyhmrjkosgta5ei6b4lqf6bxbscz.spack
-    ==> Extracting ninja-1.10.2-yxferyhmrjkosgta5ei6b4lqf6bxbscz from binary cache
-    ==> ninja: Successfully installed ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz
-    Search: 0.00s.  Fetch: 0.17s.  Install: 0.12s.  Total: 0.29s
-    [+] /home/harmen/spack/opt/spack/linux-ubuntu20.04-skylake/gcc-9.3.0/ninja-1.11.1-yxferyhmrjkosgta5ei6b4lqf6bxbscz
-
+    ==> Fetching file:///home/spackuser/spack/spack-cache/blobs/sha256/f0/f08eb62661ad159d2d258890127fc6053f5302a2f490c1c7f7bd677721010ee0
+    ==> Fetching file:///home/spackuser/spack/spack-cache/blobs/sha256/c7/c79ac6e40dfdd01ac499b020e52e57aa91151febaea3ad183f90c0f78b64a31a
+    ==> Extracting ninja-1.12.1-ngldn2kpvb6lqc44oqhhow7fzg7xu7lh from binary cache
+    ==> ninja: Successfully installed ninja-1.12.1-ngldn2kpvb6lqc44oqhhow7fzg7xu7lh
+      Search: 0.00s.  Fetch: 0.11s.  Install: 0.11s.  Extract: 0.10s.  Relocate: 0.00s.  Total: 0.22s
+    [+] /home/spackuser/spack/opt/spack/linux-ubuntu22.04-sapphirerapids/gcc-12.3.0/ninja-1.12.1-ngldn2kpvb6lqc44oqhhow7fzg7xu7lh
 
 It worked! You've just completed a full example of creating a build cache with
 a spec of interest, adding it as a mirror, updating its index, listing the contents,
@@ -344,19 +349,18 @@ which lets you get started quickly. See the following resources for more informa
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Create tarball of installed Spack package and all dependencies.
-Tarballs are checksummed and signed if gpg2 is available.
-Places them in a directory ``build_cache`` that can be copied to a mirror.
-Commands like ``spack buildcache install`` will search Spack mirrors for build_cache to get the list of build caches.
+Tarballs and specfiles are compressed and checksummed, manifests are signed if gpg2 is available.
+Commands like ``spack buildcache install`` will search Spack mirrors to get the list of build caches.
 
 ==============  ========================================================================================================================
 Arguments       Description
 ==============  ========================================================================================================================
 ``<specs>``     list of partial specs or hashes with a leading ``/`` to match from installed packages and used for creating build caches
-``-d <path>``   directory in which ``build_cache`` directory is created, defaults to ``.``
-``-f``          overwrite ``.spack`` file in ``build_cache`` directory if it exists
+``-d <path>``   directory in which ``v3`` and ``blobs`` directories are created, defaults to ``.``
+``-f``          overwrite compressed tarball and spec metadata files if they already exist
 ``-k <key>``    the key to sign package with. In the case where multiple keys exist, the package will be unsigned unless ``-k`` is used.
 ``-r``          make paths in binaries relative before creating tarball
-``-y``          answer yes to all create unsigned ``build_cache`` questions
+``-y``          answer yes to all questions about creating unsigned build caches
 ==============  ========================================================================================================================
 
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -397,6 +401,165 @@ List public keys available on Spack mirror.
 =========  ==============================================
 Arguments  Description
 =========  ==============================================
-``-i``     trust the keys downloaded with prompt for each
+``-it``    trust the keys downloaded with prompt for each
 ``-y``     answer yes to all trust all keys downloaded
 =========  ==============================================
+
+.. _build_cache_layout:
+
+------------------
+Build Cache Layout
+------------------
+
+This section describes the structure and content of URL-style build caches, as
+distinguished from OCI-style build caches.
+
+The entry point for a binary package is a manifest json file that points to at
+least two other files stored as content-addressed blobs. These files include a spec
+metadata file, as well as the installation directory of the package stored as
+a compressed archive file. Binary package manifest files are named to indicate
+the package name and version, as well as the hash of the concrete spec. For
+example::
+
+  gcc-runtime-12.3.0-qyu2lvgt3nxh7izxycugdbgf5gsdpkjt.spec.manifest.json
+
+would contain the manifest for a binary package of ``gcc-runtime@12.3.0``.
+The id of the built package is defined to be the DAG hash of the concrete spec,
+and exists in the name of the file as well. The id distinguishes a particular
+binary package from all other binary packages with the same package name and
+version. Below is an example binary package manifest file. Such a file would
+live in the versioned spec manifests directory of a binary mirror, for example
+``v3/manifests/spec/``::
+
+  {
+    "version": 3,
+    "data": [
+      {
+        "contentLength": 10731083,
+        "mediaType": "application/vnd.spack.install.v2.tar+gzip",
+        "compression": "gzip",
+        "checksumAlgorithm": "sha256",
+        "checksum": "0f24aa6b5dd7150067349865217acd3f6a383083f9eca111d2d2fed726c88210"
+      },
+      {
+        "contentLength": 1000,
+        "mediaType": "application/vnd.spack.spec.v5+json",
+        "compression": "gzip",
+        "checksumAlgorithm": "sha256",
+        "checksum": "fba751c4796536737c9acbb718dad7429be1fa485f5585d450ab8b25d12ae041"
+      }
+    ]
+  }
+
+The manifest points to both the compressed tar file as well as the compressed
+spec metadata file, and contains the checksum of each. This checksum
+is also used as the address of the associated file, and hence, must be
+known in order to locate the tarball or spec file within the mirror. Once the
+tarball or spec metadata file is downloaded, the checksum should be computed locally
+and compared to the checksum in the manifest to ensure the contents have not changed
+since the binary package was pushed. Spack stores all data files (including compressed
+tar files, spec metadata, indices, public keys, etc) within a ``blobs/<hash-algorithm>/``
+directory, using the first two characters of the checksum as a sub-directory
+to reduce the number files in a single folder.  Here is a depiction of the
+organization of binary mirror contents::
+
+  mirror_directory/
+    v3/
+      layout.json
+      manifests/
+        spec/
+          gcc-runtime/
+            gcc-runtime-12.3.0-s2nqujezsce4x6uhtvxscu7jhewqzztx.spec.manifest.json
+          gmake/
+            gmake-4.4.1-lpr4j77rcgkg5536tmiuzwzlcjsiomph.spec.manifest.json
+          compiler-wrapper/
+            compiler-wrapper-1.0-s7ieuyievp57vwhthczhaq2ogowf3ohe.spec.manifest.json
+        index/
+          index.manifest.json
+        key/
+          75BC0528114909C076E2607418010FFAD73C9B07.key.manifest.json
+          keys.manifest.json
+    blobs/
+      sha256/
+        0f/
+          0f24aa6b5dd7150067349865217acd3f6a383083f9eca111d2d2fed726c88210
+        fb/
+          fba751c4796536737c9acbb718dad7429be1fa485f5585d450ab8b25d12ae041
+        2a/
+          2a21836d206ccf0df780ab0be63fdf76d24501375306a35daa6683c409b7922f
+        ...
+
+Files within the ``manifests`` directory are organized into subdirectories by
+the type of entity they represent. Binary package manifests live in the ``spec/``
+directory, binary cache index manifests live in the ``index/`` directory, and
+manifests for public keys and their indices live in the ``key/`` subdirectory.
+Regardless of the type of entity they represent, all manifest files are named
+with an extension ``.manifest.json``.
+
+Every manifest contains a ``data`` array, each element of which refers to an
+associated file stored a content-addressed blob.  Considering the example spec
+manifest shown above, the compressed installation archive can be found by
+picking out the data blob with the appropriate ``mediaType``, which in this
+case would be ``application/vnd.spack.install.v1.tar+gzip``. The associated
+file is found by looking in the blobs directory under ``blobs/sha256/fb/`` for
+the file named with the complete checksum value.
+
+As mentioned above, every entity in a binary mirror (aka build cache) is stored
+as a content-addressed blob pointed to by a manifest. While an example spec
+manifest (i.e. a manifest for a binary package) is shown above, here is what
+the manifest of a build cache index looks like::
+
+  {
+    "version": 3,
+    "data": [
+      {
+        "contentLength": 6411,
+        "mediaType": "application/vnd.spack.db.v8+json",
+        "compression": "none",
+        "checksumAlgorithm": "sha256",
+        "checksum": "225a3e9da24d201fdf9d8247d66217f5b3f4d0fc160db1498afd998bfd115234"
+      }
+    ]
+  }
+
+Some things to note about this manifest are that it points to a blob that is not
+compressed (``compression: "none"``), and that the ``mediaType`` is one we have
+not seen yet, ``application/vnd.spack.db.v8+json``. The decision not to compress
+build cache indices stems from the fact that spack does not yet sign build cache
+index manifests. Once that changes, you may start to see these indices stored as
+compressed blobs.
+
+For completeness, here are examples of manifests for the other two types of entities
+you might find in a spack build cache. First a public key manifest::
+
+  {
+    "version": 3,
+    "data": [
+      {
+        "contentLength": 2472,
+        "mediaType": "application/pgp-keys",
+        "compression": "none",
+        "checksumAlgorithm": "sha256",
+        "checksum": "9fc18374aebc84deb2f27898da77d4d4410e5fb44c60c6238cb57fb36147e5c7"
+      }
+    ]
+  }
+
+Note the ``mediaType`` of ``application/pgp-keys``. Finally, a public key index manifest::
+
+  {
+    "version": 3,
+    "data": [
+      {
+        "contentLength": 56,
+        "mediaType": "application/vnd.spack.keyindex.v1+json",
+        "compression": "none",
+        "checksumAlgorithm": "sha256",
+        "checksum": "29b3a0eb6064fd588543bc43ac7d42d708a69058dafe4be0859e3200091a9a1c"
+      }
+    ]
+  }
+
+Again note the ``mediaType`` of ``application/vnd.spack.keyindex.v1+json``. Also note
+that both the above manifest examples refer to uncompressed blobs, this is for the same
+reason spack does not yet compress build cache index blobs.

lib/spack/docs/conf.py

@@ -35,7 +35,6 @@
 if not os.path.exists(link_name):
     os.symlink(os.path.abspath("../../.."), link_name, target_is_directory=True)
 sys.path.insert(0, os.path.abspath("_spack_root/lib/spack/external"))
-sys.path.insert(0, os.path.abspath("_spack_root/lib/spack/external/_vendoring"))
 sys.path.append(os.path.abspath("_spack_root/lib/spack/"))
 
 # Add the Spack bin directory to the path so that we can use its output in docs.

lib/spack/docs/environments.rst

@@ -539,7 +539,9 @@ from the command line.
 
 You can also include an environment directly in the ``spack.yaml`` file. It
 involves adding the ``include_concrete`` heading in the yaml followed by the
-absolute path to the independent environments.
+absolute path to the independent environments. Note, that you may use Spack
+config variables such as ``$spack`` or environment variables as long as the
+expression expands to an absolute path.
 
 .. code-block:: yaml
 
@@ -549,7 +551,7 @@ absolute path to the independent environments.
          unify: true
      include_concrete:
      - /absolute/path/to/environment1
-     - /absolute/path/to/environment2
+     - $spack/../path/to/environment2
 
 
 Once the ``spack.yaml`` has been updated you must concretize the environment to

lib/spack/docs/packaging_guide.rst

@@ -497,7 +497,7 @@ extends Spack's ``Package`` class.  For example, here is
 .. code-block:: python
    :linenos:
 
-   from spack import *
+   from spack.package import *
 
    class Libelf(Package):
        """ ... description ... """
@@ -1089,7 +1089,7 @@ You've already seen the ``homepage`` and ``url`` package attributes:
 .. code-block:: python
    :linenos:
 
-   from spack import *
+   from spack.package import *
 
 
    class Mpich(Package):
@@ -2253,22 +2253,15 @@ RPATHs in Spack are handled in one of three ways:
    set in standard variables like ``CC``, ``CXX``, ``F77``, and ``FC``,
    so most build systems (autotools and many gmake systems) pick them
    up and use them.
-#. CMake also respects Spack's compiler wrappers, but many CMake
-   builds have logic to overwrite RPATHs when binaries are
-   installed. Spack provides the ``std_cmake_args`` variable, which
-   includes parameters necessary for CMake build use the right
-   installation RPATH.  It can be used like this when ``cmake`` is
-   invoked:
-
-   .. code-block:: python
-
-      class MyPackage(Package):
-          ...
-          def install(self, spec, prefix):
-              cmake("..", *std_cmake_args)
-              make()
-              make("install")
-
+#. CMake has its own RPATH handling, and distinguishes between build and
+   install RPATHs. By default, during the build it registers RPATHs to
+   all libraries it links to, so that just-built executables can be run
+   during the build itself. Upon installation, these RPATHs are cleared,
+   unless the user defines the install RPATHs. When inheriting from
+   ``CMakePackage``, Spack handles this automatically, and sets
+   ``CMAKE_INSTALL_RPATH_USE_LINK_PATH`` and ``CMAKE_INSTALL_RPATH``,
+   so that libraries of dependencies and the package's own libraries
+   can be found at runtime.
 #. If you need to modify the build to add your own RPATHs, you can
    use the ``self.rpath`` property of your package, which will
    return a list of all the RPATHs that Spack will use when it
@@ -6183,7 +6176,7 @@ running:
 
 .. code-block:: python
 
-   from spack import *
+   from spack.package import *
 
 This is already part of the boilerplate for packages created with
 ``spack create``.

lib/spack/docs/signing.rst

@@ -176,92 +176,72 @@ community without needing deep familiarity with GnuPG or Public Key
 Infrastructure.
 
 
-.. _build_cache_format:
+.. _build_cache_signing:
 
-------------------
-Build Cache Format
-------------------
+-------------------
+Build Cache Signing
+-------------------
 
-A binary package consists of a metadata file unambiguously defining the
-built package (and including other details such as how to relocate it)
-and the installation directory of the package stored as a compressed
-archive file. The metadata files can either be unsigned, in which case
-the contents are simply the json-serialized concrete spec plus metadata,
-or they can be signed, in which case the json-serialized concrete spec
-plus metadata is wrapped in a gpg cleartext signature. Built package
-metadata files are named to indicate the operating system and
-architecture for which the package was built as well as the compiler
-used to build it and the packages name and version. For example::
+For an in-depth description of the layout of a binary mirror, see
+the :ref:`documentation<build_cache_layout>` covering binary caches. The
+key takeaway from that discussion that applies here is that the entry point
+to a binary package is it's manifest.  The manifest refers unambiguously to the
+spec metadata and compressed archive, which are stored as content-addressed
+blobs.
 
-  linux-ubuntu18.04-haswell-gcc-7.5.0-zlib-1.2.12-llv2ysfdxnppzjrt5ldybb5c52qbmoow.spec.json.sig
-
-would contain the concrete spec and binary metadata for a binary package
-of ``zlib@1.2.12``, built for the ``ubuntu`` operating system and ``haswell``
-architecture. The id of the built package exists in the name of the file
-as well (after the package name and version) and in this case begins
-with ``llv2ys``. The id distinguishes a particular built package from all
-other built packages with the same os/arch, compiler, name, and version.
-Below is an example of a signed binary package metadata file. Such a
-file would live in the ``build_cache`` directory of a binary mirror::
+The manifest files can either be signed or unsigned, but are always given
+a name ending with ``.spec.manifest.json`` regardless. The difference between
+signed and unsigned manifests is simply that the signed version is wrapped in
+a gpg cleartext signature, as illustrated below::
 
   -----BEGIN PGP SIGNED MESSAGE-----
   Hash: SHA512
 
   {
-    "spec": {
-      <concrete-spec-contents-omitted>
-    },
-
-    "buildcache_layout_version": 1,
-    "binary_cache_checksum": {
-      "hash_algorithm": "sha256",
-      "hash": "4f1e46452c35a5e61bcacca205bae1bfcd60a83a399af201a29c95b7cc3e1423"
-     }
+    "version": 3,
+    "data": [
+      {
+        "contentLength": 10731083,
+        "mediaType": "application/vnd.spack.install.v2.tar+gzip",
+        "compression": "gzip",
+        "checksumAlgorithm": "sha256",
+        "checksum": "0f24aa6b5dd7150067349865217acd3f6a383083f9eca111d2d2fed726c88210"
+      },
+      {
+        "contentLength": 1000,
+        "mediaType": "application/vnd.spack.spec.v5+json",
+        "compression": "gzip",
+        "checksumAlgorithm": "sha256",
+        "checksum": "fba751c4796536737c9acbb718dad7429be1fa485f5585d450ab8b25d12ae041"
+      }
+    ]
   }
-
   -----BEGIN PGP SIGNATURE-----
-  iQGzBAEBCgAdFiEETZn0sLle8jIrdAPLx/P+voVcifMFAmKAGvwACgkQx/P+voVc
-  ifNoVgv/VrhA+wurVs5GB9PhmMA1m5U/AfXZb4BElDRwpT8ZcTPIv5X8xtv60eyn
-  4EOneGVbZoMThVxgev/NKARorGmhFXRqhWf+jknJZ1dicpqn/qpv34rELKUpgXU+
-  QDQ4d1P64AIdTczXe2GI9ZvhOo6+bPvK7LIsTkBbtWmopkomVxF0LcMuxAVIbA6b
-  887yBvVO0VGlqRnkDW7nXx49r3AG2+wDcoU1f8ep8QtjOcMNaPTPJ0UnjD0VQGW6
-  4ZFaGZWzdo45MY6tF3o5mqM7zJkVobpoW3iUz6J5tjz7H/nMlGgMkUwY9Kxp2PVH
-  qoj6Zip3LWplnl2OZyAY+vflPFdFh12Xpk4FG7Sxm/ux0r+l8tCAPvtw+G38a5P7
-  QEk2JBr8qMGKASmnRlJUkm1vwz0a95IF3S9YDfTAA2vz6HH3PtsNLFhtorfx8eBi
-  Wn5aPJAGEPOawEOvXGGbsH4cDEKPeN0n6cy1k92uPEmBLDVsdnur8q42jk5c2Qyx
-  j3DXty57
-  =3gvm
+
+  iQGzBAEBCgAdFiEEdbwFKBFJCcB24mB0GAEP+tc8mwcFAmf2rr4ACgkQGAEP+tc8
+  mwfefwv+KJs8MsQ5ovFaBdmyx5H/3k4rO4QHBzuSPOB6UaxErA9IyOB31iP6vNTU
+  HzYpxz6F5dJCJWmmNEMN/0+vjhMHEOkqd7M1l5reVcxduTF2yc4tBZUO2gienEHL
+  W0e+SnUznl1yc/aVpChUiahO2zToCsI8HZRNT4tu6iCnE/OpghqjsSdBOZHmSNDD
+  5wuuCxfDUyWI6ZlLclaaB7RdbCUUJf/iqi711J+wubvnDFhc6Ynwm1xai5laJ1bD
+  ev3NrSb2AAroeNFVo4iECA0fZC1OZQYzaRmAEhBXtCideGJ5Zf2Cp9hmCwNK8Hq6
+  bNt94JP9LqC3FCCJJOMsPyOOhMSA5MU44zyyzloRwEQpHHLuFzVdbTHA3dmTc18n
+  HxNLkZoEMYRc8zNr40g0yb2lCbc+P11TtL1E+5NlE34MX15mPewRCiIFTMwhCnE3
+  gFSKtW1MKustZE35/RUwd2mpJRf+mSRVCl1f1RiFjktLjz7vWQq7imIUSam0fPDr
+  XD4aDogm
+  =RrFX
   -----END PGP SIGNATURE-----
 
 If a user has trusted the public key associated with the private key
-used to sign the above spec file, the signature can be verified with
+used to sign the above manifest file, the signature can be verified with
 gpg, as follows::
 
-  $ gpg –verify linux-ubuntu18.04-haswell-gcc-7.5.0-zlib-1.2.12-llv2ysfdxnppzjrt5ldybb5c52qbmoow.spec.json.sig
+  $ gpg --verify gcc-runtime-12.3.0-s2nqujezsce4x6uhtvxscu7jhewqzztx.spec.manifest.json
 
-The metadata (regardless whether signed or unsigned) contains the checksum
-of the ``.spack`` file containing the actual installation. The checksum should
-be compared to a checksum computed locally on the ``.spack`` file to ensure the
-contents have not changed since the binary spec plus metadata were signed. The
-``.spack`` files are actually tarballs containing the compressed archive of the
-install tree.  These files, along with the metadata files, live within the
-``build_cache`` directory of the mirror, and together are organized as follows::
-
-  build_cache/
-    # unsigned metadata (for indexing, contains sha256 of .spack file)
-    <arch>-<compiler>-<name>-<ver>-24zvipcqgg2wyjpvdq2ajy5jnm564hen.spec.json
-    # clearsigned metadata (same as above, but signed)
-    <arch>-<compiler>-<name>-<ver>-24zvipcqgg2wyjpvdq2ajy5jnm564hen.spec.json.sig
-    <arch>/
-      <compiler>/
-        <name>-<ver>/
-          # tar.gz-compressed prefix (may support more compression formats later)
-          <arch>-<compiler>-<name>-<ver>-24zvipcqgg2wyjpvdq2ajy5jnm564hen.spack
-
-Uncompressing and extracting the ``.spack`` file results in the install tree.
-This is in contrast to previous versions of spack, where the ``.spack`` file
-contained a (duplicated) metadata file, a signature file and a nested tarball
-containing the install tree.
+When attempting to install a binary package that has been signed, spack will
+attempt to verify the signature with one of the trusted keys in its keyring,
+and will fail if unable to do so.  While not recommended, it is possible to
+force installation of a signed package without verification by providing the
+``--no-check-signature`` argument to ``spack install ...``.
 
 .. _internal_implementation:
 
@@ -320,10 +300,10 @@ the following way:
    Reputational Public Key are imported into a keyring by the ``spack gpg …``
    sub-command. This is initiated by the job’s build script which is created by
    the generate job at the beginning of the pipeline.
-4. Assuming the package has dependencies those specs are verified using
+4. Assuming the package has dependencies those spec manifests are verified using
    the keyring.
-5. The package is built and the spec.json is generated
-6. The spec.json is signed by the keyring and uploaded to the mirror’s
+5. The package is built and the spec manifest is generated
+6. The spec manifest is signed by the keyring and uploaded to the mirror’s
    build cache.
 
 **Reputational Key**
@@ -376,24 +356,24 @@ following way:
 4.  In addition to the secret, the runner creates a tmpfs memory mounted
     directory where the GnuPG keyring will be created to verify, and
     then resign the package specs.
-5.  The job script syncs all spec.json.sig files from the build cache to
+5.  The job script syncs all spec manifest files from the build cache to
     a working directory in the job’s execution environment.
 6.  The job script then runs the ``sign.sh`` script built into the
     notary Docker image.
 7.  The ``sign.sh`` script imports the public components of the
     Reputational and Intermediate CI Keys and uses them to verify good
-    signatures on the spec.json.sig files. If any signed spec does not
-    verify the job immediately fails.
-8.  Assuming all specs are verified, the ``sign.sh`` script then unpacks
-    the spec json data from the signed file in preparation for being
+    signatures on the spec.manifest.json files. If any signed manifest
+    does not verify, the job immediately fails.
+8.  Assuming all manifests are verified, the ``sign.sh`` script then unpacks
+    the manifest json data from the signed file in preparation for being
     re-signed with the Reputational Key.
 9.  The private components of the Reputational Key are decrypted to
     standard out using ``aws-encryption-cli`` directly into a ``gpg
     –import …`` statement which imports the key into the
     keyring mounted in-memory.
-10. The private key is then used to sign each of the json specs and the
+10. The private key is then used to sign each of the manifests and the
     keyring is removed from disk.
-11. The re-signed json specs are resynced to the AWS S3 Mirror and the
+11. The re-signed manifests are resynced to the AWS S3 Mirror and the
     public signing of the packages for the develop or release pipeline
     that created them is complete.
 

lib/spack/external/_vendoring/altgraph/Dot.py

@@ -1,8 +1,8 @@
 """
-altgraph.Dot - Interface to the dot language
+_vendoring.altgraph.Dot - Interface to the dot language
 ============================================
 
-The :py:mod:`~altgraph.Dot` module provides a simple interface to the
+The :py:mod:`~_vendoring.altgraph.Dot` module provides a simple interface to the
 file format used in the
 `graphviz <http://www.research.att.com/sw/tools/graphviz/>`_
 program. The module is intended to offload the most tedious part of the process
@@ -20,7 +20,7 @@
 
 Here is a typical usage::
 
-    from altgraph import Graph, Dot
+    from _vendoring.altgraph import Graph, Dot
 
     # create a graph
     edges = [ (1,2), (1,3), (3,4), (3,5), (4,5), (5,4) ]
@@ -77,7 +77,7 @@
 
 .. note::
 
-   dotty (invoked via :py:func:`~altgraph.Dot.display`) may not be able to
+   dotty (invoked via :py:func:`~_vendoring.altgraph.Dot.display`) may not be able to
    display all graphics styles. To verify the output save it to an image file
    and look at it that way.
 
@@ -111,7 +111,7 @@
 import os
 import warnings
 
-from altgraph import GraphError
+from _vendoring.altgraph import GraphError
 
 
 class Dot(object):

lib/spack/external/_vendoring/altgraph/Graph.py

@@ -1,5 +1,5 @@
 """
-altgraph.Graph - Base Graph class
+_vendoring.altgraph.Graph - Base Graph class
 =================================
 
 ..
@@ -15,7 +15,7 @@
 
 from collections import deque
 
-from altgraph import GraphError
+from _vendoring.altgraph import GraphError
 
 
 class Graph(object):

lib/spack/external/_vendoring/altgraph/GraphAlgo.py

@@ -1,8 +1,8 @@
 """
-altgraph.GraphAlgo - Graph algorithms
+_vendoring.altgraph.GraphAlgo - Graph algorithms
 =====================================
 """
-from altgraph import GraphError
+from _vendoring.altgraph import GraphError
 
 
 def dijkstra(graph, start, end=None):
@@ -25,7 +25,7 @@ def dijkstra(graph, start, end=None):
     and will raise an exception if it discovers that a negative edge has
     caused it to make a mistake.
 
-    Adapted to altgraph by Istvan Albert, Pennsylvania State University -
+    Adapted to _vendoring.altgraph by Istvan Albert, Pennsylvania State University -
     June, 9 2004
     """
     D = {}  # dictionary of final distances

lib/spack/external/_vendoring/altgraph/GraphStat.py

@@ -1,5 +1,5 @@
 """
-altgraph.GraphStat - Functions providing various graph statistics
+_vendoring.altgraph.GraphStat - Functions providing various graph statistics
 =================================================================
 """
 

lib/spack/external/_vendoring/altgraph/GraphUtil.py

@@ -1,17 +1,17 @@
 """
-altgraph.GraphUtil - Utility classes and functions
+_vendoring.altgraph.GraphUtil - Utility classes and functions
 ==================================================
 """
 
 import random
 from collections import deque
 
-from altgraph import Graph, GraphError
+from _vendoring.altgraph import Graph, GraphError
 
 
 def generate_random_graph(node_num, edge_num, self_loops=False, multi_edges=False):
     """
-    Generates and returns a :py:class:`~altgraph.Graph.Graph` instance with
+    Generates and returns a :py:class:`~_vendoring.altgraph.Graph.Graph` instance with
     *node_num* nodes randomly connected by *edge_num* edges.
     """
     g = Graph.Graph()
@@ -52,7 +52,7 @@ def generate_random_graph(node_num, edge_num, self_loops=False, multi_edges=Fals
 
 def generate_scale_free_graph(steps, growth_num, self_loops=False, multi_edges=False):
     """
-    Generates and returns a :py:class:`~altgraph.Graph.Graph` instance that
+    Generates and returns a :py:class:`~_vendoring.altgraph.Graph.Graph` instance that
     will have *steps* \\* *growth_num* nodes and a scale free (powerlaw)
     connectivity. Starting with a fully connected graph with *growth_num*
     nodes at every step *growth_num* nodes are added to the graph and are

lib/spack/external/_vendoring/altgraph/ObjectGraph.py

@@ -1,14 +1,14 @@
 """
-altgraph.ObjectGraph - Graph of objects with an identifier
+_vendoring.altgraph.ObjectGraph - Graph of objects with an identifier
 ==========================================================
 
 A graph of objects that have a "graphident" attribute.
 graphident is the key for the object in the graph
 """
 
-from altgraph import GraphError
-from altgraph.Graph import Graph
-from altgraph.GraphUtil import filter_stack
+from _vendoring.altgraph import GraphError
+from _vendoring.altgraph.Graph import Graph
+from _vendoring.altgraph.GraphUtil import filter_stack
 
 
 class ObjectGraph(object):

lib/spack/external/_vendoring/altgraph/__init__.py

@@ -1,18 +1,18 @@
 """
-altgraph - a python graph library
+_vendoring.altgraph - a python graph library
 =================================
 
-altgraph is a fork of `graphlib <http://pygraphlib.sourceforge.net>`_ tailored
+_vendoring.altgraph is a fork of `graphlib <http://pygraphlib.sourceforge.net>`_ tailored
 to use newer Python 2.3+ features, including additional support used by the
-py2app suite (modulegraph and macholib, specifically).
+py2app suite (modulegraph and _vendoring.macholib, specifically).
 
-altgraph is a python based graph (network) representation and manipulation
+_vendoring.altgraph is a python based graph (network) representation and manipulation
 package.  It has started out as an extension to the
 `graph_lib module
 <http://www.ece.arizona.edu/~denny/python_nest/graph_lib_1.0.1.html>`_
 written by Nathan Denny it has been significantly optimized and expanded.
 
-The :class:`altgraph.Graph.Graph` class is loosely modeled after the
+The :class:`_vendoring.altgraph.Graph.Graph` class is loosely modeled after the
 `LEDA <http://www.algorithmic-solutions.com/enleda.htm>`_
 (Library of Efficient Datatypes) representation. The library
 includes methods for constructing graphs, BFS and DFS traversals,
@@ -22,22 +22,22 @@
 
 The package contains the following modules:
 
-    -  the :py:mod:`altgraph.Graph` module contains the
-       :class:`~altgraph.Graph.Graph` class that stores the graph data
+    -  the :py:mod:`_vendoring.altgraph.Graph` module contains the
+       :class:`~_vendoring.altgraph.Graph.Graph` class that stores the graph data
 
-    -  the :py:mod:`altgraph.GraphAlgo` module implements graph algorithms
-       operating on graphs (:py:class:`~altgraph.Graph.Graph`} instances)
+    -  the :py:mod:`_vendoring.altgraph.GraphAlgo` module implements graph algorithms
+       operating on graphs (:py:class:`~_vendoring.altgraph.Graph.Graph`} instances)
 
-    -  the :py:mod:`altgraph.GraphStat` module contains functions for
+    -  the :py:mod:`_vendoring.altgraph.GraphStat` module contains functions for
        computing statistical measures on graphs
 
-    -  the :py:mod:`altgraph.GraphUtil` module contains functions for
+    -  the :py:mod:`_vendoring.altgraph.GraphUtil` module contains functions for
        generating, reading and saving graphs
 
-    -  the :py:mod:`altgraph.Dot` module  contains functions for displaying
+    -  the :py:mod:`_vendoring.altgraph.Dot` module  contains functions for displaying
        graphs via `graphviz <http://www.research.att.com/sw/tools/graphviz/>`_
 
-    -  the :py:mod:`altgraph.ObjectGraph` module implements a graph of
+    -  the :py:mod:`_vendoring.altgraph.ObjectGraph` module implements a graph of
        objects with a unique identifier
 
 Installation
@@ -62,7 +62,7 @@
 Lets assume that we want to analyze the graph below (links to the full picture)
 GRAPH_IMG.  Our script then might look the following way::
 
-    from altgraph import Graph, GraphAlgo, Dot
+    from _vendoring.altgraph import Graph, GraphAlgo, Dot
 
     # these are the edges
     edges = [ (1,2), (2,4), (1,3), (2,4), (3,4), (4,5), (6,5),
@@ -141,7 +141,7 @@
 """
 import pkg_resources
 
-__version__ = pkg_resources.require("altgraph")[0].version
+__version__ = pkg_resources.require("_vendoring.altgraph")[0].version
 
 
 class GraphError(ValueError):

lib/spack/external/_vendoring/attr/_make.py

@@ -38,7 +38,7 @@
     "typing.ClassVar",
     "t.ClassVar",
     "ClassVar",
-    "typing_extensions.ClassVar",
+    "_vendoring.typing_extensions.ClassVar",
 )
 # we don't use a double-underscore prefix because that triggers
 # name mangling when trying to create a slot for the field

lib/spack/external/_vendoring/attrs/__init__.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 
-from attr import (
+from _vendoring.attr import (
     NOTHING,
     Attribute,
     Factory,
@@ -28,7 +28,7 @@
     resolve_types,
     validate,
 )
-from attr._next_gen import asdict, astuple
+from _vendoring.attr._next_gen import asdict, astuple
 
 from . import converters, exceptions, filters, setters, validators
 

lib/spack/external/_vendoring/attrs/converters.py

@@ -1,3 +1,3 @@
 # SPDX-License-Identifier: MIT
 
-from attr.converters import *  # noqa
+from _vendoring.attr.converters import *  # noqa

lib/spack/external/_vendoring/attrs/exceptions.py

@@ -1,3 +1,3 @@
 # SPDX-License-Identifier: MIT
 
-from attr.exceptions import *  # noqa
+from _vendoring.attr.exceptions import *  # noqa

lib/spack/external/_vendoring/attrs/filters.py

@@ -1,3 +1,3 @@
 # SPDX-License-Identifier: MIT
 
-from attr.filters import *  # noqa
+from _vendoring.attr.filters import *  # noqa

lib/spack/external/_vendoring/attrs/setters.py

@@ -1,3 +1,3 @@
 # SPDX-License-Identifier: MIT
 
-from attr.setters import *  # noqa
+from _vendoring.attr.setters import *  # noqa

lib/spack/external/_vendoring/attrs/validators.py

@@ -1,3 +1,3 @@
 # SPDX-License-Identifier: MIT
 
-from attr.validators import *  # noqa
+from _vendoring.attr.validators import *  # noqa

lib/spack/external/_vendoring/jinja2/bccache.py

@@ -19,7 +19,7 @@
 from types import CodeType
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
     from .environment import Environment
 
     class _MemcachedClient(te.Protocol):
@@ -101,7 +101,7 @@ def bytecode_to_string(self) -> bytes:
 class BytecodeCache:
     """To implement your own bytecode cache you have to subclass this class
     and override :meth:`load_bytecode` and :meth:`dump_bytecode`.  Both of
-    these methods are passed a :class:`~jinja2.bccache.Bucket`.
+    these methods are passed a :class:`~_vendoring.jinja2.bccache.Bucket`.
 
     A very basic bytecode cache that saves the bytecode on the file system::
 
@@ -193,7 +193,7 @@ class FileSystemBytecodeCache(BytecodeCache):
     is created for the user in the system temp directory.
 
     The pattern can be used to have multiple separate caches operate on the
-    same directory.  The default pattern is ``'__jinja2_%s.cache'``.  ``%s``
+    same directory.  The default pattern is ``'___vendoring.jinja2_%s.cache'``.  ``%s``
     is replaced with the cache key.
 
     >>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
@@ -202,7 +202,7 @@ class FileSystemBytecodeCache(BytecodeCache):
     """
 
     def __init__(
-        self, directory: t.Optional[str] = None, pattern: str = "__jinja2_%s.cache"
+        self, directory: t.Optional[str] = None, pattern: str = "___vendoring.jinja2_%s.cache"
     ) -> None:
         if directory is None:
             directory = self._get_default_cache_dir()
@@ -225,7 +225,7 @@ def _unsafe_dir() -> "te.NoReturn":
         if not hasattr(os, "getuid"):
             _unsafe_dir()
 
-        dirname = f"_jinja2-cache-{os.getuid()}"
+        dirname = f"__vendoring.jinja2-cache-{os.getuid()}"
         actual_dir = os.path.join(tmpdir, dirname)
 
         try:
@@ -332,7 +332,7 @@ class MemcachedBytecodeCache(BytecodeCache):
     def __init__(
         self,
         client: "_MemcachedClient",
-        prefix: str = "jinja2/bytecode/",
+        prefix: str = "_vendoring.jinja2/bytecode/",
         timeout: t.Optional[int] = None,
         ignore_memcache_errors: bool = True,
     ):

lib/spack/external/_vendoring/jinja2/compiler.py

@@ -6,8 +6,8 @@
 from itertools import chain
 from keyword import iskeyword as is_python_keyword
 
-from markupsafe import escape
-from markupsafe import Markup
+from _vendoring.markupsafe import escape
+from _vendoring.markupsafe import Markup
 
 from . import nodes
 from .exceptions import TemplateAssertionError
@@ -23,7 +23,7 @@
 from .visitor import NodeVisitor
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
     from .environment import Environment
 
 F = t.TypeVar("F", bound=t.Callable[..., t.Any])
@@ -836,7 +836,7 @@ def visit_Template(
             exported_names = sorted(exported)
 
         self.writeline("from __future__ import generator_stop")  # Python < 3.7
-        self.writeline("from jinja2.runtime import " + ", ".join(exported_names))
+        self.writeline("from _vendoring.jinja2.runtime import " + ", ".join(exported_names))
 
         # if we want a deferred initialization we cannot move the
         # environment into a local name

lib/spack/external/_vendoring/jinja2/defaults.py

@@ -8,7 +8,7 @@
 from .utils import Namespace
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
 
 # defaults for the parser / lexer
 BLOCK_START_STRING = "{%"

lib/spack/external/_vendoring/jinja2/environment.py

@@ -12,7 +12,7 @@
 from functools import reduce
 from types import CodeType
 
-from markupsafe import Markup
+from _vendoring.markupsafe import Markup
 
 from . import nodes
 from .compiler import CodeGenerator
@@ -55,7 +55,7 @@
 from .utils import missing
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
     from .bccache import BytecodeCache
     from .ext import Extension
     from .loaders import BaseLoader
@@ -126,7 +126,7 @@ def _environment_config_check(environment: "Environment") -> "Environment":
     """Perform a sanity check on the environment."""
     assert issubclass(
         environment.undefined, Undefined
-    ), "'undefined' must be a subclass of 'jinja2.Undefined'."
+    ), "'undefined' must be a subclass of '_vendoring.jinja2.Undefined'."
     assert (
         environment.block_start_string
         != environment.variable_start_string
@@ -221,7 +221,7 @@ class Environment:
         `autoescape`
             If set to ``True`` the XML/HTML autoescaping feature is enabled by
             default.  For more details about autoescaping see
-            :class:`~markupsafe.Markup`.  As of Jinja 2.4 this can also
+            :class:`~_vendoring.markupsafe.Markup`.  As of Jinja 2.4 this can also
             be a callable that is passed the template name and has to
             return ``True`` or ``False`` depending on autoescape should be
             enabled by default.
@@ -264,7 +264,7 @@ class Environment:
 
     #: if this environment is sandboxed.  Modifying this variable won't make
     #: the environment sandboxed though.  For a real sandboxed environment
-    #: have a look at jinja2.sandbox.  This flag alone controls the code
+    #: have a look at _vendoring.jinja2.sandbox.  This flag alone controls the code
     #: generation by the compiler.
     sandboxed = False
 
@@ -279,11 +279,11 @@ class Environment:
     shared = False
 
     #: the class that is used for code generation.  See
-    #: :class:`~jinja2.compiler.CodeGenerator` for more information.
+    #: :class:`~_vendoring.jinja2.compiler.CodeGenerator` for more information.
     code_generator_class: t.Type["CodeGenerator"] = CodeGenerator
 
     #: the context class that is used for templates.  See
-    #: :class:`~jinja2.runtime.Context` for more information.
+    #: :class:`~_vendoring.jinja2.runtime.Context` for more information.
     context_class: t.Type[Context] = Context
 
     template_class: t.Type["Template"]
@@ -650,7 +650,7 @@ def _tokenize(
         state: t.Optional[str] = None,
     ) -> TokenStream:
         """Called by the parser to do the preprocessing and filtering
-        for all the extensions.  Returns a :class:`~jinja2.lexer.TokenStream`.
+        for all the extensions.  Returns a :class:`~_vendoring.jinja2.lexer.TokenStream`.
         """
         source = self.preprocess(source, name, filename)
         stream = self.lexer.tokenize(source, name, filename, state)
@@ -1547,7 +1547,7 @@ def __repr__(self) -> str:
 
 
 class TemplateExpression:
-    """The :meth:`jinja2.Environment.compile_expression` method returns an
+    """The :meth:`_vendoring.jinja2.Environment.compile_expression` method returns an
     instance of this object.  It encapsulates the expression-like access
     to the template with an expression it wraps.
     """

lib/spack/external/_vendoring/jinja2/ext.py

@@ -4,7 +4,7 @@
 import typing as t
 import warnings
 
-from markupsafe import Markup
+from _vendoring.markupsafe import Markup
 
 from . import defaults
 from . import nodes
@@ -18,7 +18,7 @@
 from .utils import pass_context
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
     from .lexer import Token
     from .lexer import TokenStream
     from .parser import Parser
@@ -108,10 +108,10 @@ def preprocess(
     def filter_stream(
         self, stream: "TokenStream"
     ) -> t.Union["TokenStream", t.Iterable["Token"]]:
-        """It's passed a :class:`~jinja2.lexer.TokenStream` that can be used
+        """It's passed a :class:`~_vendoring.jinja2.lexer.TokenStream` that can be used
         to filter tokens returned.  This method has to return an iterable of
-        :class:`~jinja2.lexer.Token`\\s, but it doesn't have to return a
-        :class:`~jinja2.lexer.TokenStream`.
+        :class:`~_vendoring.jinja2.lexer.Token`\\s, but it doesn't have to return a
+        :class:`~_vendoring.jinja2.lexer.TokenStream`.
         """
         return stream
 
@@ -145,7 +145,7 @@ def call_method(
         lineno: t.Optional[int] = None,
     ) -> nodes.Call:
         """Call a method of the extension.  This is a shortcut for
-        :meth:`attr` + :class:`jinja2.nodes.Call`.
+        :meth:`attr` + :class:`_vendoring.jinja2.nodes.Call`.
         """
         if args is None:
             args = []
@@ -629,9 +629,9 @@ class DebugExtension(Extension):
 
     .. code-block:: text
 
-        {'context': {'cycler': <class 'jinja2.utils.Cycler'>,
+        {'context': {'cycler': <class '_vendoring.jinja2.utils.Cycler'>,
                      ...,
-                     'namespace': <class 'jinja2.utils.Namespace'>},
+                     'namespace': <class '_vendoring.jinja2.utils.Namespace'>},
          'filters': ['abs', 'attr', 'batch', 'capitalize', 'center', 'count', 'd',
                      ..., 'urlencode', 'urlize', 'wordcount', 'wordwrap', 'xmlattr'],
          'tests': ['!=', '<', '<=', '==', '>', '>=', 'callable', 'defined',
@@ -679,7 +679,7 @@ def extract_from_ast(
 
     This example explains the behavior:
 
-    >>> from jinja2 import Environment
+    >>> from _vendoring.jinja2 import Environment
     >>> env = Environment()
     >>> node = env.parse('{{ (_("foo"), _(), ngettext("foo", "bar", 42)) }}')
     >>> list(extract_from_ast(node))

lib/spack/external/_vendoring/jinja2/filters.py

@@ -9,9 +9,9 @@
 from itertools import chain
 from itertools import groupby
 
-from markupsafe import escape
-from markupsafe import Markup
-from markupsafe import soft_str
+from _vendoring.markupsafe import escape
+from _vendoring.markupsafe import Markup
+from _vendoring.markupsafe import soft_str
 
 from .async_utils import async_variant
 from .async_utils import auto_aiter
@@ -28,7 +28,7 @@
 from .utils import urlize
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
     from .environment import Environment
     from .nodes import EvalContext
     from .runtime import Context
@@ -48,7 +48,7 @@ def contextfilter(f: F) -> F:
     """Pass the context as the first argument to the decorated function.
 
     .. deprecated:: 3.0
-        Will be removed in Jinja 3.1. Use :func:`~jinja2.pass_context`
+        Will be removed in Jinja 3.1. Use :func:`~_vendoring.jinja2.pass_context`
         instead.
     """
     warnings.warn(
@@ -66,7 +66,7 @@ def evalcontextfilter(f: F) -> F:
 
     .. deprecated:: 3.0
         Will be removed in Jinja 3.1. Use
-        :func:`~jinja2.pass_eval_context` instead.
+        :func:`~_vendoring.jinja2.pass_eval_context` instead.
 
     .. versionadded:: 2.4
     """
@@ -85,7 +85,7 @@ def environmentfilter(f: F) -> F:
 
     .. deprecated:: 3.0
         Will be removed in Jinja 3.1. Use
-        :func:`~jinja2.pass_environment` instead.
+        :func:`~_vendoring.jinja2.pass_environment` instead.
     """
     warnings.warn(
         "'environmentfilter' is renamed to 'pass_environment', the old"
@@ -547,10 +547,10 @@ def do_default(
         {{ ''|default('the string was empty', true) }}
 
     .. versionchanged:: 2.11
-       It's now possible to configure the :class:`~jinja2.Environment` with
-       :class:`~jinja2.ChainableUndefined` to make the `default` filter work
+       It's now possible to configure the :class:`~_vendoring.jinja2.Environment` with
+       :class:`~_vendoring.jinja2.ChainableUndefined` to make the `default` filter work
        on nested elements and attributes that may contain undefined values
-       in the chain without getting an :exc:`~jinja2.UndefinedError`.
+       in the chain without getting an :exc:`~_vendoring.jinja2.UndefinedError`.
     """
     if isinstance(value, Undefined) or (boolean and not value):
         return default_value

lib/spack/external/_vendoring/jinja2/lexer.py

@@ -14,7 +14,7 @@
 from .utils import LRUCache
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
     from .environment import Environment
 
 # cache for the lexers. Exists in order to be able to have multiple
@@ -400,7 +400,7 @@ def close(self) -> None:
 
     def expect(self, expr: str) -> Token:
         """Expect a given token type and return it.  This accepts the same
-        argument as :meth:`jinja2.lexer.Token.test`.
+        argument as :meth:`_vendoring.jinja2.lexer.Token.test`.
         """
         if not self.current.test(expr):
             expr = describe_token_expr(expr)

lib/spack/external/_vendoring/jinja2/loaders.py

@@ -47,7 +47,7 @@ class BaseLoader:
     A very basic example for a loader that looks up templates on the file
     system could look like this::
 
-        from jinja2 import BaseLoader, TemplateNotFound
+        from _vendoring.jinja2 import BaseLoader, TemplateNotFound
         from os.path import join, exists, getmtime
 
         class MyLoader(BaseLoader):
@@ -594,7 +594,7 @@ class ModuleLoader(BaseLoader):
     def __init__(
         self, path: t.Union[str, os.PathLike, t.Sequence[t.Union[str, os.PathLike]]]
     ) -> None:
-        package_name = f"_jinja2_module_templates_{id(self):x}"
+        package_name = f"__vendoring.jinja2_module_templates_{id(self):x}"
 
         # create a fake module that looks for the templates in the
         # path given.

lib/spack/external/_vendoring/jinja2/meta.py

@@ -36,7 +36,7 @@ def find_undeclared_variables(ast: nodes.Template) -> t.Set[str]:
     variables will be used depending on the path the execution takes at
     runtime, all variables are returned.
 
-    >>> from jinja2 import Environment, meta
+    >>> from _vendoring.jinja2 import Environment, meta
     >>> env = Environment()
     >>> ast = env.parse('{% set foo = 42 %}{{ bar + foo }}')
     >>> meta.find_undeclared_variables(ast) == {'bar'}
@@ -64,7 +64,7 @@ def find_referenced_templates(ast: nodes.Template) -> t.Iterator[t.Optional[str]
     imports.  If dynamic inheritance or inclusion is used, `None` will be
     yielded.
 
-    >>> from jinja2 import Environment, meta
+    >>> from _vendoring.jinja2 import Environment, meta
     >>> env = Environment()
     >>> ast = env.parse('{% extends "layout.html" %}{% include helper %}')
     >>> list(meta.find_referenced_templates(ast))

lib/spack/external/_vendoring/jinja2/nodes.py

@@ -7,12 +7,12 @@
 import typing as t
 from collections import deque
 
-from markupsafe import Markup
+from _vendoring.markupsafe import Markup
 
 from .utils import _PassArg
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
     from .environment import Environment
 
 _NodeBound = t.TypeVar("_NodeBound", bound="Node")
@@ -1041,7 +1041,7 @@ class ExtensionAttribute(Expr):
     The identifier is the identifier of the :class:`Extension`.
 
     This node is usually constructed by calling the
-    :meth:`~jinja2.ext.Extension.attr` method on an extension.
+    :meth:`~_vendoring.jinja2.ext.Extension.attr` method on an extension.
     """
 
     fields = ("identifier", "name")
@@ -1063,7 +1063,7 @@ class ImportedName(Expr):
 class InternalName(Expr):
     """An internal name in the compiler.  You cannot create these nodes
     yourself but the parser provides a
-    :meth:`~jinja2.parser.Parser.free_identifier` method that creates
+    :meth:`~_vendoring.jinja2.parser.Parser.free_identifier` method that creates
     a new identifier for you.  This identifier is not available from the
     template and is not treated specially by the compiler.
     """
@@ -1114,7 +1114,7 @@ def as_const(
 class ContextReference(Expr):
     """Returns the current template context.  It can be used like a
     :class:`Name` node, with a ``'load'`` ctx and will return the
-    current :class:`~jinja2.runtime.Context` object.
+    current :class:`~_vendoring.jinja2.runtime.Context` object.
 
     Here an example that assigns the current template name to a
     variable named `foo`::
@@ -1123,7 +1123,7 @@ class ContextReference(Expr):
                Getattr(ContextReference(), 'name'))
 
     This is basically equivalent to using the
-    :func:`~jinja2.pass_context` decorator when using the high-level
+    :func:`~_vendoring.jinja2.pass_context` decorator when using the high-level
     API, which causes a reference to the context to be passed as the
     first argument to a function.
     """
@@ -1188,7 +1188,7 @@ class EvalContextModifier(Stmt):
 class ScopedEvalContextModifier(EvalContextModifier):
     """Modifies the eval context and reverts it later.  Works exactly like
     :class:`EvalContextModifier` but will only modify the
-    :class:`~jinja2.nodes.EvalContext` for nodes in the :attr:`body`.
+    :class:`~_vendoring.jinja2.nodes.EvalContext` for nodes in the :attr:`body`.
     """
 
     fields = ("body",)

lib/spack/external/_vendoring/jinja2/parser.py

@@ -9,7 +9,7 @@
 from .lexer import describe_token_expr
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
     from .environment import Environment
 
 _ImportInclude = t.TypeVar("_ImportInclude", nodes.Import, nodes.Include)
@@ -156,7 +156,7 @@ def is_tuple_end(
         return False
 
     def free_identifier(self, lineno: t.Optional[int] = None) -> nodes.InternalName:
-        """Return a new free identifier as :class:`~jinja2.nodes.InternalName`."""
+        """Return a new free identifier as :class:`~_vendoring.jinja2.nodes.InternalName`."""
         self._last_identifier += 1
         rv = object.__new__(nodes.InternalName)
         nodes.Node.__init__(rv, f"fi{self._last_identifier}", lineno=lineno)
@@ -687,7 +687,7 @@ def parse_tuple(
         explicit_parentheses: bool = False,
     ) -> t.Union[nodes.Tuple, nodes.Expr]:
         """Works like `parse_expression` but if multiple expressions are
-        delimited by a comma a :class:`~jinja2.nodes.Tuple` node is created.
+        delimited by a comma a :class:`~_vendoring.jinja2.nodes.Tuple` node is created.
         This method could also return a regular expression instead of a tuple
         if no commas where found.
 

lib/spack/external/_vendoring/jinja2/runtime.py

@@ -5,9 +5,9 @@
 from collections import abc
 from itertools import chain
 
-from markupsafe import escape  # noqa: F401
-from markupsafe import Markup
-from markupsafe import soft_str
+from _vendoring.markupsafe import escape  # noqa: F401
+from _vendoring.markupsafe import Markup
+from _vendoring.markupsafe import soft_str
 
 from .async_utils import auto_aiter
 from .async_utils import auto_await  # noqa: F401
@@ -28,7 +28,7 @@
 
 if t.TYPE_CHECKING:
     import logging
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
     from .environment import Environment
 
     class LoopRenderFunc(te.Protocol):
@@ -849,7 +849,7 @@ class Undefined:
     >>> foo + 42
     Traceback (most recent call last):
       ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    _vendoring.jinja2.exceptions.UndefinedError: 'foo' is undefined
     """
 
     __slots__ = (
@@ -1020,7 +1020,7 @@ class ChainableUndefined(Undefined):
     >>> foo.bar['baz'] + 42
     Traceback (most recent call last):
       ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    _vendoring.jinja2.exceptions.UndefinedError: 'foo' is undefined
 
     .. versionadded:: 2.11.0
     """
@@ -1047,7 +1047,7 @@ class DebugUndefined(Undefined):
     >>> foo + 42
     Traceback (most recent call last):
       ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    _vendoring.jinja2.exceptions.UndefinedError: 'foo' is undefined
     """
 
     __slots__ = ()
@@ -1077,15 +1077,15 @@ class StrictUndefined(Undefined):
     >>> str(foo)
     Traceback (most recent call last):
       ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    _vendoring.jinja2.exceptions.UndefinedError: 'foo' is undefined
     >>> not foo
     Traceback (most recent call last):
       ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    _vendoring.jinja2.exceptions.UndefinedError: 'foo' is undefined
     >>> foo + 42
     Traceback (most recent call last):
       ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    _vendoring.jinja2.exceptions.UndefinedError: 'foo' is undefined
     """
 
     __slots__ = ()

lib/spack/external/_vendoring/jinja2/sandbox.py

@@ -9,8 +9,8 @@
 from collections import deque
 from string import Formatter
 
-from markupsafe import EscapeFormatter
-from markupsafe import Markup
+from _vendoring.markupsafe import EscapeFormatter
+from _vendoring.markupsafe import Markup
 
 from .environment import Environment
 from .exceptions import SecurityError
@@ -128,7 +128,7 @@ def is_internal_attribute(obj: t.Any, attr: str) -> bool:
     python objects.  This is useful if the environment method
     :meth:`~SandboxedEnvironment.is_safe_attribute` is overridden.
 
-    >>> from jinja2.sandbox import is_internal_attribute
+    >>> from _vendoring.jinja2.sandbox import is_internal_attribute
     >>> is_internal_attribute(str, "mro")
     True
     >>> is_internal_attribute(str, "upper")

lib/spack/external/_vendoring/jinja2/utils.py

@@ -12,10 +12,10 @@
 from types import CodeType
 from urllib.parse import quote_from_bytes
 
-import markupsafe
+import _vendoring.markupsafe
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
 
 F = t.TypeVar("F", bound=t.Callable[..., t.Any])
 
@@ -28,7 +28,7 @@
 
 
 def pass_context(f: F) -> F:
-    """Pass the :class:`~jinja2.runtime.Context` as the first argument
+    """Pass the :class:`~_vendoring.jinja2.runtime.Context` as the first argument
     to the decorated function when called while rendering a template.
 
     Can be used on functions, filters, and tests.
@@ -45,7 +45,7 @@ def pass_context(f: F) -> F:
 
 
 def pass_eval_context(f: F) -> F:
-    """Pass the :class:`~jinja2.nodes.EvalContext` as the first argument
+    """Pass the :class:`~_vendoring.jinja2.nodes.EvalContext` as the first argument
     to the decorated function when called while rendering a template.
     See :ref:`eval-context`.
 
@@ -62,7 +62,7 @@ def pass_eval_context(f: F) -> F:
 
 
 def pass_environment(f: F) -> F:
-    """Pass the :class:`~jinja2.Environment` as the first argument to
+    """Pass the :class:`~_vendoring.jinja2.Environment` as the first argument to
     the decorated function when called while rendering a template.
 
     Can be used on functions, filters, and tests.
@@ -104,7 +104,7 @@ def contextfunction(f: F) -> F:
     """Pass the context as the first argument to the decorated function.
 
     .. deprecated:: 3.0
-        Will be removed in Jinja 3.1. Use :func:`~jinja2.pass_context`
+        Will be removed in Jinja 3.1. Use :func:`~_vendoring.jinja2.pass_context`
         instead.
     """
     warnings.warn(
@@ -122,7 +122,7 @@ def evalcontextfunction(f: F) -> F:
 
     .. deprecated:: 3.0
         Will be removed in Jinja 3.1. Use
-        :func:`~jinja2.pass_eval_context` instead.
+        :func:`~_vendoring.jinja2.pass_eval_context` instead.
 
     .. versionadded:: 2.4
     """
@@ -141,7 +141,7 @@ def environmentfunction(f: F) -> F:
 
     .. deprecated:: 3.0
         Will be removed in Jinja 3.1. Use
-        :func:`~jinja2.pass_environment` instead.
+        :func:`~_vendoring.jinja2.pass_environment` instead.
     """
     warnings.warn(
         "'environmentfunction' is renamed to 'pass_environment', the"
@@ -335,9 +335,9 @@ def trim_url(x: str) -> str:
         def trim_url(x: str) -> str:
             return x
 
-    words = re.split(r"(\s+)", str(markupsafe.escape(text)))
-    rel_attr = f' rel="{markupsafe.escape(rel)}"' if rel else ""
-    target_attr = f' target="{markupsafe.escape(target)}"' if target else ""
+    words = re.split(r"(\s+)", str(_vendoring.markupsafe.escape(text)))
+    rel_attr = f' rel="{_vendoring.markupsafe.escape(rel)}"' if rel else ""
+    target_attr = f' target="{_vendoring.markupsafe.escape(target)}"' if target else ""
 
     for i, word in enumerate(words):
         head, middle, tail = "", word, ""
@@ -455,8 +455,8 @@ def generate_lorem_ipsum(
 
     if not html:
         return "\n\n".join(result)
-    return markupsafe.Markup(
-        "\n".join(f"<p>{markupsafe.escape(x)}</p>" for x in result)
+    return _vendoring.markupsafe.Markup(
+        "\n".join(f"<p>{_vendoring.markupsafe.escape(x)}</p>" for x in result)
     )
 
 
@@ -658,7 +658,7 @@ def select_autoescape(
     If you want to enable it for all templates created from strings or
     for all templates with `.html` and `.xml` extensions::
 
-        from jinja2 import Environment, select_autoescape
+        from _vendoring.jinja2 import Environment, select_autoescape
         env = Environment(autoescape=select_autoescape(
             enabled_extensions=('html', 'xml'),
             default_for_string=True,
@@ -667,7 +667,7 @@ def select_autoescape(
     Example configuration to turn it on at all times except if the template
     ends with `.txt`::
 
-        from jinja2 import Environment, select_autoescape
+        from _vendoring.jinja2 import Environment, select_autoescape
         env = Environment(autoescape=select_autoescape(
             disabled_extensions=('txt',),
             default_for_string=True,
@@ -703,10 +703,10 @@ def autoescape(template_name: t.Optional[str]) -> bool:
 
 def htmlsafe_json_dumps(
     obj: t.Any, dumps: t.Optional[t.Callable[..., str]] = None, **kwargs: t.Any
-) -> markupsafe.Markup:
+) -> _vendoring.markupsafe.Markup:
     """Serialize an object to a string of JSON with :func:`json.dumps`,
     then replace HTML-unsafe characters with Unicode escapes and mark
-    the result safe with :class:`~markupsafe.Markup`.
+    the result safe with :class:`~_vendoring.markupsafe.Markup`.
 
     This is available in templates as the ``|tojson`` filter.
 
@@ -732,7 +732,7 @@ def htmlsafe_json_dumps(
     if dumps is None:
         dumps = json.dumps
 
-    return markupsafe.Markup(
+    return _vendoring.markupsafe.Markup(
         dumps(obj, **kwargs)
         .replace("<", "\\u003c")
         .replace(">", "\\u003e")
@@ -833,11 +833,11 @@ def __repr__(self) -> str:
         return f"<Namespace {self.__attrs!r}>"
 
 
-class Markup(markupsafe.Markup):
+class Markup(_vendoring.markupsafe.Markup):
     def __new__(cls, base="", encoding=None, errors="strict"):  # type: ignore
         warnings.warn(
-            "'jinja2.Markup' is deprecated and will be removed in Jinja"
-            " 3.1. Import 'markupsafe.Markup' instead.",
+            "'_vendoring.jinja2.Markup' is deprecated and will be removed in Jinja"
+            " 3.1. Import '_vendoring.markupsafe.Markup' instead.",
             DeprecationWarning,
             stacklevel=2,
         )
@@ -846,9 +846,9 @@ def __new__(cls, base="", encoding=None, errors="strict"):  # type: ignore
 
 def escape(s: t.Any) -> str:
     warnings.warn(
-        "'jinja2.escape' is deprecated and will be removed in Jinja"
-        " 3.1. Import 'markupsafe.escape' instead.",
+        "'_vendoring.jinja2.escape' is deprecated and will be removed in Jinja"
+        " 3.1. Import '_vendoring.markupsafe.escape' instead.",
         DeprecationWarning,
         stacklevel=2,
     )
-    return markupsafe.escape(s)
+    return _vendoring.markupsafe.escape(s)

lib/spack/external/_vendoring/jinja2/visitor.py

@@ -6,7 +6,7 @@
 from .nodes import Node
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
 
     class VisitCallable(te.Protocol):
         def __call__(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.Any:

lib/spack/external/_vendoring/jsonschema/__init__.py

@@ -8,18 +8,18 @@
 instance under a schema, and will create a validator for you.
 """
 
-from jsonschema.exceptions import (
+from _vendoring.jsonschema.exceptions import (
     ErrorTree, FormatError, RefResolutionError, SchemaError, ValidationError
 )
-from jsonschema._format import (
+from _vendoring.jsonschema._format import (
     FormatChecker,
     draft3_format_checker,
     draft4_format_checker,
     draft6_format_checker,
     draft7_format_checker,
 )
-from jsonschema._types import TypeChecker
-from jsonschema.validators import (
+from _vendoring.jsonschema._types import TypeChecker
+from _vendoring.jsonschema.validators import (
     Draft3Validator,
     Draft4Validator,
     Draft6Validator,

lib/spack/external/_vendoring/jsonschema/__main__.py

@@ -1,2 +1,2 @@
-from jsonschema.cli import main
+from _vendoring.jsonschema.cli import main
 main()

lib/spack/external/_vendoring/jsonschema/_format.py

@@ -3,8 +3,8 @@
 import socket
 import struct
 
-from jsonschema.compat import str_types
-from jsonschema.exceptions import FormatError
+from _vendoring.jsonschema.compat import str_types
+from _vendoring.jsonschema.exceptions import FormatError
 
 
 class FormatChecker(object):

lib/spack/external/_vendoring/jsonschema/_legacy_validators.py

@@ -1,6 +1,6 @@
-from jsonschema import _utils
-from jsonschema.compat import iteritems
-from jsonschema.exceptions import ValidationError
+from _vendoring.jsonschema import _utils
+from _vendoring.jsonschema.compat import iteritems
+from _vendoring.jsonschema.exceptions import ValidationError
 
 
 def dependencies_draft3(validator, dependencies, instance, schema):

lib/spack/external/_vendoring/jsonschema/_reflect.py

@@ -9,7 +9,7 @@
 
 import sys
 
-from jsonschema.compat import PY3
+from _vendoring.jsonschema.compat import PY3
 
 
 class _NoModuleFound(Exception):

lib/spack/external/_vendoring/jsonschema/_types.py

@@ -1,10 +1,10 @@
 import numbers
 
-from pyrsistent import pmap
-import attr
+from _vendoring.pyrsistent import pmap
+import _vendoring.attr
 
-from jsonschema.compat import int_types, str_types
-from jsonschema.exceptions import UndefinedTypeCheck
+from _vendoring.jsonschema.compat import int_types, str_types
+from _vendoring.jsonschema.exceptions import UndefinedTypeCheck
 
 
 def is_array(checker, instance):
@@ -45,7 +45,7 @@ def is_any(checker, instance):
     return True
 
 
-@attr.s(frozen=True)
+@_vendoring.attr.s(frozen=True)
 class TypeChecker(object):
     """
     A ``type`` property checker.
@@ -61,7 +61,7 @@ class TypeChecker(object):
 
             The initial mapping of types to their checking functions.
     """
-    _type_checkers = attr.ib(default=pmap(), converter=pmap)
+    _type_checkers = _vendoring.attr.ib(default=pmap(), converter=pmap)
 
     def is_type(self, instance, type):
         """
@@ -131,7 +131,7 @@ def redefine_many(self, definitions=()):
 
             A new `TypeChecker` instance.
         """
-        return attr.evolve(
+        return _vendoring.attr.evolve(
             self, type_checkers=self._type_checkers.update(definitions),
         )
 
@@ -162,7 +162,7 @@ def remove(self, *types):
                 checkers = checkers.remove(each)
             except KeyError:
                 raise UndefinedTypeCheck(each)
-        return attr.evolve(self, type_checkers=checkers)
+        return _vendoring.attr.evolve(self, type_checkers=checkers)
 
 
 draft3_type_checker = TypeChecker(

lib/spack/external/_vendoring/jsonschema/_utils.py

@@ -3,7 +3,7 @@
 import pkgutil
 import re
 
-from jsonschema.compat import MutableMapping, str_types, urlsplit
+from _vendoring.jsonschema.compat import MutableMapping, str_types, urlsplit
 
 
 class URIDict(MutableMapping):
@@ -51,7 +51,7 @@ def load_schema(name):
     Load a schema from ./schemas/``name``.json and return it.
     """
 
-    data = pkgutil.get_data("jsonschema", "schemas/{0}.json".format(name))
+    data = pkgutil.get_data("_vendoring.jsonschema", "schemas/{0}.json".format(name))
     return json.loads(data.decode("utf-8"))
 
 

lib/spack/external/_vendoring/jsonschema/_validators.py

@@ -1,6 +1,6 @@
 import re
 
-from jsonschema._utils import (
+from _vendoring.jsonschema._utils import (
     ensure_list,
     equal,
     extras_msg,
@@ -9,8 +9,8 @@
     unbool,
     uniq,
 )
-from jsonschema.exceptions import FormatError, ValidationError
-from jsonschema.compat import iteritems
+from _vendoring.jsonschema.exceptions import FormatError, ValidationError
+from _vendoring.jsonschema.compat import iteritems
 
 
 def patternProperties(validator, patternProperties, instance, schema):

lib/spack/external/_vendoring/jsonschema/benchmarks/issue232.py

@@ -6,10 +6,10 @@
 """
 from twisted.python.filepath import FilePath
 from pyperf import Runner
-from pyrsistent import m
+from _vendoring.pyrsistent import m
 
-from jsonschema.tests._suite import Version
-import jsonschema
+from _vendoring.jsonschema.tests._suite import Version
+import _vendoring.jsonschema
 
 
 issue232 = Version(

lib/spack/external/_vendoring/jsonschema/benchmarks/json_schema_test_suite.py

@@ -7,7 +7,7 @@
 """
 from pyperf import Runner
 
-from jsonschema.tests._suite import Suite
+from _vendoring.jsonschema.tests._suite import Suite
 
 
 if __name__ == "__main__":

lib/spack/external/_vendoring/jsonschema/cli.py

@@ -6,9 +6,9 @@
 import json
 import sys
 
-from jsonschema import __version__
-from jsonschema._reflect import namedAny
-from jsonschema.validators import validator_for
+from _vendoring.jsonschema import __version__
+from _vendoring.jsonschema._reflect import namedAny
+from _vendoring.jsonschema.validators import validator_for
 
 
 def _namedAnyWithDefault(name):

lib/spack/external/_vendoring/jsonschema/exceptions.py

@@ -6,10 +6,10 @@
 import pprint
 import textwrap
 
-import attr
+import _vendoring.attr
 
-from jsonschema import _utils
-from jsonschema.compat import PY3, iteritems
+from _vendoring.jsonschema import _utils
+from _vendoring.jsonschema.compat import PY3, iteritems
 
 
 WEAK_MATCHES = frozenset(["anyOf", "oneOf"])
@@ -149,13 +149,13 @@ class SchemaError(_Error):
     _word_for_instance_in_error_message = "schema"
 
 
-@attr.s(hash=True)
+@_vendoring.attr.s(hash=True)
 class RefResolutionError(Exception):
     """
     A ref could not be resolved.
     """
 
-    _cause = attr.ib()
+    _cause = _vendoring.attr.ib()
 
     def __str__(self):
         return str(self._cause)

lib/spack/external/_vendoring/jsonschema/tests/_helpers.py

@@ -1,5 +0,0 @@
-def bug(issue=None):
-    message = "A known bug."
-    if issue is not None:
-        message += " See issue #{issue}.".format(issue=issue)
-    return message

lib/spack/external/_vendoring/jsonschema/tests/_suite.py

@@ -1,239 +0,0 @@
-"""
-Python representations of the JSON Schema Test Suite tests.
-"""
-
-from functools import partial
-import json
-import os
-import re
-import subprocess
-import sys
-import unittest
-
-from twisted.python.filepath import FilePath
-import attr
-
-from jsonschema.compat import PY3
-from jsonschema.validators import validators
-import jsonschema
-
-
-def _find_suite():
-    root = os.environ.get("JSON_SCHEMA_TEST_SUITE")
-    if root is not None:
-        return FilePath(root)
-
-    root = FilePath(jsonschema.__file__).parent().sibling("json")
-    if not root.isdir():  # pragma: no cover
-        raise ValueError(
-            (
-                "Can't find the JSON-Schema-Test-Suite directory. "
-                "Set the 'JSON_SCHEMA_TEST_SUITE' environment "
-                "variable or run the tests from alongside a checkout "
-                "of the suite."
-            ),
-        )
-    return root
-
-
-@attr.s(hash=True)
-class Suite(object):
-
-    _root = attr.ib(default=attr.Factory(_find_suite))
-
-    def _remotes(self):
-        jsonschema_suite = self._root.descendant(["bin", "jsonschema_suite"])
-        remotes = subprocess.check_output(
-            [sys.executable, jsonschema_suite.path, "remotes"],
-        )
-        return {
-            "http://localhost:1234/" + name: schema
-            for name, schema in json.loads(remotes.decode("utf-8")).items()
-        }
-
-    def benchmark(self, runner):  # pragma: no cover
-        for name in validators:
-            self.version(name=name).benchmark(runner=runner)
-
-    def version(self, name):
-        return Version(
-            name=name,
-            path=self._root.descendant(["tests", name]),
-            remotes=self._remotes(),
-        )
-
-
-@attr.s(hash=True)
-class Version(object):
-
-    _path = attr.ib()
-    _remotes = attr.ib()
-
-    name = attr.ib()
-
-    def benchmark(self, runner, **kwargs):  # pragma: no cover
-        for suite in self.tests():
-            for test in suite:
-                runner.bench_func(
-                    test.fully_qualified_name,
-                    partial(test.validate_ignoring_errors, **kwargs),
-                )
-
-    def tests(self):
-        return (
-            test
-            for child in self._path.globChildren("*.json")
-            for test in self._tests_in(
-                subject=child.basename()[:-5],
-                path=child,
-            )
-        )
-
-    def format_tests(self):
-        path = self._path.descendant(["optional", "format"])
-        return (
-            test
-            for child in path.globChildren("*.json")
-            for test in self._tests_in(
-                subject=child.basename()[:-5],
-                path=child,
-            )
-        )
-
-    def tests_of(self, name):
-        return self._tests_in(
-            subject=name,
-            path=self._path.child(name + ".json"),
-        )
-
-    def optional_tests_of(self, name):
-        return self._tests_in(
-            subject=name,
-            path=self._path.descendant(["optional", name + ".json"]),
-        )
-
-    def to_unittest_testcase(self, *suites, **kwargs):
-        name = kwargs.pop("name", "Test" + self.name.title())
-        methods = {
-            test.method_name: test.to_unittest_method(**kwargs)
-            for suite in suites
-            for tests in suite
-            for test in tests
-        }
-        cls = type(name, (unittest.TestCase,), methods)
-
-        try:
-            cls.__module__ = _someone_save_us_the_module_of_the_caller()
-        except Exception:  # pragma: no cover
-            # We're doing crazy things, so if they go wrong, like a function
-            # behaving differently on some other interpreter, just make them
-            # not happen.
-            pass
-
-        return cls
-
-    def _tests_in(self, subject, path):
-        for each in json.loads(path.getContent().decode("utf-8")):
-            yield (
-                _Test(
-                    version=self,
-                    subject=subject,
-                    case_description=each["description"],
-                    schema=each["schema"],
-                    remotes=self._remotes,
-                    **test
-                ) for test in each["tests"]
-            )
-
-
-@attr.s(hash=True, repr=False)
-class _Test(object):
-
-    version = attr.ib()
-
-    subject = attr.ib()
-    case_description = attr.ib()
-    description = attr.ib()
-
-    data = attr.ib()
-    schema = attr.ib(repr=False)
-
-    valid = attr.ib()
-
-    _remotes = attr.ib()
-
-    def __repr__(self):  # pragma: no cover
-        return "<Test {}>".format(self.fully_qualified_name)
-
-    @property
-    def fully_qualified_name(self):  # pragma: no cover
-        return " > ".join(
-            [
-                self.version.name,
-                self.subject,
-                self.case_description,
-                self.description,
-            ]
-        )
-
-    @property
-    def method_name(self):
-        delimiters = r"[\W\- ]+"
-        name = "test_%s_%s_%s" % (
-            re.sub(delimiters, "_", self.subject),
-            re.sub(delimiters, "_", self.case_description),
-            re.sub(delimiters, "_", self.description),
-        )
-
-        if not PY3:  # pragma: no cover
-            name = name.encode("utf-8")
-        return name
-
-    def to_unittest_method(self, skip=lambda test: None, **kwargs):
-        if self.valid:
-            def fn(this):
-                self.validate(**kwargs)
-        else:
-            def fn(this):
-                with this.assertRaises(jsonschema.ValidationError):
-                    self.validate(**kwargs)
-
-        fn.__name__ = self.method_name
-        reason = skip(self)
-        return unittest.skipIf(reason is not None, reason)(fn)
-
-    def validate(self, Validator, **kwargs):
-        resolver = jsonschema.RefResolver.from_schema(
-            schema=self.schema,
-            store=self._remotes,
-            id_of=Validator.ID_OF,
-        )
-        jsonschema.validate(
-            instance=self.data,
-            schema=self.schema,
-            cls=Validator,
-            resolver=resolver,
-            **kwargs
-        )
-
-    def validate_ignoring_errors(self, Validator):  # pragma: no cover
-        try:
-            self.validate(Validator=Validator)
-        except jsonschema.ValidationError:
-            pass
-
-
-def _someone_save_us_the_module_of_the_caller():
-    """
-    The FQON of the module 2nd stack frames up from here.
-
-    This is intended to allow us to dynamicallly return test case classes that
-    are indistinguishable from being defined in the module that wants them.
-
-    Otherwise, trial will mis-print the FQON, and copy pasting it won't re-run
-    the class that really is running.
-
-    Save us all, this is all so so so so so terrible.
-    """
-
-    return sys._getframe(2).f_globals["__name__"]

lib/spack/external/_vendoring/jsonschema/tests/test_cli.py

@@ -1,151 +0,0 @@
-from unittest import TestCase
-import json
-import subprocess
-import sys
-
-from jsonschema import Draft4Validator, ValidationError, cli, __version__
-from jsonschema.compat import NativeIO
-from jsonschema.exceptions import SchemaError
-
-
-def fake_validator(*errors):
-    errors = list(reversed(errors))
-
-    class FakeValidator(object):
-        def __init__(self, *args, **kwargs):
-            pass
-
-        def iter_errors(self, instance):
-            if errors:
-                return errors.pop()
-            return []
-
-        def check_schema(self, schema):
-            pass
-
-    return FakeValidator
-
-
-class TestParser(TestCase):
-
-    FakeValidator = fake_validator()
-    instance_file = "foo.json"
-    schema_file = "schema.json"
-
-    def setUp(self):
-        cli.open = self.fake_open
-        self.addCleanup(delattr, cli, "open")
-
-    def fake_open(self, path):
-        if path == self.instance_file:
-            contents = ""
-        elif path == self.schema_file:
-            contents = {}
-        else:  # pragma: no cover
-            self.fail("What is {!r}".format(path))
-        return NativeIO(json.dumps(contents))
-
-    def test_find_validator_by_fully_qualified_object_name(self):
-        arguments = cli.parse_args(
-            [
-                "--validator",
-                "jsonschema.tests.test_cli.TestParser.FakeValidator",
-                "--instance", self.instance_file,
-                self.schema_file,
-            ]
-        )
-        self.assertIs(arguments["validator"], self.FakeValidator)
-
-    def test_find_validator_in_jsonschema(self):
-        arguments = cli.parse_args(
-            [
-                "--validator", "Draft4Validator",
-                "--instance", self.instance_file,
-                self.schema_file,
-            ]
-        )
-        self.assertIs(arguments["validator"], Draft4Validator)
-
-
-class TestCLI(TestCase):
-    def test_draft3_schema_draft4_validator(self):
-        stdout, stderr = NativeIO(), NativeIO()
-        with self.assertRaises(SchemaError):
-            cli.run(
-                {
-                    "validator": Draft4Validator,
-                    "schema": {
-                        "anyOf": [
-                            {"minimum": 20},
-                            {"type": "string"},
-                            {"required": True},
-                        ],
-                    },
-                    "instances": [1],
-                    "error_format": "{error.message}",
-                },
-                stdout=stdout,
-                stderr=stderr,
-            )
-
-    def test_successful_validation(self):
-        stdout, stderr = NativeIO(), NativeIO()
-        exit_code = cli.run(
-            {
-                "validator": fake_validator(),
-                "schema": {},
-                "instances": [1],
-                "error_format": "{error.message}",
-            },
-            stdout=stdout,
-            stderr=stderr,
-        )
-        self.assertFalse(stdout.getvalue())
-        self.assertFalse(stderr.getvalue())
-        self.assertEqual(exit_code, 0)
-
-    def test_unsuccessful_validation(self):
-        error = ValidationError("I am an error!", instance=1)
-        stdout, stderr = NativeIO(), NativeIO()
-        exit_code = cli.run(
-            {
-                "validator": fake_validator([error]),
-                "schema": {},
-                "instances": [1],
-                "error_format": "{error.instance} - {error.message}",
-            },
-            stdout=stdout,
-            stderr=stderr,
-        )
-        self.assertFalse(stdout.getvalue())
-        self.assertEqual(stderr.getvalue(), "1 - I am an error!")
-        self.assertEqual(exit_code, 1)
-
-    def test_unsuccessful_validation_multiple_instances(self):
-        first_errors = [
-            ValidationError("9", instance=1),
-            ValidationError("8", instance=1),
-        ]
-        second_errors = [ValidationError("7", instance=2)]
-        stdout, stderr = NativeIO(), NativeIO()
-        exit_code = cli.run(
-            {
-                "validator": fake_validator(first_errors, second_errors),
-                "schema": {},
-                "instances": [1, 2],
-                "error_format": "{error.instance} - {error.message}\t",
-            },
-            stdout=stdout,
-            stderr=stderr,
-        )
-        self.assertFalse(stdout.getvalue())
-        self.assertEqual(stderr.getvalue(), "1 - 9\t1 - 8\t2 - 7\t")
-        self.assertEqual(exit_code, 1)
-
-    def test_version(self):
-        version = subprocess.check_output(
-            [sys.executable, "-m", "jsonschema", "--version"],
-            stderr=subprocess.STDOUT,
-        )
-        version = version.decode("utf-8").strip()
-        self.assertEqual(version, __version__)

lib/spack/external/_vendoring/jsonschema/tests/test_exceptions.py

@@ -1,462 +0,0 @@
-from unittest import TestCase
-import textwrap
-
-from jsonschema import Draft4Validator, exceptions
-from jsonschema.compat import PY3
-
-
-class TestBestMatch(TestCase):
-    def best_match(self, errors):
-        errors = list(errors)
-        best = exceptions.best_match(errors)
-        reversed_best = exceptions.best_match(reversed(errors))
-        msg = "Didn't return a consistent best match!\nGot: {0}\n\nThen: {1}"
-        self.assertEqual(
-            best._contents(), reversed_best._contents(),
-            msg=msg.format(best, reversed_best),
-        )
-        return best
-
-    def test_shallower_errors_are_better_matches(self):
-        validator = Draft4Validator(
-            {
-                "properties": {
-                    "foo": {
-                        "minProperties": 2,
-                        "properties": {"bar": {"type": "object"}},
-                    },
-                },
-            },
-        )
-        best = self.best_match(validator.iter_errors({"foo": {"bar": []}}))
-        self.assertEqual(best.validator, "minProperties")
-
-    def test_oneOf_and_anyOf_are_weak_matches(self):
-        """
-        A property you *must* match is probably better than one you have to
-        match a part of.
-        """
-
-        validator = Draft4Validator(
-            {
-                "minProperties": 2,
-                "anyOf": [{"type": "string"}, {"type": "number"}],
-                "oneOf": [{"type": "string"}, {"type": "number"}],
-            }
-        )
-        best = self.best_match(validator.iter_errors({}))
-        self.assertEqual(best.validator, "minProperties")
-
-    def test_if_the_most_relevant_error_is_anyOf_it_is_traversed(self):
-        """
-        If the most relevant error is an anyOf, then we traverse its context
-        and select the otherwise *least* relevant error, since in this case
-        that means the most specific, deep, error inside the instance.
-
-        I.e. since only one of the schemas must match, we look for the most
-        relevant one.
-        """
-
-        validator = Draft4Validator(
-            {
-                "properties": {
-                    "foo": {
-                        "anyOf": [
-                            {"type": "string"},
-                            {"properties": {"bar": {"type": "array"}}},
-                        ],
-                    },
-                },
-            },
-        )
-        best = self.best_match(validator.iter_errors({"foo": {"bar": 12}}))
-        self.assertEqual(best.validator_value, "array")
-
-    def test_if_the_most_relevant_error_is_oneOf_it_is_traversed(self):
-        """
-        If the most relevant error is an oneOf, then we traverse its context
-        and select the otherwise *least* relevant error, since in this case
-        that means the most specific, deep, error inside the instance.
-
-        I.e. since only one of the schemas must match, we look for the most
-        relevant one.
-        """
-
-        validator = Draft4Validator(
-            {
-                "properties": {
-                    "foo": {
-                        "oneOf": [
-                            {"type": "string"},
-                            {"properties": {"bar": {"type": "array"}}},
-                        ],
-                    },
-                },
-            },
-        )
-        best = self.best_match(validator.iter_errors({"foo": {"bar": 12}}))
-        self.assertEqual(best.validator_value, "array")
-
-    def test_if_the_most_relevant_error_is_allOf_it_is_traversed(self):
-        """
-        Now, if the error is allOf, we traverse but select the *most* relevant
-        error from the context, because all schemas here must match anyways.
-        """
-
-        validator = Draft4Validator(
-            {
-                "properties": {
-                    "foo": {
-                        "allOf": [
-                            {"type": "string"},
-                            {"properties": {"bar": {"type": "array"}}},
-                        ],
-                    },
-                },
-            },
-        )
-        best = self.best_match(validator.iter_errors({"foo": {"bar": 12}}))
-        self.assertEqual(best.validator_value, "string")
-
-    def test_nested_context_for_oneOf(self):
-        validator = Draft4Validator(
-            {
-                "properties": {
-                    "foo": {
-                        "oneOf": [
-                            {"type": "string"},
-                            {
-                                "oneOf": [
-                                    {"type": "string"},
-                                    {
-                                        "properties": {
-                                            "bar": {"type": "array"},
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                },
-            },
-        )
-        best = self.best_match(validator.iter_errors({"foo": {"bar": 12}}))
-        self.assertEqual(best.validator_value, "array")
-
-    def test_one_error(self):
-        validator = Draft4Validator({"minProperties": 2})
-        error, = validator.iter_errors({})
-        self.assertEqual(
-            exceptions.best_match(validator.iter_errors({})).validator,
-            "minProperties",
-        )
-
-    def test_no_errors(self):
-        validator = Draft4Validator({})
-        self.assertIsNone(exceptions.best_match(validator.iter_errors({})))
-
-
-class TestByRelevance(TestCase):
-    def test_short_paths_are_better_matches(self):
-        shallow = exceptions.ValidationError("Oh no!", path=["baz"])
-        deep = exceptions.ValidationError("Oh yes!", path=["foo", "bar"])
-        match = max([shallow, deep], key=exceptions.relevance)
-        self.assertIs(match, shallow)
-
-        match = max([deep, shallow], key=exceptions.relevance)
-        self.assertIs(match, shallow)
-
-    def test_global_errors_are_even_better_matches(self):
-        shallow = exceptions.ValidationError("Oh no!", path=[])
-        deep = exceptions.ValidationError("Oh yes!", path=["foo"])
-
-        errors = sorted([shallow, deep], key=exceptions.relevance)
-        self.assertEqual(
-            [list(error.path) for error in errors],
-            [["foo"], []],
-        )
-
-        errors = sorted([deep, shallow], key=exceptions.relevance)
-        self.assertEqual(
-            [list(error.path) for error in errors],
-            [["foo"], []],
-        )
-
-    def test_weak_validators_are_lower_priority(self):
-        weak = exceptions.ValidationError("Oh no!", path=[], validator="a")
-        normal = exceptions.ValidationError("Oh yes!", path=[], validator="b")
-
-        best_match = exceptions.by_relevance(weak="a")
-
-        match = max([weak, normal], key=best_match)
-        self.assertIs(match, normal)
-
-        match = max([normal, weak], key=best_match)
-        self.assertIs(match, normal)
-
-    def test_strong_validators_are_higher_priority(self):
-        weak = exceptions.ValidationError("Oh no!", path=[], validator="a")
-        normal = exceptions.ValidationError("Oh yes!", path=[], validator="b")
-        strong = exceptions.ValidationError("Oh fine!", path=[], validator="c")
-
-        best_match = exceptions.by_relevance(weak="a", strong="c")
-
-        match = max([weak, normal, strong], key=best_match)
-        self.assertIs(match, strong)
-
-        match = max([strong, normal, weak], key=best_match)
-        self.assertIs(match, strong)
-
-
-class TestErrorTree(TestCase):
-    def test_it_knows_how_many_total_errors_it_contains(self):
-        # FIXME: https://github.com/Julian/jsonschema/issues/442
-        errors = [
-            exceptions.ValidationError("Something", validator=i)
-            for i in range(8)
-        ]
-        tree = exceptions.ErrorTree(errors)
-        self.assertEqual(tree.total_errors, 8)
-
-    def test_it_contains_an_item_if_the_item_had_an_error(self):
-        errors = [exceptions.ValidationError("a message", path=["bar"])]
-        tree = exceptions.ErrorTree(errors)
-        self.assertIn("bar", tree)
-
-    def test_it_does_not_contain_an_item_if_the_item_had_no_error(self):
-        errors = [exceptions.ValidationError("a message", path=["bar"])]
-        tree = exceptions.ErrorTree(errors)
-        self.assertNotIn("foo", tree)
-
-    def test_validators_that_failed_appear_in_errors_dict(self):
-        error = exceptions.ValidationError("a message", validator="foo")
-        tree = exceptions.ErrorTree([error])
-        self.assertEqual(tree.errors, {"foo": error})
-
-    def test_it_creates_a_child_tree_for_each_nested_path(self):
-        errors = [
-            exceptions.ValidationError("a bar message", path=["bar"]),
-            exceptions.ValidationError("a bar -> 0 message", path=["bar", 0]),
-        ]
-        tree = exceptions.ErrorTree(errors)
-        self.assertIn(0, tree["bar"])
-        self.assertNotIn(1, tree["bar"])
-
-    def test_children_have_their_errors_dicts_built(self):
-        e1, e2 = (
-            exceptions.ValidationError("1", validator="foo", path=["bar", 0]),
-            exceptions.ValidationError("2", validator="quux", path=["bar", 0]),
-        )
-        tree = exceptions.ErrorTree([e1, e2])
-        self.assertEqual(tree["bar"][0].errors, {"foo": e1, "quux": e2})
-
-    def test_multiple_errors_with_instance(self):
-        e1, e2 = (
-            exceptions.ValidationError(
-                "1",
-                validator="foo",
-                path=["bar", "bar2"],
-                instance="i1"),
-            exceptions.ValidationError(
-                "2",
-                validator="quux",
-                path=["foobar", 2],
-                instance="i2"),
-        )
-        exceptions.ErrorTree([e1, e2])
-
-    def test_it_does_not_contain_subtrees_that_are_not_in_the_instance(self):
-        error = exceptions.ValidationError("123", validator="foo", instance=[])
-        tree = exceptions.ErrorTree([error])
-
-        with self.assertRaises(IndexError):
-            tree[0]
-
-    def test_if_its_in_the_tree_anyhow_it_does_not_raise_an_error(self):
-        """
-        If a validator is dumb (like :validator:`required` in draft 3) and
-        refers to a path that isn't in the instance, the tree still properly
-        returns a subtree for that path.
-        """
-
-        error = exceptions.ValidationError(
-            "a message", validator="foo", instance={}, path=["foo"],
-        )
-        tree = exceptions.ErrorTree([error])
-        self.assertIsInstance(tree["foo"], exceptions.ErrorTree)
-
-
-class TestErrorInitReprStr(TestCase):
-    def make_error(self, **kwargs):
-        defaults = dict(
-            message=u"hello",
-            validator=u"type",
-            validator_value=u"string",
-            instance=5,
-            schema={u"type": u"string"},
-        )
-        defaults.update(kwargs)
-        return exceptions.ValidationError(**defaults)
-
-    def assertShows(self, expected, **kwargs):
-        if PY3:  # pragma: no cover
-            expected = expected.replace("u'", "'")
-        expected = textwrap.dedent(expected).rstrip("\n")
-
-        error = self.make_error(**kwargs)
-        message_line, _, rest = str(error).partition("\n")
-        self.assertEqual(message_line, error.message)
-        self.assertEqual(rest, expected)
-
-    def test_it_calls_super_and_sets_args(self):
-        error = self.make_error()
-        self.assertGreater(len(error.args), 1)
-
-    def test_repr(self):
-        self.assertEqual(
-            repr(exceptions.ValidationError(message="Hello!")),
-            "<ValidationError: %r>" % "Hello!",
-        )
-
-    def test_unset_error(self):
-        error = exceptions.ValidationError("message")
-        self.assertEqual(str(error), "message")
-
-        kwargs = {
-            "validator": "type",
-            "validator_value": "string",
-            "instance": 5,
-            "schema": {"type": "string"},
-        }
-        # Just the message should show if any of the attributes are unset
-        for attr in kwargs:
-            k = dict(kwargs)
-            del k[attr]
-            error = exceptions.ValidationError("message", **k)
-            self.assertEqual(str(error), "message")
-
-    def test_empty_paths(self):
-        self.assertShows(
-            """
-            Failed validating u'type' in schema:
-                {u'type': u'string'}
-
-            On instance:
-                5
-            """,
-            path=[],
-            schema_path=[],
-        )
-
-    def test_one_item_paths(self):
-        self.assertShows(
-            """
-            Failed validating u'type' in schema:
-                {u'type': u'string'}
-
-            On instance[0]:
-                5
-            """,
-            path=[0],
-            schema_path=["items"],
-        )
-
-    def test_multiple_item_paths(self):
-        self.assertShows(
-            """
-            Failed validating u'type' in schema[u'items'][0]:
-                {u'type': u'string'}
-
-            On instance[0][u'a']:
-                5
-            """,
-            path=[0, u"a"],
-            schema_path=[u"items", 0, 1],
-        )
-
-    def test_uses_pprint(self):
-        self.assertShows(
-            """
-            Failed validating u'maxLength' in schema:
-                {0: 0,
-                 1: 1,
-                 2: 2,
-                 3: 3,
-                 4: 4,
-                 5: 5,
-                 6: 6,
-                 7: 7,
-                 8: 8,
-                 9: 9,
-                 10: 10,
-                 11: 11,
-                 12: 12,
-                 13: 13,
-                 14: 14,
-                 15: 15,
-                 16: 16,
-                 17: 17,
-                 18: 18,
-                 19: 19}
-
-            On instance:
-                [0,
-                 1,
-                 2,
-                 3,
-                 4,
-                 5,
-                 6,
-                 7,
-                 8,
-                 9,
-                 10,
-                 11,
-                 12,
-                 13,
-                 14,
-                 15,
-                 16,
-                 17,
-                 18,
-                 19,
-                 20,
-                 21,
-                 22,
-                 23,
-                 24]
-            """,
-            instance=list(range(25)),
-            schema=dict(zip(range(20), range(20))),
-            validator=u"maxLength",
-        )
-
-    def test_str_works_with_instances_having_overriden_eq_operator(self):
-        """
-        Check for https://github.com/Julian/jsonschema/issues/164 which
-        rendered exceptions unusable when a `ValidationError` involved
-        instances with an `__eq__` method that returned truthy values.
-        """
-
-        class DontEQMeBro(object):
-            def __eq__(this, other):  # pragma: no cover
-                self.fail("Don't!")
-
-            def __ne__(this, other):  # pragma: no cover
-                self.fail("Don't!")
-
-        instance = DontEQMeBro()
-        error = exceptions.ValidationError(
-            "a message",
-            validator="foo",
-            instance=instance,
-            validator_value="some",
-            schema="schema",
-        )
-        self.assertIn(repr(instance), str(error))
-
-
-class TestHashable(TestCase):
-    def test_hashable(self):
-        set([exceptions.ValidationError("")])
-        set([exceptions.SchemaError("")])

lib/spack/external/_vendoring/jsonschema/tests/test_format.py

@@ -1,89 +0,0 @@
-"""
-Tests for the parts of jsonschema related to the :validator:`format` property.
-"""
-
-from unittest import TestCase
-
-from jsonschema import FormatError, ValidationError, FormatChecker
-from jsonschema.validators import Draft4Validator
-
-
-BOOM = ValueError("Boom!")
-BANG = ZeroDivisionError("Bang!")
-
-
-def boom(thing):
-    if thing == "bang":
-        raise BANG
-    raise BOOM
-
-
-class TestFormatChecker(TestCase):
-    def test_it_can_validate_no_formats(self):
-        checker = FormatChecker(formats=())
-        self.assertFalse(checker.checkers)
-
-    def test_it_raises_a_key_error_for_unknown_formats(self):
-        with self.assertRaises(KeyError):
-            FormatChecker(formats=["o noes"])
-
-    def test_it_can_register_cls_checkers(self):
-        original = dict(FormatChecker.checkers)
-        self.addCleanup(FormatChecker.checkers.pop, "boom")
-        FormatChecker.cls_checks("boom")(boom)
-        self.assertEqual(
-            FormatChecker.checkers,
-            dict(original, boom=(boom, ())),
-        )
-
-    def test_it_can_register_checkers(self):
-        checker = FormatChecker()
-        checker.checks("boom")(boom)
-        self.assertEqual(
-            checker.checkers,
-            dict(FormatChecker.checkers, boom=(boom, ()))
-        )
-
-    def test_it_catches_registered_errors(self):
-        checker = FormatChecker()
-        checker.checks("boom", raises=type(BOOM))(boom)
-
-        with self.assertRaises(FormatError) as cm:
-            checker.check(instance=12, format="boom")
-
-        self.assertIs(cm.exception.cause, BOOM)
-        self.assertIs(cm.exception.__cause__, BOOM)
-
-        # Unregistered errors should not be caught
-        with self.assertRaises(type(BANG)):
-            checker.check(instance="bang", format="boom")
-
-    def test_format_error_causes_become_validation_error_causes(self):
-        checker = FormatChecker()
-        checker.checks("boom", raises=ValueError)(boom)
-        validator = Draft4Validator({"format": "boom"}, format_checker=checker)
-
-        with self.assertRaises(ValidationError) as cm:
-            validator.validate("BOOM")
-
-        self.assertIs(cm.exception.cause, BOOM)
-        self.assertIs(cm.exception.__cause__, BOOM)
-
-    def test_format_checkers_come_with_defaults(self):
-        # This is bad :/ but relied upon.
-        # The docs for quite awhile recommended people do things like
-        # validate(..., format_checker=FormatChecker())
-        # We should change that, but we can't without deprecation...
-        checker = FormatChecker()
-        with self.assertRaises(FormatError):
-            checker.check(instance="not-an-ipv4", format="ipv4")
-
-    def test_repr(self):
-        checker = FormatChecker(formats=())
-        checker.checks("foo")(lambda thing: True)
-        checker.checks("bar")(lambda thing: True)
-        checker.checks("baz")(lambda thing: True)
-        self.assertEqual(
-            repr(checker),
-            "<FormatChecker checkers=['bar', 'baz', 'foo']>",
-        )

lib/spack/external/_vendoring/jsonschema/tests/test_jsonschema_test_suite.py

@@ -1,277 +0,0 @@
-"""
-Test runner for the JSON Schema official test suite
-
-Tests comprehensive correctness of each draft's validator.
-
-See https://github.com/json-schema-org/JSON-Schema-Test-Suite for details.
-"""
-
-import sys
-import warnings
-
-from jsonschema import (
-    Draft3Validator,
-    Draft4Validator,
-    Draft6Validator,
-    Draft7Validator,
-    draft3_format_checker,
-    draft4_format_checker,
-    draft6_format_checker,
-    draft7_format_checker,
-)
-from jsonschema.tests._helpers import bug
-from jsonschema.tests._suite import Suite
-from jsonschema.validators import _DEPRECATED_DEFAULT_TYPES, create
-
-
-SUITE = Suite()
-DRAFT3 = SUITE.version(name="draft3")
-DRAFT4 = SUITE.version(name="draft4")
-DRAFT6 = SUITE.version(name="draft6")
-DRAFT7 = SUITE.version(name="draft7")
-
-
-def skip(message, **kwargs):
-    def skipper(test):
-        if all(value == getattr(test, attr) for attr, value in kwargs.items()):
-            return message
-    return skipper
-
-
-def missing_format(checker):
-    def missing_format(test):
-        schema = test.schema
-        if schema is True or schema is False or "format" not in schema:
-            return
-
-        if schema["format"] not in checker.checkers:
-            return "Format checker {0!r} not found.".format(schema["format"])
-    return missing_format
-
-
-is_narrow_build = sys.maxunicode == 2 ** 16 - 1
-if is_narrow_build:  # pragma: no cover
-    message = "Not running surrogate Unicode case, this Python is narrow."
-
-    def narrow_unicode_build(test):  # pragma: no cover
-        return skip(
-            message=message,
-            description="one supplementary Unicode code point is not long enough",
-        )(test) or skip(
-            message=message,
-            description="two supplementary Unicode code points is long enough",
-        )(test)
-else:
-    def narrow_unicode_build(test):  # pragma: no cover
-        return
-
-
-TestDraft3 = DRAFT3.to_unittest_testcase(
-    DRAFT3.tests(),
-    DRAFT3.optional_tests_of(name="bignum"),
-    DRAFT3.optional_tests_of(name="format"),
-    DRAFT3.optional_tests_of(name="zeroTerminatedFloats"),
-    Validator=Draft3Validator,
-    format_checker=draft3_format_checker,
-    skip=lambda test: (
-        narrow_unicode_build(test)
-        or missing_format(draft3_format_checker)(test)
-        or skip(
-            message="Upstream bug in strict_rfc3339",
-            subject="format",
-            description="case-insensitive T and Z",
-        )(test)
-    ),
-)
-
-
-TestDraft4 = DRAFT4.to_unittest_testcase(
-    DRAFT4.tests(),
-    DRAFT4.optional_tests_of(name="bignum"),
-    DRAFT4.optional_tests_of(name="format"),
-    DRAFT4.optional_tests_of(name="zeroTerminatedFloats"),
-    Validator=Draft4Validator,
-    format_checker=draft4_format_checker,
-    skip=lambda test: (
-        narrow_unicode_build(test)
-        or missing_format(draft4_format_checker)(test)
-        or skip(
-            message=bug(),
-            subject="ref",
-            case_description="Recursive references between schemas",
-        )(test)
-        or skip(
-            message=bug(371),
-            subject="ref",
-            case_description="Location-independent identifier",
-        )(test)
-        or skip(
-            message=bug(371),
-            subject="ref",
-            case_description=(
-                "Location-independent identifier with absolute URI"
-            ),
-        )(test)
-        or skip(
-            message=bug(371),
-            subject="ref",
-            case_description=(
-                "Location-independent identifier with base URI change in subschema"
-            ),
-        )(test)
-        or skip(
-            message=bug(),
-            subject="refRemote",
-            case_description="base URI change - change folder in subschema",
-        )(test)
-        or skip(
-            message="Upstream bug in strict_rfc3339",
-            subject="format",
-            description="case-insensitive T and Z",
-        )(test)
-    ),
-)
-
-
-TestDraft6 = DRAFT6.to_unittest_testcase(
-    DRAFT6.tests(),
-    DRAFT6.optional_tests_of(name="bignum"),
-    DRAFT6.optional_tests_of(name="format"),
-    DRAFT6.optional_tests_of(name="zeroTerminatedFloats"),
-    Validator=Draft6Validator,
-    format_checker=draft6_format_checker,
-    skip=lambda test: (
-        narrow_unicode_build(test)
-        or missing_format(draft6_format_checker)(test)
-        or skip(
-            message=bug(),
-            subject="ref",
-            case_description="Recursive references between schemas",
-        )(test)
-        or skip(
-            message=bug(371),
-            subject="ref",
-            case_description="Location-independent identifier",
-        )(test)
-        or skip(
-            message=bug(371),
-            subject="ref",
-            case_description=(
-                "Location-independent identifier with absolute URI"
-            ),
-        )(test)
-        or skip(
-            message=bug(371),
-            subject="ref",
-            case_description=(
-                "Location-independent identifier with base URI change in subschema"
-            ),
-        )(test)
-        or skip(
-            message=bug(),
-            subject="refRemote",
-            case_description="base URI change - change folder in subschema",
-        )(test)
-        or skip(
-            message="Upstream bug in strict_rfc3339",
-            subject="format",
-            description="case-insensitive T and Z",
-        )(test)
-    ),
-)
-
-
-TestDraft7 = DRAFT7.to_unittest_testcase(
-    DRAFT7.tests(),
-    DRAFT7.format_tests(),
-    DRAFT7.optional_tests_of(name="bignum"),
-    DRAFT7.optional_tests_of(name="content"),
-    DRAFT7.optional_tests_of(name="zeroTerminatedFloats"),
-    Validator=Draft7Validator,
-    format_checker=draft7_format_checker,
-    skip=lambda test: (
-        narrow_unicode_build(test)
-        or missing_format(draft7_format_checker)(test)
-        or skip(
-            message=bug(),
-            subject="ref",
-            case_description="Recursive references between schemas",
-        )(test)
-        or skip(
-            message=bug(371),
-            subject="ref",
-            case_description="Location-independent identifier",
-        )(test)
-        or skip(
-            message=bug(371),
-            subject="ref",
-            case_description=(
-                "Location-independent identifier with absolute URI"
-            ),
-        )(test)
-        or skip(
-            message=bug(371),
-            subject="ref",
-            case_description=(
-                "Location-independent identifier with base URI change in subschema"
-            ),
-        )(test)
-        or skip(
-            message=bug(),
-            subject="refRemote",
-            case_description="base URI change - change folder in subschema",
-        )(test)
-        or skip(
-            message="Upstream bug in strict_rfc3339",
-            subject="date-time",
-            description="case-insensitive T and Z",
-        )(test)
-        or skip(
-            message=bug(593),
-            subject="content",
-            case_description=(
-                "validation of string-encoded content based on media type"
-            ),
-        )(test)
-        or skip(
-            message=bug(593),
-            subject="content",
-            case_description="validation of binary string-encoding",
-        )(test)
-        or skip(
-            message=bug(593),
-            subject="content",
-            case_description=(
-                "validation of binary-encoded media type documents"
-            ),
-        )(test)
-    ),
-)
-
-
-with warnings.catch_warnings():
-    warnings.simplefilter("ignore", DeprecationWarning)
-
-    TestDraft3LegacyTypeCheck = DRAFT3.to_unittest_testcase(
-        # Interestingly the any part couldn't really be done w/the old API.
-        (
-            (test for test in each if test.schema != {"type": "any"})
-            for each in DRAFT3.tests_of(name="type")
-        ),
-        name="TestDraft3LegacyTypeCheck",
-        Validator=create(
-            meta_schema=Draft3Validator.META_SCHEMA,
-            validators=Draft3Validator.VALIDATORS,
-            default_types=_DEPRECATED_DEFAULT_TYPES,
-        ),
-    )
-
-    TestDraft4LegacyTypeCheck = DRAFT4.to_unittest_testcase(
-        DRAFT4.tests_of(name="type"),
-        name="TestDraft4LegacyTypeCheck",
-        Validator=create(
-            meta_schema=Draft4Validator.META_SCHEMA,
-            validators=Draft4Validator.VALIDATORS,
-            default_types=_DEPRECATED_DEFAULT_TYPES,
-        ),
-    )

lib/spack/external/_vendoring/jsonschema/tests/test_types.py

@@ -1,190 +0,0 @@
-"""
-Tests on the new type interface. The actual correctness of the type checking
-is handled in test_jsonschema_test_suite; these tests check that TypeChecker
-functions correctly and can facilitate extensions to type checking
-"""
-from collections import namedtuple
-from unittest import TestCase
-
-from jsonschema import ValidationError, _validators
-from jsonschema._types import TypeChecker
-from jsonschema.exceptions import UndefinedTypeCheck
-from jsonschema.validators import Draft4Validator, extend
-
-
-def equals_2(checker, instance):
-    return instance == 2
-
-
-def is_namedtuple(instance):
-    return isinstance(instance, tuple) and getattr(instance, "_fields", None)
-
-
-def is_object_or_named_tuple(checker, instance):
-    if Draft4Validator.TYPE_CHECKER.is_type(instance, "object"):
-        return True
-    return is_namedtuple(instance)
-
-
-def coerce_named_tuple(fn):
-    def coerced(validator, value, instance, schema):
-        if is_namedtuple(instance):
-            instance = instance._asdict()
-        return fn(validator, value, instance, schema)
-    return coerced
-
-
-required = coerce_named_tuple(_validators.required)
-properties = coerce_named_tuple(_validators.properties)
-
-
-class TestTypeChecker(TestCase):
-    def test_is_type(self):
-        checker = TypeChecker({"two": equals_2})
-        self.assertEqual(
-            (
-                checker.is_type(instance=2, type="two"),
-                checker.is_type(instance="bar", type="two"),
-            ),
-            (True, False),
-        )
-
-    def test_is_unknown_type(self):
-        with self.assertRaises(UndefinedTypeCheck) as context:
-            TypeChecker().is_type(4, "foobar")
-        self.assertIn("foobar", str(context.exception))
-
-    def test_checks_can_be_added_at_init(self):
-        checker = TypeChecker({"two": equals_2})
-        self.assertEqual(checker, TypeChecker().redefine("two", equals_2))
-
-    def test_redefine_existing_type(self):
-        self.assertEqual(
-            TypeChecker().redefine("two", object()).redefine("two", equals_2),
-            TypeChecker().redefine("two", equals_2),
-        )
-
-    def test_remove(self):
-        self.assertEqual(
-            TypeChecker({"two": equals_2}).remove("two"),
-            TypeChecker(),
-        )
-
-    def test_remove_unknown_type(self):
-        with self.assertRaises(UndefinedTypeCheck) as context:
-            TypeChecker().remove("foobar")
-        self.assertIn("foobar", str(context.exception))
-
-    def test_redefine_many(self):
-        self.assertEqual(
-            TypeChecker().redefine_many({"foo": int, "bar": str}),
-            TypeChecker().redefine("foo", int).redefine("bar", str),
-        )
-
-    def test_remove_multiple(self):
-        self.assertEqual(
-            TypeChecker({"foo": int, "bar": str}).remove("foo", "bar"),
-            TypeChecker(),
-        )
-
-    def test_type_check_can_raise_key_error(self):
-        """
-        Make sure no one writes:
-
-            try:
-                self._type_checkers[type](...)
-            except KeyError:
-
-        ignoring the fact that the function itself can raise that.
-        """
-
-        error = KeyError("Stuff")
-
-        def raises_keyerror(checker, instance):
-            raise error
-
-        with self.assertRaises(KeyError) as context:
-            TypeChecker({"foo": raises_keyerror}).is_type(4, "foo")
-
-        self.assertIs(context.exception, error)
-
-
-class TestCustomTypes(TestCase):
-    def test_simple_type_can_be_extended(self):
-        def int_or_str_int(checker, instance):
-            if not isinstance(instance, (int, str)):
-                return False
-            try:
-                int(instance)
-            except ValueError:
-                return False
-            return True
-
-        CustomValidator = extend(
-            Draft4Validator,
-            type_checker=Draft4Validator.TYPE_CHECKER.redefine(
-                "integer", int_or_str_int,
-            ),
-        )
-        validator = CustomValidator({"type": "integer"})
-
-        validator.validate(4)
-        validator.validate("4")
-
-        with self.assertRaises(ValidationError):
-            validator.validate(4.4)
-
-    def test_object_can_be_extended(self):
-        schema = {"type": "object"}
-
-        Point = namedtuple("Point", ["x", "y"])
-
-        type_checker = Draft4Validator.TYPE_CHECKER.redefine(
-            u"object", is_object_or_named_tuple,
-        )
-
-        CustomValidator = extend(Draft4Validator, type_checker=type_checker)
-        validator = CustomValidator(schema)
-
-        validator.validate(Point(x=4, y=5))
-
-    def test_object_extensions_require_custom_validators(self):
-        schema = {"type": "object", "required": ["x"]}
-
-        type_checker = Draft4Validator.TYPE_CHECKER.redefine(
-            u"object", is_object_or_named_tuple,
-        )
-
-        CustomValidator = extend(Draft4Validator, type_checker=type_checker)
-        validator = CustomValidator(schema)
-
-        Point = namedtuple("Point", ["x", "y"])
-        # Cannot handle required
-        with self.assertRaises(ValidationError):
-            validator.validate(Point(x=4, y=5))
-
-    def test_object_extensions_can_handle_custom_validators(self):
-        schema = {
-            "type": "object",
-            "required": ["x"],
-            "properties": {"x": {"type": "integer"}},
-        }
-
-        type_checker = Draft4Validator.TYPE_CHECKER.redefine(
-            u"object", is_object_or_named_tuple,
-        )
-
-        CustomValidator = extend(
-            Draft4Validator,
-            type_checker=type_checker,
-            validators={"required": required, "properties": properties},
-        )
-
-        validator = CustomValidator(schema)
-
-        Point = namedtuple("Point", ["x", "y"])
-        # Can now process required and properties
-        validator.validate(Point(x=4, y=5))
-
-        with self.assertRaises(ValidationError):
-            validator.validate(Point(x="not an integer", y=5))

lib/spack/external/_vendoring/jsonschema/validators.py

@@ -8,16 +8,16 @@
 import json
 import numbers
 
-from six import add_metaclass
+from _vendoring.six import add_metaclass
 
-from jsonschema import (
+from _vendoring.jsonschema import (
     _legacy_validators,
     _types,
     _utils,
     _validators,
     exceptions,
 )
-from jsonschema.compat import (
+from _vendoring.jsonschema.compat import (
     Sequence,
     int_types,
     iteritems,
@@ -33,7 +33,7 @@
 # Sigh. https://gitlab.com/pycqa/flake8/issues/280
 #       https://github.com/pyga/ebb-lint/issues/7
 # Imported for backwards compatibility.
-from jsonschema.exceptions import ErrorTree
+from _vendoring.jsonschema.exceptions import ErrorTree
 ErrorTree
 
 

lib/spack/external/_vendoring/macholib/MachO.py

@@ -7,7 +7,7 @@
 import struct
 import sys
 
-from macholib.util import fileview
+from _vendoring.macholib.util import fileview
 
 from .mach_o import (
     FAT_MAGIC,
@@ -41,7 +41,7 @@
 from .ptypes import sizeof
 
 try:
-    from macholib.compat import bytes
+    from _vendoring.macholib.compat import bytes
 except ImportError:
     pass
 

lib/spack/external/_vendoring/macholib/MachOGraph.py

@@ -5,11 +5,11 @@
 import os
 import sys
 
-from altgraph.ObjectGraph import ObjectGraph
+from _vendoring.altgraph.ObjectGraph import ObjectGraph
 
-from macholib.dyld import dyld_find
-from macholib.itergraphreport import itergraphreport
-from macholib.MachO import MachO
+from _vendoring.macholib.dyld import dyld_find
+from _vendoring.macholib.itergraphreport import itergraphreport
+from _vendoring.macholib.MachO import MachO
 
 __all__ = ["MachOGraph"]
 

lib/spack/external/_vendoring/macholib/MachOStandalone.py

@@ -1,9 +1,9 @@
 import os
 from collections import deque
 
-from macholib.dyld import framework_info
-from macholib.MachOGraph import MachOGraph, MissingMachO
-from macholib.util import (
+from _vendoring.macholib.dyld import framework_info
+from _vendoring.macholib.MachOGraph import MachOGraph, MissingMachO
+from _vendoring.macholib.util import (
     flipwritable,
     has_filename_filter,
     in_system_path,

lib/spack/external/_vendoring/macholib/SymbolTable.py

@@ -5,7 +5,7 @@
 
 import sys
 
-from macholib.mach_o import (
+from _vendoring.macholib.mach_o import (
     MH_CIGAM_64,
     MH_MAGIC_64,
     dylib_module,

lib/spack/external/_vendoring/macholib/__main__.py

@@ -3,8 +3,8 @@
 import os
 import sys
 
-from macholib import macho_dump, macho_standalone
-from macholib.util import is_platform_file
+from _vendoring.macholib import macho_dump, macho_standalone
+from _vendoring.macholib.util import is_platform_file
 
 gCommand = None
 
@@ -43,10 +43,10 @@ def walk_tree(callback, paths):
 
 def print_usage(fp):
     print("Usage:", file=fp)
-    print("  python -mmacholib [help|--help]", file=fp)
-    print("  python -mmacholib dump FILE ...", file=fp)
-    print("  python -mmacholib find DIR ...", file=fp)
-    print("  python -mmacholib standalone DIR ...", file=fp)
+    print("  python -m_vendoring.macholib [help|--help]", file=fp)
+    print("  python -m_vendoring.macholib dump FILE ...", file=fp)
+    print("  python -m_vendoring.macholib find DIR ...", file=fp)
+    print("  python -m_vendoring.macholib standalone DIR ...", file=fp)
 
 
 def main():

lib/spack/external/_vendoring/macholib/_cmdline.py

@@ -6,7 +6,7 @@
 import os
 import sys
 
-from macholib.util import is_platform_file
+from _vendoring.macholib.util import is_platform_file
 
 
 def check_file(fp, path, callback):

lib/spack/external/_vendoring/macholib/dyld.py

@@ -8,8 +8,8 @@
 import sys
 from itertools import chain
 
-from macholib.dylib import dylib_info
-from macholib.framework import framework_info
+from _vendoring.macholib.dylib import dylib_info
+from _vendoring.macholib.framework import framework_info
 
 __all__ = ["dyld_find", "framework_find", "framework_info", "dylib_info"]
 

lib/spack/external/_vendoring/macholib/mach_o.py

@@ -13,7 +13,7 @@
 
 import time
 
-from macholib.ptypes import (
+from _vendoring.macholib.ptypes import (
     Structure,
     p_int32,
     p_int64,

lib/spack/external/_vendoring/macholib/macho_dump.py

@@ -4,9 +4,9 @@
 
 import sys
 
-from macholib._cmdline import main as _main
-from macholib.mach_o import CPU_TYPE_NAMES, MH_CIGAM_64, MH_MAGIC_64, get_cpu_subtype
-from macholib.MachO import MachO
+from _vendoring.macholib._cmdline import main as _main
+from _vendoring.macholib.mach_o import CPU_TYPE_NAMES, MH_CIGAM_64, MH_MAGIC_64, get_cpu_subtype
+from _vendoring.macholib.MachO import MachO
 
 ARCH_MAP = {
     ("<", "64-bit"): "x86_64",
@@ -45,7 +45,7 @@ def print_file(fp, path):
 
 def main():
     print(
-        "WARNING: 'macho_dump' is deprecated, use 'python -mmacholib dump' " "instead"
+        "WARNING: 'macho_dump' is deprecated, use 'python -m_vendoring.macholib dump' " "instead"
     )
     _main(print_file)
 

lib/spack/external/_vendoring/macholib/macho_find.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from __future__ import print_function
 
-from macholib._cmdline import main as _main
+from _vendoring.macholib._cmdline import main as _main
 
 
 def print_file(fp, path):
@@ -10,7 +10,7 @@ def print_file(fp, path):
 
 def main():
     print(
-        "WARNING: 'macho_find' is deprecated, " "use 'python -mmacholib dump' instead"
+        "WARNING: 'macho_find' is deprecated, " "use 'python -m_vendoring.macholib dump' instead"
     )
     _main(print_file)
 

lib/spack/external/_vendoring/macholib/macho_standalone.py

@@ -3,8 +3,8 @@
 import os
 import sys
 
-from macholib.MachOStandalone import MachOStandalone
-from macholib.util import strip_files
+from _vendoring.macholib.MachOStandalone import MachOStandalone
+from _vendoring.macholib.util import strip_files
 
 
 def standaloneApp(path):
@@ -18,7 +18,7 @@ def standaloneApp(path):
 def main():
     print(
         "WARNING: 'macho_standalone' is deprecated, use "
-        "'python -mmacholib standalone' instead"
+        "'python -m_vendoring.macholib standalone' instead"
     )
     if not sys.argv[1:]:
         raise SystemExit("usage: %s [appbundle ...]" % (sys.argv[0],))

lib/spack/external/_vendoring/macholib/util.py

@@ -4,7 +4,7 @@
 import struct
 import sys
 
-from macholib import mach_o
+from _vendoring.macholib import mach_o
 
 MAGIC = [
     struct.pack("!L", getattr(mach_o, "MH_" + _))

lib/spack/external/_vendoring/markupsafe/__init__.py

@@ -4,7 +4,7 @@
 import typing as t
 
 if t.TYPE_CHECKING:
-    import typing_extensions as te
+    import _vendoring.typing_extensions as te
 
     class HasHTML(te.Protocol):
         def __html__(self) -> str:

lib/spack/external/_vendoring/pyrsistent/__init__.py

@@ -1,35 +1,35 @@
 # -*- coding: utf-8 -*-
 
-from pyrsistent._pmap import pmap, m, PMap
+from _vendoring.pyrsistent._pmap import pmap, m, PMap
 
-from pyrsistent._pvector import pvector, v, PVector
+from _vendoring.pyrsistent._pvector import pvector, v, PVector
 
-from pyrsistent._pset import pset, s, PSet
+from _vendoring.pyrsistent._pset import pset, s, PSet
 
-from pyrsistent._pbag import pbag, b, PBag
+from _vendoring.pyrsistent._pbag import pbag, b, PBag
 
-from pyrsistent._plist import plist, l, PList
+from _vendoring.pyrsistent._plist import plist, l, PList
 
-from pyrsistent._pdeque import pdeque, dq, PDeque
+from _vendoring.pyrsistent._pdeque import pdeque, dq, PDeque
 
-from pyrsistent._checked_types import (
+from _vendoring.pyrsistent._checked_types import (
     CheckedPMap, CheckedPVector, CheckedPSet, InvariantException, CheckedKeyTypeError,
     CheckedValueTypeError, CheckedType, optional)
 
-from pyrsistent._field_common import (
+from _vendoring.pyrsistent._field_common import (
     field, PTypeError, pset_field, pmap_field, pvector_field)
 
-from pyrsistent._precord import PRecord
+from _vendoring.pyrsistent._precord import PRecord
 
-from pyrsistent._pclass import PClass, PClassMeta
+from _vendoring.pyrsistent._pclass import PClass, PClassMeta
 
-from pyrsistent._immutable import immutable
+from _vendoring.pyrsistent._immutable import immutable
 
-from pyrsistent._helpers import freeze, thaw, mutant
+from _vendoring.pyrsistent._helpers import freeze, thaw, mutant
 
-from pyrsistent._transformations import inc, discard, rex, ny
+from _vendoring.pyrsistent._transformations import inc, discard, rex, ny
 
-from pyrsistent._toolz import get_in
+from _vendoring.pyrsistent._toolz import get_in
 
 
 __all__ = ('pmap', 'm', 'PMap',

lib/spack/external/_vendoring/pyrsistent/_checked_types.py

@@ -3,9 +3,9 @@
 from abc import abstractmethod, ABCMeta
 from collections.abc import Iterable
 
-from pyrsistent._pmap import PMap, pmap
-from pyrsistent._pset import PSet, pset
-from pyrsistent._pvector import PythonPVector, python_pvector
+from _vendoring.pyrsistent._pmap import PMap, pmap
+from _vendoring.pyrsistent._pset import PSet, pset
+from _vendoring.pyrsistent._pvector import PythonPVector, python_pvector
 
 
 class CheckedType(object):

lib/spack/external/_vendoring/pyrsistent/_field_common.py

@@ -1,6 +1,6 @@
 import sys
 
-from pyrsistent._checked_types import (
+from _vendoring.pyrsistent._checked_types import (
     CheckedPMap,
     CheckedPSet,
     CheckedPVector,
@@ -11,8 +11,8 @@
     maybe_parse_user_type,
     maybe_parse_many_user_types,
 )
-from pyrsistent._checked_types import optional as optional_type
-from pyrsistent._checked_types import wrap_invariant
+from _vendoring.pyrsistent._checked_types import optional as optional_type
+from _vendoring.pyrsistent._checked_types import wrap_invariant
 import inspect
 
 PY2 = sys.version_info[0] < 3

lib/spack/external/_vendoring/pyrsistent/_helpers.py

@@ -1,11 +1,11 @@
 from functools import wraps
-from pyrsistent._pmap import PMap, pmap
-from pyrsistent._pset import PSet, pset
-from pyrsistent._pvector import PVector, pvector
+from _vendoring.pyrsistent._pmap import PMap, pmap
+from _vendoring.pyrsistent._pset import PSet, pset
+from _vendoring.pyrsistent._pvector import PVector, pvector
 
 def freeze(o, strict=True):
     """
-    Recursively convert simple Python containers into pyrsistent versions
+    Recursively convert simple Python containers into _vendoring.pyrsistent versions
     of those containers.
 
     - list is converted to pvector, recursively
@@ -47,7 +47,7 @@ def freeze(o, strict=True):
 
 def thaw(o, strict=True):
     """
-    Recursively convert pyrsistent containers into simple Python containers.
+    Recursively convert _vendoring.pyrsistent containers into simple Python containers.
 
     - pvector is converted to list, recursively
     - pmap is converted to dict, recursively on values (but not keys)
@@ -59,7 +59,7 @@ def thaw(o, strict=True):
     - thaw is called on elements of lists
     - thaw is called on values in dicts
 
-    >>> from pyrsistent import s, m, v
+    >>> from _vendoring.pyrsistent import s, m, v
     >>> thaw(s(1, 2))
     {1, 2}
     >>> thaw(v(1, m(a=3)))

lib/spack/external/_vendoring/pyrsistent/_immutable.py

@@ -94,7 +94,7 @@ def set(self, **kwargs):
         print(template)
 
     from collections import namedtuple
-    namespace = dict(namedtuple=namedtuple, __name__='pyrsistent_immutable')
+    namespace = dict(namedtuple=namedtuple, __name__='_vendoring.pyrsistent_immutable')
     try:
         exec(template, namespace)
     except SyntaxError as e:

lib/spack/external/_vendoring/pyrsistent/_pbag.py

@@ -1,6 +1,6 @@
 from collections.abc import Container, Iterable, Sized, Hashable
 from functools import reduce
-from pyrsistent._pmap import pmap
+from _vendoring.pyrsistent._pmap import pmap
 
 
 def _add_to_counters(counters, element):

lib/spack/external/_vendoring/pyrsistent/_pclass.py

@@ -1,8 +1,8 @@
-from pyrsistent._checked_types import (InvariantException, CheckedType, _restore_pickle, store_invariants)
-from pyrsistent._field_common import (
+from _vendoring.pyrsistent._checked_types import (InvariantException, CheckedType, _restore_pickle, store_invariants)
+from _vendoring.pyrsistent._field_common import (
     set_fields, check_type, is_field_ignore_extra_complaint, PFIELD_NO_INITIAL, serialize, check_global_invariants
 )
-from pyrsistent._transformations import transform
+from _vendoring.pyrsistent._transformations import transform
 
 
 def _is_pclass(bases):
@@ -41,7 +41,7 @@ class PClass(CheckedType, metaclass=PClassMeta):
     is not a PMap and hence not a collection but rather a plain Python object.
 
 
-    More documentation and examples of PClass usage is available at https://github.com/tobgu/pyrsistent
+    More documentation and examples of PClass usage is available at https://github.com/tobgu/_vendoring.pyrsistent
     """
     def __new__(cls, **kwargs):    # Support *args?
         result = super(PClass, cls).__new__(cls)
@@ -84,7 +84,7 @@ def set(self, *args, **kwargs):
         Set a field in the instance. Returns a new instance with the updated value. The original instance remains
         unmodified. Accepts key-value pairs or single string representing the field name and a value.
 
-        >>> from pyrsistent import PClass, field
+        >>> from _vendoring.pyrsistent import PClass, field
         >>> class AClass(PClass):
         ...     x = field()
         ...

lib/spack/external/_vendoring/pyrsistent/_pdeque.py

@@ -1,7 +1,7 @@
 from collections.abc import Sequence, Hashable
 from itertools import islice, chain
 from numbers import Integral
-from pyrsistent._plist import plist
+from _vendoring.pyrsistent._plist import plist
 
 
 class PDeque(object):

lib/spack/external/_vendoring/pyrsistent/_pmap.py

@@ -1,7 +1,7 @@
 from collections.abc import Mapping, Hashable
 from itertools import chain
-from pyrsistent._pvector import pvector
-from pyrsistent._transformations import transform
+from _vendoring.pyrsistent._pvector import pvector
+from _vendoring.pyrsistent._transformations import transform
 
 
 class PMap(object):
@@ -256,7 +256,7 @@ def transform(self, *transformations):
         consists of two parts. One match expression that specifies which elements to transform
         and one transformation function that performs the actual transformation.
 
-        >>> from pyrsistent import freeze, ny
+        >>> from _vendoring.pyrsistent import freeze, ny
         >>> news_paper = freeze({'articles': [{'author': 'Sara', 'content': 'A short article'},
         ...                                   {'author': 'Steve', 'content': 'A slightly longer article'}],
         ...                      'weather': {'temperature': '11C', 'wind': '5m/s'}})

lib/spack/external/_vendoring/pyrsistent/_precord.py

@@ -1,8 +1,8 @@
-from pyrsistent._checked_types import CheckedType, _restore_pickle, InvariantException, store_invariants
-from pyrsistent._field_common import (
+from _vendoring.pyrsistent._checked_types import CheckedType, _restore_pickle, InvariantException, store_invariants
+from _vendoring.pyrsistent._field_common import (
     set_fields, check_type, is_field_ignore_extra_complaint, PFIELD_NO_INITIAL, serialize, check_global_invariants
 )
-from pyrsistent._pmap import PMap, pmap
+from _vendoring.pyrsistent._pmap import PMap, pmap
 
 
 class _PRecordMeta(type):
@@ -28,7 +28,7 @@ class PRecord(PMap, CheckedType, metaclass=_PRecordMeta):
     from PRecord. Because it is a PMap it has full support for all Mapping methods such as iteration and element
     access using subscript notation.
 
-    More documentation and examples of PRecord usage is available at https://github.com/tobgu/pyrsistent
+    More documentation and examples of PRecord usage is available at https://github.com/tobgu/_vendoring.pyrsistent
     """
     def __new__(cls, **kwargs):
         # Hack total! If these two special attributes exist that means we can create

lib/spack/external/_vendoring/pyrsistent/_pset.py

@@ -1,6 +1,6 @@
 from collections.abc import Set, Hashable
 import sys
-from pyrsistent._pmap import pmap
+from _vendoring.pyrsistent._pmap import pmap
 
 
 class PSet(object):

lib/spack/external/_vendoring/pyrsistent/_pvector.py

@@ -2,7 +2,7 @@
 from collections.abc import Sequence, Hashable
 from numbers import Integral
 import operator
-from pyrsistent._transformations import transform
+from _vendoring.pyrsistent._transformations import transform
 
 
 def _bitcount(val):
@@ -626,7 +626,7 @@ def transform(self, *transformations):
         consists of two parts. One match expression that specifies which elements to transform
         and one transformation function that performs the actual transformation.
 
-        >>> from pyrsistent import freeze, ny
+        >>> from _vendoring.pyrsistent import freeze, ny
         >>> news_paper = freeze({'articles': [{'author': 'Sara', 'content': 'A short article'},
         ...                                   {'author': 'Steve', 'content': 'A slightly longer article'}],
         ...                      'weather': {'temperature': '11C', 'wind': '5m/s'}})

lib/spack/external/_vendoring/pyrsistent/_toolz.py

@@ -56,7 +56,7 @@ def get_in(keys, coll, default=None, no_default=False):
 
     ``get_in`` is a generalization of ``operator.getitem`` for nested data
     structures such as dictionaries and lists.
-    >>> from pyrsistent import freeze
+    >>> from _vendoring.pyrsistent import freeze
     >>> transaction = freeze({'name': 'Alice',
     ...                       'purchase': {'items': ['Apple', 'Orange'],
     ...                                    'costs': [0.50, 1.25]},

lib/spack/external/_vendoring/pyrsistent/_transformations.py

@@ -117,7 +117,7 @@ def _get_arity(f):
 
 
 def _update_structure(structure, kvs, path, command):
-    from pyrsistent._pmap import pmap
+    from _vendoring.pyrsistent._pmap import pmap
     e = structure.evolver()
     if not path and command is discard:
         # Do this in reverse to avoid index problems with vectors. See #92.

lib/spack/external/_vendoring/pyrsistent/typing.py

@@ -5,8 +5,8 @@
 
 For example,
 
-    from pyrsistent import pvector
-    from pyrsistent.typing import PVector
+    from _vendoring.pyrsistent import pvector
+    from _vendoring.pyrsistent.typing import PVector
 
     myvector: PVector[str] = pvector(['a', 'b', 'c'])
 

lib/spack/external/_vendoring/ruamel/yaml/__init__.py

@@ -4,18 +4,18 @@
     from typing import Dict, Any  # NOQA
 
 _package_data = dict(
-    full_package_name='ruamel.yaml',
+    full_package_name='_vendoring.ruamel.yaml',
     version_info=(0, 17, 21),
     __version__='0.17.21',
     version_timestamp='2022-02-12 09:49:22',
     author='Anthon van der Neut',
     author_email='a.van.der.neut@ruamel.eu',
-    description='ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order',  # NOQA
+    description='_vendoring.ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order',  # NOQA
     entry_points=None,
     since=2014,
     extras_require={
-        ':platform_python_implementation=="CPython" and python_version<"3.11"': ['ruamel.yaml.clib>=0.2.6'],  # NOQA
-        'jinja2': ['ruamel.yaml.jinja2>=0.2'],
+        ':platform_python_implementation=="CPython" and python_version<"3.11"': ['_vendoring.ruamel.yaml.clib>=0.2.6'],  # NOQA
+        '_vendoring.jinja2': ['_vendoring.ruamel.yaml._vendoring.jinja2>=0.2'],
         'docs': ['ryd'],
     },
     classifiers=[
@@ -54,4 +54,4 @@
 except (ImportError, ValueError):  # for Jython
     __with_libyaml__ = False
 
-from ruamel.yaml.main import *  # NOQA
+from _vendoring.ruamel.yaml.main import *  # NOQA

lib/spack/external/_vendoring/ruamel/yaml/comments.py

@@ -10,10 +10,10 @@
 import copy
 
 
-from ruamel.yaml.compat import ordereddict
-from ruamel.yaml.compat import MutableSliceableSequence, _F, nprintf  # NOQA
-from ruamel.yaml.scalarstring import ScalarString
-from ruamel.yaml.anchor import Anchor
+from _vendoring.ruamel.yaml.compat import ordereddict
+from _vendoring.ruamel.yaml.compat import MutableSliceableSequence, _F, nprintf  # NOQA
+from _vendoring.ruamel.yaml.scalarstring import ScalarString
+from _vendoring.ruamel.yaml.anchor import Anchor
 
 from collections.abc import MutableSet, Sized, Set, Mapping
 
@@ -375,8 +375,8 @@ def yaml_set_comment_before_after_key(
         """
         expects comment (before/after) to be without `#` and possible have multiple lines
         """
-        from ruamel.yaml.error import CommentMark
-        from ruamel.yaml.tokens import CommentToken
+        from _vendoring.ruamel.yaml.error import CommentMark
+        from _vendoring.ruamel.yaml.tokens import CommentToken
 
         def comment_token(s, mark):
             # type: (Any, Any) -> Any

lib/spack/external/_vendoring/ruamel/yaml/compat.py

@@ -169,7 +169,7 @@ def fp(self, mode='a'):
 
 
 nprint = Nprint()
-nprintf = Nprint('/var/tmp/ruamel.yaml.log')
+nprintf = Nprint('/var/tmp/_vendoring.ruamel.yaml.log')
 
 # char checkers following production rules
 
@@ -197,9 +197,9 @@ def check_anchorname_char(ch):
 def version_tnf(t1, t2=None):
     # type: (Any, Any) -> Any
     """
-    return True if ruamel.yaml version_info < t1, None if t2 is specified and bigger else False
+    return True if _vendoring.ruamel.yaml version_info < t1, None if t2 is specified and bigger else False
     """
-    from ruamel.yaml import version_info  # NOQA
+    from _vendoring.ruamel.yaml import version_info  # NOQA
 
     if version_info < t1:
         return True

lib/spack/external/_vendoring/ruamel/yaml/composer.py

@@ -2,10 +2,10 @@
 
 import warnings
 
-from ruamel.yaml.error import MarkedYAMLError, ReusedAnchorWarning
-from ruamel.yaml.compat import _F, nprint, nprintf  # NOQA
+from _vendoring.ruamel.yaml.error import MarkedYAMLError, ReusedAnchorWarning
+from _vendoring.ruamel.yaml.compat import _F, nprint, nprintf  # NOQA
 
-from ruamel.yaml.events import (
+from _vendoring.ruamel.yaml.events import (
     StreamStartEvent,
     StreamEndEvent,
     MappingStartEvent,
@@ -15,7 +15,7 @@
     AliasEvent,
     ScalarEvent,
 )
-from ruamel.yaml.nodes import MappingNode, ScalarNode, SequenceNode
+from _vendoring.ruamel.yaml.nodes import MappingNode, ScalarNode, SequenceNode
 
 if False:  # MYPY
     from typing import Any, Dict, Optional, List  # NOQA

lib/spack/external/_vendoring/ruamel/yaml/configobjwalker.py

@@ -2,7 +2,7 @@
 
 import warnings
 
-from ruamel.yaml.util import configobj_walker as new_configobj_walker
+from _vendoring.ruamel.yaml.util import configobj_walker as new_configobj_walker
 
 if False:  # MYPY
     from typing import Any  # NOQA
@@ -10,5 +10,5 @@
 
 def configobj_walker(cfg):
     # type: (Any) -> Any
-    warnings.warn('configobj_walker has moved to ruamel.yaml.util, please update your code')
+    warnings.warn('configobj_walker has moved to _vendoring.ruamel.yaml.util, please update your code')
     return new_configobj_walker(cfg)

lib/spack/external/_vendoring/ruamel/yaml/constructor.py

@@ -9,29 +9,29 @@
 from collections.abc import Hashable, MutableSequence, MutableMapping
 
 # fmt: off
-from ruamel.yaml.error import (MarkedYAMLError, MarkedYAMLFutureWarning,
+from _vendoring.ruamel.yaml.error import (MarkedYAMLError, MarkedYAMLFutureWarning,
                                MantissaNoDotYAML1_1Warning)
-from ruamel.yaml.nodes import *                               # NOQA
-from ruamel.yaml.nodes import (SequenceNode, MappingNode, ScalarNode)
-from ruamel.yaml.compat import (_F, builtins_module, # NOQA
+from _vendoring.ruamel.yaml.nodes import *                               # NOQA
+from _vendoring.ruamel.yaml.nodes import (SequenceNode, MappingNode, ScalarNode)
+from _vendoring.ruamel.yaml.compat import (_F, builtins_module, # NOQA
                                 nprint, nprintf, version_tnf)
-from ruamel.yaml.compat import ordereddict
+from _vendoring.ruamel.yaml.compat import ordereddict
 
-from ruamel.yaml.comments import *                               # NOQA
-from ruamel.yaml.comments import (CommentedMap, CommentedOrderedMap, CommentedSet,
+from _vendoring.ruamel.yaml.comments import *                               # NOQA
+from _vendoring.ruamel.yaml.comments import (CommentedMap, CommentedOrderedMap, CommentedSet,
                                   CommentedKeySeq, CommentedSeq, TaggedScalar,
                                   CommentedKeyMap,
                                   C_KEY_PRE, C_KEY_EOL, C_KEY_POST,
                                   C_VALUE_PRE, C_VALUE_EOL, C_VALUE_POST,
                                   )
-from ruamel.yaml.scalarstring import (SingleQuotedScalarString, DoubleQuotedScalarString,
+from _vendoring.ruamel.yaml.scalarstring import (SingleQuotedScalarString, DoubleQuotedScalarString,
                                       LiteralScalarString, FoldedScalarString,
                                       PlainScalarString, ScalarString,)
-from ruamel.yaml.scalarint import ScalarInt, BinaryInt, OctalInt, HexInt, HexCapsInt
-from ruamel.yaml.scalarfloat import ScalarFloat
-from ruamel.yaml.scalarbool import ScalarBoolean
-from ruamel.yaml.timestamp import TimeStamp
-from ruamel.yaml.util import timestamp_regexp, create_timestamp
+from _vendoring.ruamel.yaml.scalarint import ScalarInt, BinaryInt, OctalInt, HexInt, HexCapsInt
+from _vendoring.ruamel.yaml.scalarfloat import ScalarFloat
+from _vendoring.ruamel.yaml.scalarbool import ScalarBoolean
+from _vendoring.ruamel.yaml.timestamp import TimeStamp
+from _vendoring.ruamel.yaml.util import timestamp_regexp, create_timestamp
 
 if False:  # MYPY
     from typing import Any, Dict, List, Set, Generator, Union, Optional  # NOQA
@@ -1282,7 +1282,7 @@ def construct_rt_sequence(self, node, seqtyp, deep=False):
             if node.comment:
                 nprintf('nc3', node.comment)
         if node.anchor:
-            from ruamel.yaml.serializer import templated_id
+            from _vendoring.ruamel.yaml.serializer import templated_id
 
             if not templated_id(node.anchor):
                 seqtyp.yaml_set_anchor(node.anchor)
@@ -1418,7 +1418,7 @@ def construct_mapping(self, node, maptyp, deep=False):  # type: ignore
                 for cmnt in self.comments(node.comment, 0):
                     maptyp.ca.pre.append(cmnt)
         if node.anchor:
-            from ruamel.yaml.serializer import templated_id
+            from _vendoring.ruamel.yaml.serializer import templated_id
 
             if not templated_id(node.anchor):
                 maptyp.yaml_set_anchor(node.anchor)
@@ -1517,7 +1517,7 @@ def construct_setting(self, node, typ, deep=False):
             if node.comment:
                 nprintf('nc6', node.comment)
         if node.anchor:
-            from ruamel.yaml.serializer import templated_id
+            from _vendoring.ruamel.yaml.serializer import templated_id
 
             if not templated_id(node.anchor):
                 typ.yaml_set_anchor(node.anchor)
@@ -1592,8 +1592,8 @@ def construct_yaml_object(self, node, cls):
             else:
                 data.__dict__.update(state)
         if node.anchor:
-            from ruamel.yaml.serializer import templated_id
-            from ruamel.yaml.anchor import Anchor
+            from _vendoring.ruamel.yaml.serializer import templated_id
+            from _vendoring.ruamel.yaml.anchor import Anchor
 
             if not templated_id(node.anchor):
                 if not hasattr(data, Anchor.attrib):
@@ -1691,7 +1691,7 @@ def construct_undefined(self, node):
                 data.yaml_set_tag(node.tag)
                 yield data
                 if node.anchor:
-                    from ruamel.yaml.serializer import templated_id
+                    from _vendoring.ruamel.yaml.serializer import templated_id
 
                     if not templated_id(node.anchor):
                         data.yaml_set_anchor(node.anchor)
@@ -1704,7 +1704,7 @@ def construct_undefined(self, node):
                 data2.yaml_set_tag(node.tag)
                 yield data2
                 if node.anchor:
-                    from ruamel.yaml.serializer import templated_id
+                    from _vendoring.ruamel.yaml.serializer import templated_id
 
                     if not templated_id(node.anchor):
                         data2.yaml_set_anchor(node.anchor, always_dump=True)
@@ -1719,7 +1719,7 @@ def construct_undefined(self, node):
                 data3.yaml_set_tag(node.tag)
                 yield data3
                 if node.anchor:
-                    from ruamel.yaml.serializer import templated_id
+                    from _vendoring.ruamel.yaml.serializer import templated_id
 
                     if not templated_id(node.anchor):
                         data3.yaml_set_anchor(node.anchor)

lib/spack/external/_vendoring/ruamel/yaml/cyaml.py

@@ -1,14 +1,14 @@
 # coding: utf-8
 
-from _ruamel_yaml import CParser, CEmitter  # type: ignore
+from __vendoring.ruamel.yaml import CParser, CEmitter  # type: ignore
 
-from ruamel.yaml.constructor import Constructor, BaseConstructor, SafeConstructor
-from ruamel.yaml.representer import Representer, SafeRepresenter, BaseRepresenter
-from ruamel.yaml.resolver import Resolver, BaseResolver
+from _vendoring.ruamel.yaml.constructor import Constructor, BaseConstructor, SafeConstructor
+from _vendoring.ruamel.yaml.representer import Representer, SafeRepresenter, BaseRepresenter
+from _vendoring.ruamel.yaml.resolver import Resolver, BaseResolver
 
 if False:  # MYPY
     from typing import Any, Union, Optional  # NOQA
-    from ruamel.yaml.compat import StreamTextType, StreamType, VersionType  # NOQA
+    from _vendoring.ruamel.yaml.compat import StreamTextType, StreamType, VersionType  # NOQA
 
 __all__ = ['CBaseLoader', 'CSafeLoader', 'CLoader', 'CBaseDumper', 'CSafeDumper', 'CDumper']
 

lib/spack/external/_vendoring/ruamel/yaml/dumper.py

@@ -1,18 +1,18 @@
 # coding: utf-8
 
-from ruamel.yaml.emitter import Emitter
-from ruamel.yaml.serializer import Serializer
-from ruamel.yaml.representer import (
+from _vendoring.ruamel.yaml.emitter import Emitter
+from _vendoring.ruamel.yaml.serializer import Serializer
+from _vendoring.ruamel.yaml.representer import (
     Representer,
     SafeRepresenter,
     BaseRepresenter,
     RoundTripRepresenter,
 )
-from ruamel.yaml.resolver import Resolver, BaseResolver, VersionedResolver
+from _vendoring.ruamel.yaml.resolver import Resolver, BaseResolver, VersionedResolver
 
 if False:  # MYPY
     from typing import Any, Dict, List, Union, Optional  # NOQA
-    from ruamel.yaml.compat import StreamType, VersionType  # NOQA
+    from _vendoring.ruamel.yaml.compat import StreamType, VersionType  # NOQA
 
 __all__ = ['BaseDumper', 'SafeDumper', 'Dumper', 'RoundTripDumper']
 

lib/spack/external/_vendoring/ruamel/yaml/emitter.py

@@ -8,17 +8,17 @@
 # mapping ::= MAPPING-START (node node)* MAPPING-END
 
 import sys
-from ruamel.yaml.error import YAMLError, YAMLStreamError
-from ruamel.yaml.events import *  # NOQA
+from _vendoring.ruamel.yaml.error import YAMLError, YAMLStreamError
+from _vendoring.ruamel.yaml.events import *  # NOQA
 
 # fmt: off
-from ruamel.yaml.compat import _F, nprint, dbg, DBG_EVENT, \
+from _vendoring.ruamel.yaml.compat import _F, nprint, dbg, DBG_EVENT, \
     check_anchorname_char, nprintf  # NOQA
 # fmt: on
 
 if False:  # MYPY
     from typing import Any, Dict, List, Union, Text, Tuple, Optional  # NOQA
-    from ruamel.yaml.compat import StreamType  # NOQA
+    from _vendoring.ruamel.yaml.compat import StreamType  # NOQA
 
 __all__ = ['Emitter', 'EmitterError']
 

lib/spack/external/_vendoring/ruamel/yaml/error.py

@@ -3,7 +3,7 @@
 import warnings
 import textwrap
 
-from ruamel.yaml.compat import _F
+from _vendoring.ruamel.yaml.compat import _F
 
 if False:  # MYPY
     from typing import Any, Dict, Optional, List, Text  # NOQA
@@ -240,11 +240,11 @@ class ReusedAnchorWarning(YAMLWarning):
 class UnsafeLoaderWarning(YAMLWarning):
     text = """
 The default 'Loader' for 'load(stream)' without further arguments can be unsafe.
-Use 'load(stream, Loader=ruamel.yaml.Loader)' explicitly if that is OK.
+Use 'load(stream, Loader=_vendoring.ruamel.yaml.Loader)' explicitly if that is OK.
 Alternatively include the following in your code:
 
   import warnings
-  warnings.simplefilter('ignore', ruamel.yaml.error.UnsafeLoaderWarning)
+  warnings.simplefilter('ignore', _vendoring.ruamel.yaml.error.UnsafeLoaderWarning)
 
 In most other cases you should consider using 'safe_load(stream)'"""
     pass
@@ -273,7 +273,7 @@ def __str__(self):
 or alternatively include the following in your code:
 
   import warnings
-  warnings.simplefilter('ignore', ruamel.yaml.error.MantissaNoDotYAML1_1Warning)
+  warnings.simplefilter('ignore', _vendoring.ruamel.yaml.error.MantissaNoDotYAML1_1Warning)
 
 """.format(
             self.flt, line, col

lib/spack/external/_vendoring/ruamel/yaml/events.py

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-from ruamel.yaml.compat import _F
+from _vendoring.ruamel.yaml.compat import _F
 
 # Abstract classes.
 

lib/spack/external/_vendoring/ruamel/yaml/loader.py

@@ -1,20 +1,20 @@
 # coding: utf-8
 
-from ruamel.yaml.reader import Reader
-from ruamel.yaml.scanner import Scanner, RoundTripScanner
-from ruamel.yaml.parser import Parser, RoundTripParser
-from ruamel.yaml.composer import Composer
-from ruamel.yaml.constructor import (
+from _vendoring.ruamel.yaml.reader import Reader
+from _vendoring.ruamel.yaml.scanner import Scanner, RoundTripScanner
+from _vendoring.ruamel.yaml.parser import Parser, RoundTripParser
+from _vendoring.ruamel.yaml.composer import Composer
+from _vendoring.ruamel.yaml.constructor import (
     BaseConstructor,
     SafeConstructor,
     Constructor,
     RoundTripConstructor,
 )
-from ruamel.yaml.resolver import VersionedResolver
+from _vendoring.ruamel.yaml.resolver import VersionedResolver
 
 if False:  # MYPY
     from typing import Any, Dict, List, Union, Optional  # NOQA
-    from ruamel.yaml.compat import StreamTextType, VersionType  # NOQA
+    from _vendoring.ruamel.yaml.compat import StreamTextType, VersionType  # NOQA
 
 __all__ = ['BaseLoader', 'SafeLoader', 'Loader', 'RoundTripLoader']
 

lib/spack/external/_vendoring/ruamel/yaml/main.py

@@ -7,39 +7,39 @@
 from importlib import import_module
 
 
-import ruamel.yaml
-from ruamel.yaml.error import UnsafeLoaderWarning, YAMLError  # NOQA
+import _vendoring.ruamel.yaml
+from _vendoring.ruamel.yaml.error import UnsafeLoaderWarning, YAMLError  # NOQA
 
-from ruamel.yaml.tokens import *  # NOQA
-from ruamel.yaml.events import *  # NOQA
-from ruamel.yaml.nodes import *  # NOQA
+from _vendoring.ruamel.yaml.tokens import *  # NOQA
+from _vendoring.ruamel.yaml.events import *  # NOQA
+from _vendoring.ruamel.yaml.nodes import *  # NOQA
 
-from ruamel.yaml.loader import BaseLoader, SafeLoader, Loader, RoundTripLoader  # NOQA
-from ruamel.yaml.dumper import BaseDumper, SafeDumper, Dumper, RoundTripDumper  # NOQA
-from ruamel.yaml.compat import StringIO, BytesIO, with_metaclass, nprint, nprintf  # NOQA
-from ruamel.yaml.resolver import VersionedResolver, Resolver  # NOQA
-from ruamel.yaml.representer import (
+from _vendoring.ruamel.yaml.loader import BaseLoader, SafeLoader, Loader, RoundTripLoader  # NOQA
+from _vendoring.ruamel.yaml.dumper import BaseDumper, SafeDumper, Dumper, RoundTripDumper  # NOQA
+from _vendoring.ruamel.yaml.compat import StringIO, BytesIO, with_metaclass, nprint, nprintf  # NOQA
+from _vendoring.ruamel.yaml.resolver import VersionedResolver, Resolver  # NOQA
+from _vendoring.ruamel.yaml.representer import (
     BaseRepresenter,
     SafeRepresenter,
     Representer,
     RoundTripRepresenter,
 )
-from ruamel.yaml.constructor import (
+from _vendoring.ruamel.yaml.constructor import (
     BaseConstructor,
     SafeConstructor,
     Constructor,
     RoundTripConstructor,
 )
-from ruamel.yaml.loader import Loader as UnsafeLoader
-from ruamel.yaml.comments import CommentedMap, CommentedSeq, C_PRE
+from _vendoring.ruamel.yaml.loader import Loader as UnsafeLoader
+from _vendoring.ruamel.yaml.comments import CommentedMap, CommentedSeq, C_PRE
 
 if False:  # MYPY
     from typing import List, Set, Dict, Union, Any, Callable, Optional, Text  # NOQA
-    from ruamel.yaml.compat import StreamType, StreamTextType, VersionType  # NOQA
+    from _vendoring.ruamel.yaml.compat import StreamType, StreamTextType, VersionType  # NOQA
     from pathlib import Path
 
 try:
-    from _ruamel_yaml import CParser, CEmitter  # type: ignore
+    from __vendoring.ruamel.yaml import CParser, CEmitter  # type: ignore
 except:  # NOQA
     CParser = CEmitter = None
 
@@ -74,7 +74,7 @@ def __init__(self, *, typ=None, pure=False, output=None, plug_ins=None):  # inpu
         for pu in ([] if plug_ins is None else plug_ins) + self.official_plug_ins():
             file_name = pu.replace(os.sep, '.')
             self.plug_ins.append(import_module(file_name))
-        self.Resolver = ruamel.yaml.resolver.VersionedResolver  # type: Any
+        self.Resolver = _vendoring.ruamel.yaml.resolver.VersionedResolver  # type: Any
         self.allow_unicode = True
         self.Reader = None  # type: Any
         self.Representer = None  # type: Any
@@ -89,37 +89,37 @@ def __init__(self, *, typ=None, pure=False, output=None, plug_ins=None):  # inpu
             setup_rt = True
         elif 'safe' in self.typ:
             self.Emitter = (
-                ruamel.yaml.emitter.Emitter if pure or CEmitter is None else CEmitter
+                _vendoring.ruamel.yaml.emitter.Emitter if pure or CEmitter is None else CEmitter
             )
-            self.Representer = ruamel.yaml.representer.SafeRepresenter
-            self.Parser = ruamel.yaml.parser.Parser if pure or CParser is None else CParser
-            self.Composer = ruamel.yaml.composer.Composer
-            self.Constructor = ruamel.yaml.constructor.SafeConstructor
+            self.Representer = _vendoring.ruamel.yaml.representer.SafeRepresenter
+            self.Parser = _vendoring.ruamel.yaml.parser.Parser if pure or CParser is None else CParser
+            self.Composer = _vendoring.ruamel.yaml.composer.Composer
+            self.Constructor = _vendoring.ruamel.yaml.constructor.SafeConstructor
         elif 'base' in self.typ:
-            self.Emitter = ruamel.yaml.emitter.Emitter
-            self.Representer = ruamel.yaml.representer.BaseRepresenter
-            self.Parser = ruamel.yaml.parser.Parser if pure or CParser is None else CParser
-            self.Composer = ruamel.yaml.composer.Composer
-            self.Constructor = ruamel.yaml.constructor.BaseConstructor
+            self.Emitter = _vendoring.ruamel.yaml.emitter.Emitter
+            self.Representer = _vendoring.ruamel.yaml.representer.BaseRepresenter
+            self.Parser = _vendoring.ruamel.yaml.parser.Parser if pure or CParser is None else CParser
+            self.Composer = _vendoring.ruamel.yaml.composer.Composer
+            self.Constructor = _vendoring.ruamel.yaml.constructor.BaseConstructor
         elif 'unsafe' in self.typ:
             self.Emitter = (
-                ruamel.yaml.emitter.Emitter if pure or CEmitter is None else CEmitter
+                _vendoring.ruamel.yaml.emitter.Emitter if pure or CEmitter is None else CEmitter
             )
-            self.Representer = ruamel.yaml.representer.Representer
-            self.Parser = ruamel.yaml.parser.Parser if pure or CParser is None else CParser
-            self.Composer = ruamel.yaml.composer.Composer
-            self.Constructor = ruamel.yaml.constructor.Constructor
+            self.Representer = _vendoring.ruamel.yaml.representer.Representer
+            self.Parser = _vendoring.ruamel.yaml.parser.Parser if pure or CParser is None else CParser
+            self.Composer = _vendoring.ruamel.yaml.composer.Composer
+            self.Constructor = _vendoring.ruamel.yaml.constructor.Constructor
         elif 'rtsc' in self.typ:
             self.default_flow_style = False
             # no optimized rt-dumper yet
-            self.Emitter = ruamel.yaml.emitter.Emitter
-            self.Serializer = ruamel.yaml.serializer.Serializer
-            self.Representer = ruamel.yaml.representer.RoundTripRepresenter
-            self.Scanner = ruamel.yaml.scanner.RoundTripScannerSC
+            self.Emitter = _vendoring.ruamel.yaml.emitter.Emitter
+            self.Serializer = _vendoring.ruamel.yaml.serializer.Serializer
+            self.Representer = _vendoring.ruamel.yaml.representer.RoundTripRepresenter
+            self.Scanner = _vendoring.ruamel.yaml.scanner.RoundTripScannerSC
             # no optimized rt-parser yet
-            self.Parser = ruamel.yaml.parser.RoundTripParserSC
-            self.Composer = ruamel.yaml.composer.Composer
-            self.Constructor = ruamel.yaml.constructor.RoundTripConstructor
+            self.Parser = _vendoring.ruamel.yaml.parser.RoundTripParserSC
+            self.Composer = _vendoring.ruamel.yaml.composer.Composer
+            self.Constructor = _vendoring.ruamel.yaml.constructor.RoundTripConstructor
             self.comment_handling = C_PRE
         else:
             setup_rt = True
@@ -127,14 +127,14 @@ def __init__(self, *, typ=None, pure=False, output=None, plug_ins=None):  # inpu
         if setup_rt:
             self.default_flow_style = False
             # no optimized rt-dumper yet
-            self.Emitter = ruamel.yaml.emitter.Emitter
-            self.Serializer = ruamel.yaml.serializer.Serializer
-            self.Representer = ruamel.yaml.representer.RoundTripRepresenter
-            self.Scanner = ruamel.yaml.scanner.RoundTripScanner
+            self.Emitter = _vendoring.ruamel.yaml.emitter.Emitter
+            self.Serializer = _vendoring.ruamel.yaml.serializer.Serializer
+            self.Representer = _vendoring.ruamel.yaml.representer.RoundTripRepresenter
+            self.Scanner = _vendoring.ruamel.yaml.scanner.RoundTripScanner
             # no optimized rt-parser yet
-            self.Parser = ruamel.yaml.parser.RoundTripParser
-            self.Composer = ruamel.yaml.composer.Composer
-            self.Constructor = ruamel.yaml.constructor.RoundTripConstructor
+            self.Parser = _vendoring.ruamel.yaml.parser.RoundTripParser
+            self.Composer = _vendoring.ruamel.yaml.composer.Composer
+            self.Constructor = _vendoring.ruamel.yaml.constructor.RoundTripConstructor
         del setup_rt
         self.stream = None
         self.canonical = None
@@ -477,20 +477,20 @@ def get_constructor_parser(self, stream):
         """
         if self.Parser is not CParser:
             if self.Reader is None:
-                self.Reader = ruamel.yaml.reader.Reader
+                self.Reader = _vendoring.ruamel.yaml.reader.Reader
             if self.Scanner is None:
-                self.Scanner = ruamel.yaml.scanner.Scanner
+                self.Scanner = _vendoring.ruamel.yaml.scanner.Scanner
             self.reader.stream = stream
         else:
             if self.Reader is not None:
                 if self.Scanner is None:
-                    self.Scanner = ruamel.yaml.scanner.Scanner
-                self.Parser = ruamel.yaml.parser.Parser
+                    self.Scanner = _vendoring.ruamel.yaml.scanner.Scanner
+                self.Parser = _vendoring.ruamel.yaml.parser.Parser
                 self.reader.stream = stream
             elif self.Scanner is not None:
                 if self.Reader is None:
-                    self.Reader = ruamel.yaml.reader.Reader
-                self.Parser = ruamel.yaml.parser.Parser
+                    self.Reader = _vendoring.ruamel.yaml.reader.Reader
+                self.Parser = _vendoring.ruamel.yaml.parser.Parser
                 self.reader.stream = stream
             else:
                 # combined C level reader>scanner>parser
@@ -498,8 +498,8 @@ def get_constructor_parser(self, stream):
                 # if you just initialise the CParser, to much of resolver.py
                 # is actually used
                 rslvr = self.Resolver
-                # if rslvr is ruamel.yaml.resolver.VersionedResolver:
-                #     rslvr = ruamel.yaml.resolver.Resolver
+                # if rslvr is _vendoring.ruamel.yaml.resolver.VersionedResolver:
+                #     rslvr = _vendoring.ruamel.yaml.resolver.Resolver
 
                 class XLoader(self.Parser, self.Constructor, rslvr):  # type: ignore
                     def __init__(selfx, stream, version=self.version, preserve_quotes=None):
@@ -640,7 +640,7 @@ def get_serializer_representer_emitter(self, stream, tlca):
         # we have only .Serializer to deal with (vs .Reader & .Scanner), much simpler
         if self.Emitter is not CEmitter:
             if self.Serializer is None:
-                self.Serializer = ruamel.yaml.serializer.Serializer
+                self.Serializer = _vendoring.ruamel.yaml.serializer.Serializer
             self.emitter.stream = stream
             self.emitter.top_level_colon_align = tlca
             if self.scalar_after_indicator is not None:
@@ -648,7 +648,7 @@ def get_serializer_representer_emitter(self, stream, tlca):
             return self.serializer, self.representer, self.emitter
         if self.Serializer is not None:
             # cannot set serializer with CEmitter
-            self.Emitter = ruamel.yaml.emitter.Emitter
+            self.Emitter = _vendoring.ruamel.yaml.emitter.Emitter
             self.emitter.stream = stream
             self.emitter.top_level_colon_align = tlca
             if self.scalar_after_indicator is not None:
@@ -657,9 +657,9 @@ def get_serializer_representer_emitter(self, stream, tlca):
         # C routines
 
         rslvr = (
-            ruamel.yaml.resolver.BaseResolver
+            _vendoring.ruamel.yaml.resolver.BaseResolver
             if 'base' in self.typ
-            else ruamel.yaml.resolver.Resolver
+            else _vendoring.ruamel.yaml.resolver.Resolver
         )
 
         class XDumper(CEmitter, self.Representer, rslvr):  # type: ignore
@@ -743,7 +743,7 @@ def official_plug_ins(self):
         single file installers that are not properly emulating a file-system (issue 324)
         no plug-ins will be found. If any are packaged, you know which file that are
         and you can explicitly provide it during instantiation:
-            yaml = ruamel.yaml.YAML(plug_ins=['ruamel/yaml/jinja2/__plug_in__'])
+            yaml = _vendoring.ruamel.yaml.YAML(plug_ins=['_vendoring.ruamel.yaml/_vendoring.jinja2/__plug_in__'])
         """
         try:
             bd = os.path.dirname(__file__)
@@ -982,7 +982,7 @@ def f_y(constructor, node):
 ########################################################################################
 def warn_deprecation(fun, method, arg=''):
     # type: (Any, Any, str) -> None
-    from ruamel.yaml.compat import _F
+    from _vendoring.ruamel.yaml.compat import _F
 
     warnings.warn(
         _F(
@@ -1469,7 +1469,7 @@ def add_implicit_resolver(
         if hasattr(Loader, 'add_implicit_resolver'):
             Loader.add_implicit_resolver(tag, regexp, first)
         elif issubclass(
-            Loader, (BaseLoader, SafeLoader, ruamel.yaml.loader.Loader, RoundTripLoader)
+            Loader, (BaseLoader, SafeLoader, _vendoring.ruamel.yaml.loader.Loader, RoundTripLoader)
         ):
             Resolver.add_implicit_resolver(tag, regexp, first)
         else:
@@ -1478,7 +1478,7 @@ def add_implicit_resolver(
         if hasattr(Dumper, 'add_implicit_resolver'):
             Dumper.add_implicit_resolver(tag, regexp, first)
         elif issubclass(
-            Dumper, (BaseDumper, SafeDumper, ruamel.yaml.dumper.Dumper, RoundTripDumper)
+            Dumper, (BaseDumper, SafeDumper, _vendoring.ruamel.yaml.dumper.Dumper, RoundTripDumper)
         ):
             Resolver.add_implicit_resolver(tag, regexp, first)
         else:
@@ -1501,7 +1501,7 @@ def add_path_resolver(tag, path, kind=None, Loader=None, Dumper=None, resolver=R
         if hasattr(Loader, 'add_path_resolver'):
             Loader.add_path_resolver(tag, path, kind)
         elif issubclass(
-            Loader, (BaseLoader, SafeLoader, ruamel.yaml.loader.Loader, RoundTripLoader)
+            Loader, (BaseLoader, SafeLoader, _vendoring.ruamel.yaml.loader.Loader, RoundTripLoader)
         ):
             Resolver.add_path_resolver(tag, path, kind)
         else:
@@ -1510,7 +1510,7 @@ def add_path_resolver(tag, path, kind=None, Loader=None, Dumper=None, resolver=R
         if hasattr(Dumper, 'add_path_resolver'):
             Dumper.add_path_resolver(tag, path, kind)
         elif issubclass(
-            Dumper, (BaseDumper, SafeDumper, ruamel.yaml.dumper.Dumper, RoundTripDumper)
+            Dumper, (BaseDumper, SafeDumper, _vendoring.ruamel.yaml.dumper.Dumper, RoundTripDumper)
         ):
             Resolver.add_path_resolver(tag, path, kind)
         else:
@@ -1560,7 +1560,7 @@ def add_multi_constructor(tag_prefix, multi_constructor, Loader=None, constructo
             BaseConstructor.add_multi_constructor(tag_prefix, multi_constructor)
         elif issubclass(Loader, SafeLoader):
             SafeConstructor.add_multi_constructor(tag_prefix, multi_constructor)
-        elif issubclass(Loader, ruamel.yaml.loader.Loader):
+        elif issubclass(Loader, _vendoring.ruamel.yaml.loader.Loader):
             Constructor.add_multi_constructor(tag_prefix, multi_constructor)
         elif issubclass(Loader, RoundTripLoader):
             RoundTripConstructor.add_multi_constructor(tag_prefix, multi_constructor)

lib/spack/external/_vendoring/ruamel/yaml/nodes.py

@@ -2,7 +2,7 @@
 
 import sys
 
-from ruamel.yaml.compat import _F
+from _vendoring.ruamel.yaml.compat import _F
 
 if False:  # MYPY
     from typing import Dict, Any, Text  # NOQA

lib/spack/external/_vendoring/ruamel/yaml/parser.py

@@ -74,13 +74,13 @@
 # and for Jython too
 
 
-from ruamel.yaml.error import MarkedYAMLError
-from ruamel.yaml.tokens import *  # NOQA
-from ruamel.yaml.events import *  # NOQA
-from ruamel.yaml.scanner import Scanner, RoundTripScanner, ScannerError  # NOQA
-from ruamel.yaml.scanner import BlankLineComment
-from ruamel.yaml.comments import C_PRE, C_POST, C_SPLIT_ON_FIRST_BLANK
-from ruamel.yaml.compat import _F, nprint, nprintf  # NOQA
+from _vendoring.ruamel.yaml.error import MarkedYAMLError
+from _vendoring.ruamel.yaml.tokens import *  # NOQA
+from _vendoring.ruamel.yaml.events import *  # NOQA
+from _vendoring.ruamel.yaml.scanner import Scanner, RoundTripScanner, ScannerError  # NOQA
+from _vendoring.ruamel.yaml.scanner import BlankLineComment
+from _vendoring.ruamel.yaml.comments import C_PRE, C_POST, C_SPLIT_ON_FIRST_BLANK
+from _vendoring.ruamel.yaml.compat import _F, nprint, nprintf  # NOQA
 
 if False:  # MYPY
     from typing import Any, Dict, Optional, List, Optional  # NOQA