def test_version_comparisons(self):
def _eq(a, b):
_print("'%s' == '%s'" % (a, b))
self.assertTrue(Version(a) == Version(b))
_print()
_eq("", "")
_eq("1", "1")
_eq("1.2", "1-2")
_eq("1.2-3", "1-2.3")
ascending = [
"", "0.0.0", "1", "2", "2.alpha1", "2.alpha2", "2.beta", "2.0",
"2.0.8.8", "2.1", "2.1.0"
]
self._test_ordered([Version(x) for x in ascending])
def _eq2(a, b):
_print("'%s' == '%s'" % (a, b))
self.assertTrue(a == b)
# test behaviour in sets
a = Version("1.0")
b = Version("1.0")
c = Version("1.0alpha")
d = Version("2.0.0")
_eq2(set([a]) - set([a]), set())
_eq2(set([a]) - set([b]), set())
_eq2(set([a, a]) - set([a]), set())
_eq2(set([b, c, d]) - set([a]), set([c, d]))
_eq2(set([b, c]) | set([c, d]), set([b, c, d]))
_eq2(set([b, c]) & set([c, d]), set([c]))
def test_comparison(self):
"""Validate we can compare VersionSplitPackageOrder together."""
inst1 = VersionSplitPackageOrder(first_version=Version("1.2.3"))
inst2 = VersionSplitPackageOrder(first_version=Version("1.2.3"))
inst3 = VersionSplitPackageOrder(first_version=Version("1.2.4"))
self.assertTrue(inst1 == inst2) # __eq__ positive
self.assertFalse(inst1 == inst3) # __eq__ negative
self.assertTrue(inst1 != inst3) # __ne__ positive
self.assertFalse(inst1 != inst2) # __ne__ negative
self.assertFalse(inst1 == "wrong_type") # __eq__ negative (wrong type)
self.assertTrue(inst1 != "wrong_type") # __eq__ negative (wrong type)
def test_3(self):
"""check package contents."""
# a py-based package
package = get_package("versioned", "3.0")
expected_data = dict(
name="versioned",
version=Version("3.0"),
base=os.path.join(self.py_packages_path, "versioned", "3.0"),
commands=SourceCode('env.PATH.append("{root}/bin")'))
data = package.validated_data()
# Account for case-insensitive paths
for d in (expected_data, data):
d["base"] = d["base"].lower()
self.assertDictEqual(data, expected_data)
# a yaml-based package
package = get_package("versioned", "2.0")
expected_uri = os.path.join(self.yaml_packages_path,
"versioned", "2.0", "package.yaml")
self.assertEqual(package.uri, expected_uri)
# a py-based package with late binding attribute functions
package = get_package("late_binding", "1.0")
self.assertEqual(package.tools, ["util"])
# a 'combined' type package
package = get_package("multi", "1.0")
expected_uri = os.path.join(self.yaml_packages_path, "multi.yaml<1.0>")
self.assertEqual(package.uri, expected_uri)
expected_data = dict(
name="multi",
version=Version("1.0"),
tools=["tweak"])
data = package.validated_data()
self.assertDictEqual(data, expected_data)
# a 'combined' type package, with version overrides
package = get_package("multi", "1.1")
expected_uri = os.path.join(self.yaml_packages_path, "multi.yaml<1.1>")
self.assertEqual(package.uri, expected_uri)
expected_data = dict(
name="multi",
version=Version("1.1"),
tools=["twerk"])
data = package.validated_data()
self.assertDictEqual(data, expected_data)
# check that visibility of 'combined' packages is correct
package = get_package("multi", "2.0")
expected_uri = os.path.join(self.py_packages_path, "multi.py<2.0>")
self.assertEqual(package.uri, expected_uri)
def test_package_ignore(self):
"""Test package ignore/unignore."""
pkg_name = "pydad"
pkg_version = Version("2")
# copy packages to a temp repo
repo_path = os.path.join(self.root, "tmp1_packages")
shutil.copytree(self.solver_packages_path, repo_path)
# check that a known package exists
pkg = get_package_from_repository(pkg_name, pkg_version, repo_path)
self.assertNotEqual(pkg, None)
repo = pkg.repository
# ignore a pkg that doesn't exist
i = repo.ignore_package("i_dont_exist", Version("1"))
self.assertEqual(i, -1)
# ignore a pkg that doesn't exist, but allow it
i = repo.ignore_package("i_dont_exist",
Version("1"),
allow_missing=True)
self.assertEqual(i, 1)
# unignore a pkg that doesn't exist
i = repo.unignore_package("i_dont_exist", Version("1"))
self.assertEqual(i, -1)
# ignore an existing package
i = repo.ignore_package(pkg_name, pkg_version)
self.assertEqual(i, 1)
# verify that ignoring it again does nothing
i = repo.ignore_package(pkg_name, pkg_version)
self.assertEqual(i, 0)
# verify that we cannot see it
pkg = get_package_from_repository(pkg_name, pkg_version, repo_path)
self.assertEqual(pkg, None)
# unignore it
i = repo.unignore_package(pkg_name, pkg_version)
self.assertEqual(i, 1)
# verify that unignoring it again does nothing
i = repo.unignore_package(pkg_name, pkg_version)
self.assertEqual(i, 0)
# verify that we can see it again
pkg = get_package_from_repository(pkg_name, pkg_version, repo_path)
self.assertNotEqual(pkg, None)
def bind(path, version_range=None, opts=None, parser=None):
# find executable, determine version
if opts and opts.exe:
exepath = find_exe("python", opts.exe)
code = "import sys; print '.'.join(str(x) for x in sys.version_info)"
version = extract_version(exepath, ["-c", code])
else:
exepath = sys.executable
strver = '.'.join(str(x) for x in sys.version_info[:3])
version = Version(strver)
check_version(version, version_range)
def make_root(variant, root):
if platform_.name != 'windows':
binpath = make_dirs(root, "bin")
link = os.path.join(binpath, "python")
platform_.symlink(exepath, link)
with make_package("python", path, make_root=make_root) as pkg:
pkg.version = version
pkg.tools = ["python"]
if platform_.name == 'windows':
pkg.commands = win_commands(exepath)
else:
pkg.commands = nix_commands
pkg.variants = [system.variant]
return "python", version
def test_package_move(self):
"""Test package move."""
pkg_name = "pydad"
pkg_version = Version("2")
# copy packages to a temp repo
repo_path = os.path.join(self.root, "tmp2_packages")
shutil.copytree(self.solver_packages_path, repo_path)
# create an empty temp repo
dest_repo_path = os.path.join(self.root, "tmp3_packages")
os.mkdir(dest_repo_path)
# verify that source pkg exists
src_pkg = get_package_from_repository(pkg_name, pkg_version, repo_path)
self.assertNotEqual(src_pkg, None)
# move it to dest repo
move_package(src_pkg, dest_repo_path)
# verify it exists in dest repo
dest_pkg = get_package_from_repository(pkg_name, pkg_version,
dest_repo_path)
self.assertNotEqual(dest_pkg, None)
# verify it is not visible in source repo
src_pkg = get_package_from_repository(pkg_name, pkg_version, repo_path)
self.assertEqual(src_pkg, None)
def test_from_pod_old_style(self):
"""Validate from_pod is still compatible with the older pod style."""
self.assertEqual(
VersionSplitPackageOrder(first_version=Version("1.2.3")),
from_pod(("version_split", {
"first_version": "1.2.3"
})))
def get_package(self):
"""Create the analogous package.
Returns:
`Package` object.
"""
# get and validate package data
package_data = self._get_data()
package_data = package_schema.validate(package_data)
# check compatibility with rez version
if "requires_rez_version" in package_data:
ver = package_data.pop("requires_rez_version")
if Version(_rez_version) < ver:
raise PackageMetadataError(
"Failed reading package definition file: rez version >= %s "
"needed (current version is %s)" % (ver, _rez_version)
)
# create a 'memory' package repository containing just this package
version_str = package_data.get("version") or "_NO_VERSION"
repo_data = {self.name: {version_str: package_data}}
repo = create_memory_package_repository(repo_data)
# retrieve the package from the new repository
family_resource = repo.get_package_family(self.name)
it = repo.iter_packages(family_resource)
package_resource = next(it)
package = self.package_cls(package_resource)
# revalidate the package for extra measure
package.validate_data()
return package
def test_pod(self):
"""Validate we can save and load a PackageOrdererList to pod representation."""
inst = PackageOrderList(
(VersionSplitPackageOrder(Version("2.6.0")),
PerFamilyOrder(order_dict={},
default_order=SortedOrder(descending=False))))
self._test_pod(inst)
def extract_version(exepath, version_arg, word_index=-1, version_rank=3):
"""Run an executable and get the program version.
Args:
exepath: Filepath to executable.
version_arg: Arg to pass to program, eg "-V". Can also be a list.
word_index: Expect the Nth word of output to be the version.
version_rank: Cap the version to this many tokens.
Returns:
`Version` object.
"""
if isinstance(version_arg, basestring):
version_arg = [version_arg]
args = [exepath] + version_arg
stdout, stderr, returncode = _run_command(args)
if returncode:
raise RezBindError("failed to execute %s: %s\n(error code %d)" %
(exepath, stderr, returncode))
stdout = stdout.strip().split('\n')[0].strip()
log("extracting version from output: '%s'" % stdout)
try:
strver = stdout.split()[word_index]
toks = strver.replace('.', ' ').replace('-', ' ').split()
strver = '.'.join(toks[:version_rank])
version = Version(strver)
except Exception as e:
raise RezBindError("failed to parse version from output '%s': %s" %
(stdout, str(e)))
log("extracted version: '%s'" % str(version))
return version
def bind(path, version_range=None, opts=None, parser=None):
rez_version = Version(rez.__version__)
check_version(rez_version, version_range)
rez_major_version = rez_version.trim(1)
rez_major_minor_version = rez_version.trim(2)
next_major = int(str(rez_major_version)) + 1
rez_req_str = "rez-%s+<%d" % (str(rez_major_minor_version), next_major)
gui_lib = getattr(opts, "gui_lib", "")
def make_root(variant, root):
# copy source
rez_path = rez.__path__[0]
site_path = os.path.dirname(rez_path)
rezgui_path = os.path.join(site_path, "rezgui")
shutil.copytree(rezgui_path, os.path.join(root, "rezgui"))
# create rez-gui executable
binpath = make_dirs(root, "bin")
filepath = os.path.join(binpath, "rez-gui")
create_executable_script(filepath, rez_gui_source)
# create package
with make_package("rezgui", path, make_root=make_root) as pkg:
pkg.version = rez_version
pkg.variants = [system.variant]
pkg.commands = commands
pkg.tools = ["rez-gui"]
pkg.requires = [rez_req_str]
if gui_lib:
pkg.requires.append(gui_lib)
return "rezgui", rez_version
def bind(path, version_range=None, opts=None, parser=None):
version = Version(system.arch)
check_version(version, version_range)
with make_package("arch", path) as pkg:
pkg.version = version
return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None):
version = Version(system.platform)
check_version(version, version_range)
with make_package("platform", path) as pkg:
pkg.version = version
return "platform", version
def __init__(self, s):
self.name_ = None
self.version_ = None
self.sep_ = '-'
if s is None:
return
m = self.sep_regex.search(s)
if m:
i = m.start()
self.name_ = s[:i]
self.sep_ = s[i]
ver_str = s[i + 1:]
self.version_ = Version(ver_str)
else:
self.name_ = s
self.version_ = Version()
def test_containment(self):
# basic containment
self.assertTrue(Version("3") in VersionRange("3+"))
self.assertTrue(Version("5") in VersionRange("3..5"))
self.assertTrue(Version("5_") not in VersionRange("3..5"))
self.assertTrue(Version("3.0.0") in VersionRange("3+"))
self.assertTrue(Version("3.0.0") not in VersionRange("3.1+"))
self.assertTrue(Version("3") in VersionRange("<1|5|6|8|7|3|60+"))
self.assertTrue(Version("3") in VersionRange("<1|5|6|8|7|==3|60+"))
self.assertTrue(VersionRange("2.1+<4") in VersionRange("<4"))
self.assertTrue(VersionRange("2.1..4") not in VersionRange("<4"))
self.assertTrue(VersionRange("3") in VersionRange("3"))
self.assertTrue(VersionRange("==3") in VersionRange("3"))
self.assertTrue(VersionRange("3.5+<3_") in VersionRange("3"))
self.assertTrue(VersionRange("3") not in VersionRange("4+<6"))
self.assertTrue(VersionRange("3+<10") not in VersionRange("4+<6"))
# iterating over sorted version list
numbers = [2, 3, 5, 10, 11, 13, 14]
versions = [Version(str(x)) for x in numbers]
rev_versions = list(reversed(versions))
composite_range = VersionRange.from_versions(versions)
entries = [(VersionRange(""), 7), (VersionRange("0+"), 7),
(VersionRange("5+"), 5), (VersionRange("6+"), 4),
(VersionRange("50+"), 0), (VersionRange(">5"), 4),
(VersionRange("5"), 1), (VersionRange("6"), 0),
(VersionRange("<5"), 2), (VersionRange("<6"), 3),
(VersionRange("<50"), 7), (VersionRange("<=5"), 3),
(VersionRange("<1"), 0), (VersionRange("2|9+"), 5),
(VersionRange("3+<6|12+<13.5"), 3),
(VersionRange("<1|20+"), 0), (VersionRange(">0<20"), 7)]
for range_, count in entries:
# brute-force containment tests
matches = set(x for x in versions if x in range_)
self.assertEqual(len(matches), count)
# more optimal containment tests
def _test_it(it):
matches_ = set(version for contains, version in it if contains)
self.assertEqual(matches_, matches)
_test_it(range_.iter_intersect_test(versions))
_test_it(range_.iter_intersect_test(rev_versions, descending=True))
# throw in an intersection test
self.assertEqual(composite_range.intersects(range_), (count != 0))
int_range = composite_range & range_
versions_ = [] if int_range is None else int_range.to_versions()
self.assertEqual(set(versions_), matches)
# throw in a superset test as well
self.assertEqual(range_.issuperset(composite_range), (count == 7))
if count:
self.assertTrue(composite_range.issuperset(int_range))
def install_variant(self, variant_resource, dry_run=False, overrides=None):
overrides = overrides or {}
# Name and version overrides are a special case - they change the
# destination variant to be created/replaced.
#
variant_name = variant_resource.name
variant_version = variant_resource.version
if "name" in overrides:
variant_name = overrides["name"]
if variant_name is self.remove:
raise PackageRepositoryError(
"Cannot remove package attribute 'name'")
if "version" in overrides:
ver = overrides["version"]
if ver is self.remove:
raise PackageRepositoryError(
"Cannot remove package attribute 'version'")
if isinstance(ver, basestring):
ver = Version(ver)
overrides = overrides.copy()
overrides["version"] = ver
variant_version = ver
# cannot install over one's self, just return existing variant
if variant_resource._repository is self and \
variant_name == variant_resource.name and \
variant_version == variant_resource.version:
return variant_resource
# create repo path on disk if it doesn't exist
path = self.location
try:
os.makedirs(path)
except OSError as e:
if e.errno != errno.EEXIST:
raise PackageRepositoryError(
"Package repository path %r could not be created: %s: %s" %
(path, e.__class__.__name__, e))
# install the variant
def _create_variant():
return self._create_variant(variant_resource,
dry_run=dry_run,
overrides=overrides)
if dry_run:
variant = _create_variant()
else:
with self._lock_package(variant_name, variant_version):
variant = _create_variant()
return variant
def test_3(self):
"""check package contents."""
# a py-based package
package = get_package("versioned", "3.0")
expected_data = dict(
name="versioned",
version=Version("3.0"),
base=os.path.join(self.py_packages_path, "versioned", "3.0"),
commands=SourceCode('env.PATH.append("{root}/bin")'))
data = package.validated_data()
self.assertDictEqual(data, expected_data)
# a yaml-based package
package = get_package("versioned", "2.0")
expected_uri = os.path.join(self.yaml_packages_path,
"versioned", "2.0", "package.yaml")
self.assertEqual(package.uri, expected_uri)
# a 'combined' type package
package = get_package("multi", "1.0")
expected_uri = os.path.join(self.yaml_packages_path, "multi.yaml<1.0>")
self.assertEqual(package.uri, expected_uri)
expected_data = dict(
name="multi",
version=Version("1.0"),
tools=["tweak"])
data = package.validated_data()
self.assertDictEqual(data, expected_data)
# a 'combined' type package, with version overrides
package = get_package("multi", "1.1")
expected_uri = os.path.join(self.yaml_packages_path, "multi.yaml<1.1>")
self.assertEqual(package.uri, expected_uri)
expected_data = dict(
name="multi",
version=Version("1.1"),
tools=["twerk"])
data = package.validated_data()
self.assertDictEqual(data, expected_data)
# check that visibility of 'combined' packages is correct
package = get_package("multi", "2.0")
expected_uri = os.path.join(self.py_packages_path, "multi.py<2.0>")
self.assertEqual(package.uri, expected_uri)
def install_variant(self, variant_resource, dry_run=False, overrides=None):
overrides = overrides or {}
# Name and version overrides are a special case - they change the
# destination variant to be created/replaced.
#
variant_name = variant_resource.name
variant_version = variant_resource.version
if "name" in overrides:
variant_name = overrides["name"]
if variant_name is self.remove:
raise PackageRepositoryError(
"Cannot remove package attribute 'name'")
if "version" in overrides:
ver = overrides["version"]
if ver is self.remove:
raise PackageRepositoryError(
"Cannot remove package attribute 'version'")
if isinstance(ver, basestring):
ver = Version(ver)
overrides = overrides.copy()
overrides["version"] = ver
variant_version = ver
# cannot install over one's self, just return existing variant
if variant_resource._repository is self and \
variant_name == variant_resource.name and \
variant_version == variant_resource.version:
return variant_resource
# check repo exists on disk
path = self.location
if not os.path.exists(path):
raise PackageRepositoryError(
"Package repository path does not exist: %s" % path)
# install the variant
def _create_variant():
return self._create_variant(
variant_resource,
dry_run=dry_run,
overrides=overrides
)
if dry_run:
variant = _create_variant()
else:
with self._lock_package(variant_name, variant_version):
variant = _create_variant()
return variant
def construct(cls, name, version=None):
"""Create a VersionedObject directly from an object name and version.
Args:
name: Object name string.
version: Version object.
"""
other = VersionedObject(None)
other.name_ = name
other.version_ = Version() if version is None else version
return other
def convert_spec(spec):
def parsed_rez_ver():
v = spec.version.replace(".*", "")
return pip_to_rez_version(v)
def fmt(txt):
v = parsed_rez_ver()
vnext = next_ver(v)
vadj = adjacent_ver(v)
return txt.format(V=v, VNEXT=vnext, VADJ=vadj)
# ==1.* --> 1
if spec.operator == "==" and spec.version.endswith(".*"):
return fmt("{V}")
# ==1 --> 1+<1.1
if spec.operator == "==":
return fmt("{V}+<{VADJ}")
# >=1 --> 1+
if spec.operator == ">=":
return fmt("{V}+")
# >1 --> 1.1+
if spec.operator == ">":
return fmt("{VADJ}+")
# <= 1 --> <1.1
if spec.operator == "<=":
return fmt("<{VADJ}")
# <1 --> <1
if spec.operator == "<":
return fmt("<{V}")
# ~=1.2 --> 1.2+<2; ~=1.2.3 --> 1.2.3+<1.3
if spec.operator == "~=":
v = Version(parsed_rez_ver())
v = v.trim(len(v) - 1)
v_next = next_ver(str(v))
return fmt("{V}+<" + v_next)
# !=1.* --> <1|2+; !=1.2.* --> <1.2|1.3+
if spec.operator == "!=" and spec.version.endswith(".*"):
return fmt("<{V}|{VNEXT}+")
# !=1 --> <1|1.1+; !=1.2 --> <1.2|1.2.1+
if spec.operator == "!=":
return fmt("<{V}|{VADJ}+")
raise PackageRequestError(
"Don't know how to convert PEP440 specifier %r "
"into rez equivalent" % specifier
)
def bind(path, version_range=None, opts=None, parser=None):
version = Version(system.os)
check_version(version, version_range)
with make_package("os", path) as pkg:
pkg.version = version
pkg.requires = [
"platform-%s" % system.platform,
"arch-%s" % system.arch
]
return "os", version
def test_version_binding(self):
"""Test the Rex binding of the Version class."""
v = VersionBinding(Version("1.2.3alpha"))
self.assertEqual(v.major, 1)
self.assertEqual(v.minor, 2)
self.assertEqual(v.patch, "3alpha")
self.assertEqual(len(v), 3)
self.assertEqual(v[1], 2)
self.assertEqual(v[:2], (1, 2))
self.assertEqual(str(v), "1.2.3alpha")
self.assertEqual(v[5], None)
self.assertEqual(v.as_tuple(), (1, 2, "3alpha"))
def bind(path, version_range=None, opts=None, parser=None):
version = Version(system.os)
check_version(version, version_range)
with make_package("os", path) as pkg:
pkg.version = version
pkg.requires = [
"platform-%s" % system.platform,
"arch-%s" % system.arch
]
pkg.relocatable = True
return pkg.installed_variants
def test_9(self):
"""test package orderers."""
from rez.package_order import NullPackageOrder, PerFamilyOrder, \
VersionSplitPackageOrder, TimestampPackageOrder, SortedOrder, \
to_pod, from_pod
def _test(orderer, package_name, expected_order):
it = iter_packages(package_name)
descending = sorted(it, key=lambda x: x.version, reverse=True)
pod = to_pod(orderer)
orderer2 = from_pod(pod)
for orderer_ in (orderer, orderer2):
ordered = orderer_.reorder(descending)
result = [str(x.version) for x in ordered]
self.assertEqual(result, expected_order)
null_orderer = NullPackageOrder()
split_orderer = VersionSplitPackageOrder(Version("2.6.0"))
# after v1.1.0 and before v1.1.1
timestamp_orderer = TimestampPackageOrder(timestamp=3001, rank=3)
# after v2.1.0 and before v2.1.5
timestamp2_orderer = TimestampPackageOrder(timestamp=7001, rank=3)
expected_null_result = ["7", "6", "5"]
expected_split_result = ["2.6.0", "2.5.2", "2.7.0", "2.6.8"]
expected_timestamp_result = [
"1.1.1", "1.1.0", "1.0.6", "1.0.5", "1.2.0", "2.0.0", "2.1.5",
"2.1.0"
]
expected_timestamp2_result = [
"2.1.5", "2.1.0", "2.0.0", "1.2.0", "1.1.1", "1.1.0", "1.0.6",
"1.0.5"
]
_test(null_orderer, "pysplit", expected_null_result)
_test(split_orderer, "python", expected_split_result)
_test(timestamp_orderer, "timestamped", expected_timestamp_result)
_test(timestamp2_orderer, "timestamped", expected_timestamp2_result)
fam_orderer = PerFamilyOrder(
order_dict=dict(pysplit=null_orderer,
python=split_orderer,
timestamped=timestamp_orderer),
default_order=SortedOrder(descending=False))
_test(fam_orderer, "pysplit", expected_null_result)
_test(fam_orderer, "python", expected_split_result)
_test(fam_orderer, "timestamped", expected_timestamp_result)
_test(fam_orderer, "pymum", ["1", "2", "3"])
def test_developer(self):
"""test developer package."""
path = os.path.join(self.packages_base_path, "developer")
package = get_developer_package(path)
expected_data = dict(name="foo",
version=Version("3.0.1"),
description="a foo type thing.",
authors=["joe.bloggs"],
requires=[PackageRequest('bah-1.2+<2')],
variants=[[PackageRequest('floob-4.1')],
[PackageRequest('floob-2.0')]],
uuid="28d94bcd1a934bb4999bcf70a21106cc")
data = package.validated_data()
self.assertDictEqual(data, expected_data)
def create_context(pip_version=None, python_version=None):
"""Create a context containing the specific pip and python.
Args:
pip_version (str or `Version`): Version of pip to use, or latest if None.
python_version (str or `Version`): Python version to use, or latest if
None.
Returns:
`ResolvedContext`: Context containing pip and python.
"""
# determine pip pkg to use for install, and python variants to install on
if pip_version:
pip_req = "pip-%s" % str(pip_version)
else:
pip_req = "pip"
if python_version:
ver = Version(str(python_version))
major_minor_ver = ver.trim(2)
py_req = "python-%s" % str(major_minor_ver)
else:
# use latest major.minor
package = get_latest_package("python")
if package:
major_minor_ver = package.version.trim(2)
else:
# no python package. We're gonna fail, let's just choose current
# python version (and fail at context creation time)
major_minor_ver = '.'.join(map(str, sys.version_info[:2]))
py_req = "python-%s" % str(major_minor_ver)
# use pip + latest python to perform pip download operations
request = [pip_req, py_req]
with convert_errors(from_=(PackageFamilyNotFoundError,
PackageNotFoundError),
to=BuildError,
msg="Cannot run - pip or python rez "
"package is not present"):
context = ResolvedContext(request)
# print pip package used to perform the install
pip_variant = context.get_resolved_package("pip")
pip_package = pip_variant.parent
print_info("Using %s (%s)" % (pip_package.qualified_name, pip_variant.uri))
return context
def bind(path, version_range=None, opts=None, parser=None):
version = Version("1.0")
check_version(version, version_range)
def make_root(variant, root):
binpath = make_dirs(root, "bin")
filepath = os.path.join(binpath, "hello_world")
create_executable_script(filepath, hello_world_source)
with make_package("hello_world", path, make_root=make_root) as pkg:
pkg.version = version
pkg.tools = ["hello_world"]
pkg.commands = commands
return pkg.installed_variants
def _load(self):
data = self.parent._data.copy()
if "versions" in data:
del data["versions"]
version_str = self.get("version")
data["version"] = version_str
version = Version(version_str)
overrides = self.parent.version_overrides
if overrides:
for range_, data_ in overrides.iteritems():
if version in range_:
data.update(data_)
del data["version_overrides"]
return data
def test_4(self):
"""test package creation."""
package_data = {
"name": "foo",
"version": "1.0.0",
"description": "something foo-like",
"requires": ["python-2.6+"]}
package = create_package("foo", package_data)
self.assertEqual(package.version, Version("1.0.0"))
self.assertEqual(package.description, "something foo-like")
self.assertEqual(package.requires, [PackageRequest("python-2.6+")])
family = package.parent
self.assertEqual(family.name, package.name)
packages = list(family.iter_packages())
self.assertEqual(len(packages), 1)
self.assertEqual(package, packages[0])
def test_6(self):
"""test variant iteration."""
expected_data = dict(
name="variants_py",
version=Version("2.0"),
description="package with variants",
base=os.path.join(self.py_packages_path, "variants_py", "2.0"),
requires=[PackageRequest("python-2.7")],
commands=SourceCode('env.PATH.append("{root}/bin")'))
requires_ = ["platform-linux", "platform-osx"]
package = get_package("variants_py", "2.0")
for i, variant in enumerate(package.iter_variants()):
data = variant.validated_data()
self.assertDictEqual(data, expected_data)
self.assertEqual(variant.index, i)
self.assertEqual(variant.parent, package)
