Python BucketManager.move方法代码示例

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import move [as 别名]
def move_file(username,path,filename,newpath,newfilename,bucket=None):  # bucket即bucketmanager path='/dir/dir' 可用于重命名文件,移动文件,移动目录，重命名目录 # ok
    user = User.objects.filter(username=username)
    if bool(user):
        user = user[0]
    else:
        return False
    if bucket == None:
        q = Auth(settings.QINIU_ACCESS_KEY, settings.QINIU_SECRET_KEY)  # 授权
        bucket = BucketManager(q)
        if  not check_str(filename) or not check_str(path,ispath=True) or  not check_str(newfilename) or not check_str(newpath,ispath=True):
            return False

        file1 = FileInfo.objects.filter(owner=user,file_name=filename,file_path=path)
        filecheck = FileInfo.objects.filter(owner=user,file_path=newpath)  # filepath 可以不存在
        if bool(file1) and bool(filecheck):
            update_dir_size(username,path,0-file1[0].size)
            update_dir_size(username,newpath,file1[0].size)
        else:
            return False
    # 数据库操作
    file1 = FileInfo.objects.filter(owner=user,file_name=filename,file_path=path)
    if bool(file1):
        file1 = file1[0]
    else:
        return False  # 文件名或者文件夹名不存在
    filecheck = FileInfo.objects.filter(owner=user,file_name=newfilename,file_path=newpath)
    if bool(filecheck):
        return False
    file1.file_path = newpath
    file1.file_name = newfilename
    file1.save()
    if path == '/':
        path = ''
    if newpath == '/':
        newpath = ''
    if file1.file_type == 'dir': 
        subpath = ''.join([path,'/',filename])
        files = FileInfo.objects.filter(owner=user,file_path=subpath)
        subpath2 = ''.join([newpath,'/',newfilename])
        for f in files:
            if f.file_type != 'dir':
                f.file_path = subpath2
                f.save()
                key = ''.join([username, subpath , '/', f.file_name])
                key2 = ''.join([username, subpath2, '/', f.file_name])
                ret, info = bucket.move(settings.QINIU_BUCKET_NAME, key, settings.QINIU_BUCKET_NAME, key2)
                print info
                # assert ret=={}
            else :
                move_file(username,subpath,f.file_name,subpath2,f.file_name,bucket)
    else:
        key = ''.join([username, path, '/', filename])
        key2 = ''.join([username, newpath, '/', newfilename])
        ret, info = bucket.move(settings.QINIU_BUCKET_NAME, key, settings.QINIU_BUCKET_NAME, key2)
        print info
        # assert ret == {}
    return True

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import move [as 别名]
class QiniuWrapper():

    policy = {'returnBody': '{"key": $(key), "type": $(mimeType), "name": $(fname), "size": $(fsize), "hash": $(etag)}'}
    bucket_name = QINIU_BUCKET_NAME
    domain = 'http://%s.qiniudn.com/' % bucket_name

    def __init__(self):
        self.q = Auth(QINIU_ACCESS_KEY, QINIU_SECRET_KEY)
        self.bucket_manager = BucketManager(self.q)

    def get_upload_token(self, key, expires=3600):
        return self.q.upload_token(self.bucket_name, key, expires, self.policy)

    def upload_file(self, key, filename, mime_type="application/octet-stream"):
        '''
        上传文件到七牛，如果指定的key对应的文件在七牛上已经存在, 会覆盖原来七牛上的文件
        '''
        ret, info = put_file(self.get_upload_token(key), key, filename, mime_type=mime_type, check_crc=True)
        if info.status_code != 200:
            return (False, info)
        return (True, info)

    def upload_stream(self, key, input_stream, data_size, mime_type="application/octet-stream"):
        '''
        上传文件到七牛，如果指定的key对应的文件在七牛上已经存在, 会覆盖原来七牛上的文件
        '''
        ret, info = put_stream(self.get_upload_token(key), key, input_stream, data_size, mime_type=mime_type, check_crc=True)
        if info.status_code != 200:
            return (False, info)
        return (True, info)

    def move(self, old_key, new_key):
        ret, info = self.bucket_manager.move(self.bucket_name, old_key, self.bucket_name, new_key)
        if info.status_code != 200:
            return (False, info)
        return (True, info)

    def delete(self, key):
        ret, info = self.bucket_manager.delete(self.bucket_name, key)
        if info.status_code != 200:
            return (False, info)
        return (True, info)

    def batch_delete(self, keys):
        '''
        keys = ['key1', 'key2', 'key3']
        '''
        ops = build_batch_delete(self.bucket_name, keys)
        ret, info = self.bucket_manager.batch(ops)
        if info.status_code != 200:
            return (False, info)
        return (True, info)

    def list(self, prefix=None, limit=1000, marker=None):
        return self.bucket_manager.list(self.bucket_name, prefix=prefix, marker=marker, limit=limit)

    @classmethod
    def get_url(cls, key):
        return cls.domain + key

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import move [as 别名]
class QiniuBucketManager:
    def __init__(self, auth, bucket):
        """
        @param auth: qiniu auth object
        @param bucket: bucket name
        """
        self.auth = auth
        self.bucket = bucket
        self.bktmanager = BucketManager(auth)

        self.upload_token = auth.upload_token(bucket)
        
    def data_info(self, key):
        """
        return information with keys {fsize, hash, mimetype, putTime} else
        raise  `QiniuReadDataError` with status_code and error message
        """
        r, info = self.bktmanager.stat(self.bucket, key)
        if not r:
            raise QiniuReadDataError('status_code:{0}, error:{1}'.format(info.status_code,
                            info.text_body))
        else:
            return r
    
    def push_data(self, key, data):
        """
        return hash code if upload sucess else raise `QiniuPushDataError` 
        with status_code and error message
        """
        ret, info = put_data(self.upload_token, key, data)
        if not ret:
            raise QiniuPushDataError('status_code:{0}, error:{1}'.format(info.status_code,
                            info.text_body))
        else:
            return ret['hash']
    
    def delete_data(self, key):
        """
        delete data `key`
        """
        _, info = self.bktmanager.delete(self.bucket, key)
        if info.status_code != 200:
            raise QiniuError('status_code:{0}, error:{1}'.format(info.status_code,
                            info.text_body))
    
    def batch_delete_data(self, keys):
        if keys:
            ops = build_batch_delete(self.bucket, keys)
            _, info = self.bktmanager.batch(ops)
            if info.status_code != 200:
                msg = ''
                for e in info.text_body:
                    msg += msg + ';' + 'status_code:{0}, error:{1}'.format(e)
                raise QiniuError(msg)
        
    def copy_data_to(self, sdata, dbucket, ddata):
        """
        copy data `sdata` in this bucket to destination bucket `dbucket` with name `ddata`
        """
        _, info = self.bktmanager.copy(self.bucket, sdata, dbucket, ddata)
        if info.status_code != 200:
            raise QiniuError('status_code:{0}, error:{1}'.format(info.status_code,
                            info.text_body))
    
    def copy_data_from(self, sbucket, sdata, ddata):
        """
        copy data from `sdata` in bucket `sbucket` to this bucket with name `ddata`
        """
        _, info = self.bktmanager.copy(sbucket, sdata, self.bucket, ddata)
        if info.status_code != 200:
            raise QiniuError('status_code:{0}, error:{1}'.format(info.status_code,
                            info.text_body))
    
    def move_data_to(self, sdata, dbucket, ddata):
        """
        move data `sdata` in this bucket to destination bucket `dbucket` with name `ddata`
        """
        _, info = self.bktmanager.move(self.bucket, sdata, dbucket, ddata)
        if info.status_code != 200:
            raise QiniuError('status_code:{0}, error:{1}'.format(info.status_code,
                            info.text_body))
    
    def move_data_from(self, sbucket, sdata, ddata):
        """
        move data from `sdata` in bucket `sbucket` to this bucket with name `ddata`
        """
        _, info = self.bktmanager.move(sbucket, sdata, self.bucket, ddata)
        if info.status_code != 200:
            raise QiniuError('status_code:{0}, error:{1}'.format(info.status_code,
                            info.text_body))
    
    def datas(self, prefix=None, limit=None, marker=None):
        """
        list datas in bucket with keys fsize, hash, key, mimeType, puttime of each data 
        """
        def list_files(marker, limit):
            k = {'bucket':self.bucket}
            if limit:
                k['limit'] = limit
            if prefix:
#.........这里部分代码省略.........

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import move [as 别名]
# -*- coding: utf-8 -*-
# flake8: noqa
from qiniu import Auth
from qiniu import BucketManager

access_key = '...'
secret_key = '...'

#初始化Auth状态
q = Auth(access_key, secret_key)

#初始化BucketManager
bucket = BucketManager(q)

#你要测试的空间， 并且这个key在你空间中存在
bucket_name = 'Bucket_Name'
key = 'python-logo.png'

#将文件从文件key 移动到文件key2，可以实现文件的重命名 可以在不同bucket移动
key2 = 'python-logo2.png'

ret, info = bucket.move(bucket_name, key, bucket, key2)
print(info)
assert ret == {}

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import move [as 别名]
class Qiniu(object):
    def __init__(self, _ak, _sk):
        import os
        from qiniu import Auth, BucketManager
        if os.name in ['nt']:
            os.environ["HOME"] = r"../"
        self.q = Auth(_ak, _sk)
        self.bucket = BucketManager(self.q)
        self.domain = "images.miasun.cn"

    def upload_file_by_file(self, _bucket_name, local_file, key=None):
        import os
        from qiniu import put_file
        if not os.path.exists(local_file):
            print("文件不存在，请检查文件地址！")
            return False
        if key is None:
            # 未传入key时，使用文件名作为key
            key = os.path.split(local_file)[-1]
        token = self.q.upload_token(bucket=_bucket_name, key=key)
        ret, info = self.get_file_info(bucket_name, key)
        if ret:
            print("已上传: http://{domain}/{key}".format(domain=self.domain, key=key))
        else:
            ret, info = put_file(token, key, local_file)
        return ret, info

    def upload_files_by_dir(self, _bucket_name, dir_):
        failed = []
        for dirpath, dirnames, filenames in os.walk(dir_):
            for filename in filenames:
                local_file = os.path.join(dirpath, filename)
                key = local_file[len(os.path.split(dir_)[0]) + 1:].replace("\\", "/")
                if self.is_file_uploaded(bucket_name, key):
                    print("已上传: http://{domain}/{key}".format(domain=self.domain, key=key))
                    continue
                ret, info = self.upload_file_by_file(_bucket_name, local_file, key)
                if ret is None:
                    failed.append(key)
                    print("上传失败：{key}".format(key=key))
                else:
                    print("上传成功：\n![{filename}](http://{domain}/{key}) \n".format(
                        filename=filename,
                        key=key,
                        domain=self.domain
                    ))
        return failed

    def upload(self, bucket_name, to_upload):
        if os.path.isfile(to_upload):
            return self.upload_file_by_file(bucket_name, to_upload)
        elif os.path.isdir(to_upload):
            return self.upload_files_by_dir(bucket_name, to_upload)
        else:
            return False

    def upload_and_callback(self, bucket_name, local_file, key=None):
        import os
        from qiniu import put_file
        if not os.path.exists(local_file):
            print("文件不存在，请检查文件地址！")
            return False
        if key is None:
            key = os.path.split(local_file)[-1]
        policy = {
            "callbackUrl": "http://your.domain.com/callback.php",
            "callbackBody": "filename=$(fname)&filesize=$(fsize)"
        }
        token = self.q.upload_token(bucket=bucket_name, key=key, policy=policy)
        ret, info = put_file(token, key, local_file)
        return ret, info

    def get_file_info(self, bucket_name, key):
        return self.bucket.stat(bucket_name, key)

    def is_file_uploaded(self, bucket_name, key):
        ret, info = self.get_file_info(bucket_name, key)
        if ret is None:
            return False
        else:
            return True

    def move_file(self, old_bucket, old_key, new_bucket, new_key):
        return self.bucket.move(old_bucket, old_key, new_bucket, new_key)

    def copy_file(self, old_bucket, old_key, new_bucket, new_key):
        return self.bucket.copy(old_bucket, old_key, new_bucket, new_key)

    def delete_file(self, bucket_name, key):
        return self.bucket.delete(bucket_name, key)