Python base.FS类代码示例

 def move(self, src, dst, **kwds):
     if self.getmeta("atomic.rename",False):
         if kwds.get("overwrite",False) or not self.exists(dst):
             try:
                 self.rename(src,dst)
                 return
             except FSError:
                 pass
     FS.move(self, src, dst, **kwds)

def movefile(src_fs, src_path, dst_fs, dst_path, overwrite=True, chunk_size=64*1024):
    """Move a file from one filesystem to another. Will use system copyfile, if both files have a syspath.
    Otherwise file will be copied a chunk at a time.

    :param src_fs: Source filesystem object
    :param src_path: Source path
    :param dst_fs: Destination filesystem object
    :param dst_path: Destination filesystem object
    :param chunk_size: Size of chunks to move if system copyfile is not available (default 64K)

    """
    src_syspath = src_fs.getsyspath(src_path, allow_none=True)
    dst_syspath = dst_fs.getsyspath(dst_path, allow_none=True)

    if not overwrite and dst_fs.exists(dst_path):
        raise DestinationExistsError(dst_path)

    if src_fs is dst_fs:
        src_fs.move(src_path, dst_path, overwrite=overwrite)
        return

    # System copy if there are two sys paths
    if src_syspath is not None and dst_syspath is not None:
        FS._shutil_movefile(src_syspath, dst_syspath)
        return

    src_lock = getattr(src_fs, '_lock', None)

    if src_lock is not None:
        src_lock.acquire()

    try:
        src = None
        try:
            # Chunk copy
            src = src_fs.open(src_path, 'rb')
            dst_fs.setcontents(dst_path, src, chunk_size=chunk_size)
        except:
            raise
        else:
            src_fs.remove(src_path)
        finally:
            if src is not None:
                src.close()
    finally:
        if src_lock is not None:
            src_lock.release()

def copyfile(src_fs, src_path, dst_fs, dst_path, overwrite=True, update=False,
             chunk_size=64*1024):
    """Copy a file from one filesystem to another. Will use system copyfile, if both files have a syspath.
    Otherwise file will be copied a chunk at a time. In the case where ``overwrite`` is False and
    ``update`` is True, the behaviour of ``update`` takes precedence.

    :param src_fs: Source filesystem object
    :param src_path: -- Source path
    :param dst_fs: Destination filesystem object
    :param dst_path: Destination filesystem object
    :param overwrite: Write to destination files even if they already exist
    :param update: Write to destination files only if the source is newer
    :param chunk_size: Size of chunks to move if system copyfile is not available (default 64K)

    """

    assert_write(src_fs, src_path, dst_fs, dst_path, overwrite, update)

    # If the src and dst fs objects are the same, then use a direct copy
    if src_fs is dst_fs:
        src_fs.copy(src_path, dst_path, overwrite=overwrite)
        return

    src_syspath = src_fs.getsyspath(src_path, allow_none=True)
    dst_syspath = dst_fs.getsyspath(dst_path, allow_none=True)

    # System copy if there are two sys paths
    if src_syspath is not None and dst_syspath is not None:
        FS._shutil_copyfile(src_syspath, dst_syspath)
        return

    src_lock = getattr(src_fs, '_lock', None)

    if src_lock is not None:
        src_lock.acquire()

    try:
        src = None
        try:
            src = src_fs.open(src_path, 'rb')
            dst_fs.setcontents(dst_path, src, chunk_size=chunk_size)
        finally:
            if src is not None:
                src.close()
    finally:
        if src_lock is not None:
            src_lock.release()

 def copydir(self, src, dst, overwrite=False, ignore_errors=False, chunk_size=16384):
     if self.getmeta("read_only"):
         raise errors.UnsupportedError('read only filesystem')
     # FIXME: this is out of date; how to do native tahoe copy?
     # FIXME: Workaround because isfile() not exists on _TahoeLAFS
     FS.copydir(self, src, dst, overwrite, ignore_errors, chunk_size)

 def copydir(self, src, dst, **kwds):
     FS.copydir(self,src,dst,**kwds)

 def movedir(self, src, dst, **kwds):
     FS.movedir(self,src,dst,**kwds)

 def move(self, src, dst, **kwds):
     FS.move(self,src,dst,**kwds)
     path = relpath(normpath(src))
     with self._size_lock:
         self._file_sizes.pop(path,None)

    def __init__(self):
        FS.__init__(self, thread_synchronize=True)

        self.fs_sequence = []
        self.fs_lookup =  {}

 def close(self):
     self._olefile.close()
     FS.close(self)