Python send2trash.send2trash函数代码示例

    def remove(self, force=False):
        """
        Removes the Container of Applications (dmgs, zips, pkgs).

        This method can only be called after install() has run succesfully.

        Args:
            force: If set, Installable will be removed even if it has not been
                installed. Defaults to 'False'

        Raises:
            NotInstalledException: If Installable().install has not been called
                successfully and force is 'False'
        """

        if not self.installed and not force:
            logger.debug("Cant remove %s!" % self)
            raise NotInstalledException()

        try:
            send2trash.send2trash(self.path)
            self.removed = True
            logger.info("Moved %s to trash." % self)
        except OSError as ose:
            logger.exception(ose)

	def execute_repair(self):
		repairedfiles=[]
		recreatedfiles=[]
		if self.len_verified_actions>0:
			for f,retcode in self.verifiedfiles_repairable:
				yield f
				retval = self.runpar([self.par_cmd,"r",f])
				if retval == 0:
					if not self.keep_old and os.path.isfile(f+".1"):
						send2trash(f+".1")
					repairedfiles.append([ f , retval ])
			for f,retcode in self.verifiedfiles_err:
				yield f
				pars = glob.glob(glob.escape(f)+'*.par2')
				for p in pars:
					send2trash(p)
				recreatedfiles.append([ f , self.runpar([self.par_cmd,"c","-r"+self.percentage,"-n"+self.nr_parfiles,f]) ])

		self.recreate = sorted(recreatedfiles)
		self.recreate_err = sorted([f for f,err in recreatedfiles if err !=0])
		self.fixes = sorted([f for f,err in repairedfiles if err ==0])
		self.fixes_err = sorted([f for f,err in repairedfiles if err !=0])

		self.len_all_err = self.len_all_err + len(self.recreate_err) + len(self.fixes_err)

		return

 def deleteLocalFile(self, localPath, remotePath):
     #logging.warn('delete local file %s' % localPath)
     head, tail = os.path.split(localPath)
     self.outputQueue.put(messages.Status('Deleting %s' % tail))
     send2trash(localPath)
     self.state.removeObjectSyncRecord(remotePath)
     self.outputQueue.put(self._get_working_message())

 def run(self, dirs):
     if sublime.ok_cancel_dialog("Delete Folder?", "Delete"):
         try:
             for d in dirs:
                 send2trash.send2trash(d)
         except:
             sublime.status_message("Unable to delete folder")

def import_file(_file, destination, album_from_folder, trash, allow_duplicates):
    """Set file metadata and move it to destination.
    """
    if not os.path.exists(_file):
        log.warn('Could not find %s' % _file)
        print('{"source":"%s", "error_msg":"Could not find %s"}' % \
            (_file, _file))
        return
    # Check if the source, _file, is a child folder within destination
    elif destination.startswith(os.path.dirname(_file)):
        print('{"source": "%s", "destination": "%s", "error_msg": "Source cannot be in destination"}' % (_file, destination))
        return


    media = Media.get_class_by_file(_file, [Text, Audio, Photo, Video])
    if not media:
        log.warn('Not a supported file (%s)' % _file)
        print('{"source":"%s", "error_msg":"Not a supported file"}' % _file)
        return

    if album_from_folder:
        media.set_album_from_folder()

    dest_path = FILESYSTEM.process_file(_file, destination,
        media, allowDuplicate=allow_duplicates, move=False)
    if dest_path:
        print('%s -> %s' % (_file, dest_path))
    if trash:
        send2trash(_file)

    return dest_path or None

    def backup(self):
        nbacks = self.pm.profile['numBackups']
        if not nbacks or devMode:
            return
        dir = self.pm.backupFolder()
        path = self.pm.collectionPath()

        # do backup
        fname = time.strftime("backup-%Y-%m-%d-%H.%M.%S.apkg", time.localtime(time.time()))
        newpath = os.path.join(dir, fname)
        data = open(path, "rb").read()
        b = self.BackupThread(newpath, data)
        b.start()

        # find existing backups
        backups = []
        for file in os.listdir(dir):
            # only look for new-style format
            m = re.match("backup-\{4}-.+.apkg", file)
            if not m:
                continue
            backups.append(file)
        backups.sort()

        # remove old ones
        while len(backups) > nbacks:
            fname = backups.pop(0)
            path = os.path.join(dir, fname)
            send2trash(path)

 def backup(self):
     nbacks = self.pm.profile['numBackups']
     if not nbacks:
         return
     dir = self.pm.backupFolder()
     path = self.pm.collectionPath()
     # find existing backups
     backups = []
     for file in os.listdir(dir):
         m = re.search("backup-(\d+).apkg", file)
         if not m:
             # unknown file
             continue
         backups.append((int(m.group(1)), file))
     backups.sort()
     # get next num
     if not backups:
         n = 1
     else:
         n = backups[-1][0] + 1
     # do backup
     newpath = os.path.join(dir, "backup-%d.apkg" % n)
     z = zipfile.ZipFile(newpath, "w", zipfile.ZIP_DEFLATED)
     z.write(path, "collection.anki2")
     z.writestr("media", "{}")
     z.close()
     # remove if over
     if len(backups) + 1 > nbacks:
         delete = len(backups) + 1 - nbacks
         delete = backups[:delete]
         for file in delete:
             send2trash(os.path.join(dir, file[1]))

def clean_empty_dirs():
    #print 'cleaning dirs...'
    def get_subdirs(path):
        for root, dirs, files in os.walk(path):
            return [os.path.join(root, x) for x in dirs]
        return []

    def has_subs(path):
        for root, dirs, files in os.walk(path):
            files = [x for x in files if not x.startswith('.')]
            return len(dirs)+len(files) != 0
        return False

    for show_dir in get_subdirs(tv_shows_dir):
        for subdir in get_subdirs(show_dir):
            if not has_subs(subdir):
                #print 'removing directory',subdir
                if not DEBUG:
                    send2trash(subdir)
                continue
            for subdir2 in get_subdirs(subdir):
                if not has_subs(subdir2):
                    #print 'removing directory',subdir2
                    if not DEBUG:
                        send2trash(subdir2)

    def delete_file(self, path):
        """Delete file at path."""
        path = path.strip('/')
        os_path = self._get_os_path(path)
        rm = os.unlink
        if os.path.isdir(os_path):
            listing = os.listdir(os_path)
            # Don't delete non-empty directories.
            # A directory containing only leftover checkpoints is
            # considered empty.
            cp_dir = getattr(self.checkpoints, 'checkpoint_dir', None)
            for entry in listing:
                if entry != cp_dir:
                    raise web.HTTPError(400, u'Directory %s not empty' % os_path)
        elif not os.path.isfile(os_path):
            raise web.HTTPError(404, u'File does not exist: %s' % os_path)

        if self.delete_to_trash:
            self.log.debug("Sending %s to trash", os_path)
            # Looking at the code in send2trash, I don't think the errors it
            # raises let us distinguish permission errors from other errors in
            # code. So for now, just let them all get logged as server errors.
            send2trash(os_path)
            return

        if os.path.isdir(os_path):
            self.log.debug("Removing directory %s", os_path)
            with self.perm_to_403():
                shutil.rmtree(os_path)
        else:
            self.log.debug("Unlinking file %s", os_path)
            with self.perm_to_403():
                rm(os_path)

 def _send_path_to_trash(self, local_item_name, local_path):
     try:
         send2trash(local_path)
         self.items_store.delete_item(item_name=local_item_name, parent_path=self.remote_path)
         self.logger.debug('Delete untouched local item "%s" as it seems deleted remotely.', local_path)
     except (IOError, OSError) as e:
         self.logger.error('An error occurred when deleting untouched local item "%s": %s.', local_path, e)

  def run(self, edit):        
    f = self.view.file_name()
    if (f is None):
      return

    send2trash.send2trash(f)
    self.view.window().run_command('close')

 def remove(self, name):
     p = self.profileFolder()
     if os.path.exists(p):
         send2trash(p)
     self.db.execute("delete from profiles where name = ?",
                     name.encode("utf8"))
     self.db.commit()

def check_recycle(name, verbose=True):
    """ 
    places old file in recycle bin, if it exists.
    this should work for any system, but requires the send2trash module
    (see https://pypi.python.org/pypi/Send2Trash)
    
    input: 
        name    = file name, with extension (must be in current working dir)
        verbose = optional input (default=True) which will print messages
                  to the command window
    """
    # import send2trash module:
    # it's bad practice to import within a function, but the use of
    # check_recycle is optional, since check_delete exists. Thus, I don't
    # want the import of myFileOperations to break simply because someone
    # does not have the optional send2trash module installed...
    from send2trash import send2trash

    if verbose:
        try:
            send2trash(name)
            print "\nold file sent to recycle bin"
            print 'saving new "%s"\n' % (name)
        except:
            print '\nno file found, saving new file "%s"\n' % (name)
    else:
        try:
            send2trash(name)
        except:
            pass

    def remove_file(self, file, message):
        to_trash = get_setting(self.window.active_view(), 'jekyll_send_to_trash', False)

        if to_trash:
            message = message + (
                '\n\nYou seem to be using the `jekyll_send_to_trash` setting, so you '
                'can retrieve this file later in your system Trash or Recylcing Bin.'
            )
        else:
            message = message + (
                '\n\nThis action is permanent and irreversible since you are not using '
                'the `jekyll_send_to_trash` setting. Are you sure you want to continue?'
            )

        delete = sublime.ok_cancel_dialog(message, 'Confirm Delete')

        if delete is True:
            self.window.run_command('close_file')
            self.window.run_command('refresh_folder_list')

            if to_trash:
                send2trash(file)

            else:
                os.remove(file)

        else:
            return

def deleteFile(path):
    for foldername, subfolders, filenames in os.walk(path):
        for filename in filenames:
            filePath = os.path.join(foldername, filename)
            if os.path.getsize(filePath) > MaxSize:
                print(filename + " is more than 100MB")
                send2trash.send2trash(filePath)