Skip to content

Commit

Permalink
Query PyPI to find versions to test
Browse files Browse the repository at this point in the history
The logic we actually want for versions to test is "find the versions
that _should_ be installable", rather than "try it and see"; the latter
is susceptible to silently suppressing errors.  This new form now
queries PyPI to find what versions of Qiskit are available in binary
distributions for this platform, and filters based on that.
  • Loading branch information
jakelishman committed Sep 23, 2024
1 parent 3c08d44 commit c45dc04
Show file tree
Hide file tree
Showing 4 changed files with 123 additions and 90 deletions.
40 changes: 0 additions & 40 deletions test/qpy_compat/compare_versions.py

This file was deleted.

74 changes: 74 additions & 0 deletions test/qpy_compat/get_versions.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,74 @@
# This code is part of Qiskit.
#
# (C) Copyright IBM 2024.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.

import json
import urllib.request

import packaging.version
import packaging.tags

import qiskit


def tag_from_wheel_name(wheel: str) -> packaging.tags.Tag:
assert wheel.lowercase().endswith(".whl")
_prefix, interpreter, abi, platform = wheel[:-4].rsplit("-", 3)
tag = packaging.tags.Tag(interpreter, abi, platform)
return tag


def available_versions():
"""Get all the versions of Qiskit that support exporting QPY, and are installable with the
active version of Python on this platform."""
our_version = packaging.version.parse(qiskit.__version__)
supported_tags = set(packaging.tags.sys_tags())

def available_versions_for_package(package, min_version=None, max_version=None):
with urllib.request.urlopen(f"https://pypi.org/pypi/{package}/json") as fd:
data = json.load(fd)
min_version = min_version and packaging.version.parse(min_version)
max_version = max_version and packaging.version.parse(max_version)
for other_version, payload in data["releases"].items():
other_version = packaging.version.parse(other_version)
if min_version is not None and other_version < min_version:
continue
if max_version is not None and other_version >= max_version:
continue
if other_version > our_version or other_version.is_prerelease:
continue
# Note: this silently ignores versions that are uninstallable because we're using a
# Python version that's too new, which can be a problem for the oldest Terras,
# especially from before we built for abi3.
if not any(
tag_from_wheel_name(release["filename"]) in supported_tags
for release in payload
if release["packagetype"] == "bdist_wheel"
):
continue
yield other_version

yield from (
("qiskit-terra", version)
for version in available_versions_for_package("qiskit-terra", "0.18.0", "1.0.0")
)
yield from (
("qiskit", version) for version in available_versions_for_package("qiskit", "1.0.0")
)


def main():
for package, version in available_versions():
print(package, version)


if __name__ == "__main__":
main()
82 changes: 38 additions & 44 deletions test/qpy_compat/process_version.sh
Original file line number Diff line number Diff line change
Expand Up @@ -14,56 +14,50 @@
set -e
set -x

# version is the source version, this is the release with which to generate
# qpy files with to load with the version under test
version=$1
parts=( ${version//./ } )
# qiskit_version is the version under test, We're testing that we can correctly
# read the qpy files generated with source version with this version.
qiskit_version=$(./qiskit_venv/bin/python -c "import qiskit;print(qiskit.__version__)")
qiskit_parts=( ${qiskit_version//./ } )
function usage {
echo "usage: ${BASH_SOURCE[0]} -p /path/to/qiskit/python <package> <version>" 1>&2
exit 1
}


# If source version is less than 0.18 QPY didn't exist yet so exit fast
if [[ ${parts[0]} -eq 0 && ${parts[1]} -lt 18 ]] ; then
exit 0
python="python"
while getopts "p:" opt; do
case "$opt" in
p)
python="$OPTARG"
;;
*)
usage
;;
esac
done
shift "$((OPTIND-1))"
if [[ $# != 2 ]]; then
usage
fi

# Exclude any non-rc pre-releases as they don't have stable API guarantees
if [[ $version == *"b"* || $version == *"a"* ]] ; then
exit 0
fi
# `package` is the name of the Python distribution to install (qiskit or qiskit-terra). `version` is
# the source version: the release with which to generate qpy files with to load with the version
# under test.
package="$1"
version="$2"

# If the source version is newer than the version under test exit fast because
# there is no QPY compatibility for loading a qpy file generated from a newer
# release with an older release of Qiskit.
if ! ./qiskit_venv/bin/python ./compare_versions.py "$version" "$qiskit_version" ; then
exit 0
fi
our_dir="$(realpath -- "$(dirname -- "${BASH_SOURCE[0]}")")"
cache_dir="$(pwd -P)/qpy_$version"
venv_dir="$(pwd -P)/${version}"

if [[ ! -d qpy_$version ]] ; then
echo "Building venv for qiskit-terra $version"
python -m venv "$version"
if [[ ${parts[0]} -eq 0 ]] ; then
if ! "./$version/bin/pip" install -c qpy_test_constraints.txt "qiskit-terra==$version"; then
echo "Skipping uninstallable version $version";
exit 0;
fi
else
if ! "./$version/bin/pip" install -c qpy_test_constraints.txt "qiskit==$version"; then
echo "Skipping uninstallable version $version";
exit 0;
fi
fi
mkdir "qpy_$version"
pushd "qpy_$version"
echo "Generating qpy files with qiskit-terra $version"
"../$version/bin/python" ../test_qpy.py generate --version="$version"
if [[ ! -d $cache_dir ]] ; then
echo "Building venv for $package==$version"
"$python" -m venv "$venv_dir"
"$venv_dir/bin/pip" install -c "${our_dir}/qpy_test_constraints.txt" "${package}==${version}"
mkdir "$cache_dir"
pushd "$cache_dir"
echo "Generating QPY files with $package==$version"
"$venv_dir/bin/python" "${our_dir}/test_qpy.py" generate --version="$version"
else
echo "Using cached QPY files for $version"
pushd "qpy_$version"
pushd "${cache_dir}"
fi
echo "Loading qpy files from $version with dev qiskit-terra"
../qiskit_venv/bin/python ../test_qpy.py load --version="$version"
echo "Loading qpy files from $version with dev Qiskit"
"$python" "${our_dir}/test_qpy.py" load --version="$version"
popd
rm -rf "./$version"
rm -rf "$venv_dir"
17 changes: 11 additions & 6 deletions test/qpy_compat/run_tests.sh
Original file line number Diff line number Diff line change
Expand Up @@ -12,19 +12,24 @@
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
set -e
set -o pipefail
set -x

# Set fixed hash seed to ensure set orders are identical between saving and
# loading.
export PYTHONHASHSEED=$(python -S -c "import random; print(random.randint(1, 4294967295))")
echo "PYTHONHASHSEED=$PYTHONHASHSEED"

python -m venv qiskit_venv
qiskit_venv/bin/pip install -c ../../constraints.txt ../..
our_dir="$(realpath -- "$(dirname -- "${BASH_SOURCE[0]}")")"

parallel bash ./process_version.sh ::: `git tag --sort=-creatordate`
qiskit_venv="$(pwd -P)/qiskit_venv"
qiskit_python="$qiskit_venv/bin/python"
python -m venv "$qiskit_venv"
"$qiskit_venv/bin/pip" install -c "$our_dir/../../constraints.txt" "$our_dir/../.."

"$qiskit_python" "$our_dir/get_versions.py" | parallel -- bash "$our_dir/process_version.sh" -p "$qiskit_python"

# Test dev compatibility
dev_version=`qiskit_venv/bin/python -c 'import qiskit;print(qiskit.__version__)'`
qiskit_venv/bin/python test_qpy.py generate --version=$dev_version
qiskit_venv/bin/python test_qpy.py load --version=$dev_version
dev_version="$("$qiskit_python" -c 'import qiskit; print(qiskit.__version__)')"
"$qiskit_python" "$our_dir/test_qpy.py" generate --version="$dev_version"
"$qiskit_python" "$our_dir/test_qpy.py" load --version="$dev_version"

0 comments on commit c45dc04

Please sign in to comment.