remove hardware package.

    :param name: hardware package name (e.g. 'Sanguino')
    :rtype: None
513546
def remove_hwpack(name):
    
    targ_dlib = hwpack_dir() / name
    log.debug('remove %s', targ_dlib)
    targ_dlib.rmtree()
943626
def removePlugin(self, package):
        
        res = dict(code=1, msg=None)
        if package and isinstance(package, string_types):
            path = os.path.join(self.plugin_abspath, package)
            if os.path.isdir(path):
                try:
                    shutil.rmtree(path)
                except Exception as e:
                    res.update(msg=str(e))
                else:
                    res.update(code=0)
            else:
                res.update(msg="No Such Package")
        else:
            res.update(msg="Invalid Package Format")
        return res
1172693
def remove_system(self, system):
        '''
        
        '''
        if system in self._systems:
            self._systems.remove(system)
        else:
            raise UnmanagedSystemError(system)
967249
def remove_global(self, name):
        
        with self._lock:
            if self._gpayload is not None:
                if name in self._gpayload:
                    del self._gpayload[name]
                if not self._gpayload:
                    self._gpayload = None
341743
def remove(name)
      name = File.basename(name)
      path = File.join(Config::TEMPLATES_DIR,name)

      unless File.exists?(path)
        say "Unknown template: #{name}", :red
        exit -1
      end

      FileUtils.rm_rf(path)
    end
18186
def pip_remove(self, name=None, prefix=None, pkgs=None):
        """"""
        logger.debug(str((prefix, pkgs)))

        if isinstance(pkgs, (list, tuple)):
            pkg = ' '.join(pkgs)
        else:
            pkg = pkgs

        extra_args = ['uninstall', '--yes', pkg]

        return self._call_pip(name=name, prefix=prefix, extra_args=extra_args)
1167346
def remove_specification(self, name):
		
		if name in self.__specs:
			self.__specs.pop(name)
1238435
def _sysv_delete(name):
    '''
    
    '''
    if not _service_is_chkconfig(name):
        return False
    cmd = '/sbin/chkconfig --del {0}'.format(name)
    return not __salt__['cmd.retcode'](cmd)
617417
def delete(self, name):
    '''
    
    '''
    # TODO: confirm that this does not use the combo index and determine
    # performance implications.
    num_deleted = 0
    for interval,config in self._intervals.items():
      # TODO: use write preference settings if we have them
      num_deleted += self._client[interval].remove( {'name':name} )['n']
    return num_deleted
647555
def unregisterAddon(cls, name):
        
        prop = '_{0}__addons'.format(cls.__name__)
        cmds = getattr(cls, prop, {})
        cmds.pop(name, None)
60073
def remove_sprocket(name)
      if sprocket = get_sprocket(name)
        sprockets.delete sprocket
        set_sprocket(name, nil)
      end
    end
1072354
def remove_from_bin(self, name):
        
        self.__remove_path(os.path.join(self.root_dir, "bin", name))
1235820
def remove(self, auto_confirm=False, verbose=False):
        """"""

        if not self.paths:
            logger.info(
                "Can't uninstall '%s'. No files were found to uninstall.",
                self.dist.project_name,
            )
            return

        dist_name_version = (
            self.dist.project_name + "-" + self.dist.version
        )
        logger.info('Uninstalling %s:', dist_name_version)

        with indent_log():
            if auto_confirm or self._allowed_to_proceed(verbose):
                moved = self._moved_paths

                for_rename = compress_for_rename(self.paths)

                for path in sorted(compact(for_rename)):
                    moved.stash(path)
                    logger.debug('Removing file or directory %s', path)

                for pth in self.pth.values():
                    pth.remove()

                logger.info('Successfully uninstalled %s', dist_name_version)
852990
def uninstall(args, env, console, ciprcfg):
    
    for name in args:
        package_dir = path.join(env.package_dir, name)
        if path.exists(package_dir):
            console.quiet('Removing %s...' % name)
            if path.islink(package_dir):
                os.remove(package_dir)
            else:
                shutil.rmtree(package_dir)

        ciprcfg.remove_package(name)
640275
def delete_package(self, cache, pkg):
        
        if self.is_virtual_package(pkg):
            log("Package '%s' appears to be virtual - purging provides" %
                pkg.name, level=DEBUG)
            for _p in pkg.provides_list:
                self.delete_package(cache, _p[2].parent_pkg)
        elif not pkg.current_ver:
            log("Package '%s' not installed" % pkg.name, level=DEBUG)
            return
        else:
            log("Purging package '%s'" % pkg.name, level=DEBUG)
            apt_purge(pkg.name)
1278243
def release_plugin(self, name):
        
        plugin = self._active_plugins[name]
        if id(plugin) in self._provided_by_preset:
            self._provided_by_preset.remove(id(plugin))

        del self._active_plugins[name]
        delattr(self, name)
1286466
def remove_lib(lib_name):
    
    targ_dlib = libraries_dir() / lib_name
    log.debug('remove %s', targ_dlib)
    targ_dlib.rmtree()