Beispiel #1
0
 def test_unpinned_hash_checking(self, data):
     """Make sure prepare_files() raises an error when a requirement is not
     version-pinned in hash-checking mode.
     """
     reqset = RequirementSet()
     # Test that there must be exactly 1 specifier:
     reqset.add_requirement(
         list(
             process_line(
                 'simple --hash=sha256:a90427ae31f5d1d0d7ec06ee97'
                 'd9fcf2d0fc9a786985250c1c83fd68df5911dd', 'file', 1))[0])
     # Test that the operator must be ==:
     reqset.add_requirement(
         list(
             process_line(
                 'simple2>1.0 --hash=sha256:3ad45e1e9aa48b4462af0'
                 '123f6a7e44a9115db1ef945d4d92c123dfe21815a06', 'file',
                 2))[0])
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     assert_raises_regexp(
         HashErrors,
         # Make sure all failing requirements are listed:
         r'versions pinned with ==. These do not:\n'
         r'    simple .* \(from -r file \(line 1\)\)\n'
         r'    simple2>1.0 .* \(from -r file \(line 2\)\)',
         resolver.resolve,
         reqset)
 def run(self, options, args):
     with self._build_session(options) as session:
         format_control = pip.index.FormatControl(set(), set())
         wheel_cache = WheelCache(options.cache_dir, format_control)
         requirement_set = RequirementSet(
             build_dir=None,
             src_dir=None,
             download_dir=None,
             isolated=options.isolated_mode,
             session=session,
             wheel_cache=wheel_cache,
         )
         for name in args:
             requirement_set.add_requirement(
                 InstallRequirement.from_line(
                     name,
                     isolated=options.isolated_mode,
                     wheel_cache=wheel_cache))
         for filename in options.requirements:
             for req in parse_requirements(filename,
                                           options=options,
                                           session=session,
                                           wheel_cache=wheel_cache):
                 requirement_set.add_requirement(req)
         if not requirement_set.has_requirements:
             raise InstallationError(
                 'You must give at least one requirement to %(name)s (see '
                 '"pip help %(name)s")' % dict(name=self.name))
         requirement_set.uninstall(auto_confirm=options.yes)
    def _install_requirement(self, requirement):
        if not self.local_options:
            self.local_options = []

        if self._check_requirement(requirement):
            return True, None

        try:
            # Parse requirement
            requirement = InstallRequirement.from_line(str(requirement), None)

            # Build the requirement set.  We're doing this one at a time so we can actually detect
            # which ones fail.
            requirement_set = RequirementSet(build_dir=build_prefix, src_dir=src_prefix, download_dir=None)        
            requirement_set.add_requirement(requirement)

            # Download and build requirement
            try:
                requirement_set.prepare_files(self.finder, force_root_egg_info=False, bundle=False)
            except PreviousBuildDirError, err:
                # Remove previous build directories if they're detected.. shouldn't be an issue
                # now that we've removed upstream dependencies from requirements.txt.
                location = requirement.build_location(build_prefix, True)

                shutil.rmtree(location)
                requirement_set.prepare_files(self.finder, force_root_egg_info=False, bundle=False)

            # Finally, install the requirement.
            requirement_set.install(self.local_options, [])
Beispiel #4
0
def getDependencies(name, requirementSet=None, finder=None):
    """Get dependencies of a python project
    
    @param name: name of python project
    @param requirements: RequirementSet
    @param finder: PackageFinder
    """
    if requirementSet is None:
        requirementSet = RequirementSet(
            build_dir=os.path.abspath(build_prefix),
            src_dir=os.path.abspath(src_prefix),
            download_dir=None,
            download_cache=None,
            upgrade=False,
            ignore_installed=True,
            ignore_dependencies=False)
    if finder is None:
        finder = PackageFinder(find_links=[], 
                               index_urls=['http://pypi.python.org/simple'])

    # lead pip download all dependencies
    req = InstallRequirement.from_line(name, None)
    requirementSet.add_requirement(req)
    requirementSet.install_files(finder)
    
    # trace the dependencies relationships between projects
    dependencies = []
    traceDependencys(req, requirementSet, dependencies)
    return dependencies
Beispiel #5
0
class Pip(object):
    """
    A class to puppet PIP to install new eggs
    """

    requirement_set = None  # the requirement set
    # the package finder
    finder = PackageFinder(find_links=[], index_urls=["http://pypi.python.org/simple/"], session=PipSession())

    def __init__(self, egg_directory):
        self.egg_directory = egg_directory = os.path.abspath(os.path.expanduser(egg_directory))
        sys.path += [os.path.join(egg_directory, "lib", "python" + PYTHON_VERSION, "site-packages")]
        with BuildDirectory() as build_prefix:
            self.requirement_set = RequirementSet(
                build_dir=build_prefix, src_dir=src_prefix, download_dir=None, upgrade=True, session=PipSession()
            )

    def delete_all_eggs(self):
        """ delete all the eggs in the directory specified """
        path_to_delete = os.path.join(self.egg_directory, "lib", "python")
        if os.path.exists(path_to_delete):
            shutil.rmtree(path_to_delete)

    def install_egg(self, egg_name):
        """ Install an egg into the egg directory """
        if not os.path.exists(self.egg_directory):
            os.makedirs(self.egg_directory)
        self.requirement_set.add_requirement(InstallRequirement.from_line(egg_name, None))
        try:
            self.requirement_set.prepare_files(self.finder)
            self.requirement_set.install(["--prefix=" + self.egg_directory], [])
        except DistributionNotFound:
            self.requirement_set.requirements._keys.remove(egg_name)
            raise PipException()
Beispiel #6
0
def _make_requirement_set(session, tempdir, download_dir, wheel_download_dir):
    """
    construction a RequirementSet
    """
    format_control = FormatControl(set(), set())
    wheel_cache = WheelCache(os.path.join(tempdir, ".cache"), format_control)
    requirement_set = RequirementSet(
        build_dir=os.path.join(tempdir, 'build'),
        src_dir=os.path.join(tempdir, 'src'),
        ignore_installed=True,
        download_dir=download_dir,
        wheel_download_dir=wheel_download_dir,
        wheel_cache=wheel_cache,
        session=session,
    )
    try:
        requirement_set.add_requirement(
            EditInstallRequirement.from_editable("."), )
    except Exception as e:
        sys.exit(e)
    if os.path.exists("requirements.txt"):
        with open("requirements.txt") as f:
            for line in f:
                requirement_set.add_requirement(
                    InstallRequirement.from_line(line), )
    return requirement_set
Beispiel #7
0
    def test_unsupported_hashes(self, data):
        """VCS and dir links should raise errors when --require-hashes is
        on.

        In addition, complaints about the type of requirement (VCS or dir)
        should trump the presence or absence of a hash.

        """
        reqset = RequirementSet(require_hashes=True)
        reqset.add_requirement(
            list(
                process_line(
                    'git+git://github.com/pypa/pip-test-package --hash=sha256:123',
                    'file', 1))[0])
        dir_path = data.packages.join('FSPkg')
        reqset.add_requirement(
            list(process_line('file://%s' % (dir_path, ), 'file', 2))[0])
        finder = PackageFinder([data.find_links], [], session=PipSession())
        resolver = self._basic_resolver(finder)
        sep = os.path.sep
        if sep == '\\':
            sep = '\\\\'  # This needs to be escaped for the regex
        assert_raises_regexp(
            HashErrors,
            r"Can't verify hashes for these requirements because we don't "
            r"have a way to hash version control repositories:\n"
            r"    git\+git://github\.com/pypa/pip-test-package \(from -r file "
            r"\(line 1\)\)\n"
            r"Can't verify hashes for these file:// requirements because they "
            r"point to directories:\n"
            r"    file://.*{sep}data{sep}packages{sep}FSPkg "
            r"\(from -r file \(line 2\)\)".format(sep=sep), resolver.resolve,
            reqset)
def install(name):
    """
    Try to install the package with 'name' into folder 'libs/python27'.
    """
    print "Installation directory:"
    print python27_dir()

    requirement_set = RequirementSet(build_dir=build_prefix,
                                     src_dir=src_prefix,
                                     download_dir=None)

    requirement_set.add_requirement(InstallRequirement.from_line(name, None))

    install_options = ["--prefix=%s" % python27_dir()]
    global_options = []
    finder = PackageFinder(find_links=[],
                           index_urls=["http://pypi.python.org/simple/"])

    try:
        requirement_set.prepare_files(finder,
                                      force_root_egg_info=False,
                                      bundle=False)

        requirement_set.install(install_options, global_options)

        print "\nSuccessfully installed\n=================================="
        for package in requirement_set.successfully_installed:
            print package.name
        print "\nDone.\n"

    except DistributionNotFound:
        print "No package found with name: %s" % name

    except Exception as e:
        print "Error:", e
Beispiel #9
0
def pip_install(name, tmpdir):
    build_dir = os.path.join(tmpdir, 'build')
    src_dir = os.path.join(tmpdir, 'src')
    download_dir = os.path.join(tmpdir, 'download')

    os.mkdir(build_dir)
    os.mkdir(src_dir)
    os.mkdir(download_dir)

    finder = PackageFinder(
        find_links=[],
        index_urls=['https://pypi.python.org/simple/'],
        use_mirrors=False,
        allow_all_external=True,
        allow_all_insecure=True,
    )

    requirement_set = RequirementSet(
        build_dir=build_dir,
        src_dir=src_dir,
        download_dir=download_dir,
        ignore_installed=True,
        ignore_dependencies=True
    )
    requirement_set.add_requirement(InstallRequirement.from_line(name, None))
    requirement_set.prepare_files(finder)

    # should be exactly one
    filename = os.listdir(download_dir)[0]
    path = os.path.join(download_dir, filename)
    return path
Beispiel #10
0
def install(name):
    """
    Try to install the package with 'name' into folder 'libs/python27'.
    """
    print "Installation directory:"
    print python27_dir()

    requirement_set = RequirementSet(build_dir=build_prefix,
                                     src_dir=src_prefix,
                                     download_dir=None)

    requirement_set.add_requirement(InstallRequirement.from_line(name, None))

    install_options = ["--prefix=%s" % python27_dir()]
    global_options = []
    finder = PackageFinder(find_links=[],
                           index_urls=["http://pypi.python.org/simple/"])

    try:
        requirement_set.prepare_files(finder,
                                      force_root_egg_info=False,
                                      bundle=False)

        requirement_set.install(install_options, global_options)

        print "\nSuccessfully installed\n=================================="
        for package in requirement_set.successfully_installed:
            print package.name
        print "\nDone.\n"

    except DistributionNotFound:
        print "No package found with name: %s" % name

    except Exception as e:
        print "Error:", e
Beispiel #11
0
def get_requirements(req_specs, requirement_files=None):
    """ Get set of requirements from pip-like input arguments

    Parameters
    ----------
    req_specs : sequence
        sequence of requirement specifiers, maybe with versions
    requirement_files : None or sequence, optional
        sequence of filenames or URLs with requirements

    Returns
    -------
    requirement_set : RequiremenSet instance
        Pip requirements set
    """
    if requirement_files is None:
        requirement_files = []
    session = PipSession()
    requirement_set = RequirementSet(
        build_dir=None,
        src_dir=None,
        download_dir=None,
        session=session,
    )
    for name in req_specs:
        requirement_set.add_requirement(
            InstallRequirement.from_line(name))
    for filename in requirement_files:
        for req in parse_requirements(filename, session=session):
            requirement_set.add_requirement(req)
    return requirement_set
Beispiel #12
0
class Pip(object):
    """
    A class to puppet PIP to install new eggs
    """
    requirement_set = None  # the requirement set
    # the package finder
    finder = PackageFinder(find_links=[], index_urls=["http://pypi.python.org/simple/"])
    install_options = []  # the install options with pip
    global_options = []  # the global options with pip

    def __init__(self, egg_directory, install_options=[], global_options=[]):
        self.egg_directory = egg_directory = os.path.abspath(os.path.expanduser(egg_directory))
        self.install_options += ["--home=%s" % egg_directory]
        sys.path += [os.path.join(egg_directory, "lib", "python")]
        self.requirement_set = RequirementSet(
            build_dir=build_prefix,
            src_dir=src_prefix,
            download_dir=None,
            upgrade=True)
    
    def install_egg(self, egg_name):
        """ Install an egg into the egg directory """
        if not os.path.exists(self.egg_directory):
            os.makedirs(self.egg_directory)
        self.requirement_set.add_requirement(
            InstallRequirement.from_line(egg_name, None))
        try:
            self.requirement_set.prepare_files(self.finder,
                                               force_root_egg_info=False,
                                               bundle=False)
            self.requirement_set.install(self.install_options,
                                         self.global_options)
        except DistributionNotFound:
            self.requirement_set.requirements._keys.remove(egg_name)
            raise PipException()
Beispiel #13
0
def getDependencies(name, requirementSet=None, finder=None):
    """Get dependencies of a python project
    
    @param name: name of python project
    @param requirements: RequirementSet
    @param finder: PackageFinder
    """
    if requirementSet is None:
        requirementSet = RequirementSet(
            build_dir=os.path.abspath(build_prefix),
            src_dir=os.path.abspath(src_prefix),
            download_dir=None,
            download_cache=None,
            upgrade=False,
            ignore_installed=True,
            ignore_dependencies=False)
    if finder is None:
        finder = PackageFinder(find_links=[],
                               index_urls=['http://pypi.python.org/simple'])

    # lead pip download all dependencies
    req = InstallRequirement.from_line(name, None)
    requirementSet.add_requirement(req)
    requirementSet.install_files(finder)

    # trace the dependencies relationships between projects
    dependencies = []
    traceDependencys(req, requirementSet, dependencies)
    return dependencies
Beispiel #14
0
    def run(self, options, args):
        super(UninstallCommand, self).run(options, args)
        if not options.remove_uninstalled:
            return

        with self._build_session(options) as session:
            requirement_set = RequirementSet(
                build_dir=None,
                src_dir=None,
                download_dir=None,
                isolated=options.isolated_mode,
                session=session,
            )

            for name in args:
                requirement_set.add_requirement(
                    InstallRequirement.from_line(
                        name, isolated=options.isolated_mode
                    )
                )
            for filename in options.requirements:
                for req in parse_requirements(
                        filename,
                        options=options,
                        session=session):
                    requirement_set.add_requirement(req)

            if not requirement_set.has_requirements:
                return

            here = os.getcwd()
            requirements_file = os.path.abspath(os.path.join(here, options.save_file))
            requirements = self._parse_requirements(requirement_set.requirements.values())
            self._update_requirements_file(requirements_file, remove_requirements=requirements, session=session)
Beispiel #15
0
 def run(self, options, args):
     with self._build_session(options) as session:
         format_control = pip.index.FormatControl(set(), set())
         wheel_cache = WheelCache(options.cache_dir, format_control)
         requirement_set = RequirementSet(
             build_dir=None,
             src_dir=None,
             download_dir=None,
             isolated=options.isolated_mode,
             session=session,
             wheel_cache=wheel_cache,
         )
         for name in args:
             requirement_set.add_requirement(
                 InstallRequirement.from_line(
                     name, isolated=options.isolated_mode,
                     wheel_cache=wheel_cache
                 )
             )
         for filename in options.requirements:
             for req in parse_requirements(
                     filename,
                     options=options,
                     session=session,
                     wheel_cache=wheel_cache):
                 requirement_set.add_requirement(req)
         if not requirement_set.has_requirements:
             raise InstallationError(
                 'You must give at least one requirement to %(name)s (see '
                 '"pip help %(name)s")' % dict(name=self.name)
             )
         requirement_set.uninstall(auto_confirm=options.yes)
Beispiel #16
0
 def test_unpinned_hash_checking(self, data):
     """Make sure prepare_files() raises an error when a requirement is not
     version-pinned in hash-checking mode.
     """
     reqset = RequirementSet()
     # Test that there must be exactly 1 specifier:
     reqset.add_requirement(
         list(process_line('simple --hash=sha256:a90427ae31f5d1d0d7ec06ee97'
                           'd9fcf2d0fc9a786985250c1c83fd68df5911dd',
                           'file',
                           1))[0])
     # Test that the operator must be ==:
     reqset.add_requirement(list(process_line(
         'simple2>1.0 --hash=sha256:3ad45e1e9aa48b4462af0'
         '123f6a7e44a9115db1ef945d4d92c123dfe21815a06',
         'file',
         2))[0])
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     assert_raises_regexp(
         HashErrors,
         # Make sure all failing requirements are listed:
         r'versions pinned with ==. These do not:\n'
         r'    simple .* \(from -r file \(line 1\)\)\n'
         r'    simple2>1.0 .* \(from -r file \(line 2\)\)',
         resolver.resolve,
         reqset)
Beispiel #17
0
    def _install_requirement(self, requirement):
        if not self.local_options:
            self.local_options = []

        if self._check_requirement(requirement):
            return True, None

        try:
            # Parse requirement
            requirement = InstallRequirement.from_line(str(requirement), None)

            # Build the requirement set.  We're doing this one at a time so we can actually detect
            # which ones fail.
            requirement_set = RequirementSet(build_dir=build_prefix,
                                             src_dir=src_prefix,
                                             download_dir=None)
            requirement_set.add_requirement(requirement)

            # Download and build requirement
            try:
                requirement_set.prepare_files(self.finder,
                                              force_root_egg_info=False,
                                              bundle=False)
            except PreviousBuildDirError, err:
                # Remove previous build directories if they're detected.. shouldn't be an issue
                # now that we've removed upstream dependencies from requirements.txt.
                location = requirement.build_location(build_prefix, True)

                shutil.rmtree(location)
                requirement_set.prepare_files(self.finder,
                                              force_root_egg_info=False,
                                              bundle=False)

            # Finally, install the requirement.
            requirement_set.install(self.local_options, [])
Beispiel #18
0
def test_exclusive_environment_markers():
    """Make sure RequirementSet accepts several excluding env markers"""
    eq26 = InstallRequirement.from_line("Django>=1.6.10,<1.7 ; python_version == '2.6'")
    ne26 = InstallRequirement.from_line("Django>=1.6.10,<1.8 ; python_version != '2.6'")

    req_set = RequirementSet("", "", "", session=PipSession())
    req_set.add_requirement(eq26)
    req_set.add_requirement(ne26)
    assert req_set.has_requirement("Django")
Beispiel #19
0
    def wheel(self, package, sender_data):
        source = sender_data[1].pop('path')

        # If the file has the wheel extention, we bail. We don't have to do
        # anything :)
        if re.findall('whl$', source):
            raise NotForMe

        target = os.path.dirname(source)

        # The package finder is what PIP uses to find packages given their
        # names. This finder won't use internet at all, only the folder we know
        # that our file is.
        finder = PackageFinder(find_links=[target], index_urls=[])

        # Another requirement to use PIP API, we have to build a requirement
        # set.
        build_dir = tempfile.mkdtemp()
        requirement_set = RequirementSet(
            build_dir=build_dir,
            src_dir=None,
            download_dir=None,
            download_cache=None,
            ignore_dependencies=True,
            ignore_installed=True,
        )
        requirement_set.add_requirement(
            InstallRequirement.from_line(package))

        # Here we go, we're finally converting the package from a regular
        # format to a wheel. Notice that the wheel dir is another tmp
        # directory. See comments below.
        wheel_dir = tempfile.mkdtemp()
        builder = WheelBuilder(
            requirement_set,
            finder,
            wheel_dir=wheel_dir,
            build_options=[],
            global_options=[],
        )
        builder.build()

        # Since I just can't retrieve the brand new file name through the API,
        # the wheel dir is a tmp directory so the *only* file over there *is*
        # the one that we want.
        wheel_file = os.listdir(wheel_dir)[0]
        path = self.index.from_file(os.path.join(wheel_dir, wheel_file))

        # Cleaning up the mess. Here I kill the two temp folders I created to
        # 1) build the package into a wheel, 2) output the wheel file
        # separately
        shutil.rmtree(build_dir)
        shutil.rmtree(wheel_dir)

        # Finally, we just say where in the storage the file is
        return {'path': os.path.join(os.path.dirname(source), wheel_file)}
Beispiel #20
0
 def run(self, options, args):
     requirement_set = RequirementSet(build_dir=None,
                                      src_dir=None,
                                      download_dir=None)
     for name in args:
         requirement_set.add_requirement(InstallRequirement.from_line(name))
     for filename in options.requirements:
         for req in parse_requirements(filename, options=options):
             requirement_set.add_requirement(req)
     requirement_set.uninstall(auto_confirm=options.yes)
Beispiel #21
0
    def test_unsupported_wheel_link_requirement_raises(self):
        reqset = RequirementSet()
        req = InstallRequirement.from_line(
            'https://whatever.com/peppercorn-0.4-py2.py3-bogus-any.whl', )
        assert req.link is not None
        assert req.link.is_wheel
        assert req.link.scheme == "https"

        with pytest.raises(InstallationError):
            reqset.add_requirement(req)
Beispiel #22
0
    def test_unsupported_wheel_local_file_requirement_raises(self, data):
        reqset = RequirementSet()
        req = InstallRequirement.from_line(
            data.packages.join('simple.dist-0.1-py1-none-invalid.whl'), )
        assert req.link is not None
        assert req.link.is_wheel
        assert req.link.scheme == "file"

        with pytest.raises(InstallationError):
            reqset.add_requirement(req)
Beispiel #23
0
    def wheel(self, package, sender_data):
        source = sender_data[1].pop('path')

        # If the file has the wheel extention, we bail. We don't have to do
        # anything :)
        if re.findall('whl$', source):
            raise NotForMe

        target = os.path.dirname(source)

        # The package finder is what PIP uses to find packages given their
        # names. This finder won't use internet at all, only the folder we know
        # that our file is.
        finder = PackageFinder(find_links=[target], index_urls=[])

        # Another requirement to use PIP API, we have to build a requirement
        # set.
        build_dir = tempfile.mkdtemp()
        requirement_set = RequirementSet(
            build_dir=build_dir,
            src_dir=None,
            download_dir=None,
            download_cache=None,
            ignore_dependencies=True,
            ignore_installed=True,
        )
        requirement_set.add_requirement(InstallRequirement.from_line(package))

        # Here we go, we're finally converting the package from a regular
        # format to a wheel. Notice that the wheel dir is another tmp
        # directory. See comments below.
        wheel_dir = tempfile.mkdtemp()
        builder = WheelBuilder(
            requirement_set,
            finder,
            wheel_dir=wheel_dir,
            build_options=[],
            global_options=[],
        )
        builder.build()

        # Since I just can't retrieve the brand new file name through the API,
        # the wheel dir is a tmp directory so the *only* file over there *is*
        # the one that we want.
        wheel_file = os.listdir(wheel_dir)[0]
        path = self.index.from_file(os.path.join(wheel_dir, wheel_file))

        # Cleaning up the mess. Here I kill the two temp folders I created to
        # 1) build the package into a wheel, 2) output the wheel file
        # separately
        shutil.rmtree(build_dir)
        shutil.rmtree(wheel_dir)

        # Finally, we just say where in the storage the file is
        return {'path': os.path.join(os.path.dirname(source), wheel_file)}
Beispiel #24
0
    def test_unsupported_wheel_link_requirement_raises(self):
        reqset = RequirementSet()
        req = InstallRequirement.from_line(
            'https://whatever.com/peppercorn-0.4-py2.py3-bogus-any.whl',
        )
        assert req.link is not None
        assert req.link.is_wheel
        assert req.link.scheme == "https"

        with pytest.raises(InstallationError):
            reqset.add_requirement(req)
Beispiel #25
0
    def test_unsupported_wheel_local_file_requirement_raises(self, data):
        reqset = RequirementSet()
        req = InstallRequirement.from_line(
            data.packages.join('simple.dist-0.1-py1-none-invalid.whl'),
        )
        assert req.link is not None
        assert req.link.is_wheel
        assert req.link.scheme == "file"

        with pytest.raises(InstallationError):
            reqset.add_requirement(req)
Beispiel #26
0
def test_exclusive_environment_markers():
    """Make sure RequirementSet accepts several excluding env markers"""
    eq26 = InstallRequirement.from_line(
        "Django>=1.6.10,<1.7 ; python_version == '2.6'")
    ne26 = InstallRequirement.from_line(
        "Django>=1.6.10,<1.8 ; python_version != '2.6'")

    req_set = RequirementSet('', '', '', session=PipSession())
    req_set.add_requirement(eq26)
    req_set.add_requirement(ne26)
    assert req_set.has_requirement('Django')
Beispiel #27
0
 def run(self, options, args):
     requirement_set = RequirementSet(
         build_dir=None,
         src_dir=None,
         download_dir=None)
     for name in args:
         requirement_set.add_requirement(
             InstallRequirement.from_line(name))
     for filename in options.requirements:
         for req in parse_requirements(filename, options=options):
             requirement_set.add_requirement(req)
     requirement_set.uninstall(auto_confirm=options.yes)
Beispiel #28
0
  def run(self, options, args):
    if not options.req_repository:
      logger.notify('You need to specify a repository. This utility '
                    'does not upload to PyPI')
      return 1
    options.build_dir = os.path.abspath(options.req_cache_dir)
    options.src_dir = os.path.abspath(options.req_cache_dir)
    options.no_install = True
    options.ignore_installed = True
    install_options = options.install_options or []
    global_options = options.global_options or []
    index_urls = [options.index_url] + options.extra_index_urls
    if options.no_index:
      logger.notify('Ignoring indexes: %s' % ','.join(index_urls))
      index_urls = []
    
    finder = self._build_package_finder(options, index_urls)
    
    requirement_set = RequirementSet(build_dir=options.build_dir,
                                     src_dir=options.src_dir,
                                     download_dir=options.download_dir,
                                     download_cache=options.download_cache,
                                     upgrade=options.upgrade,
                                     ignore_installed=options.ignore_installed,
                                     ignore_dependencies=options.ignore_dependencies)
    
    req_req = open(os.path.abspath(options.req_req_requirements), 'w')
    req_req.writelines(['--index-url=%s' % self.repository_url(options), '\n'])
    
    try:
      for filename in options.requirements:
        for req in parse_requirements(filename, finder=finder, options=options):
          logger.info('req ' + str(req.req))
          req_req.writelines([str(req.req), '\n'])
          requirement_set.add_requirement(req)
    finally:
      req_req.close()

    if not options.no_download:
      requirement_set.prepare_files(finder, force_root_egg_info=False, bundle=False)
    else:
      requirement_set.locate_files()
    
    if not os.path.exists(os.path.abspath(options.req_cache_dir)):
      os.mkdir(os.path.abspath(options.req_cache_dir))
    
    if not options.req_no_upload:
      self.upload_to_repository(options)
    
    if options.req_clean_cache:
      requirement_set.cleanup_files(bundle=False)
    
    return requirement_set
Beispiel #29
0
def install(args, lock_filename="requirements.txt"):
    deps = OrderedDict()

    filename = get_requirement_file()
    for line in get_requirements(filename):
        line = line.strip()
        deps[line] = []

        requirement_set = RequirementSet(
            build_dir=build_prefix,
            src_dir=src_prefix,
            download_dir=None)

        requirement = InstallRequirement.from_line(line, None)

        requirement_set.add_requirement(requirement)

        install_options = []
        global_options = []
        # TODO: specify index_urls from optional requirements.yml
        finder = PackageFinder(
            find_links=[],
            index_urls=["http://pypi.python.org/simple/"]
        )

        requirement_set.prepare_files(finder, force_root_egg_info=False, bundle=False)
        requirement_set.install(install_options, global_options)

        for package in requirement_set.requirements.values():
            deps[line].append("%s==%s" % (package.name, package.installed_version))

        for package in requirement_set.successfully_installed:
            deps[line].append("%s==%s" % (package.name, package.installed_version))

        deps[line] = set(deps[line])

    package_set = set([])

    with open(lock_filename, "w") as output:
        output.write("# this file generated from '%s' by pundler:\n" % (filename,))
        for requested_package in deps:
            output.write("# requirement '%s' depends on:\n" % (requested_package,))
            for dependency in deps[requested_package]:
                logger.info("dependency %s" % dependency)
                if dependency not in package_set:
                    dependency = dependency.lower()
                    package_set.add(dependency)
                    output.write("%s\n" % (dependency,))
                else:
                    output.write("#%s\n" % (dependency,))
            output.write("\n")
Beispiel #30
0
 def run(self, options, args):
     requirement_set = RequirementSet(build_dir=None,
                                      src_dir=None,
                                      download_dir=None)
     for name in args:
         requirement_set.add_requirement(InstallRequirement.from_line(name))
     for filename in options.requirements:
         for req in parse_requirements(filename, options=options):
             requirement_set.add_requirement(req)
     if not requirement_set.has_requirements:
         raise InstallationError('You must give at least one requirement '
                                 'to %(name)s (see "pip help %(name)s")' %
                                 dict(name=self.name))
     requirement_set.uninstall(auto_confirm=options.yes)
Beispiel #31
0
 def test_missing_hash_with_require_hashes(self, data):
     """Setting --require-hashes explicitly should raise errors if hashes
     are missing.
     """
     reqset = RequirementSet(require_hashes=True)
     reqset.add_requirement(list(process_line('simple==1.0', 'file', 1))[0])
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     assert_raises_regexp(
         HashErrors,
         r'Hashes are required in --require-hashes mode, but they are '
         r'missing .*\n'
         r'    simple==1.0 --hash=sha256:393043e672415891885c9a2a0929b1af95'
         r'fb866d6ca016b42d2e6ce53619b653$', resolver.resolve, reqset)
class PrintRequirementsTestCase(TestCase):
    def setUp(self):
        self.requirement_set = RequirementSet(None, None, None,
                                              session='dummy')

    def tearDown(self):
        output = StringIO()
        pip_compile.print_requirements(self.requirement_set, output=output)
        assert output.getvalue() == self.expected

    def test_no_requirements(self):
        self.expected = ''

    def test_one_requirement_no_version(self):
        self.requirement_set.add_requirement(
            InstallRequirement('pkg', None))
        self.expected = 'pkg\n'

    def test_one_requirement_with_version(self):
        self.requirement_set.add_requirement(
            InstallRequirement('pkg==1.0.1', None))
        self.expected = 'pkg==1.0.1\n'

    def test_one_requirement_with_constraint(self):
        self.requirement_set.add_requirement(
            InstallRequirement('pkg==1.0.1', None, constraint=True))
        self.requirement_set.add_requirement(
            InstallRequirement('pkg==1.0.2-ignored', None))
        self.expected = 'pkg==1.0.1\n'
Beispiel #33
0
 def run(self, options, args):
     requirement_set = RequirementSet(
         build_dir=None,
         src_dir=None,
         download_dir=None)
     for name in args:
         requirement_set.add_requirement(
             InstallRequirement.from_line(name))
     for filename in options.requirements:
         for req in parse_requirements(filename, options=options):
             requirement_set.add_requirement(req)
     if not requirement_set.has_requirements:
         raise InstallationError('You must give at least one requirement '
             'to %(name)s (see "pip help %(name)s")' % dict(name=self.name))
     requirement_set.uninstall(auto_confirm=options.yes)
Beispiel #34
0
 def test_hash_mismatch(self, data):
     """A hash mismatch should raise an error."""
     file_url = path_to_url((data.packages / 'simple-1.0.tar.gz').abspath)
     reqset = RequirementSet(require_hashes=True)
     reqset.add_requirement(
         list(process_line('%s --hash=sha256:badbad' % file_url, 'file',
                           1))[0])
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     assert_raises_regexp(
         HashErrors, r'THESE PACKAGES DO NOT MATCH THE HASHES.*\n'
         r'    file:///.*/data/packages/simple-1\.0\.tar\.gz .*:\n'
         r'        Expected sha256 badbad\n'
         r'             Got        393043e672415891885c9a2a0929b1af95fb866d'
         r'6ca016b42d2e6ce53619b653$', resolver.resolve, reqset)
Beispiel #35
0
def install_package(package, version=None):
    requirement_set = RequirementSet(build_dir=build_prefix,
                                     src_dir=src_prefix, download_dir=None)

    if version:
        install = '{}=={}'.format(package, version)
    else:
        install = package

    requirement = InstallRequirement.from_line(install, None)
    requirement_set.add_requirement(requirement)
    finder = PackageFinder(find_links=[],
                           index_urls=["http://pypi.python.org/simple/"])
    requirement_set.prepare_files(finder, force_root_egg_info=False,
                                  bundle=False)
    requirement_set.install([], [])
Beispiel #36
0
    def get_requirement_set(self, finder, line):
        requirement_set = RequirementSet(
            build_dir=build_prefix,
            src_dir=src_prefix,
            download_dir=None,
            upgrade=self.upgrade,
        )

        with tempfile.NamedTemporaryFile() as single_req_file:
            single_req_file.write(line)
            single_req_file.flush()
            for requirement in parse_requirements(single_req_file.name, finder=finder):
                requirement = InstallRequirement.from_line(line, None)
                requirement_set.add_requirement(requirement)

        return requirement_set
Beispiel #37
0
    def run(self, options, args):
        if not options.build_dir:
            options.build_dir = build_prefix
        if not options.src_dir:
            options.src_dir = src_prefix
        if options.download_dir:
            options.no_install = True
            options.ignore_installed = True
        else:
            options.build_dir = os.path.abspath(options.build_dir)
            options.src_dir = os.path.abspath(options.src_dir)
        index_urls = [options.index_url] + options.extra_index_urls
        if options.no_index:
            logger.notify('Ignoring indexes: %s' % ','.join(index_urls))
            index_urls = []
        finder = PackageFinder(find_links=options.find_links,
                               index_urls=index_urls)
        requirementSet = RequirementSet(
            build_dir=options.build_dir,
            src_dir=options.src_dir,
            download_dir=options.download_dir,
            download_cache=options.download_cache,
            upgrade=options.upgrade,
            ignore_installed=options.ignore_installed,
            ignore_dependencies=False)

        requirements = []
        for name in args:
            requirements.append(InstallRequirement.from_line(name, None))
        for name in options.editables:
            requirements.append(
                InstallRequirement.from_editable(
                    name, default_vcs=options.default_vcs))
        for filename in options.requirements:
            for req in parse_requirements(filename,
                                          finder=finder,
                                          options=options):
                requirements.append(req)
        # add all requirements into requirements set
        for req in requirements:
            requirementSet.add_requirement(req)

        requirementSet.install_files(finder,
                                     force_root_egg_info=self.bundle,
                                     bundle=self.bundle)

        return requirements, requirementSet
Beispiel #38
0
 def test_environment_marker_extras(self, data):
     """
     Test that the environment marker extras are used with
     non-wheel installs.
     """
     reqset = RequirementSet()
     req = InstallRequirement.from_editable(
         data.packages.join("LocalEnvironMarker"))
     reqset.add_requirement(req)
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     resolver.resolve(reqset)
     # This is hacky but does test both case in py2 and py3
     if sys.version_info[:2] in ((2, 7), (3, 4)):
         assert reqset.has_requirement('simple')
     else:
         assert not reqset.has_requirement('simple')
Beispiel #39
0
 def run(self, options, args):
     if not options.build_dir:
         options.build_dir = build_prefix
     if not options.src_dir:
         options.src_dir = src_prefix
     if options.download_dir:
         options.no_install = True
         options.ignore_installed = True
     else:
         options.build_dir = os.path.abspath(options.build_dir)
         options.src_dir = os.path.abspath(options.src_dir)
     index_urls = [options.index_url] + options.extra_index_urls
     if options.no_index:
         logger.notify('Ignoring indexes: %s' % ','.join(index_urls))
         index_urls = []
     finder = PackageFinder(
         find_links=options.find_links,
         index_urls=index_urls)
     requirementSet = RequirementSet(
         build_dir=options.build_dir,
         src_dir=options.src_dir,
         download_dir=options.download_dir,
         download_cache=options.download_cache,
         upgrade=options.upgrade,
         ignore_installed=options.ignore_installed,
         ignore_dependencies=False)
     
     requirements = []
     for name in args:
         requirements.append(
             InstallRequirement.from_line(name, None))
     for name in options.editables:
         requirements.append(
             InstallRequirement.from_editable(name, default_vcs=options.default_vcs))
     for filename in options.requirements:
         for req in parse_requirements(filename, finder=finder, options=options):
             requirements.append(req)
     # add all requirements into requirements set
     for req in requirements:
         requirementSet.add_requirement(req)
     
     requirementSet.install_files(finder, 
                                   force_root_egg_info=self.bundle, 
                                   bundle=self.bundle)
     
     return requirements, requirementSet
Beispiel #40
0
 def test_missing_hash_with_require_hashes(self, data):
     """Setting --require-hashes explicitly should raise errors if hashes
     are missing.
     """
     reqset = RequirementSet(require_hashes=True)
     reqset.add_requirement(
         list(process_line('simple==1.0', 'file', 1))[0])
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     assert_raises_regexp(
         HashErrors,
         r'Hashes are required in --require-hashes mode, but they are '
         r'missing .*\n'
         r'    simple==1.0 --hash=sha256:393043e672415891885c9a2a0929b1af95'
         r'fb866d6ca016b42d2e6ce53619b653$',
         resolver.resolve,
         reqset)
Beispiel #41
0
 def test_environment_marker_extras(self, data):
     """
     Test that the environment marker extras are used with
     non-wheel installs.
     """
     reqset = RequirementSet()
     req = InstallRequirement.from_editable(
         data.packages.join("LocalEnvironMarker"))
     reqset.add_requirement(req)
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     resolver.resolve(reqset)
     # This is hacky but does test both case in py2 and py3
     if sys.version_info[:2] in ((2, 7), (3, 4)):
         assert reqset.has_requirement('simple')
     else:
         assert not reqset.has_requirement('simple')
Beispiel #42
0
    def test_no_reuse_existing_build_dir(self, data):
        """Test prepare_files raise exception with previous build dir"""

        build_dir = os.path.join(self.tempdir, 'build', 'simple')
        os.makedirs(build_dir)
        open(os.path.join(build_dir, "setup.py"), 'w')
        reqset = RequirementSet()
        req = InstallRequirement.from_line('simple')
        reqset.add_requirement(req)
        finder = PackageFinder([data.find_links], [], session=PipSession())
        resolver = self._basic_resolver(finder)
        assert_raises_regexp(
            PreviousBuildDirError,
            r"pip can't proceed with [\s\S]*%s[\s\S]*%s" %
            (req, build_dir.replace('\\', '\\\\')),
            resolver.resolve,
            reqset,
        )
Beispiel #43
0
 def test_unhashed_deps_on_require_hashes(self, data):
     """Make sure unhashed, unpinned, or otherwise unrepeatable
     dependencies get complained about when --require-hashes is on."""
     reqset = RequirementSet()
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     reqset.add_requirement(next(process_line(
         'TopoRequires2==0.0.1 '  # requires TopoRequires
         '--hash=sha256:eaf9a01242c9f2f42cf2bd82a6a848cd'
         'e3591d14f7896bdbefcf48543720c970',
         'file', 1)))
     assert_raises_regexp(
         HashErrors,
         r'In --require-hashes mode, all requirements must have their '
         r'versions pinned.*\n'
         r'    TopoRequires from .*$',
         resolver.resolve,
         reqset)
Beispiel #44
0
    def test_no_reuse_existing_build_dir(self, data):
        """Test prepare_files raise exception with previous build dir"""

        build_dir = os.path.join(self.tempdir, 'build', 'simple')
        os.makedirs(build_dir)
        open(os.path.join(build_dir, "setup.py"), 'w')
        reqset = RequirementSet()
        req = InstallRequirement.from_line('simple')
        reqset.add_requirement(req)
        finder = PackageFinder([data.find_links], [], session=PipSession())
        resolver = self._basic_resolver(finder)
        assert_raises_regexp(
            PreviousBuildDirError,
            r"pip can't proceed with [\s\S]*%s[\s\S]*%s" %
            (req, build_dir.replace('\\', '\\\\')),
            resolver.resolve,
            reqset,
        )
Beispiel #45
0
 def test_unhashed_deps_on_require_hashes(self, data):
     """Make sure unhashed, unpinned, or otherwise unrepeatable
     dependencies get complained about when --require-hashes is on."""
     reqset = RequirementSet()
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     reqset.add_requirement(
         next(
             process_line(
                 'TopoRequires2==0.0.1 '  # requires TopoRequires
                 '--hash=sha256:eaf9a01242c9f2f42cf2bd82a6a848cd'
                 'e3591d14f7896bdbefcf48543720c970',
                 'file',
                 1)))
     assert_raises_regexp(
         HashErrors,
         r'In --require-hashes mode, all requirements must have their '
         r'versions pinned.*\n'
         r'    TopoRequires from .*$', resolver.resolve, reqset)
Beispiel #46
0
class Pip(object):
    """
    A class to puppet PIP to install new eggs
    """
    requirement_set = None  # the requirement set
    # the package finder
    finder = PackageFinder(find_links=[],
                           index_urls=["http://pypi.python.org/simple/"],
                           session=PipSession())

    def __init__(self, egg_directory):
        self.egg_directory = egg_directory = os.path.abspath(
            os.path.expanduser(egg_directory))
        sys.path += [
            os.path.join(egg_directory, "lib", "python" + PYTHON_VERSION,
                         "site-packages")
        ]
        with BuildDirectory() as build_prefix:
            self.requirement_set = RequirementSet(build_dir=build_prefix,
                                                  src_dir=src_prefix,
                                                  download_dir=None,
                                                  upgrade=True,
                                                  session=PipSession())

    def delete_all_eggs(self):
        """ delete all the eggs in the directory specified """
        path_to_delete = os.path.join(self.egg_directory, "lib", "python")
        if os.path.exists(path_to_delete):
            shutil.rmtree(path_to_delete)

    def install_egg(self, egg_name):
        """ Install an egg into the egg directory """
        if not os.path.exists(self.egg_directory):
            os.makedirs(self.egg_directory)
        self.requirement_set.add_requirement(
            InstallRequirement.from_line(egg_name, None))
        try:
            self.requirement_set.prepare_files(self.finder)
            self.requirement_set.install(['--prefix=' + self.egg_directory],
                                         [])
        except DistributionNotFound:
            self.requirement_set.requirements._keys.remove(egg_name)
            raise PipException()
Beispiel #47
0
class Pip(object):
    """
    A class to puppet PIP to install new eggs
    """
    requirement_set = None  # the requirement set
    # the package finder
    finder = PackageFinder(find_links=[],
                           index_urls=["http://pypi.python.org/simple/"])
    install_options = []  # the install options with pip
    global_options = []  # the global options with pip

    def __init__(self, egg_directory, install_options=[], global_options=[]):
        self.egg_directory = egg_directory = os.path.abspath(
            os.path.expanduser(egg_directory))
        self.install_options += ["--home=%s" % egg_directory]
        sys.path += [os.path.join(egg_directory, "lib", "python")]
        self.requirement_set = RequirementSet(build_dir=build_prefix,
                                              src_dir=src_prefix,
                                              download_dir=None,
                                              upgrade=True)

    def delete_all_eggs(self):
        """ delete all the eggs in the directory specified """
        path_to_delete = os.path.join(self.egg_directory, "lib", "python")
        if os.path.exists(path_to_delete):
            shutil.rmtree(path_to_delete)

    def install_egg(self, egg_name):
        """ Install an egg into the egg directory """
        if not os.path.exists(self.egg_directory):
            os.makedirs(self.egg_directory)
        self.requirement_set.add_requirement(
            InstallRequirement.from_line(egg_name, None))
        try:
            self.requirement_set.prepare_files(self.finder,
                                               force_root_egg_info=False,
                                               bundle=False)
            self.requirement_set.install(self.install_options,
                                         self.global_options)
        except DistributionNotFound:
            self.requirement_set.requirements._keys.remove(egg_name)
            raise PipException()
Beispiel #48
0
    def test_hashed_deps_on_require_hashes(self, data):
        """Make sure hashed dependencies get installed when --require-hashes
        is on.

        (We actually just check that no "not all dependencies are hashed!"
        error gets raised while preparing; there is no reason to expect
        installation to then fail, as the code paths are the same as ever.)

        """
        reqset = RequirementSet()
        reqset.add_requirement(next(process_line(
            'TopoRequires2==0.0.1 '  # requires TopoRequires
            '--hash=sha256:eaf9a01242c9f2f42cf2bd82a6a848cd'
            'e3591d14f7896bdbefcf48543720c970',
            'file', 1)))
        reqset.add_requirement(next(process_line(
            'TopoRequires==0.0.1 '
            '--hash=sha256:d6dd1e22e60df512fdcf3640ced3039b3b02a56ab2cee81ebcb'
            '3d0a6d4e8bfa6',
            'file', 2)))
Beispiel #49
0
 def test_hash_mismatch(self, data):
     """A hash mismatch should raise an error."""
     file_url = path_to_url(
         (data.packages / 'simple-1.0.tar.gz').abspath)
     reqset = RequirementSet(require_hashes=True)
     reqset.add_requirement(
         list(process_line('%s --hash=sha256:badbad' % file_url,
                           'file',
                           1))[0])
     finder = PackageFinder([data.find_links], [], session=PipSession())
     resolver = self._basic_resolver(finder)
     assert_raises_regexp(
         HashErrors,
         r'THESE PACKAGES DO NOT MATCH THE HASHES.*\n'
         r'    file:///.*/data/packages/simple-1\.0\.tar\.gz .*:\n'
         r'        Expected sha256 badbad\n'
         r'             Got        393043e672415891885c9a2a0929b1af95fb866d'
         r'6ca016b42d2e6ce53619b653$',
         resolver.resolve,
         reqset)
Beispiel #50
0
    def req_set_from_file(cls, filename, download_dir, deplinks=None):
        src_dir = path(src_prefix).abspath()

        finder = cls.package_finder(deplinks)

        requirement_set = RequirementSet(
            build_dir=cls.build_dir,
            src_dir=src_dir,
            download_dir=download_dir,
            download_cache=None,
            upgrade=False,
            ignore_installed=True,
            ignore_dependencies=False)

        options = cls.options()
        names = []
        for req in cls.parse_requirements(filename, finder=finder, options=options):
            requirement_set.add_requirement(req)
            names.append(req.req)
        yield requirement_set
        yield finder
Beispiel #51
0
    def req_set_from_file(cls, filename, download_dir, deplinks=None):
        src_dir = path(src_prefix).abspath()

        finder = cls.package_finder(deplinks)

        requirement_set = RequirementSet(
            build_dir=cls.build_dir,
            src_dir=src_dir,
            download_dir=download_dir,
            download_cache=None,
            upgrade=False,
            ignore_installed=True,
            ignore_dependencies=False)

        options = cls.options()
        names = []
        for req in cls.parse_requirements(filename, finder=finder, options=options):
            requirement_set.add_requirement(req)
            names.append(req.req)
        yield requirement_set
        yield finder
Beispiel #52
0
def pip_install(package, test_module=None):
  if not test_module:
    test_module = package
  if module_exists(test_module):
    return
  # If pip doesn't exist install it first.
  if not module_exists('pip'):
    with download('https://bootstrap.pypa.io/get-pip.py') as f:
      check_call(['python', f])
  # Install the package.
  print('Installing', package)
  from pip.index import PackageFinder
  from pip.req import InstallRequirement, RequirementSet
  from pip.locations import build_prefix, src_prefix
  requirement_set = RequirementSet(
      build_dir=build_prefix,
      src_dir=src_prefix,
      download_dir=None)
  requirement_set.add_requirement(InstallRequirement.from_line(package, None))
  finder = PackageFinder(
    find_links=[], index_urls=['http://pypi.python.org/simple/'])
  requirement_set.prepare_files(finder, force_root_egg_info=False, bundle=False)
  requirement_set.install([], [])
def main():
    requirement_set = RequirementSet(
        build_dir=build_prefix,
        src_dir=src_prefix,
        download_dir=None)

    requirement_set.add_requirement(InstallRequirement.from_line('git+ssh://[email protected]/arc90/readability-selectors@5-bootstrap#egg=rdbselectors', None))

    install_options = []
    global_options = []
    finder = PackageFinder(find_links=[], index_urls=['http://pypi.python.org/simple/'])

    requirement_set.prepare_files(finder, force_root_egg_info=False, bundle=False)
    requirement_set.install(install_options, global_options)

    print '\n'
    print 'Installed'
    print '=================================='
    names = [package.name for package in requirement_set.successfully_installed]
    print names
    print '\n'

    pass
Beispiel #54
0
    def test_hashed_deps_on_require_hashes(self, data):
        """Make sure hashed dependencies get installed when --require-hashes
        is on.

        (We actually just check that no "not all dependencies are hashed!"
        error gets raised while preparing; there is no reason to expect
        installation to then fail, as the code paths are the same as ever.)

        """
        reqset = RequirementSet()
        reqset.add_requirement(
            next(
                process_line(
                    'TopoRequires2==0.0.1 '  # requires TopoRequires
                    '--hash=sha256:eaf9a01242c9f2f42cf2bd82a6a848cd'
                    'e3591d14f7896bdbefcf48543720c970',
                    'file',
                    1)))
        reqset.add_requirement(
            next(
                process_line(
                    'TopoRequires==0.0.1 '
                    '--hash=sha256:d6dd1e22e60df512fdcf3640ced3039b3b02a56ab2cee81ebcb'
                    '3d0a6d4e8bfa6', 'file', 2)))
Beispiel #55
0
 def run(self, options, args):
     if not options.build_dir:
         options.build_dir = build_prefix
     if not options.src_dir:
         options.src_dir = src_prefix
     if options.download_dir:
         options.no_install = True
         options.ignore_installed = True
     else:
         options.build_dir = os.path.abspath(options.build_dir)
         options.src_dir = os.path.abspath(options.src_dir)
     install_options = options.install_options or []
     index_urls = [options.index_url] + options.extra_index_urls
     if options.no_index:
         logger.notify('Ignoring indexes: %s' % ','.join(index_urls))
         index_urls = []
     finder = PackageFinder(find_links=options.find_links,
                            index_urls=index_urls)
     requirement_set = RequirementSet(
         build_dir=options.build_dir,
         src_dir=options.src_dir,
         download_dir=options.download_dir,
         download_cache=options.download_cache,
         upgrade=options.upgrade,
         ignore_installed=options.ignore_installed,
         ignore_dependencies=options.ignore_dependencies)
     for name in args:
         requirement_set.add_requirement(
             InstallRequirement.from_line(name, None))
     for name in options.editables:
         requirement_set.add_requirement(
             InstallRequirement.from_editable(
                 name, default_vcs=options.default_vcs))
     for filename in options.requirements:
         for req in parse_requirements(filename,
                                       finder=finder,
                                       options=options):
             requirement_set.add_requirement(req)
     requirement_set.install_files(finder,
                                   force_root_egg_info=self.bundle,
                                   bundle=self.bundle)
     if not options.no_install and not self.bundle:
         requirement_set.install(install_options)
         installed = ' '.join(
             [req.name for req in requirement_set.successfully_installed])
         if installed:
             logger.notify('Successfully installed %s' % installed)
     elif not self.bundle:
         downloaded = ' '.join(
             [req.name for req in requirement_set.successfully_downloaded])
         if downloaded:
             logger.notify('Successfully downloaded %s' % downloaded)
     return requirement_set
Beispiel #56
0
 def test_missing_hash_checking(self, data):
     """Make sure prepare_files() raises an error when a requirement has no
     hash in implicit hash-checking mode.
     """
     reqset = RequirementSet()
     # No flags here. This tests that detection of later flags nonetheless
     # requires earlier packages to have hashes:
     reqset.add_requirement(
         list(process_line('blessings==1.0', 'file', 1))[0])
     # This flag activates --require-hashes mode:
     reqset.add_requirement(
         list(
             process_line('tracefront==0.1 --hash=sha256:somehash', 'file',
                          2))[0])
     # This hash should be accepted because it came from the reqs file, not
     # from the internet:
     reqset.add_requirement(
         list(
             process_line(
                 'https://pypi.python.org/packages/source/m/more-'
                 'itertools/more-itertools-1.0.tar.gz#md5=b21850c'
                 '3cfa7efbb70fd662ab5413bdd', 'file', 3))[0])
     # The error text should list this as a URL and not `peep==3.1.1`:
     reqset.add_requirement(
         list(
             process_line(
                 'https://pypi.python.org/packages/source/p/peep/'
                 'peep-3.1.1.tar.gz', 'file', 4))[0])
     finder = PackageFinder([], ['https://pypi.python.org/simple'],
                            session=PipSession())
     resolver = self._basic_resolver(finder)
     assert_raises_regexp(
         HashErrors,
         r'Hashes are required in --require-hashes mode, but they are '
         r'missing .*\n'
         r'    https://pypi\.python\.org/packages/source/p/peep/peep'
         r'-3\.1\.1\.tar\.gz --hash=sha256:[0-9a-f]+\n'
         r'    blessings==1.0 --hash=sha256:[0-9a-f]+\n'
         r'THESE PACKAGES DO NOT MATCH THE HASHES.*\n'
         r'    tracefront==0.1 .*:\n'
         r'        Expected sha256 somehash\n'
         r'             Got        [0-9a-f]+$', resolver.resolve, reqset)
Beispiel #57
0
    def run(self, options, args):

        # confirm requirements
        try:
            import wheel.bdist_wheel
        except ImportError:
            if sys.version_info < (3,):
                debian_package = 'python-wheel'
            else:
                debian_package = 'python3-wheel'
            raise CommandError("'pip wheel' requires the 'wheel' package. To fix this, run: sudo apt-get install %s" % debian_package)

        try:
            import pkg_resources
        except ImportError:
            raise CommandError(
                "'pip wheel' requires setuptools >= 0.8 for dist-info support."
                " To fix this, run: pip install --upgrade setuptools"
            )
        else:
            if not hasattr(pkg_resources, 'DistInfoDistribution'):
                raise CommandError(
                    "'pip wheel' requires setuptools >= 0.8 for dist-info "
                    "support. To fix this, run: pip install --upgrade "
                    "setuptools"
                )

        index_urls = [options.index_url] + options.extra_index_urls
        if options.no_index:
            logger.notify('Ignoring indexes: %s' % ','.join(index_urls))
            index_urls = []

        if options.use_mirrors:
            logger.deprecated("1.7",
                        "--use-mirrors has been deprecated and will be removed"
                        " in the future. Explicit uses of --index-url and/or "
                        "--extra-index-url is suggested.")

        if options.mirrors:
            logger.deprecated("1.7",
                        "--mirrors has been deprecated and will be removed in "
                        " the future. Explicit uses of --index-url and/or "
                        "--extra-index-url is suggested.")
            index_urls += options.mirrors

        if options.build_dir:
            options.build_dir = os.path.abspath(options.build_dir)

        session = self._build_session(options)

        finder = PackageFinder(find_links=options.find_links,
                               index_urls=index_urls,
                               use_wheel=options.use_wheel,
                               allow_external=options.allow_external,
                               allow_unverified=options.allow_unverified,
                               allow_all_external=options.allow_all_external,
                               allow_all_prereleases=options.pre,
                               process_dependency_links=
                                options.process_dependency_links,
                               session=session,
                            )

        build_delete = (not (options.no_clean or options.build_dir))
        with BuildDirectory(options.build_dir, delete=build_delete) as build_dir:
            requirement_set = RequirementSet(
                build_dir=build_dir,
                src_dir=None,
                download_dir=None,
                download_cache=options.download_cache,
                ignore_dependencies=options.ignore_dependencies,
                ignore_installed=True,
                session=session,
                wheel_download_dir=options.wheel_dir
            )

            # make the wheelhouse
            if not os.path.exists(options.wheel_dir):
                os.makedirs(options.wheel_dir)

            #parse args and/or requirements files
            for name in args:
                requirement_set.add_requirement(
                    InstallRequirement.from_line(name, None))

            for filename in options.requirements:
                for req in parse_requirements(
                    filename,
                    finder=finder,
                    options=options,
                    session=session):
                    if req.editable:
                        logger.notify("ignoring %s" % req.url)
                        continue
                    requirement_set.add_requirement(req)

            #fail if no requirements
            if not requirement_set.has_requirements:
                opts = {'name': self.name}
                msg = ('You must give at least one requirement '
                       'to %(name)s (see "pip help %(name)s")' % opts)
                logger.error(msg)
                return

            try:
                #build wheels
                wb = WheelBuilder(
                    requirement_set,
                    finder,
                    options.wheel_dir,
                    build_options = options.build_options or [],
                    global_options = options.global_options or []
                    )
                wb.build()
            except PreviousBuildDirError:
                options.no_clean = True
                raise
            finally:
                if not options.no_clean:
                    requirement_set.cleanup_files()
Beispiel #58
0
    def run(self, options, args):

        if (
            options.no_install or
            options.no_download
        ):
            warnings.warn(
                "--no-install and --no-download are deprecated. "
                "See https://github.com/pypa/pip/issues/906.",
                RemovedInPip7Warning,
            )

        # If we have --no-install or --no-download and no --build we use the
        # legacy static build dir
        if (options.build_dir is None and
                (options.no_install or options.no_download)):
            options.build_dir = build_prefix

        if options.download_dir:
            options.no_install = True
            options.ignore_installed = True

        if options.build_dir:
            options.build_dir = os.path.abspath(options.build_dir)

        options.src_dir = os.path.abspath(options.src_dir)
        install_options = options.install_options or []
        if options.use_user_site:
            if virtualenv_no_global():
                raise InstallationError(
                    "Can not perform a '--user' install. User site-packages "
                    "are not visible in this virtualenv."
                )
            install_options.append('--user')

        temp_target_dir = None
        if options.target_dir:
            options.ignore_installed = True
            temp_target_dir = tempfile.mkdtemp()
            options.target_dir = os.path.abspath(options.target_dir)
            if (os.path.exists(options.target_dir) and not
                    os.path.isdir(options.target_dir)):
                raise CommandError(
                    "Target path exists but is not a directory, will not "
                    "continue."
                )
            install_options.append('--home=' + temp_target_dir)

        global_options = options.global_options or []
        index_urls = [options.index_url] + options.extra_index_urls
        if options.no_index:
            logger.info('Ignoring indexes: %s', ','.join(index_urls))
            index_urls = []

        if options.use_mirrors:
            warnings.warn(
                "--use-mirrors has been deprecated and will be removed in the "
                "future. Explicit uses of --index-url and/or --extra-index-url"
                " is suggested.",
                RemovedInPip7Warning,
            )

        if options.mirrors:
            warnings.warn(
                "--mirrors has been deprecated and will be removed in the "
                "future. Explicit uses of --index-url and/or --extra-index-url"
                " is suggested.",
                RemovedInPip7Warning,
            )
            index_urls += options.mirrors

        if options.download_cache:
            warnings.warn(
                "--download-cache has been deprecated and will be removed in "
                "the future. Pip now automatically uses and configures its "
                "cache.",
                RemovedInPip8Warning,
            )

        with self._build_session(options) as session:

            finder = self._build_package_finder(options, index_urls, session)

            build_delete = (not (options.no_clean or options.build_dir))
            with BuildDirectory(options.build_dir,
                                delete=build_delete) as build_dir:
                requirement_set = RequirementSet(
                    build_dir=build_dir,
                    src_dir=options.src_dir,
                    download_dir=options.download_dir,
                    upgrade=options.upgrade,
                    as_egg=options.as_egg,
                    ignore_installed=options.ignore_installed,
                    ignore_dependencies=options.ignore_dependencies,
                    force_reinstall=options.force_reinstall,
                    use_user_site=options.use_user_site,
                    target_dir=temp_target_dir,
                    session=session,
                    pycompile=options.compile,
                    isolated=options.isolated_mode,
                )

                for name in args:
                    requirement_set.add_requirement(
                        InstallRequirement.from_line(
                            name, None, isolated=options.isolated_mode,
                        )
                    )

                for name in options.editables:
                    requirement_set.add_requirement(
                        InstallRequirement.from_editable(
                            name,
                            default_vcs=options.default_vcs,
                            isolated=options.isolated_mode,
                        )
                    )

                for filename in options.requirements:
                    for req in parse_requirements(
                            filename,
                            finder=finder, options=options, session=session):
                        requirement_set.add_requirement(req)

                if not requirement_set.has_requirements:
                    opts = {'name': self.name}
                    if options.find_links:
                        msg = ('You must give at least one requirement to '
                               '%(name)s (maybe you meant "pip %(name)s '
                               '%(links)s"?)' %
                               dict(opts, links=' '.join(options.find_links)))
                    else:
                        msg = ('You must give at least one requirement '
                               'to %(name)s (see "pip help %(name)s")' % opts)
                    logger.warning(msg)
                    return

                try:
                    if not options.no_download:
                        requirement_set.prepare_files(finder)
                    else:
                        # This is the only call site of locate_files. Nuke with
                        # fire.
                        requirement_set.locate_files()

                    if not options.no_install:
                        requirement_set.install(
                            install_options,
                            global_options,
                            root=options.root_path,
                        )
                        reqs = sorted(
                            requirement_set.successfully_installed,
                            key=operator.attrgetter('name'))
                        items = []
                        for req in reqs:
                            item = req.name
                            try:
                                if hasattr(req, 'installed_version'):
                                    if req.installed_version:
                                        item += '-' + req.installed_version
                            except Exception:
                                pass
                            items.append(item)
                        installed = ' '.join(items)
                        if installed:
                            logger.info('Successfully installed %s', installed)
                    else:
                        downloaded = ' '.join([
                            req.name
                            for req in requirement_set.successfully_downloaded
                        ])
                        if downloaded:
                            logger.info(
                                'Successfully downloaded %s', downloaded
                            )
                except PreviousBuildDirError:
                    options.no_clean = True
                    raise
                finally:
                    # Clean up
                    if ((not options.no_clean) and
                            ((not options.no_install) or
                                options.download_dir)):
                        requirement_set.cleanup_files()

        if options.target_dir:
            if not os.path.exists(options.target_dir):
                os.makedirs(options.target_dir)

            lib_dir = distutils_scheme('', home=temp_target_dir)['purelib']

            for item in os.listdir(lib_dir):
                target_item_dir = os.path.join(options.target_dir, item)
                if os.path.exists(target_item_dir):
                    if not options.upgrade:
                        logger.warning(
                            'Target directory %s already exists. Specify '
                            '--upgrade to force replacement.',
                            target_item_dir
                        )
                        continue
                    if os.path.islink(target_item_dir):
                        logger.warning(
                            'Target directory %s already exists and is '
                            'a link. Pip will not automatically replace '
                            'links, please remove if replacement is '
                            'desired.',
                            target_item_dir
                        )
                        continue
                    if os.path.isdir(target_item_dir):
                        shutil.rmtree(target_item_dir)
                    else:
                        os.remove(target_item_dir)

                shutil.move(
                    os.path.join(lib_dir, item),
                    target_item_dir
                )
            shutil.rmtree(temp_target_dir)
        return requirement_set
Beispiel #59
0
    def run(self, options, args):
        if not options.build_dir:
            options.build_dir = build_prefix
        if not options.src_dir:
            options.src_dir = src_prefix
        if options.download_dir:
            options.no_install = True
            options.ignore_installed = True
        options.build_dir = os.path.abspath(options.build_dir)
        options.src_dir = os.path.abspath(options.src_dir)
        install_options = options.install_options or []
        if options.use_user_site:
            install_options.append('--user')
        global_options = options.global_options or []
        index_urls = [options.index_url] + options.extra_index_urls
        if options.no_index:
            logger.notify('Ignoring indexes: %s' % ','.join(index_urls))
            index_urls = []

        finder = self._build_package_finder(options, index_urls)

        requirement_set = RequirementSet(
            build_dir=options.build_dir,
            src_dir=options.src_dir,
            download_dir=options.download_dir,
            download_cache=options.download_cache,
            upgrade=options.upgrade,
            ignore_installed=options.ignore_installed,
            ignore_dependencies=options.ignore_dependencies)
        for name in args:
            requirement_set.add_requirement(
                InstallRequirement.from_line(name, None))
        for name in options.editables:
            requirement_set.add_requirement(
                InstallRequirement.from_editable(
                    name, default_vcs=options.default_vcs))
        for filename in options.requirements:
            for req in parse_requirements(filename,
                                          finder=finder,
                                          options=options):
                requirement_set.add_requirement(req)

        if not requirement_set.has_requirements:
            if options.find_links:
                raise InstallationError(
                    'You must give at least one '
                    'requirement to %s (maybe you meant "pip install %s"?)' %
                    (self.name, " ".join(options.find_links)))
            raise InstallationError('You must give at least one requirement '
                                    'to %(name)s (see "pip help %(name)s")' %
                                    dict(name=self.name))

        if (options.use_user_site and sys.version_info < (2, 6)):
            raise InstallationError(
                '--user is only supported in Python version 2.6 and newer')

        import setuptools
        if (options.use_user_site and requirement_set.has_editables
                and not getattr(setuptools, '_distribute', False)):

            raise InstallationError(
                '--user --editable not supported with setuptools, use distribute'
            )

        if not options.no_download:
            requirement_set.prepare_files(finder,
                                          force_root_egg_info=self.bundle,
                                          bundle=self.bundle)
        else:
            requirement_set.locate_files()

        if not options.no_install and not self.bundle:
            requirement_set.install(install_options, global_options)
            installed = ' '.join(
                [req.name for req in requirement_set.successfully_installed])
            if installed:
                logger.notify('Successfully installed %s' % installed)
        elif not self.bundle:
            downloaded = ' '.join(
                [req.name for req in requirement_set.successfully_downloaded])
            if downloaded:
                logger.notify('Successfully downloaded %s' % downloaded)
        elif self.bundle:
            requirement_set.create_bundle(self.bundle_filename)
            logger.notify('Created bundle in %s' % self.bundle_filename)
        # Clean up
        if not options.no_install:
            requirement_set.cleanup_files(bundle=self.bundle)
        return requirement_set
Beispiel #60
0
    def run(self, options, args):

        # confirm requirements
        try:
            import wheel.bdist_wheel
            # Hack to make flake8 not complain about an unused import
            wheel.bdist_wheel
        except ImportError:
            raise CommandError(
                "'pip wheel' requires the 'wheel' package. To fix this, run: "
                "pip install wheel")

        try:
            import pkg_resources
        except ImportError:
            raise CommandError(
                "'pip wheel' requires setuptools >= 0.8 for dist-info support."
                " To fix this, run: pip install --upgrade setuptools")
        else:
            if not hasattr(pkg_resources, 'DistInfoDistribution'):
                raise CommandError(
                    "'pip wheel' requires setuptools >= 0.8 for dist-info "
                    "support. To fix this, run: pip install --upgrade "
                    "setuptools")

        index_urls = [options.index_url] + options.extra_index_urls
        if options.no_index:
            logger.info('Ignoring indexes: %s', ','.join(index_urls))
            index_urls = []

        if options.use_mirrors:
            warnings.warn(
                "--use-mirrors has been deprecated and will be removed in the "
                "future. Explicit uses of --index-url and/or --extra-index-url"
                " is suggested.",
                RemovedInPip7Warning,
            )

        if options.mirrors:
            warnings.warn(
                "--mirrors has been deprecated and will be removed in the "
                "future. Explicit uses of --index-url and/or --extra-index-url"
                " is suggested.",
                RemovedInPip7Warning,
            )
            index_urls += options.mirrors

        if options.download_cache:
            warnings.warn(
                "--download-cache has been deprecated and will be removed in "
                "the future. Pip now automatically uses and configures its "
                "cache.",
                RemovedInPip8Warning,
            )

        if options.build_dir:
            options.build_dir = os.path.abspath(options.build_dir)

        with self._build_session(options) as session:

            finder = PackageFinder(
                find_links=options.find_links,
                index_urls=index_urls,
                use_wheel=options.use_wheel,
                allow_external=options.allow_external,
                allow_unverified=options.allow_unverified,
                allow_all_external=options.allow_all_external,
                allow_all_prereleases=options.pre,
                trusted_hosts=options.trusted_hosts,
                process_dependency_links=options.process_dependency_links,
                session=session,
            )

            build_delete = (not (options.no_clean or options.build_dir))
            with BuildDirectory(options.build_dir,
                                delete=build_delete) as build_dir:
                requirement_set = RequirementSet(
                    build_dir=build_dir,
                    src_dir=options.src_dir,
                    download_dir=None,
                    ignore_dependencies=options.ignore_dependencies,
                    ignore_installed=True,
                    isolated=options.isolated_mode,
                    session=session,
                    wheel_download_dir=options.wheel_dir)

                # make the wheelhouse
                if not os.path.exists(options.wheel_dir):
                    os.makedirs(options.wheel_dir)

                # parse args and/or requirements files
                for name in args:
                    requirement_set.add_requirement(
                        InstallRequirement.from_line(
                            name,
                            None,
                            isolated=options.isolated_mode,
                        ))
                for name in options.editables:
                    requirement_set.add_requirement(
                        InstallRequirement.from_editable(
                            name,
                            default_vcs=options.default_vcs,
                            isolated=options.isolated_mode,
                        ))
                for filename in options.requirements:
                    for req in parse_requirements(filename,
                                                  finder=finder,
                                                  options=options,
                                                  session=session):
                        requirement_set.add_requirement(req)

                # fail if no requirements
                if not requirement_set.has_requirements:
                    logger.error(
                        "You must give at least one requirement to %s "
                        "(see \"pip help %s\")",
                        self.name,
                    )
                    return

                try:
                    # build wheels
                    wb = WheelBuilder(
                        requirement_set,
                        finder,
                        options.wheel_dir,
                        build_options=options.build_options or [],
                        global_options=options.global_options or [],
                    )
                    if not wb.build():
                        raise CommandError(
                            "Failed to build one or more wheels")
                except PreviousBuildDirError:
                    options.no_clean = True
                    raise
                finally:
                    if not options.no_clean:
                        requirement_set.cleanup_files()