-added native support for expanding 'pkg-*' requirements lists

-added rez-build --view-pre option
-fix for case where @included module used both in developer pkg and installed pkg

Author: ajohns

src/rez/cli/build.py

@@ -59,6 +59,9 @@ def setup_parser(parser, completions=False):
         help="create build scripts rather than performing the full build. "
         "Running these scripts will place you into a build environment, where "
         "you can invoke the build system directly.")
+    parser.add_argument(
+        "--view-pre", action="store_true",
+        help="just view the preprocessed package definition, and exit.")
     setup_parser_common(parser)
 
 
@@ -85,12 +88,17 @@ def command(opts, parser, extra_arg_groups=None):
     from rez.packages_ import get_developer_package
     from rez.build_process_ import create_build_process
     from rez.build_system import create_build_system
+    from rez.serialise import FileFormat
     import sys
 
     # load package
     working_dir = os.getcwd()
     package = get_developer_package(working_dir)
 
+    if opts.view_pre:
+        package.print_info(format_=FileFormat.py, skip_attributes=["preprocess"])
+        sys.exit(0)
+
     # create build system
     build_args, child_build_args = get_build_args(opts, parser, extra_arg_groups)
     buildsys_type = opts.buildsys if ("buildsys" in opts) else None

src/rez/package_maker__.py

@@ -7,13 +7,17 @@
     _function_schema, late_bound
 from rez.package_repository import create_memory_package_repository
 from rez.packages_ import Package
+from rez.package_py_utils import expand_requirement
 from rez.vendor.schema.schema import Schema, Optional, Or, Use, And
 from rez.vendor.version.version import Version
 from contextlib import contextmanager
 import os
 
 
-package_request_schema = Or(basestring,
+# this schema will automatically harden request strings like 'python-*'; see
+# the 'expand_requires' function for more info.
+#
+package_request_schema = Or(And(basestring, Use(expand_requirement)),
                             And(PackageRequest, Use(str)))
 
 

src/rez/package_py_utils.py

@@ -4,44 +4,54 @@
 
 - the special 'preprocess' function;
 - early bound functions that use the @early decorator.
+"""
 
-An example of use:
+# these imports just forward the symbols into this module's namespace
+from rez.utils.sourcecode import late
+from rez.exceptions import InvalidPackageError
 
-    # in package.py
-    name = 'mypackage'
 
-    version = '1.2.3'
+def expand_requirement(request):
+    """Expands a requirement string like 'python-2.*'
 
-    @early()
-    def requires():
-        from rez.package_py_utils import expand_requires
+    Only trailing wildcards are supported; they will be replaced with the
+    latest package version found within the range. If none are found, the
+    wildcards will just be stripped.
 
-        return expand_requires(
-            'boost-1.*.*',
-            'maya-2017.*'
-        )
-"""
+    Example:
 
-# Here to allow 'from rez.package_utils import late' in package.py
-from rez.utils.sourcecode import late
+        >>> print expand_requirement('python-2.*')
+        python-2.7
 
-# Here to allow 'from rez.package_utils import InvalidPackageError' in package.py
-from rez.exceptions import InvalidPackageError
+    Args:
+        request (str): Request to expand, eg 'python-2.*'
 
+    Returns:
+        str: Expanded request string.
+    """
+    from rez.vendor.version.requirement import VersionedObject, Requirement
+    from rez.packages_ import get_latest_package
 
-def expand_requires(*requests):
-    """Create an expanded requirements list.
+    txt = request.replace('*', '_')
+    obj = VersionedObject(txt)
+    rank = len(obj.version)
+
+    request_ = request
+    while request_.endswith('*'):
+        request_ = request_[:-2]  # strip sep + *
 
-    Given a list of requirements with optional trailing wildcards, expand each
-    out to the latest package found within that range. This is useful when a
-    package is compatible with a version range of a package at build time, but
-    requires a stricter requirement at runtime. For example, a compiled library
-    may build with many versions of boost (boost-1.*.*), but once compiled, must
-    be used with the boost version that has then been linked against (1.55.0).
+    req = Requirement(request_)
+    package = get_latest_package(name=req.name, range_=req.range_)
 
-    Note:
-        If a package is not found in the given range, it is expanded to the
-        request as-is, with trailing wildcards removed.
+    if package is None:
+        return request_
+
+    obj.version_ = package.version.trim(rank)
+    return str(obj)
+
+
+def expand_requires(*requests):
+    """Create an expanded requirements list.
 
     Example:
 
@@ -57,27 +67,4 @@ def expand_requires(*requests):
     Returns:
         List of str: Expanded requirements.
     """
-    from rez.vendor.version.requirement import VersionedObject
-    from rez.packages_ import get_latest_package
-
-    result = []
-
-    for request in requests:
-        txt = request.replace('*', '_')
-        obj = VersionedObject(txt)
-        rank = len(obj.version)
-
-        request_ = request
-        while request_.endswith('*'):
-            request_ = request_[:-2]  # consume sep + *
-
-        package = get_latest_package(request_)
-
-        if package is None:
-            result.append(request_)
-            continue
-
-        obj.version_ = package.version.trim(rank)
-        result.append(str(obj))
-
-    return result
+    return [expand_requirement(x) for x in requests]

src/rez/packages_.py

@@ -3,6 +3,7 @@
     VariantResource, package_family_schema, package_schema, variant_schema, \
     package_release_keys, late_requires_schema
 from rez.package_serialise import dump_package_data
+from rez.utils import reraise
 from rez.utils.logging_ import print_info, print_error
 from rez.utils.sourcecode import SourceCode
 from rez.utils.data_utils import cached_property, _missing
@@ -234,7 +235,7 @@ def iter_variants(self):
         """
         repo = self.resource._repository
         for variant in repo.iter_variants(self.resource):
-            yield Variant(variant, context=self.context)
+            yield Variant(variant, context=self.context, parent=self)
 
     def get_variant(self, index=None):
         """Get the variant with the associated index.
@@ -257,9 +258,10 @@ class Variant(PackageBaseResourceWrapper):
     keys = schema_keys(variant_schema)
     keys.update(["index", "root", "subpath"])
 
-    def __init__(self, resource, context=None):
+    def __init__(self, resource, context=None, parent=None):
         _check_class(resource, VariantResource)
         super(Variant, self).__init__(resource, context)
+        self._parent = parent
 
     # arbitrary keys
     def __getattr__(self, name):
@@ -293,24 +295,35 @@ def parent(self):
         Returns:
             `Package`.
         """
-        repo = self.resource._repository
-        package = repo.get_parent_package(self.resource)
-        return Package(package, context=self.context)
+        if self._parent is not None:
+            return self._parent
+
+        try:
+            repo = self.resource._repository
+            package = repo.get_parent_package(self.resource)
+            self._parent = Package(package, context=self.context)
+        except AttributeError as e:
+            reraise(e, ValueError)
+
+        return self._parent
 
     @property
     def requires(self):
         """Get variant requirements.
 
-        This is a concatenation of the package requirements and those if this
+        This is a concatenation of the package requirements and those of this
         specific variant.
         """
-        package_requires = self.parent.requires or []
+        try:
+            package_requires = self.parent.requires or []
 
-        if self.index is None:
-            return package_requires
-        else:
-            variant_requires = self.parent.variants[self.index] or []
-            return package_requires + variant_requires
+            if self.index is None:
+                return package_requires
+            else:
+                variant_requires = self.parent.variants[self.index] or []
+                return package_requires + variant_requires
+        except AttributeError as e:
+            reraise(e, ValueError)
 
     def get_requires(self, build_requires=False, private_build_requires=False):
         """Get the requirements of the variant.

src/rez/utils/sourcecode.py

@@ -293,16 +293,40 @@ def __init__(self):
 
     def load_module(self, name, package):
         from rez.config import config  # avoiding circular import
+        from rez.developer_package import DeveloperPackage
 
-        path = os.path.join(package.base, self.include_modules_subpath)
-        pathname = os.path.join(path, "%s-*.py" % name)
+        # in rare cases, a @late bound function may get called before the
+        # package is built. An example is 'requires' and the other requires-like
+        # functions. These need to be evaluated before a build, but it does also
+        # make sense to sometimes implement these as late-bound functions. We
+        # detect this case here, and load the modules from the original (pre-
+        # copied into package payload) location.
+        #
+        if isinstance(package, DeveloperPackage):
+            from hashlib import sha1
 
-        pathnames = glob(pathname)
-        if not pathnames:
-            return None
+            # load sourcefile from original location
+            path = config.package_definition_python_path
+            filepath = os.path.join(path, "%s.py" % name)
+
+            if not os.path.exists(filepath):
+                return None
+
+            with open(filepath) as f:
+                txt = f.read().strip()
+
+            hash_str = sha1(txt).hexdigest()
+        else:
+            # load sourcefile that's been copied into package install payload
+            path = os.path.join(package.base, self.include_modules_subpath)
+            pathname = os.path.join(path, "%s-*.py" % name)
+
+            pathnames = glob(pathname)
+            if not pathnames:
+                return None
 
-        filepath = pathnames[0]
-        hash_str = filepath.rsplit('-', 1)[-1].split('.', 1)[0]
+            filepath = pathnames[0]
+            hash_str = filepath.rsplit('-', 1)[-1].split('.', 1)[0]
 
         module = self.modules.get(hash_str)
         if module is not None: