def create_build_context(self, variant, build_type, build_path):
"""Create a context to build the variant within."""
request = variant.get_requires(build_requires=True,
private_build_requires=True)
requests_str = ' '.join(map(str, request))
self._print("Resolving build environment: %s", requests_str)
if build_type == BuildType.local:
packages_path = self.package.config.packages_path
else:
packages_path = self.package.config.nonlocal_packages_path
if self.package.config.is_overridden("package_filter"):
from rez.package_filter import PackageFilterList
data = self.package.config.package_filter
package_filter = PackageFilterList.from_pod(data)
else:
package_filter = None
context = ResolvedContext(request,
package_paths=packages_path,
package_filter=package_filter,
building=True)
if self.verbose:
context.print_info()
# save context before possible fail, so user can debug
rxt_filepath = os.path.join(build_path, "build.rxt")
context.save(rxt_filepath)
if context.status != ResolverStatus.solved:
raise BuildContextResolveError(context)
return context, rxt_filepath
def resolve_context(self, verbosity=0, max_fails=-1, timestamp=None,
callback=None, buf=None, package_load_callback=None):
"""Update the current context by performing a re-resolve.
The newly resolved context is only applied if it is a successful solve.
Returns:
`ResolvedContext` object, which may be a successful or failed solve.
"""
package_filter = PackageFilterList.from_pod(self.package_filter)
context = ResolvedContext(
self.request,
package_paths=self.packages_path,
package_filter=package_filter,
verbosity=verbosity,
max_fails=max_fails,
timestamp=timestamp,
buf=buf,
callback=callback,
package_load_callback=package_load_callback,
caching=self.caching)
if context.success:
if self._context and self._context.load_path:
context.set_load_path(self._context.load_path)
self._set_context(context)
self._modified = True
return context
def resolve_context(self, verbosity=0, max_fails=-1, timestamp=None,
callback=None, buf=None, package_load_callback=None):
"""Update the current context by performing a re-resolve.
The newly resolved context is only applied if it is a successful solve.
Returns:
`ResolvedContext` object, which may be a successful or failed solve.
"""
package_filter = PackageFilterList.from_pod(self.package_filter)
context = ResolvedContext(
self.request,
package_paths=self.packages_path,
package_filter=package_filter,
verbosity=verbosity,
max_fails=max_fails,
timestamp=timestamp,
buf=buf,
callback=callback,
package_load_callback=package_load_callback)
if context.success:
if self._context and self._context.load_path:
context.set_load_path(self._context.load_path)
self._set_context(context)
self._modified = True
return context
def create_build_context(self, variant, build_type, build_path):
"""Create a context to build the variant within."""
request = variant.get_requires(build_requires=True,
private_build_requires=True)
req_strs = map(str, request)
quoted_req_strs = map(quote, req_strs)
self._print("Resolving build environment: %s",
' '.join(quoted_req_strs))
if build_type == BuildType.local:
packages_path = self.package.config.packages_path
else:
packages_path = self.package.config.nonlocal_packages_path
# It is uncommon, but possible, to define the package filters in the
# developer package. Example scenario: you may want to enable visiblity
# of *.dev packages if the current package is *.dev also, for example
# (assuming you have a production-time package filter which filters out
# *.dev packages by default).
#
if self.package.config.is_overridden("package_filter"):
from rez.package_filter import PackageFilterList
data = self.package.config.package_filter
package_filter = PackageFilterList.from_pod(data)
else:
package_filter = None
# create the build context
context = ResolvedContext(request,
package_paths=packages_path,
package_filter=package_filter,
building=True)
if self.verbose:
context.print_info()
# save context before possible fail, so user can debug
rxt_filepath = os.path.join(build_path, "build.rxt")
context.save(rxt_filepath)
if context.status != ResolverStatus.solved:
raise BuildContextResolveError(context)
return context, rxt_filepath
def _test(self, fltr, pkg_family, expected_result):
# convert from json if required
if isinstance(fltr, dict):
fltr = PackageFilter.from_pod(fltr)
elif isinstance(fltr, list):
fltr = PackageFilterList.from_pod(fltr)
def filter_versions(fltr_):
matching_versions = set()
for pkg in iter_packages(pkg_family):
if not fltr_.excludes(pkg):
matching_versions.add(str(pkg.version))
self.assertEqual(matching_versions, set(expected_result))
# apply filter to all pkg versions
filter_versions(fltr)
# serialise to/from json and do it again
data = fltr.to_pod()
fltr2 = fltr.from_pod(data)
filter_versions(fltr2)
def create_build_context(self, variant, build_type, build_path):
"""Create a context to build the variant within."""
request = variant.get_requires(build_requires=True,
private_build_requires=True)
req_strs = map(str, request)
quoted_req_strs = map(quote, req_strs)
self._print("Resolving build environment: %s", ' '.join(quoted_req_strs))
if build_type == BuildType.local:
packages_path = self.package.config.packages_path
else:
packages_path = self.package.config.nonlocal_packages_path
if self.package.config.is_overridden("package_filter"):
from rez.package_filter import PackageFilterList
data = self.package.config.package_filter
package_filter = PackageFilterList.from_pod(data)
else:
package_filter = None
context = ResolvedContext(request,
package_paths=packages_path,
package_filter=package_filter,
building=True)
if self.verbose:
context.print_info()
# save context before possible fail, so user can debug
rxt_filepath = os.path.join(build_path, "build.rxt")
context.save(rxt_filepath)
if context.status != ResolverStatus.solved:
raise BuildContextResolveError(context)
return context, rxt_filepath
def _contextChanged(self, flags=0):
self._set_stale(self.context_model.is_stale())
if flags & (ContextModel.PACKAGES_PATH_CHANGED |
ContextModel.CONTEXT_CHANGED):
# update icons
new_icons = []
if self.variant.index is not None:
package = self.variant.parent
if package.num_variants > 1:
txt = "1 of %d variants" % package.num_variants
new_icons.append(("variant", txt))
if self.variant.is_local:
new_icons.append(("local", "package is local"))
package_paths = PackageSearchPath(self.context_model.packages_path)
package_filter = PackageFilterList.from_pod(self.context_model.package_filter)
# TODO: move this all into a thread, it's blocking up the GUI during context load
if self.variant in package_paths:
# find all >= version packages, so we can determine tick type
ge_range = VersionRange.from_version(self.variant.version, ">=")
packages = None
try:
it = package_paths.iter_packages(name=self.variant.name,
range_=ge_range)
packages = sorted(it, key=lambda x: x.version)
except:
pass
# apply a tick icon if appropriate
ticked = False
if packages:
# test if variant is latest package
latest_pkg = packages[-1]
if self.variant.version == latest_pkg.version:
new_icons.append(("green_tick", "package is latest"))
ticked = True
range_ = None
packages_ = None
# test if variant is in request, and is latest possible
if not ticked:
range_ = None
try:
request = self.context().requested_packages(True)
reqlist = RequirementList(request)
if self.variant.name in reqlist.names:
variant_ = reqlist.get(self.variant.name)
if not variant_.conflict:
range_ = variant_.range
except:
pass
if range_ is not None:
packages_ = [x for x in packages if x.version in range_]
if packages_:
latest_pkg = packages_[-1]
if self.variant.version == latest_pkg.version:
new_icons.append(("yellow_tick",
"package is latest possible"))
ticked = True
packages2 = [x for x in (packages_ or packages)
if x.version > self.variant.version]
# test if variant is latest within package filter
if (not ticked
and packages2
and package_filter):
if all(package_filter.excludes(x) for x in packages2):
new_icons.append(("yellow_tick",
"package is latest possible"))
ticked = True
# test if variant was latest package at time of resolve
if not ticked and self.variant.timestamp:
untimestamped_packages = [x for x in packages
if not x.timestamp]
if not untimestamped_packages:
resolve_time = self.context().timestamp
old_packages = [x for x in packages
if x.timestamp <= resolve_time]
if old_packages:
latest_pkg = old_packages[-1]
if self.variant.version == latest_pkg.version:
new_icons.append(
("green_white_tick",
"package was latest at time of resolve"))
ticked = True
# test if variant is in request, and was latest possible at
# the time of resolve
if (not ticked
and self.variant.timestamp
and range_ is not None
and packages_ is not None):
untimestamped_packages = any(x for x in packages_ if not x.timestamp)
if not untimestamped_packages:
resolve_time = self.context().timestamp
old_packages = [x for x in packages_
if x.timestamp <= resolve_time]
if old_packages:
latest_pkg = old_packages[-1]
if self.variant.version == latest_pkg.version:
new_icons.append(
("yellow_white_tick",
"package was latest possible at time of resolve"))
ticked = True
# test if variant is within package filter, and was latest
# possible at the time of resolve
if (not ticked
and packages2
and package_filter
and self.variant.timestamp):
untimestamped_packages = any(x for x in (packages_ or packages)
if not x.timestamp)
if not untimestamped_packages:
newer_package = any(x for x in packages2
if not package_filter.excludes(x)
and x.timestamp <= resolve_time)
if not newer_package:
new_icons.append(
("yellow_white_tick",
"package was latest possible at time of resolve"))
ticked = True
# bring in the old man
if not ticked:
new_icons.append(
("old_man", "newer packages are/were available"))
else:
new_icons.append(("error", "package is not in the search path"))
self._set_icons(new_icons)
if (not self.hide_locks) and (flags & (ContextModel.LOCKS_CHANGED |
ContextModel.CONTEXT_CHANGED)):
# update lock icon
lock = self.context_model.get_patch_lock(self.variant.name)
if lock is None:
lock = self.context_model.default_patch_lock
icon_name = "%s_faint" % lock.name
else:
icon_name = lock.name
# update lock tooltip
if lock == PatchLock.no_lock:
desc = lock.description
else:
req = self._get_lock_requirement(lock)
if req:
if lock == PatchLock.lock:
desc = "Exact version (%s)" % str(req)
else:
unit = lock.description.split()[0]
desc = ("%s version updates only (%s.*)"
% (unit.capitalize(), str(req)))
else:
desc = lock.description
self._set_lock_icon(icon_name, desc.lower())
def _set_variant(self, variant, preloaded_packages=None):
self.clear()
hh = self.horizontalHeader()
self.setHorizontalHeaderLabels(["path", "released"])
hh.setResizeMode(0, QtGui.QHeaderView.Interactive)
hh.setStretchLastSection(True)
hh.setVisible(True)
package_paths = self.context_model.packages_path
package_filter = PackageFilterList.from_pod(
self.context_model.package_filter)
if variant and variant.wrapped.location in package_paths:
self.version_index = -1
self.reference_version_index = -1
reference_version = None
range_ = None
if self.reference_variant and self.reference_variant.name == variant.name:
reference_version = self.reference_variant.version
versions = sorted([reference_version, variant.version])
range_ = VersionRange.as_span(*versions)
timestamp = self.context().timestamp
if preloaded_packages is not None:
if range_ is None:
packages = preloaded_packages
else:
packages = [
x for x in preloaded_packages if x.version in range_
]
else:
it = iter_packages(name=variant.name,
paths=package_paths,
range_=range_)
packages = sorted(it, key=lambda x: x.version, reverse=True)
self.setRowCount(len(packages))
brush = self.palette().brush(QtGui.QPalette.Active,
QtGui.QPalette.Base)
for row, package in enumerate(packages):
version_str = str(package.version) + ' '
item = QtGui.QTableWidgetItem(version_str)
item.setTextAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
self.setVerticalHeaderItem(row, item)
if package.version == variant.version:
self.version_index = row
update_font(item, bold=True)
if reference_version is not None \
and package.version == reference_version:
self.reference_version_index = row
update_font(item, bold=True, italic=True)
def _item():
item_ = QtGui.QTableWidgetItem()
item_.setBackground(
brush) # get rid of mouse-hover coloring
return item_
if package.timestamp:
release_str = get_timestamp_str(package.timestamp)
in_future = (package.timestamp > timestamp)
else:
release_str = '-'
in_future = False
item = _item()
txt = package.uri + " "
icons = []
if in_future:
icon = get_icon_widget(
"clock_warning",
"package did not exist at time of resolve")
icons.append(icon)
rule = package_filter.excludes(package)
if rule:
icon = get_icon_widget(
"excluded",
"package was excluded by rule %s" % str(rule))
icons.append(icon)
if icons:
label = QtGui.QLabel(txt)
pane = create_pane(icons + [label, None],
True,
compact=True)
self.setCellWidget(row, 0, pane)
else:
item.setText(txt)
self.setItem(row, 0, item)
item = _item()
item.setText(release_str)
self.setItem(row, 1, item)
vh = self.verticalHeader()
vh.setVisible(True)
self.resizeColumnsToContents()
hh.setStretchLastSection(True)
self.update()
self.allow_selection = True
self.selectRow(self.version_index)
self.allow_selection = False
self.variant = variant
def _set_variant(self, variant, preloaded_packages=None):
self.clear()
hh = self.horizontalHeader()
self.setHorizontalHeaderLabels(["path", "released"])
hh.setResizeMode(0, QtGui.QHeaderView.Interactive)
hh.setStretchLastSection(True)
hh.setVisible(True)
package_paths = self.context_model.packages_path
package_filter = PackageFilterList.from_pod(self.context_model.package_filter)
if variant and variant.wrapped.location in package_paths:
self.version_index = -1
self.reference_version_index = -1
reference_version = None
range_ = None
if self.reference_variant and self.reference_variant.name == variant.name:
reference_version = self.reference_variant.version
versions = sorted([reference_version, variant.version])
range_ = VersionRange.as_span(*versions)
timestamp = self.context().timestamp
if preloaded_packages is not None:
if range_ is None:
packages = preloaded_packages
else:
packages = [x for x in preloaded_packages if x.version in range_]
else:
it = iter_packages(name=variant.name, paths=package_paths, range_=range_)
packages = sorted(it, key=lambda x: x.version, reverse=True)
self.setRowCount(len(packages))
brush = self.palette().brush(QtGui.QPalette.Active, QtGui.QPalette.Base)
for row, package in enumerate(packages):
version_str = str(package.version) + ' '
item = QtGui.QTableWidgetItem(version_str)
item.setTextAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self.setVerticalHeaderItem(row, item)
if package.version == variant.version:
self.version_index = row
update_font(item, bold=True)
if reference_version is not None \
and package.version == reference_version:
self.reference_version_index = row
update_font(item, bold=True, italic=True)
def _item():
item_ = QtGui.QTableWidgetItem()
item_.setBackground(brush) # get rid of mouse-hover coloring
return item_
if package.timestamp:
release_str = get_timestamp_str(package.timestamp)
in_future = (package.timestamp > timestamp)
else:
release_str = '-'
in_future = False
item = _item()
txt = package.uri + " "
icons = []
if in_future:
icon = get_icon_widget(
"clock_warning", "package did not exist at time of resolve")
icons.append(icon)
rule = package_filter.excludes(package)
if rule:
icon = get_icon_widget(
"excluded", "package was excluded by rule %s" % str(rule))
icons.append(icon)
if icons:
label = QtGui.QLabel(txt)
pane = create_pane(icons + [label, None], True, compact=True)
self.setCellWidget(row, 0, pane)
else:
item.setText(txt)
self.setItem(row, 0, item)
item = _item()
item.setText(release_str)
self.setItem(row, 1, item)
vh = self.verticalHeader()
vh.setVisible(True)
self.resizeColumnsToContents()
hh.setStretchLastSection(True)
self.update()
self.allow_selection = True
self.selectRow(self.version_index)
self.allow_selection = False
self.variant = variant
