예제 #1
0
파일: inst.py 프로젝트: fdev31/pyg
 def uninstall(self):
     path_re = re.compile(r'\./{0}-[\d\w\.]+-py\d\.\d.egg'.format(self.name), re.I)
     path_re2 = re.compile(r'\.{0}'.format(self.name), re.I)
     to_del = self.find_files()
     if not to_del:
         logger.warn('{0}: did not find any files to delete', self.name)
         raise PygError
     logger.info('Uninstalling {0}', self.name)
     logger.indent += 8
     for d in to_del:
         logger.info(d)
     logger.indent -= 8
     do_it = logger.ask('Proceed', bool=('remove files', 'cancel'), dont_ask=args_manager['install']['yes'])
     if do_it:
         for d in to_del:
             try:
                 logger.verbose('Deleting: {0}', d)
                 shutil.rmtree(d)
             except OSError: ## It is not a directory
                 try:
                     os.remove(d)
                 except OSError:
                     logger.error('Error: cannot delete {0}', d)
         logger.verbose('Removing egg path from easy_install.pth...')
         with open(EASY_INSTALL) as f:
             lines = f.readlines()
         with open(EASY_INSTALL, 'w') as f:
             for line in lines:
                 if path_re.match(line) or path_re2.match(line):
                     continue
                 f.write(line)
         logger.success('{0} uninstalled succesfully', self.name)
     else:
        logger.info('{0} has not been uninstalled', self.name)
예제 #2
0
파일: inst.py 프로젝트: fdev31/pyg
    def install(self):
        try:
            r = Requirement(self.req)
            updater = Updater(skip=True)
            if self.upgrading:
                updater.remove_files(self.req)
            r.install()

            # Now let's install dependencies
            Installer._install_deps(r.reqset, r.name, updater)
            logger.success('{0} installed successfully', r.name)
        except (KeyboardInterrupt, Exception) as e:
            try:
                msg = e.args[0]
            except IndexError:
                msg = repr(e)

            if isinstance(e, KeyboardInterrupt):
                logger.warn('Process interrupted...')
            else:
                logger.warn('Error: An error occurred during the {0} of {1}: {2}',
                        'upgrading' if self.upgrading else 'installation',
                        self.req,
                        msg)
            if self.upgrading:
                logger.info('Restoring files...')
                updater.restore_files(self.req)
            else:
                logger.info('Removing broken files...')
                Uninstaller(self.req).uninstall()
            logger.error(msg, exc=InstallationError)
예제 #3
0
파일: inst.py 프로젝트: fdev31/pyg
    def update(self):
        '''
        Searches for updates for every package in the WorkingSet.
        Then calls :meth:`~pyg.inst.Updater.upgrade`.
        '''

        logger.info('Searching for updates')
        for dist in self.working_set:
            package = dist.project_name
            version = Version(dist.version)
            logger.verbose('Found: {0}=={1}', package, version)
            try:
                json = PyPIJson(package).retrieve()
                new_version = Version(json['info']['version'])
            except Exception as e:
                logger.error('Error: Failed to fetch data for {0} ({1})', package, e)
                continue
            if version >= new_version:
                continue

            txt = 'A new release is avaiable for {0}: {1!s} (old {2}), update'.format(package, new_version, dist.version)
            u = logger.ask(txt, bool=('upgrade version', 'keep working version'), dont_ask=self.yes)
            if u:
                self.upgrade(package, json, new_version)
            else:
                logger.info('{0} has not been upgraded', package)
        self._clean()
        logger.success('Updating finished successfully')
예제 #4
0
파일: core.py 프로젝트: Malex/pyg
    def install(self):
        '''
        Install a bundle. For every package runs ``setup.py install``.
        '''

        with TempDir() as tempdir:
            with ZipFile(self.path) as z:
                z.extractall(tempdir)
            location = os.path.join(tempdir, 'build')
            for f in os.listdir(location):
                logger.info('Installing {0}...', f)
                fullpath = os.path.join(location, f)
                Dir(fullpath, f, tempdir).install()
            logger.success('Bundle installed successfully')
예제 #5
0
파일: inst.py 프로젝트: Malex/pyg
 def _download_all(self, dir):
     reqs = list(self.reqs)
     already_downloaded = set()
     while reqs:
         r = reqs.pop()
         # Hack for virtualenvs
         if r.name.lower == 'python':
             continue
         if any(r.name == rq.name for rq in already_downloaded):
             logger.debug('debug: Already downloaded: {0}', r)
             continue
         if any(r == rq for rq in self.exclude):
             logger.info('Excluding {0}', r)
             continue
         logger.indent = 0
         logger.info('{0}:', r)
         logger.indent = 8
         try:
             dist = SDist(self._download(dir, r))
             self.callback(r, dist)
         except ConfigParser.MissingSectionHeaderError:
             continue
         try:
             logger.info('Looking for {0} dependencies', r)
             logger.indent += 8
             found = False
             try:
                 requirements = dist.file('requires.txt')
             except KeyError:
                 requirements = []
             for requirement in requirements:
                 rq = Requirement(requirement)
                 if rq not in already_downloaded:
                     logger.info('Found: {0}', requirement)
                     reqs.append(rq)
                     found = True
             if not found:
                 logger.info('None found')
         except KeyError:
             logger.debug('debug: requires.txt not found for {0}', dist)
         try:
             as_req = dist.as_req
         except KeyError:
             as_req = str(r)
         already_downloaded.add(Requirement(as_req))
     logger.indent = 0
     logger.success('Finished processing dependencies')
예제 #6
0
파일: inst.py 프로젝트: fdev31/pyg
 def from_dir(path, name=None):
     name = name or os.path.basename(path)
     reqset = ReqSet(name)
     try:
         with TempDir() as tempdir:
             logger.info('Installing {0}', name)
             Dir(path, name, tempdir, reqset).install()
     except Exception as e:
         try:
             msg = e.args[0]
         except IndexError:
             msg = repr(e)
         logger.fatal('Error: {0}: cannot install the package', msg, exc=InstallationError)
     else:
         if reqset:
             Installer._install_deps(reqset)
         logger.success('{0} installed successfully', name)
예제 #7
0
파일: web.py 프로젝트: Malex/pyg
    def download(self, dest):
        dest = os.path.abspath(dest)
        files = self.files()

        ## We need a placeholder because of the nested for loops
        success = False

        for p in self.pref:
            if success:
                break
            if not files[p]:
                logger.warn('{0} files not found. Continue searching...', p)
                continue
            for v, name, hash, url in files[p]:
                if success:
                    break
                if p == '.egg' and not right_egg(name):
                    logger.info('Found egg file for another Python version: {0}. Continue searching...',                               version_egg(name))
                    continue
                try:
                    data = download(url, 'Retrieving data for {0}'.format(self.name)).getvalue()
                except (urllib2.URLError, urllib2.HTTPError) as e:
                    logger.debug('urllib2 error: {0}', e.args)
                    continue
                if not data:
                    logger.debug('debug: Request failed')
                    continue
                if not os.path.exists(dest):
                    os.makedirs(dest)
                try:
                    # Fix for packages with no version in the name
                    if '-' not in name:
                        name = '{0}-{1}{2}'.format(name, v, p)
                    logger.info('Writing data into {0}', name)
                    with open(os.path.join(dest, name), 'w') as f:
                        f.write(data)
                except (IOError, OSError):
                    logger.debug('debug: Error while writing data')
                    continue
                logger.success('{0} downloaded successfully', self.name)
                success = True
            self.downloaded_name = name
            self.downloaded_version = v
예제 #8
0
파일: inst.py 프로젝트: fdev31/pyg
 def _install_deps(rs, name=None, updater=None):
     if not rs:
         return
     if args_manager['install']['no_deps']:
         logger.info('Skipping dependencies for {0}', name)
         logger.indent = 8
         for req in rs:
             logger.info(req)
         logger.indent = 0
         return
     logger.info('Installing dependencies...')
     dep_error = False
     newly_installed = []
     for req in rs:
         if is_installed(req) and not args_manager['install']['upgrade_all']:
             logger.indent = 8
             logger.info('{0} is already installed, use -A, --upgrade-all to upgrade dependencies', req)
             continue
         logger.indent = 0
         logger.info('Installing {0} (from {1})', req, rs.comes_from)
         logger.indent = 8
         try:
             Installer(req).install()
             newly_installed.append(req)
         except AlreadyInstalled:
             continue
         except InstallationError:
             dep_error = True
             logger.error('Error: {0} has not been installed correctly', req)
             continue
     logger.indent = 0
     if dep_error:
         if updater:
             for req in newly_installed:
                 updater.restore_files(req)
             updater.remove_files(rs.comes_from.name)
             updater.restore_files(rs.comes_from.name)
         logger.error("{0}'s dependencies installation failed", rs.comes_from.name, exc=InstallationError)
     else:
         logger.success('Finished installing dependencies for {0}', rs.comes_from.name)
예제 #9
0
파일: inst.py 프로젝트: fdev31/pyg
    def from_file(filepath, packname=None):
        packname = packname or os.path.basename(filepath).split('-')[0]
        reqset = ReqSet(packname)

        e = ext(filepath)
        path = os.path.abspath(filepath)
        if e in ('.tar.gz', '.tar.bz2', '.zip'):
            installer = Archive(open(path), e, packname, reqset)
        elif e in ('.pybundle', '.pyb'):
            installer = Bundle(filepath)
        elif e == '.egg':
            installer = Egg(open(path), path, reqset)
        elif e in ('.exe', '.msi') and is_windows():
            installer = Binary(open(path), e, packname)
        else:
            if tarfile.is_tarfile(path):
                installer = Archive(open(path), None, packname, reqset)
            elif zipfile.is_zipfile(path):
                installer = Archive(open(path), '.zip', packname, reqset)
            else:
                logger.fatal('Error: Cannot install {0}: unknown filetype', packname, exc=InstallationError)
        installer.install()
        Installer._install_deps(reqset, packname)
        logger.success('{0} installed successfully', packname)
예제 #10
0
파일: inst.py 프로젝트: fdev31/pyg
    def bundle(self, include_manifest=True, build_dir=True, additional_files=[]):
        '''
        Create a bundle of the specified package:

            1. Download all required packages (included dependencies)
            2. Clean the build directory
            3. Collect the packages in a single zip file (bundle)
            4. Add the manifest file
            5. Move the bundle from the build dir to the destination
        '''

        def _add_to_archive(zfile, dir):
            for file in os.listdir(dir):
                path = os.path.join(dir, file)
                if os.path.isfile(path):
                    zfile.write(path, os.path.join(dir, file)[len(tempdir):])
                elif os.path.isdir(path):
                    _add_to_archive(zfile, path)

        with TempDir() as tempdir, TempDir() as bundle_dir:
            ## Step 1: we create the `build` directory
            ## If you choose to create a bundle without the build directory,
            ## be aware that your bundle will not be compatible with Pip.
            #####
            if build_dir:
                build = os.path.join(tempdir, 'build')
                os.mkdir(build)
            else:
                build = tempdir
            tmp_bundle = os.path.join(bundle_dir, self.bundle_name)

            ## Step 2: we *recursively* download all required packages
            #####
            reqs = list(self.reqs)
            already_downloaded = set()
            while reqs:
                r = reqs.pop()
                if any(rq.name == r.name and rq.match(r.version) for rq in self.exclude):
                    logger.info('Excluding {0}', r)
                    continue
                logger.indent = 0
                logger.info('{0}:', r)
                logger.indent = 8
                try:
                    dist = SDist(self._download(build, r))
                except ConfigParser.MissingSectionHeaderError:
                    continue
                try:
                    logger.info('Looking for {0} dependencies', r)
                    logger.indent += 8
                    for requirement in dist.file('requires.txt'):
                        if requirement not in already_downloaded:
                            logger.info('Found: {0}', requirement)
                            reqs.append(Requirement(requirement))
                except KeyError:
                    logger.debug('debug: requires.txt not found for {0}', dist)
                try:
                    as_req = dist.as_req
                except KeyError:
                    as_req = str(r)
                already_downloaded.add(as_req)
            logger.indent = 0
            logger.success('Finished processing dependencies')

            ## Step 3: we remove all files in the build directory, so we make sure
            ## that when we collect packages we collect only dirs
            #####
            self._clean(build)

            ## Step 4: we collect the downloaded packages and bundle all together
            ## in a single file (zipped)
            #####
            logger.info('Adding packages to the bundle')
            bundle = zipfile.ZipFile(tmp_bundle, mode='w')
            _add_to_archive(bundle, build)

            ## Step 4: add the manifest file
            if include_manifest:
                logger.info('Adding the manifest file')
                bundle.writestr('pyg-manifest.txt', Bundler.MANIFEST.format('\n'.join(self.bundled)))

            # Additional files to add
            for path in additional_files:
                try:
                    _add_to_archive(bundle, path)
                except (IOError, OSError):
                    logger.debug('debug: Error while adding an additional file: {0}', path)
            bundle.close()

            ## Last step: move the bundle to the current working directory
            dest = os.path.join(os.getcwd(), self.bundle_name)
            if os.path.exists(dest):
                logger.debug('debug: dest already exists, removing it')
                os.remove(dest)
            shutil.move(tmp_bundle, os.getcwd())