rez 3.1.0__tar.gz → 3.2.0__tar.gz

{rez-3.1.0 → rez-3.2.0}/MANIFEST.in

@@ -1,8 +1,7 @@
 include src/rez/data/*
-include src/rez/rezconfig
 include src/rez/completion/*
 include src/rez/vendor/distlib/*.exe
 include src/rezgui/rezguiconfig
 include src/rezgui/icons/*
 recursive-include src/rez README*
-recursive-include src/rezplugins *.cmake Doxyfile rezconfig
+recursive-include src/rezplugins *.cmake Doxyfile

{rez-3.1.0/src/rez.egg-info → rez-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rez
-Version: 3.1.0
+Version: 3.2.0
 Summary: A cross-platform packaging system that can build and install multiple version of packages, and dynamically configure resolved environments at runtime.
 Home-page: https://github.com/AcademySoftwareFoundation/rez
 Author: Allan Johns

{rez-3.1.0 → rez-3.2.0}/setup.py

@@ -76,7 +76,6 @@ setup(
             find_files('*', 'data') +
             find_files('*.exe', 'vendor/distlib'),
         'rezplugins':
-            find_files('rezconfig', root='rezplugins') +
             find_files('*.cmake', 'build_system', root='rezplugins') +
             find_files('*', 'build_system/template_files', root='rezplugins'),
         'rezgui':

{rez-3.1.0 → rez-3.2.0}/src/rez/bind/rez.py

@@ -34,7 +34,7 @@ def bind(path, version_range=None, opts=None, parser=None):
     with make_package("rez", path, make_root=make_root) as pkg:
         pkg.version = version
         pkg.commands = commands
-        pkg.requires = ["python-2.7+<4"]
+        pkg.requires = ["python-3.7+<3.12"]
         pkg.variants = [system.variant]
 
     return pkg.installed_variants

{rez-3.1.0 → rez-3.2.0}/src/rez/cli/build.py

@@ -30,11 +30,13 @@ def setup_parser_common(parser):
     """Parser setup common to both rez-build and rez-release."""
     from rez.build_process import get_build_process_types
     from rez.build_system import get_valid_build_systems
+    from rez.config import config
     from rez.exceptions import PackageMetadataError
 
     process_types = get_build_process_types()
     parser.add_argument(
-        "--process", type=str, choices=process_types, default="local",
+        "--process", type=str, choices=process_types,
+        default=config.default_build_process,
         help="the build process to use (default: %(default)s).")
 
     # add build system choices valid for this package

{rez-3.1.0 → rez-3.2.0}/src/rez/cli/env.py

@@ -119,6 +119,11 @@ def setup_parser(parser, completions=False):
     parser.add_argument(
         "--no-pkg-cache", action="store_true",
         help="Disable package caching")
+    parser.add_argument(
+        "--pkg-cache-mode", choices=["sync", "async"],
+        help="If provided, override the rezconfig's package_cache_async key. "
+             "If 'sync', the process will block until packages are cached. "
+             "If 'async', the process will not block while packages are cached.")
     parser.add_argument(
         "--pre-command", type=str, help=SUPPRESS)
     PKG_action = parser.add_argument(
@@ -201,6 +206,13 @@ def command(opts, parser, extra_arg_groups=None):
             rule = Rule.parse_rule(rule_str)
             package_filter.add_inclusion(rule)
 
+        if opts.pkg_cache_mode == "async":
+            package_cache_mode = True
+        elif opts.pkg_cache_mode == "sync":
+            package_cache_mode = False
+        else:
+            package_cache_mode = None
+
         # perform the resolve
         context = ResolvedContext(
             package_requests=request,
@@ -215,7 +227,8 @@ def command(opts, parser, extra_arg_groups=None):
             caching=(not opts.no_cache),
             suppress_passive=opts.no_passive,
             print_stats=opts.stats,
-            package_caching=(not opts.no_pkg_cache)
+            package_caching=(not opts.no_pkg_cache),
+            package_cache_async=package_cache_mode,
         )
 
     success = (context.status == ResolverStatus.solved)

{rez-3.1.0 → rez-3.2.0}/src/rez/cli/pkg-cache.py

@@ -41,6 +41,14 @@ def setup_parser(parser, completions=False):
     group.add_argument(
         "--daemon", action="store_true", help=SUPPRESS
     )
+    parser.add_argument(
+        "--pkg-cache-mode",
+        choices=["sync", "async"],
+        default=None,
+        help="If provided, override the rezconfig's package_cache_async key. "
+             "If 'sync', the process will block until packages are cached. "
+             "If 'async', the process will not block while packages are cached."
+    )
     parser.add_argument(
         "-c", "--columns", nargs='+', choices=column_choices,
         default=["status", "package", "variant_uri", "cache_path"],
@@ -59,6 +67,7 @@ def setup_parser(parser, completions=False):
 
 
 def add_variant(pkgcache, uri, opts):
+    from rez.config import config
     from rez.packages import get_variant_from_uri
     from rez.utils.logging_ import print_info, print_warning
     from rez.package_cache import PackageCache
@@ -70,7 +79,17 @@ def add_variant(pkgcache, uri, opts):
         print("No such variant: %s" % uri, file=sys.stderr)
         sys.exit(1)
 
-    destpath, status = pkgcache.add_variant(variant, force=opts.force)
+    if opts.pkg_cache_mode == "async":
+        sync = False
+    elif opts.pkg_cache_mode == "sync":
+        sync = True
+    else:
+        sync = not config.package_cache_async
+
+    destpath, status = pkgcache.add_variant(
+        variant, force=opts.force,
+        wait_for_copying=sync
+    )
 
     if status == PackageCache.VARIANT_FOUND:
         print_info("Already exists: %s", destpath)

{rez-3.1.0 → rez-3.2.0}/src/rez/config.py

@@ -397,6 +397,7 @@ config_schema = Schema({
     "release_packages_path":                        Str,
     "dot_image_format":                             Str,
     "build_directory":                              Str,
+    "default_build_process":                        Str,
     "documentation_url":                            Str,
     "suite_visibility":                             SuiteVisibility_,
     "rez_tools_visibility":                         RezToolsVisibility_,
@@ -453,6 +454,7 @@ config_schema = Schema({
     "package_cache_during_build":                   Bool,
     "package_cache_local":                          Bool,
     "package_cache_same_device":                    Bool,
+    "package_cache_async":                          Bool,
     "color_enabled":                                ForceOrBool,
     "resolve_caching":                              Bool,
     "cache_package_files":                          Bool,

rez-3.2.0/src/rez/data/tests/builds/packages/testing_obj/1.0.0/build.py

@@ -0,0 +1,24 @@
+from build_util import build_directory_recurse
+import os.path
+
+
+def build(source_path, build_path, install_path, targets):
+
+    if "install" not in (targets or []):
+        install_path = None
+
+    build_directory_recurse(src_dir="testing_obj",
+                            dest_dir=os.path.join("python", "testing_obj"),
+                            source_path=source_path,
+                            build_path=build_path,
+                            install_path=install_path)
+
+
+if __name__ == '__main__':
+    import os, sys
+    build(
+        source_path=os.environ['REZ_BUILD_SOURCE_PATH'],
+        build_path=os.environ['REZ_BUILD_PATH'],
+        install_path=os.environ['REZ_BUILD_INSTALL_PATH'],
+        targets=sys.argv[1:]
+    )

rez-3.2.0/src/rez/data/tests/builds/packages/testing_obj/1.0.0/package.py

@@ -0,0 +1,42 @@
+name = 'testing obj'
+version = '1.0.0'
+authors = ["Dan Flashes"]
+
+description = "testing the 'testing' attribute available during rez test"
+
+@late()
+def requires():
+    if in_context() and testing:
+        return ["floob"]
+    return ["hello"]
+
+private_build_requires = ["build_util", "python"]
+
+def commands():
+    env.PYTHONPATH.append('{root}/python')
+    if testing:
+        env.CAR_IDEA = "STURDY STEERING WHEEL"
+    else:
+        env.SKIP_LUNCH = "False"
+
+build_command = 'python {root}/build.py {install}'
+
+tests = {
+    "command_as_string_success": {
+        "command": "exit 0"
+    },
+    "command_as_string_fail": {
+        "command": "exit 1"
+    },
+    "check_car_ideas": {
+        "command": ["python", "-c", "import os; assert os.environ.get('CAR_IDEA') == 'STURDY STEERING WHEEL'"],
+        "requires": ["python"]
+    },
+    "move_meeting_to_noon": {
+        # We want this test to fail. SKIP_LUNCH should not be set.
+        # TODO: We should not test for failures here. Testing failures, str vs lsit commands, etc
+        # should we tested separately.
+        "command": ["python", "-c", "import os; assert os.environ.get('SKIP_LUNCH') is not None"],
+        "requires": ["python"]
+    }
+}

rez-3.2.0/src/rez/data/tests/builds/packages/testing_obj/1.0.0/testing_obj/__init__.py

@@ -0,0 +1,2 @@
+def hello():
+    return "This shirt was $150 out the door and the pattern's not that complicated"

rez-3.2.0/src/rez/data/tests/solver/packages/test_weakly_reference_requires/2.0/package.py

@@ -0,0 +1,4 @@
+name = "test_weakly_reference_requires"
+version = "2.0"
+
+requires = ["~test_variant_split_mid1", "~test_variant_split_mid2"]

rez-3.2.0/src/rez/data/tests/solver/packages/test_weakly_reference_variant/2.0/package.py

@@ -0,0 +1,6 @@
+name = "test_weakly_reference_variant"
+version = "2.0"
+
+requires = ["~pyfoo"]
+
+variants = [["test_variant_split_mid1", "~test_variant_split_mid2-1..3"]]

{rez-3.1.0 → rez-3.2.0}/src/rez/deprecations.py

@@ -7,12 +7,12 @@ import warnings
 
 def warn(message, category, pre_formatted=False, stacklevel=1, filename=None, **kwargs):
     """
-    Wrapper around warnings.warn that allows to passa a pre-formatter
+    Wrapper around warnings.warn that allows to pass a pre-formatter
     warning message. This allows to warn about things that aren't coming
     from python files, like environment variables, etc.
     """
     if not pre_formatted:
-        message = warnings.warn(
+        warnings.warn(
             message, category=category, stacklevel=stacklevel + 1, **kwargs
         )
         return

{rez-3.1.0 → rez-3.2.0}/src/rez/package_cache.py

@@ -22,6 +22,7 @@ from contextlib import contextmanager
 from rez.config import config
 from rez.exceptions import PackageCacheError
 from rez.vendor.lockfile import LockFile, NotLocked
+from rez.vendor.progress.spinner import PixelSpinner
 from rez.utils.filesystem import safe_listdir, safe_makedirs, safe_remove, \
     forceful_rmtree
 from rez.utils.colorize import ColorizedStreamHandler
@@ -70,6 +71,18 @@ class PackageCache(object):
     VARIANT_PENDING = 5  #: Variant is pending caching
     VARIANT_REMOVED = 6  #: Variant was deleted
 
+    STATUS_DESCRIPTIONS = {
+        VARIANT_NOT_FOUND: "was not found",
+        VARIANT_FOUND: "was found",
+        VARIANT_CREATED: "was created",
+        VARIANT_COPYING: "payload is still being copied to this cache",
+        VARIANT_COPY_STALLED: "payload copy has stalled.\nSee "
+                              "https://rez.readthedocs.io/en/stable/caching.html#cleaning-the-cache "
+                              "for more information.",
+        VARIANT_PENDING: "is pending caching",
+        VARIANT_REMOVED: "was deleted",
+    }
+
     _FILELOCK_TIMEOUT = 10
     _COPYING_TIME_INC = 0.2
     _COPYING_TIME_MAX = 5.0
@@ -117,7 +130,7 @@ class PackageCache(object):
 
         return rootpath
 
-    def add_variant(self, variant, force=False):
+    def add_variant(self, variant, force=False, wait_for_copying=False, logger=None):
         """Copy a variant's payload into the cache.
 
         The following steps are taken to ensure muti-thread/proc safety, and to
@@ -148,6 +161,9 @@ class PackageCache(object):
             variant (Variant): The variant to copy into this cache
             force (bool): Copy the variant regardless. Use at your own risk (there
                 is no guarantee the resulting variant payload will be functional).
+            wait_for_copying (bool): Whether the caching step should block when one of the
+                pending variants is marked as already copying.
+            logger (None | Logger): If a logger is provided, log information to it.
 
         Returns:
             tuple: 2-tuple:
@@ -208,15 +224,40 @@ class PackageCache(object):
                     % package.repository
                 )
 
-        no_op_statuses = (
+        no_op_statuses = {
             self.VARIANT_FOUND,
-            self.VARIANT_COPYING,
-            self.VARIANT_COPY_STALLED
-        )
+            self.VARIANT_COPY_STALLED,
+        }
+        if not wait_for_copying:
+            # Copying variants are only no-ops if we want to ignore them.
+            no_op_statuses.add(self.VARIANT_COPYING)
 
         # variant already exists, or is being copied to cache by another thread/proc
         status, rootpath = self._get_cached_root(variant)
         if status in no_op_statuses:
+            if logger:
+                logger.warning(f"Not caching {variant.qualified_name}. "
+                               f"Variant {self.STATUS_DESCRIPTIONS[status]}")
+            return (rootpath, status)
+
+        if wait_for_copying and status == self.VARIANT_COPYING:
+            spinner = PixelSpinner(f"Waiting for {variant.qualified_name} to finish copying. ")
+            while status == self.VARIANT_COPYING:
+                spinner.next()
+                time.sleep(self._COPYING_TIME_INC)
+                status, rootpath = self._get_cached_root(variant)
+
+            # Status has changed, so report the change and return
+            if logger:
+                if status == self.VARIANT_FOUND:
+                    # We have resolved into a satisfactory state
+                    logger.info(
+                        f"{variant.qualified_name} {self.STATUS_DESCRIPTIONS[status]}"
+                    )
+                else:
+                    logger.warning(
+                        f"{variant.qualified_name} {self.STATUS_DESCRIPTIONS[status]}"
+                    )
             return (rootpath, status)
 
         # 1.
@@ -365,20 +406,39 @@ class PackageCache(object):
 
         This method is called when a context is created or sourced. Variants
         are then added to the cache in a separate process.
+
+        .. deprecated:: 3.2.0
+           Use :method:`add_variants` instead.
         """
+        return self.add_variants(variants, package_cache_async=True)
 
-        # A prod install is necessary because add_variants_async works by
+    def add_variants(self, variants, package_cache_async=True):
+        """Add the given variants to the package payload cache.
+        """
+
+        # A prod install is necessary because add_variants works by
         # starting a rez-pkg-cache proc, and this can only be done reliably in
         # a prod install. On non-windows we could fork instead, but there would
         # remain no good solution on windows.
         #
         if not system.is_production_rez_install:
             raise PackageCacheError(
-                "PackageCache.add_variants_async is only supported in a "
+                "PackageCache.add_variants is only supported in a "
                 "production rez installation."
             )
 
         variants_ = []
+        cachable_statuses = {
+            self.VARIANT_NOT_FOUND,
+        }
+        if not package_cache_async:
+            # We want to monitor copying variants if we're synchronous.
+            # We also want to report that a status has been stalled, so we'll
+            # hand that off to the caching function as well
+            cachable_statuses.update({
+                self.VARIANT_COPYING,
+                self.VARIANT_COPY_STALLED,
+            })
 
         # trim down to those variants that are cachable, and not already cached
         for variant in variants:
@@ -386,7 +446,7 @@ class PackageCache(object):
                 continue
 
             status, _ = self._get_cached_root(variant)
-            if status == self.VARIANT_NOT_FOUND:
+            if status in cachable_statuses:
                 variants_.append(variant)
 
         # if there are no variants to add, and no potential cleanup to do, then exit
@@ -427,6 +487,20 @@ class PackageCache(object):
             with open(filepath, 'w') as f:
                 f.write(json.dumps(handle_dict))
 
+        if package_cache_async:
+            self._subprocess_package_caching_daemon(self.path)
+        else:
+            # syncronous caching
+            self._run_caching_operation(wait_for_copying=True)
+
+    @staticmethod
+    def _subprocess_package_caching_daemon(path):
+        """
+        Run the package cache in a daemon process
+
+        Returns:
+            subprocess.Popen : The package caching daemon process
+        """
         # configure executable
         if platform.system() == "Windows":
             kwargs = {
@@ -443,7 +517,7 @@ class PackageCache(object):
             raise RuntimeError("Did not find rez-pkg-cache executable")
 
         # start caching subproc
-        args = [exe, "--daemon", self.path]
+        args = [exe, "--daemon", path]
 
         try:
             with open(os.devnull, 'w') as devnull:
@@ -454,8 +528,8 @@ class PackageCache(object):
                 else:
                     out_target = devnull
 
-                subprocess.Popen(
-                    [exe, "--daemon", self.path],
+                return subprocess.Popen(
+                    args,
                     stdout=out_target,
                     stderr=out_target,
                     **kwargs
@@ -558,6 +632,15 @@ class PackageCache(object):
             if pid > 0:
                 sys.exit(0)
 
+        self._run_caching_operation(wait_for_copying=False)
+
+    def _run_caching_operation(self, wait_for_copying=True):
+        """Copy pending variants.
+
+        Args:
+            wait_for_copying (bool): Whether the caching step should block when one of the
+                pending variants is marked as already copying.
+        """
         logger = self._init_logging()
 
         # somewhere for the daemon to store stateful info
@@ -568,7 +651,7 @@ class PackageCache(object):
         # copy variants into cache
         try:
             while True:
-                keep_running = self._run_daemon_step(state)
+                keep_running = self._run_caching_step(state, wait_for_copying=wait_for_copying)
                 if not keep_running:
                     break
         except Exception:
@@ -682,12 +765,13 @@ class PackageCache(object):
             except NotLocked:
                 pass
 
-    def _run_daemon_step(self, state):
+    def _run_caching_step(self, state, wait_for_copying=False):
         logger = state["logger"]
 
         # pick a random pending variant to copy
         pending_filenames = set(os.listdir(self._pending_dir))
-        pending_filenames -= set(state.get("copying", set()))
+        if not wait_for_copying:
+            pending_filenames -= set(state.get("copying", set()))
         if not pending_filenames:
             return False
 
@@ -710,7 +794,11 @@ class PackageCache(object):
         t = time.time()
 
         try:
-            rootpath, status = self.add_variant(variant)
+            rootpath, status = self.add_variant(
+                variant,
+                wait_for_copying=wait_for_copying,
+                logger=logger,
+            )
 
         except PackageCacheError as e:
             # variant cannot be cached, so remove as a pending variant

{rez-3.1.0 → rez-3.2.0}/src/rez/package_order.py

@@ -116,8 +116,9 @@ class PackageOrder(object):
 
         Args:
             package_name: (str) The family name of the package we are sorting
-            version_like: (Version|_LowerBound|_UpperBound|_Bound|VersionRange)
-                the version-like object you wish to generate a key for
+            version_like: (Version|_LowerBound|_UpperBound|_Bound|VersionRange|None)
+                The version-like object to be used as a basis for generating a sort key.
+                Note that 'None' is also a supported value, which maintains the default sorting order.
 
         Returns:
             Sortable object
@@ -126,21 +127,26 @@ class PackageOrder(object):
         """
         if isinstance(version_like, VersionRange):
             return tuple(self.sort_key(package_name, bound) for bound in version_like.bounds)
-        elif isinstance(version_like, _Bound):
+        if isinstance(version_like, _Bound):
             return (self.sort_key(package_name, version_like.lower),
                     self.sort_key(package_name, version_like.upper))
-        elif isinstance(version_like, _LowerBound):
+        if isinstance(version_like, _LowerBound):
             inclusion_key = -2 if version_like.inclusive else -1
             return self.sort_key(package_name, version_like.version), inclusion_key
-        elif isinstance(version_like, _UpperBound):
+        if isinstance(version_like, _UpperBound):
             inclusion_key = 2 if version_like.inclusive else 1
             return self.sort_key(package_name, version_like.version), inclusion_key
-        elif isinstance(version_like, Version):
+        if isinstance(version_like, Version):
             # finally, the bit that we actually use the sort_key_implementation for.
             return FallbackComparable(
                 self.sort_key_implementation(package_name, version_like), version_like)
-        else:
-            raise TypeError(version_like)
+        if version_like is None:
+            # As no version range is provided for this package,
+            # Python's sort preserves the order of equal elements.
+            # Thus, to maintain the original order,
+            # we return the same object for all None values.
+            return 0
+        raise TypeError(version_like)
 
     def sort_key_implementation(self, package_name, version):
         """Returns a sort key usable for sorting these packages within the
@@ -171,7 +177,7 @@ class PackageOrder(object):
         raise NotImplementedError
 
     def __eq__(self, other):
-        return type(self) == type(other) and str(self) == str(other)
+        return type(self) == type(other) and str(self) == str(other)  # noqa: E721
 
     def __ne__(self, other):
         return not self == other
@@ -198,7 +204,7 @@ class NullPackageOrder(PackageOrder):
         return "{}"
 
     def __eq__(self, other):
-        return type(self) == type(other)
+        return type(self) == type(other)  # noqa: E721
 
     def to_pod(self):
         """
@@ -244,7 +250,7 @@ class SortedOrder(PackageOrder):
         return str(self.descending)
 
     def __eq__(self, other):
-        return (
+        return (  # noqa: E721
             type(self) == type(other)
             and self.descending == other.descending
         )
@@ -321,7 +327,7 @@ class PerFamilyOrder(PackageOrder):
         return str((items, str(self.default_order)))
 
     def __eq__(self, other):
-        return (
+        return (  # noqa: E721
             type(other) == type(self)
             and self.order_dict == other.order_dict
             and self.default_order == other.default_order
@@ -413,7 +419,7 @@ class VersionSplitPackageOrder(PackageOrder):
         return str(self.first_version)
 
     def __eq__(self, other):
-        return (
+        return (  # noqa: E721
             type(other) == type(self)
             and self.first_version == other.first_version
         )
@@ -576,7 +582,7 @@ class TimestampPackageOrder(PackageOrder):
         return str((self.timestamp, self.rank))
 
     def __eq__(self, other):
-        return (
+        return (  # noqa: E721
             type(other) == type(self)
             and self.timestamp == other.timestamp
             and self.rank == other.rank

{rez-3.1.0 → rez-3.2.0}/src/rez/package_test.py

@@ -394,7 +394,9 @@ class PackageTestRunner(object):
             if isinstance(command, str):
                 command = variant.format(command)
             else:
-                command = map(variant.format, command)
+                # Note that we convert the iterator to a list to
+                # make sure that we can consume the variable more than once.
+                command = [x for x in map(variant.format, command)]
 
             if extra_test_args:
                 if isinstance(command, str):
@@ -601,6 +603,7 @@ class PackageTestRunner(object):
                     package_paths=self.package_paths,
                     buf=(f if quiet else None),
                     timestamp=self.timestamp,
+                    testing=True,
                     **self.context_kwargs
                 )