Python BucketManager.batch方法代码示例

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import batch [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 batch [as 别名]
 def get_file_info(self,bucket_name,keys=[]):
     """Args:
     bucket_name:'bucket_name'
     keys:  ['fileName1','fileName2']
     """
     bucket = BucketManager(self.__auth)
     ops = build_batch_stat(bucket_name, keys)
     ret, info = bucket.batch(ops)
     return ret,info

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import batch [as 别名]
 def delete_files(self,source_bucket,pathlist=[]):
     """Args:
     source_bucket： 'source_bucket'
     pathlist: ['source_file_name',...]
     """
     bucket = BucketManager(self.__auth)
     ops = build_batch_delete(source_bucket, pathlist)
     ret, info = bucket.batch(ops)
     return ret,info

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import batch [as 别名]
 def move_files(self,source_bucket,target_bucket,pathdict={}):
     """Args:
     source_bucket： 'source_bucket'
     target_bucket:  'target_bucket'
     pathdict: {'source_file_name':'target_file_name',...}
     """
     bucket = BucketManager(self.__auth)
     ops = build_batch_move(source_bucket, pathdict, target_bucket)
     ret, info = bucket.batch(ops)
     return ret,info

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import batch [as 别名]
    def multi_delete(self, key_list):
        # key_list: [key1, key2, key3, ...]
        from qiniu import build_batch_delete
        bucket = BucketManager(self.q)
        ops = build_batch_delete(self.bucket_name, key_list)
        ret, info = bucket.batch(ops)
        # print('QiniuStorage - multi_delete: %s' % info)

        json_info = json.loads(info.text_body)
        for m_info in json_info:
            # "code":612,"data":{"error":"no such file or directory"
            assert m_info[u'code'] == 200 or m_info[u'code'] == 612

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import batch [as 别名]
def delete_data(urls, bucket='lucky-web', key_prefix=''):
    keys = []
    for url in urls:
        if not url.endswith('/'):
            url += '/'
        key = url.split('/')[-2]
        if key_prefix:
            key = '%s/%s' % (key_prefix, key)
        keys.append(key)

    ops = build_batch_delete(bucket, keys)
    b = BucketManager(Q)
    ret, info = b.batch(ops)

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import batch [as 别名]
def delete_files(bucket_name, files_key, bucket=None):
    if bucket is None:
        bucket = BucketManager(q)
    if len(files_key) == 0:
        logging.info('nothing to delete')
        return
    ops = build_batch_delete(bucket_name,files_key)

    ret,info = bucket.batch(ops)

    if ret[0]['code'] == 200:
        logging.info('delete all success!')
    else:
        logging.error('delete failed!')

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import batch [as 别名]
# -*- coding: utf-8 -*-
"""
批量删除文件

https://developer.qiniu.com/kodo/api/1250/batch
"""


from qiniu import build_batch_delete, Auth, BucketManager

access_key = ''

secret_key = ''

q = Auth(access_key, secret_key)

bucket = BucketManager(q)

bucket_name = ''

keys = ['1.gif', '2.txt', '3.png', '4.html']

ops = build_batch_delete(bucket_name, keys)
ret, info = bucket.batch(ops)
print(info)

# 需要导入模块: from qiniu import BucketManager [as 别名]
# 或者: from qiniu.BucketManager import batch [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 batch [as 别名]
 def delete(self, bucket_name, del_list):
     mbucket = BucketManager(self.mauth)
     del_item = build_batch_delete(bucket_name, del_list)
     ret, info = mbucket.batch(del_item)
     print info