def delete_content(self):
chunks = self.meta.get('chunks')
if not chunks:
return
ops = qiniu.build_batch_delete(self.bucket_name,
[c['path'] for c in chunks])
self.bucket_manager.batch(ops)
def sync(self):
"""
同步操作
:return:
"""
remote_files = self.list_remote()
local_files = self.list_local()
# 首先删除远端多余的文件
remove_remote_files = []
for remote_filename in remote_files:
if remote_filename not in local_files:
remove_remote_files.append(remote_filename)
self.bucket.batch(
build_batch_delete(self.bucket_name, remove_remote_files))
# 上传本地文件到远端(未出现过的)
for local_filename in local_files:
if local_filename not in remote_files or local_files[
local_filename]['hash'] != remote_files[local_filename][
'hash']:
print('puting ' + local_filename)
ret, info = put_file(
self.q.upload_token(self.bucket_name, local_filename,
3600), local_filename,
local_files[local_filename]['fullpath'])
pass
def delete():
key = request.form.get('key', '')
if not key:
return jsonify({'result': 'fail'})
real_key = (g.user.account + key).encode('utf8')
bucket = qiniu.BucketManager(qn)
if real_key[-1] != '/':
ret, info = bucket.delete(qiniu_bucket, real_key)
if ret:
return jsonify({'result': 'fail'})
else:
items = []
marker = None
while True:
ret, eof, _ = bucket.list(qiniu_bucket, prefix=real_key, marker=marker, limit=1000)
for item in ret['items']:
items.append(item['key'].encode('utf8'))
if eof:
break
marker = ret['marker']
ops = qiniu.build_batch_delete(qiniu_bucket, items)
ret, info = bucket.batch(ops)
if ret[0]['code'] != 200:
return jsonify({'result': 'fail'})
return jsonify({'result': 'success'})
def sync(self):
"""
同步操作
:return:
"""
remote_files = self.list_remote()
local_files = self.list_local()
# 首先删除远端仓库中多余的文件
remove_remote_files = []
for remote_filename in remote_files:
if remote_filename not in local_files:
remove_remote_files.append(remote_filename)
self.bucket.batch(
build_batch_delete(self.bucket_name, remove_remote_files))
# 上传本地文件到远端(仅上传远端不存在的以及修改过的)
for local_filename in local_files:
win_path = local_filename.replace('\\', '/')
if (win_path not in remote_files or local_files[win_path]["hash"]
!= remote_files[win_path]["hash"]):
print("puting " + win_path)
ret, info = put_file(
self.q.upload_token(self.bucket_name, win_path, 3600),
win_path,
local_files[local_filename]["fullpath"],
)
def sync(self):
"""
同步操作
:return:
"""
remote_files = self.list_remote()
local_files = self.list_local()
# 首先删除远端仓库中多余的文件
remove_remote_files = []
remove_count = 0
put_count = 0
for remote_filename in remote_files:
if remote_filename not in local_files:
remove_remote_files.append(remote_filename)
remove_count += 1
print("remve " + str(remove_count) + " => " + remote_filename)
self.bucket.batch(
build_batch_delete(self.bucket_name, remove_remote_files))
# 上传本地文件到远端(仅上传远端不存在的以及修改过的)
for local_filename in local_files:
if (local_filename not in remote_files
or local_files[local_filename]["hash"] !=
remote_files[local_filename]["hash"]):
ret, info = put_file(
self.q.upload_token(self.bucket_name, local_filename,
3600),
local_filename,
local_files[local_filename]["fullpath"],
)
put_count += 1
print("puting " + str(put_count) + " => " + local_filename)
def delete_fonts(self,
keyword='',
pref='',
prefix=config.qiniu_fonts_prefix):
fonts_list = self.get_fonts(keyword=keyword, pref=pref, prefix=prefix)
delete_fonts_object = list(
filter(
lambda fonts_file: keyword in fonts_file['key'] and fonts_file[
'key'].split(prefix)[-1].startswith(pref), fonts_list))
delete_fonts = list(
map(lambda font_object: font_object['key'], delete_fonts_object))
if not delete_fonts:
print('No fonts matched for delete in qiniu fonts bucket')
else:
print('Fonts to be deleted %s' % delete_fonts)
self.logger.info('Fonts to be deleted %s' % delete_fonts)
bucket = qiniu.BucketManager(self.auth)
ops = qiniu.build_batch_delete(config.qiniu_fonts_bucket,
delete_fonts)
res, info = bucket.batch(ops)
print(res, info)
assert info.status_code == 200
print('Fonts %s delete success' % delete_fonts)
self.logger.info('Fonts %s delete success' % delete_fonts)
def deleteSelectedFile(self, files):
ops = build_batch_delete(self.__bucketName, files)
ret, info = self.__bucketManger.batch(ops)
if info.ok():
wx.CallAfter(wx.MessageBox, u"删除成功", u"提示")
wx.CallAfter(self.setBucketName, self.__bucketName)
else:
wx.CallAfter(wx.MessageBox, info.error)
def deleteSelectedFile(self,files):
ops = build_batch_delete(self.__bucketName, files)
ret, info = self.__bucketManger.batch(ops)
if info.ok() :
wx.CallAfter(wx.MessageBox,u"删除成功",u"提示")
wx.CallAfter(self.setBucketName, self.__bucketName)
else:
wx.CallAfter(wx.MessageBox,info.error)
def delete_file(bucket_name, key):
q = get_quniu_auth()
bucket = qiniu.BucketManager(q)
ops = qiniu.build_batch_delete(bucket_name, [key])
ret, info = bucket.batch(ops)
return ret, info
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 batch_delete(self, keys):
"""
Batch delete files
:param keys: file names list -> []
:return: True or False
"""
ops = qiniu.build_batch_delete(self._bucket, keys)
ret, info = self._bucket_manager.batch(ops)
return True if info.status_code == 200 else False
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
def batch_delete(storages):
to_delete = [x.key_name.encode('utf8') for x in storages]
for storage in storages:
to_delete += [
x.key.encode('utf8') for x in storage.converted_storage.all()
]
storages.delete()
ops = qiniu.build_batch_delete(BUCKET_NAME, to_delete)
return qn_bucket_mng.batch(ops)
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
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 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 test_batch_copy(self):
key = 'copyto'+rand_string(8)
ops = build_batch_copy(bucket_name, {'copyfrom': key}, bucket_name)
ret, info = self.bucket.batch(ops)
print(info)
assert ret[0]['code'] == 200
ops = build_batch_delete(bucket_name, [key])
ret, info = self.bucket.batch(ops)
print(info)
assert ret[0]['code'] == 200
def clear_qiniu():
global DELETE_COUNT
q = Auth(access_key, secret_key)
bucket = BucketManager(q)
l = bucket.list(bucket_name)
items = l[0].get('items')
keys = [item.get('key') for item in items]
DELETE_COUNT = len(keys)
ops = build_batch_delete(bucket_name, keys)
bucket.batch(ops)
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
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)
def batch_delete(self, filenames):
"""批量删除文件
"""
try:
ops = build_batch_delete(self.bucket_name, filenames)
result, info = self.bucket.batch(ops)
except Exception as exc:
return {'error': True, 'exception': str(exc)}
else:
return {
'error': info.status_code != 200,
'exception': info.exception
}
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)
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!')
def push():
local = get_local_files_name_and_hash_and_date()
remote = get_remote_files_name_and_hash_date()
delete_files = []
push_files = []
for local_file in local:
for remote_file in remote:
if remote_file[1] == local_file[1]:
if not remote_file[0] == local_file[0]:
push_files.append(remote_file)
if not local_file[1] in [i[1] for i in remote]:
push_files.append(local_file)
for remote_file in remote:
if not remote_file[1] in [i[1] for i in local]:
delete_files.append(remote_file)
x = PrettyTable(["Delete Remote Files"])
x.align["Delete Remote Files"] = "l" # Left align city names
x.padding_width = 1 # One space between column edges and contents (default)
for i in delete_files:
x.add_row([i[1]])
print x
x = PrettyTable(["Upload Files"])
x.align["Upload Files"] = "l" # Left align city names
x.padding_width = 1 # One space between column edges and contents (default)
for i in push_files:
x.add_row([i[1]])
print x
deletes = ['%s/%s' % (i[0], i[1]) for i in delete_files]
ops = build_batch_delete(bucket_name, deletes)
bucket.batch(ops)
for key in push_files:
token = q.upload_token(bucket_name, key[1])
hashkey = key[0]
sys.stdout.write('Upload %s ' % str(key[1]))
sys.stdout.flush()
fpath = os.path.join(our_dir, key[1])
ret, info = put_file(token, key[1].decode('utf8'), fpath, mime_type=mime_type,
check_crc=True) # 上传文件
print '.................... HTTP %s OK' % str(info.status_code)
bucket.move(bucket_name, key[1], bucket_name, '%s/%s' % (hashkey, key[1])) # 移动文件
bucket.delete(bucket_name, key[1]) # 删除移动以前的文件
try:
bucket.delete(bucket_name, '%s/%s' % (key[3], key[1])) # 删除旧的文件
except IndexError:
pass
def delete_remote_file(args):
files = args.FILE
ret, eof, info = bucket.list(bucket_name, limit=100)
remote_files = [f.get('key') for f in json.loads(info.text_body).get('items')]
delete_l_files = [f.split('/')[1] for f in remote_files if f.split('/')[1] in files]
delete_r_files = [f for f in remote_files if f.split('/')[1] in files]
x = PrettyTable(["Delete Files"])
x.align["Delete name"] = "l" # Left align city names
x.padding_width = 1 # One space between column edges and contents (default)
for i in delete_l_files:
x.add_row([i])
print x
ops = build_batch_delete(bucket_name, delete_r_files)
bucket.batch(ops)
def multi_delete(where: str, delete_key_list: List[str]) -> None:
access_key = Facade.config["qiniu"]["access_key"]
secret_key = Facade.config["qiniu"]["secret_key"]
# original code
q = Auth(access_key, secret_key)
bucket = BucketManager(q)
# 1. what i do
bucket_name = Facade.config["qiniu"]["category"][where]
logworker.warning('------multi_copy---------start')
logworker.warning(delete_key_list)
logworker.warning(bucket_name)
logworker.warning('end------multi_copy---------')
# original code
ops = build_batch_delete(bucket_name, delete_key_list)
ret, info = bucket.batch(ops)
def delete_files(keys=None):
"""
批量删除
:param keys:
:return:
"""
if keys is None:
keys = []
config = get_qiniu_config()
# 七牛上传数据的凭证
q = Auth(config['access_key'], config['secret_key'])
bucket = BucketManager(q)
ops = build_batch_delete(config['bucket_name'], keys)
ret, info = bucket.batch(ops)
if info.status_code == 200:
return True
else:
print(ret)
return False
def delete_queryset(self, request, queryset):
access_key = settings.QINIU_ACCESS_KEY
secret_key = settings.QINIU_SECRET_KEY
bucket = settings.QINIU_BUCKET
host = settings.QINIU_HOST
auth = Auth(access_key, secret_key)
bucketManager = BucketManager(auth)
keys = []
for item in queryset:
filename = str(item.link)
if (filename.startswith(host)):
filename = filename.replace(host + '/', '')
else:
if re.match(r'^https?:/{2}\w.+$', filename):
continue
keys.append(filename)
bucketManager.batch(build_batch_delete(bucket, keys))
queryset.delete()
# -*- 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)
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
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
def delete_data_by_key(keys, bucket):
ops = build_batch_delete(bucket, keys)
b = BucketManager(Q)
b.batch(ops)
from qiniu import Auth
from qiniu import BucketManager, build_batch_delete
access_key = 'U8VGSrOjjPpoPFEG-qHUJrywNL743V2PsrMjW6WM'
secret_key = 'ZcWIywOvp1NaaUNMU0o3ml8OTC-kk8TG_5e_T0kN'
BUCKET_NAME = 'img4wc-dev'
q = Auth(access_key, secret_key)
bucket = BucketManager(q)
prefix = 'thumb/'
ret, eof, info = bucket.list(BUCKET_NAME, prefix, limit=2000)
keys = []
for x in ret['items']:
print(x['key'])
keys.append(x['key'])
print(len(keys))
ops = build_batch_delete(BUCKET_NAME, keys)
ret, info = bucket.batch(ops)
# print(info)
def delete_file(self, prefix):
files = self.list_file("fw")
if len(files) == self.file_list_size:
ops = qiniu.build_batch_delete(BUCKET_NAME, files)
ret, info = self._bucket.batch(ops)
