Exemple #1
0
def get_plugins(package_name, paths=None):
    """Find packages that are plugins of the given package.

    Args:
        package_name (str): Name of the package.
        paths (list of str): Paths to search for packages, defaults to
            `config.packages_path`.

    Returns:
        list of str: The packages that are plugins of the given package.
    """
    pkg = get_latest_package(package_name, paths=paths, error=True)
    if not pkg.has_plugins:
        return []

    it = iter_package_families(paths)
    package_names = set(x.name for x in it)
    bar = ProgressBar("Searching", len(package_names))

    plugin_pkgs = []
    for package_name_ in package_names:
        bar.next()
        if package_name_ == package_name:
            continue  # not a plugin of itself

        plugin_pkg = get_latest_package(package_name_, paths=paths)
        if not plugin_pkg.plugin_for:
            continue
        for plugin_for in plugin_pkg.plugin_for:
            if plugin_for == pkg.name:
                plugin_pkgs.append(package_name_)

    bar.finish()
    return plugin_pkgs
Exemple #2
0
def get_plugins(package_name, paths=None):
    """Find packages that are plugins of the given package.

    Args:
        package_name (str): Name of the package.
        paths (list of str): Paths to search for packages, defaults to
            `config.packages_path`.

    Returns:
        list of str: The packages that are plugins of the given package.
    """
    pkg = get_latest_package(package_name, paths=paths, error=True)
    if not pkg.has_plugins:
        return []

    it = iter_package_families(paths)
    package_names = set(x.name for x in it)
    bar = ProgressBar("Searching", len(package_names))

    plugin_pkgs = []
    for package_name_ in package_names:
        bar.next()
        if package_name_ == package_name:
            continue  # not a plugin of itself

        plugin_pkg = get_latest_package(package_name_, paths=paths)
        if not plugin_pkg.plugin_for:
            continue
        for plugin_for in plugin_pkg.plugin_for:
            if plugin_for == pkg.name:
                plugin_pkgs.append(package_name_)

    bar.finish()
    return plugin_pkgs
Exemple #3
0
    def expand_version(version):
        rank = len(version)
        wildcard_found = False

        while version and str(version[-1]) in wildcard_map:
            token = wildcard_map[str(version[-1])]
            version = version.trim(len(version) - 1)

            if token == "**":
                if wildcard_found:  # catches bad syntax '**.*'
                    return None
                else:
                    wildcard_found = True
                    rank = 0
                    break

            wildcard_found = True

        if not wildcard_found:
            return None

        range_ = VersionRange(str(version))
        package = get_latest_package(name=req.name, range_=range_, paths=paths)

        if package is None:
            return version

        if rank:
            return package.version.trim(rank)
        else:
            return package.version
Exemple #4
0
 def _get_dest_pkg(self, name, version):
     return get_latest_package(
         name,
         range_=VersionRange("==" + version),
         paths=[self.dest_install_root],
         error=True
     )
    def expand_version(version):
        rank = len(version)
        wildcard_found = False

        while version and str(version[-1]) in wildcard_map:
            token = wildcard_map[str(version[-1])]
            version = version.trim(len(version) - 1)

            if token == "**":
                if wildcard_found:  # catches bad syntax '**.*'
                    return None
                else:
                    wildcard_found = True
                    rank = 0
                    break

            wildcard_found = True

        if not wildcard_found:
            return None

        range_ = VersionRange(str(version))
        package = get_latest_package(name=req.name, range_=range_, paths=paths)

        if package is None:
            return version

        if rank:
            return package.version.trim(rank)
        else:
            return package.version
Exemple #6
0
 def _get_dest_pkg(self, name, version):
     return get_latest_package(
         name,
         range_=VersionRange("==" + version),
         paths=[self.dest_install_root],
         error=True
     )
Exemple #7
0
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
Exemple #8
0
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 find_intersphinx_links(requirements):
    """Convert a Rez package's list of requirements into API documentation links.

    Args:
        requirements (iter[:class:`rez.utils.formatting.PackageRequest`]):
            The Package + version (if there is a version) information
            that will be used to query documentation details.

    Returns:
        dict[str, tuple[str, None]]:
            Get every Rez package and its URL help documentation, if found.

    """
    packages = set()

    for requirement in requirements:
        package = packages_.get_latest_package(requirement.name,
                                               range_=requirement.range_)

        if package:
            packages.add(package)

            continue

        _LOGGER.warning('No Rez package was found for requirement "%s".',
                        requirement)

    output = dict()

    finders = [
        url_help.find_package_documentation, url_help.find_api_documentation
    ]

    for package in packages:
        for finder in finders:
            documentation = finder(package)

            if documentation:
                output[package.name] = (documentation, None)

                break

    return output
Exemple #10
0
def expand_requirement(request):
    """Expands a requirement string like 'python-2.*'

    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.

    Example:

        >>> print expand_requirement('python-2.*')
        python-2.7

    Args:
        request (str): Request to expand, eg 'python-2.*'

    Returns:
        str: Expanded request string.
    """
    if '*' not in request:
        return request

    from rez.vendor.version.requirement import VersionedObject, Requirement
    from rez.packages_ import get_latest_package

    txt = request.replace('*', '_')
    obj = VersionedObject(txt)
    rank = len(obj.version)

    request_ = request
    while request_.endswith('*'):
        request_ = request_[:-2]  # strip sep + *

    req = Requirement(request_)
    package = get_latest_package(name=req.name, range_=req.range_)

    if package is None:
        return request_

    obj.version_ = package.version.trim(rank)
    return str(obj)
def iter_latest_packages(paths=None, packages=None):
    """Get one package from every Rez package family.

    Args:
        paths (list[str], optional):
            The directories to search for Rez package families,
            Default: :attr:`rez.config.config.packages_path`.
        packages (set[str], optional):
            If this parameter is given a value, any Rez package families
            that are discovered in `paths` will be filtered by the list
            of Rez package family names in this parameter.

    Yields:
        :class:`rez.packages_.Package`:
            The latest version of every package in the current environment.

    """
    names = sorted(
        set(family.name
            for family in packages_.iter_package_families(paths=paths)))

    if packages:
        names = [name for name in names if name in packages]

    for name in names:
        package = packages_.get_latest_package(name, paths=paths)

        if not package:
            _LOGGER.warning(
                'Package family "%s" was found but `get_latest_package` returned None.'
                "The package is probably damaged.",
                name,
            )

            continue

        yield package
Exemple #12
0
Fichier : pip.py Projet : rvsiy/rez
def pip_install_package(source_name, pip_version=None, python_versions=None,
                        no_deps=False, install_newer_deps=False):
    """Install a pip-compatible python package as a rez package.

    Args:
        source_name (str): Name of package or archive/url containing the pip
            package source. This is the same as the arg you would pass to
            the 'pip install' command.
        pip_version (str or `Version`): Version of pip to use to perform the
            install, uses latest if None.
        python_versions (list of str or `Version`): Python version(s) to use to
            perform the install, and subsequently have the resulting rez package
            depend on. If multiple values are provided, this will create
            multiple variants in the package, each based on the python version.
            Defaults to a single variant for the latest python version.
        no_deps (bool): If True, don't install dependencies.
        install_newer_deps (bool): If True, newer package dependencies will be
            installed, even if existing rez package versions already exist that
            already satisfy the package's dependencies.
    """
    if pip_version:
        pip_req = "pip-%s" % str(pip_version)
    else:
        pip_req = "pip"

    py_reqs = []
    if python_versions:
        py_vers = set()
        for ver in python_versions:
            ver_ = Version(str(ver))
            major_minor_ver = ver_[:2]
            py_vers.add(major_minor_ver)

        for py_ver in sorted(py_vers):
            py_req = "python-%s" % str(py_ver)
            py_reqs.append(py_req)
    else:
        # use latest major.minor
        package = get_latest_package("python")
        major_minor_ver = package.version[:2]
        py_req = "python-%s" % str(major_minor_ver)
        py_reqs.append(py_req)

    tmpdir = mkdtemp(suffix="-rez", prefix="pip-")
    packages = {}

    # use pip + latest python to perform common operations
    request = [pip_req, py_reqs[-1]]
    context = ResolvedContext(request)

    # download package and dependency archives
    dl_path = os.path.join(tmpdir, "download")
    os.mkdir(dl_path)
    primary_name = _download_packages(source_name,
                                      context=context,
                                      tmpdir=dl_path,
                                      no_deps=no_deps)

    # build each so we can extract dependencies and determine if they are
    # platform-specific (ie if they contain .so or similar)
    tmp_installs_path = os.path.join(tmpdir, "install")
    os.mkdir(tmp_installs_path)

    for name in os.listdir(dl_path):
        filepath = os.path.join(dl_path, name)
        tmp_install_path = os.path.join(tmp_installs_path, name)
        os.mkdir(tmp_install_path)

        metadata = _analyse_package(context, filepath, tmp_install_path)
        metadata["primary"] = (name == primary_name)
        packages[metadata["package_name"]] = metadata

    # sort as reverse dependency tree, we need to install from bottom of tree
    # up, since a rez-release must have rez package dependencies present
    package_list = _get_install_list(packages, install_newer_deps)

    # perform a rez-release on each package
    tmp_rezbuilds_path = os.path.join(tmpdir, "rez-build")
    os.mkdir(tmp_rezbuilds_path)

    for package in package_list:
        package_name = package["package_name"]
        tmp_rezbuild_path = os.path.join(tmp_rezbuilds_path, package_name)

        _rez_release_package(package,
                             pip_requirement=pip_req,
                             python_requirements=py_reqs,
                             tmpdir=tmp_rezbuild_path)
Exemple #13
0
Fichier : pip.py Projet : skral/rez
def pip_install_package(source_name, pip_version=None, python_versions=None,
                        no_deps=False, install_newer_deps=False):
    """Install a pip-compatible python package as a rez package.

    Args:
        source_name (str): Name of package or archive/url containing the pip
            package source. This is the same as the arg you would pass to
            the 'pip install' command.
        pip_version (str or `Version`): Version of pip to use to perform the
            install, uses latest if None.
        python_versions (list of str or `Version`): Python version(s) to use to
            perform the install, and subsequently have the resulting rez package
            depend on. If multiple values are provided, this will create
            multiple variants in the package, each based on the python version.
            Defaults to a single variant for the latest python version.
        no_deps (bool): If True, don't install dependencies.
        install_newer_deps (bool): If True, newer package dependencies will be
            installed, even if existing rez package versions already exist that
            already satisfy the package's dependencies.
    """
    if pip_version:
        pip_req = "pip-%s" % str(pip_version)
    else:
        pip_req = "pip"

    py_reqs = []
    if python_versions:
        py_vers = set()
        for ver in python_versions:
            ver_ = Version(str(ver))
            major_minor_ver = ver_[:2]
            py_vers.add(major_minor_ver)

        for py_ver in sorted(py_vers):
            py_req = "python-%s" % str(py_ver)
            py_reqs.append(py_req)
    else:
        # use latest major.minor
        package = get_latest_package("python")
        major_minor_ver = package.version[:2]
        py_req = "python-%s" % str(major_minor_ver)
        py_reqs.append(py_req)

    tmpdir = mkdtemp(suffix="-rez", prefix="pip-")
    packages = {}

    # use pip + latest python to perform common operations
    request = [pip_req, py_reqs[-1]]
    context = ResolvedContext(request)

    # download package and dependency archives
    dl_path = os.path.join(tmpdir, "download")
    os.mkdir(dl_path)
    primary_name = _download_packages(source_name,
                                      context=context,
                                      tmpdir=dl_path,
                                      no_deps=no_deps)

    # build each so we can extract dependencies and determine if they are
    # platform-specific (ie if they contain .so or similar)
    tmp_installs_path = os.path.join(tmpdir, "install")
    os.mkdir(tmp_installs_path)

    for name in os.listdir(dl_path):
        filepath = os.path.join(dl_path, name)
        tmp_install_path = os.path.join(tmp_installs_path, name)
        os.mkdir(tmp_install_path)

        metadata = _analyse_package(context, filepath, tmp_install_path)
        metadata["primary"] = (name == primary_name)
        packages[metadata["package_name"]] = metadata

    # sort as reverse dependency tree, we need to install from bottom of tree
    # up, since a rez-release must have rez package dependencies present
    package_list = _get_install_list(packages, install_newer_deps)

    # perform a rez-release on each package
    tmp_rezbuilds_path = os.path.join(tmpdir, "rez-build")
    os.mkdir(tmp_rezbuilds_path)

    for package in package_list:
        package_name = package["package_name"]
        tmp_rezbuild_path = os.path.join(tmp_rezbuilds_path, package_name)

        _rez_release_package(package,
                             pip_requirement=pip_req,
                             python_requirements=py_reqs,
                             tmpdir=tmp_rezbuild_path)
Exemple #14
0
Fichier : pip.py Projet : rjq/rez
def find_pip_from_context(python_version, pip_version=None):
    """Find pip from rez context.

    Args:
        python_version (str or `Version`): Python version to use
        pip_version (str or `Version`): Version of pip to use, or latest.

    Returns:
        3-tuple:
        - str: Python executable or None if we fell back to system pip.
        - str: Pip version or None if we fell back to system pip.
        - `ResolvedContext`: Context containing pip, or None if we fell back
          to system pip.
    """
    target = "python"
    package_request = []

    if python_version:
        ver = Version(str(python_version))
        python_major_minor_ver = ver.trim(2)
    else:
        # use latest major.minor
        package = get_latest_package("python")
        if package:
            python_major_minor_ver = package.version.trim(2)
        else:
            raise BuildError("Found no python package.")

    python_package = "python-%s" % str(python_major_minor_ver)

    package_request.append(python_package)

    if pip_version:
        target = "pip"
        if pip_version == "latest":
            package_request.append("pip")
        else:
            package_request.append("pip-%s" % str(pip_version))

    print_info("Trying to use pip from %s package", target)

    try:
        context = ResolvedContext(package_request)
    except (PackageFamilyNotFoundError, PackageNotFoundError):
        print_debug("No rez package called %s found", target)
        return None, None, None

    py_exe_name = "python"
    if platform_.name != "windows":
        # Python < 2 on Windows doesn't have versionned executable.
        py_exe_name += str(python_major_minor_ver.trim(1))

    py_exe = context.which(py_exe_name)

    proc = context.execute_command(
        # -E and -s are used to isolate the environment as much as possible.
        # See python --help for more details. We absolutely don't want to get
        # pip from the user home.
        [
            py_exe, "-E", "-s", "-c",
            "import pip, sys; sys.stdout.write(pip.__version__)"
        ],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True)
    out, err = proc.communicate()
    if proc.returncode:
        print_debug("Failed to get pip from package %s", target)
        print_debug(out)
        print_debug(err)
        return None, None, None

    pip_version = out.strip()

    variant = context.get_resolved_package(target)
    package = variant.parent
    print_info("Found pip-%s inside %s. Will use it with %s", pip_version,
               package.uri, py_exe)

    return py_exe, pip_version, context
Exemple #15
0
def _is_missing_python_version(version):
    """Check if the given version / version-range has a valid package."""
    return packages.get_latest_package("python", version) is None