class Qiniu(object):
def init_app(self, app):
access_key = app.config.get('QINIU_ACCESS_KEY')
secret_key = app.config.get('QINIU_SECRET_KEY')
self.app = app
self.bucket = app.config.get('QINIU_BUCKET')
self.auth = Auth(access_key, secret_key)
def upload_file(self, filename, filepath):
"""上传本地文件"""
token = self.auth.upload_token(self.bucket, filename)
ret, info = put_file(token, filename, filepath)
if info.exception is not None:
raise UploadError(info)
def upload_data(self, filename, data):
"""上传二进制数据"""
token = self.auth.upload_token(self.bucket, filename)
ret, info = put_data(token, filename, data)
if info.exception is not None:
raise UploadError(info)
def generate_token(self, filename=None, policy=None):
"""生成上传凭证"""
return self.auth.upload_token(self.bucket, filename, policy=policy)
class QiNiu(object):
def __init__(self):
self.authed = Auth(AccessKey, SecretKey)
def upload(self, data):
"""
:param data:
{
"filename":"",
"filepath":"",
"policy":{}
}
:return:
ret
info
"""
filename = data["filename"]
filepath = data["filepath"]
policy = data.get("policy", {})
if policy:
token = self.authed.upload_token(BucketName, filename, Expired, policy)
else:
token = self.authed.upload_token(BucketName, filename, Expired)
ret, info = put_file(token, filename, filepath)
return ret, info
class QiNiuProvider(object):
def __init__(self, access_key, secret_key, bucket_name, imageServerUrl):
self.access_key = access_key
self.secret_key = secret_key
self.bucket_name = bucket_name
self.imageServerUrl = imageServerUrl
self.credentials = Auth(self.access_key, self.secret_key)
def token(self):
return self.credentials.upload_token(self.bucket_name)
def store(self, raw):
key = hash(str(uuid.uuid1()))
upload_token = self.credentials.upload_token(self.bucket_name, key)
ret, err = put_data(upload_token, key, raw)
if ret is not None:
return "%s/%s" % (self.imageServerUrl, ret['key'])
else:
logging.error('upload error.')
def store_file(self, file_path, file_name):
upload_token = self.credentials.upload_token(self.bucket_name, file_name)
ret, err = put_file(upload_token, file_name, file_path)
if ret is not None:
return "%s/%s" % (self.imageServerUrl, ret['key'])
else:
logging.error('upload: %s error.' % file_name)
def uploadsong(request):
q = Auth('ToNLYIGLfHy5tpKSsRcBV2pw18b20LrYuBdvHaA_', 'rrD25c6RoHoMajmLR8lSz9wW4FcGEHvGMDL4l2zV')
print q
token = q.upload_token('outshineamazing', '')
print token
context = {'uptoken_url':token}
return render(request,'comments/test.html',context)
def upload_file(localfile):
# 需要填写你的 Access Key 和 Secret Key
access_key = 'aRzVj18_VFA_p4EZ9z8ClWkVwYvAOWuoMStYnJhi'
secret_key = 'bh_hBotfph77wcmHHIgCwExqKEvQN_eyT5m1r9_c'
# 构建鉴权对象
q = Auth(access_key, secret_key)
# 要上传的空间
bucket_name = 'myselfres'
# 上传到七牛后保存的文件名
key = time.strftime("%Y-%m-%d-%H-%M-%S.png", time.localtime())
print key
# 生成上传 Token，可以指定过期时间等
token = q.upload_token(bucket_name, key, 3600)
# 要上传文件的本地路径
ret, info = put_file(token, key, localfile)
print (info)
assert ret['key'] == key
assert ret['hash'] == etag(localfile)
pngOnlinePath = myselfres_dom + key + ')'
setText(pngOnlinePath)
def upload():
# Get the name of the uploaded file
file = request.files['file']
# Check if the file is one of the allowed types/extensions
if file and allowed_file(file.filename):
# Make the filename safe, remove unsupported chars
filename = secure_filename(file.filename)
# Move the file form the temporal folder to
# the upload folder we setup
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
# Redirect the user to the uploaded_file route, which
# will basicaly show on the browser the uploaded file
path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
access_key = ''
secret_key = ''
bucket_name = ''
q = Auth(access_key, secret_key)
token = q.upload_token(bucket_name, None, 3600)
ret, info = qiniu.put_file(token, filename, path)
return redirect(url_for('uploaded_file', filename=filename))
def uploadToQiNiu(filePath,name):
q = Auth(access_key, secret_key)
localfile = filePath
key = name
mime_type = "image/jpeg"
token = q.upload_token(bucket_name, key)
ret, info = put_file(token, key, localfile, mime_type=mime_type, check_crc=True)
class Qiniu(object):
def __init__(self, uri):
assert uri.startswith('http://')
self.qn = Auth(qnconf['access_key'], qnconf['secret_key'])
self.token = self.qn.upload_token(qnconf['bucket_name'])
self.bucket = BucketManager(self.qn)
# def stat_image(self, key):
# status, image_info = self.bucket.stat(qnconf['bucket_name'], key)
# last_modified = int(status['putTime'] / 1000000)
# return {'checksum': status['hash'], 'last_modified': last_modified}
# def persist_image(self, key, image, buf, info):
# buf.seek(0)
# return threads.deferToThread(put_data, self.token, key, buf.getvalue())
def get_file_stat(self, key):
stat, error = self.bucket.stat(qnconf['bucket_name'], key)
return stat
def stat_file(self, path, info):
def _onsuccess(stat):
if stat:
checksum = stat['hash']
timestamp = stat['putTime'] / 10000000
return {'checksum': checksum, 'last_modified': timestamp}
else:
return {}
return threads.deferToThread(self.get_file_stat, path).addCallback(_onsuccess)
def persist_file(self, path, buf, info, meta=None, headers=None):
buf.seek(0)
return threads.deferToThread(put_data, self.token, path, buf.getvalue())
def test_upload():
q = Auth(access_key, secret_key)
token = q.upload_token(bucket, mykey.encode('utf-8'))
file = '/tmp/abc.txt'
ret, info = put_file(token, mykey.encode('utf-8'), file, mime_type="text/plain", check_crc=True)
print(info)
print(ret)
def post(self):
for i in request.forms.keys():
print i, request.forms[i], type(request.forms[i])
for i in request.files.keys():
print i, request.files[i], type(request.files[i])
print request.files[i].__dict__
image = request.files['image']
name = image.raw_filename
data = image.file.read()
key = md5('data').hexdigest() + '.' + name.split('.')[-1]
auth = Auth(QINIU_ACCESS_KEY, QINIU_SECRET_KEY)
token = auth.upload_token(
QINIU_BUCKET_NAME, None, 7200,
{
'returnBody': json.dumps({
'key': '$(key)',
'hash': '$(etag)',
'format': '$(imageInfo.format)',
'width': '$(imageInfo.width)',
'height': '$(imageInfo.height)',
}),
'save_key': '$(etag)',
}
)
ret, info = put_data(token, key, data)
def get_token(key):
q = Auth(qiniu_access_key, qiniu_secret_key)
# 上传策略仅指定空间名和上传后的文件名，其他参数仅为默认值
token = q.upload_token(qiniu_bucket_name, key)
return token
def upload_token():
q = Auth(ACCESS_KEY, SECRET_KEY)
# 上传策略仅指定空间名和上传后的文件名，其他参数仅为默认值
token = q.upload_token('wm-test', None, 7200, {'callbackUrl':"http://298074.cicp.net:59295/upload/callback/", 'callbackBody':"name=$(key)&fname=$(fname)&hash=$(etag)&size=$(imageInfo.width)x$(imageInfo.height)", \
'saveKey':'aaa$(year)$(mon)$(day)$(hour)$(min)$(sec).jpg',
'mimeType':'image/jpg'})
return token
class Qiniu(object):
def __init__(self, access_key = None, secret_key = None, bucket_name = None):
self.access_key = access_key
self.secret_key = secret_key
self.bucket_name = bucket_name
self.q = Auth(self.access_key, self.secret_key)
def upload(self, key, localfile = None, expires = 3600, deleteAfterDays = 7):
policy = {'deleteAfterDays': deleteAfterDays}
print policy
#token = self.q.upload_token(self.bucket_name, key, expires, policy, False)
token = self.q.upload_token(self.bucket_name, key, expires, policy)
ret, info = put_file(token, key, localfile)
print(info)
assert ret['key'] == key
assert ret['hash'] == etag(localfile)
def delete(self, key):
bucket = BucketManager(self.q)
ret, info = bucket.delete(self.bucket_name, key)
print(info)
assert ret == {}
def stat(self, key):
bucket = BucketManager(self.q)
ret, info = bucket.stat(self.bucket_name, key)
print(info)
assert 'hash' in ret
def upload_file(file_name=None, data=None):
if not file_name:
file_name = hashlib.md5(data).hexdigest()
q = Auth(settings.QINIU_KEY, settings.QINIU_TOKEN)
token = q.upload_token(settings.QINIU_BUCKET)
ret, info = put_data(token, file_name, data)
return ret['key'] == file_name, file_name
def get(self, request):
q = Auth(settings.QNACCESSKEY, settings.QNSECRETKEY)
filename = str(uuid.uuid1()).replace("-", "") + ".jpg"
print (filename)
token = q.upload_token(settings.QNBUKET, filename)
print (token)
return Response({"key": filename, "token": token}, status=status.HTTP_202_ACCEPTED)
class QiniuLPic(LPic):
def __init__(self, conf=None, **option):
super(QiniuLPic, self).__init__(conf, **option)
self.cloud_name = '七牛云'
def auth(self):
self.client = Auth(self.cloud['AccessKey'], self.cloud['SecretKey'])
@property
def web_url(self):
return 'https://portal.qiniu.com/bucket/{}/resource'.format(self.cloud['Bucket'])
def upload(self, file, prefix=''):
_token = self.client.upload_token(self.cloud['Bucket'], os.path.basename(file), 600)
_, ret = put_file(_token, prefix + os.path.basename(file), file)
return ret.ok()
def list(self, prefix):
bucket = BucketManager(self.client)
ret, _, _ = bucket.list(self.cloud['Bucket'], prefix=prefix, limit=self.MAX_KEYS)
return [i['key'] for i in sorted([i for i in ret['items']], key=lambda x: -x['putTime'])]
def delete(self, key):
bucket = BucketManager(self.client)
_, ret = bucket.delete(self.cloud['Bucket'], key)
return ret.ok()
def close(self):
cache = '.qiniu_pythonsdk_hostscache.json'
if os.path.isfile(cache):
os.remove(cache)
def main():
q = Auth('FCFQs6B-thjgt30-HEmCS9ZUCGQBxx2Zsg_WO1k5', 'Z8LCTm4gxo_dfX7HT0EhFnXmsFTGwZ8MyCFXmSXF')
# 上传策略仅指定空间名和上传后的文件名，其他参数仅为默认值
token = q.upload_token('qile')
f = open('qiniu_auth_token.txt', 'w')
f.write(str(token))
def tuchuang_index():
github_user = _get_user()
if not github_user:
flash(u'请正确完成牛逼参数设置后上传图片！', category='warning')
return redirect(url_for('.info'))
if request.method == 'POST':
access_key = str(github_user.get('access_key'))
secret_key = str(github_user.get('secret_key'))
bucket_name = str(github_user.get('bucket_name'))
domain_name = str(github_user.get('domain_name'))
q = Auth(access_key, secret_key)
token = q.upload_token(bucket_name)
upload_files = request.files.getlist('file')
for upload_file in upload_files:
key = '%s_%s' % (datetime.now().isoformat(), upload_file.filename)
ret, info = put_data(up_token=token, key=key, data=upload_file)
url = '%s/%s' % (domain_name, key)
f = File()
f.set('url', url)
f.set('user', github_user)
f.save()
flash(u'成功上传%s张照片！' % len(upload_files), category='success')
return redirect(url_for('.tuchuang_index'))
image_id = request.args.get('image_id')
image = Query(File).get(image_id) if image_id else None
return render_template('tuchuang.html', image=image)
def create(self):
# TODO: 表单验证
image = request.files['image']
# TODO: 解包检查
origin_name, suffix = image.raw_filename.split('.')
data = image.file.read()
data_hash = md5(data).hexdigest()
key = data_hash
model = ImageModel.query.get(data_hash)
if model:
return model.as_dict()
auth = Auth(QINIU_ACCESS_KEY, QINIU_SECRET_KEY)
token = auth.upload_token(
QINIU_BUCKET_NAME, None, 7200,
{
'returnBody': json.dumps({
'key': '$(key)',
'hash': '$(etag)',
'format': '$(imageInfo.format)',
'width': '$(imageInfo.width)',
'height': '$(imageInfo.height)',
}),
'save_key': '$(etag)',
}
)
ret, info = put_data(token, key, data)
model = ImageModel(
hashkey=data_hash, suffix=ret['format'],
width=ret['width'], height=ret['height'])
db.session.add(model)
db.session.commit()
return model.as_dict()
def token(request):
# wiicome服务器设置七牛上传token
q = Auth(ACCESS_KEY, SECRET_KEY)
# 上传策略仅指定空间名和上传后的文件名，其他参数仅为默认值
token = q.upload_token(BUCKET_KEY)
data = {"uptoken": token}
return JsonResponse(data)
def upload(filepath):
qiniu_domain = 'http://7xtq0y.com1.z0.glb.clouddn.com/'
#需要填写你的 Access Key 和 Secret Key
access_key = 'NhxOewLDWpAs_THJNvtKN8kZHG3r0_tkWOaJSycc'
secret_key = 'Cx7AJItEyNWaEG1eLvu85PpCGq0vAaX1xmvJC7c0'
#构建鉴权对象
q = Auth(access_key, secret_key)
#要上传的空间
bucket_name = 'images'
#上传到七牛后保存的文件名
key = os.path.basename(filepath)
qiniu_url = qiniu_domain + key
#生成上传 Token，可以指定过期时间等
token = q.upload_token(bucket_name, key, 3600)
#要上传文件的本地路径
localfile = filepath
ret, info = put_file(token, key, localfile)
print(info)
print('===============')
print(qiniu_url)
return qiniu_url
def get(self):
access_key = 'YOUR_ACCESS_KEY'
secret_key = 'YOUR_SECRET_KEY'
q = Auth(access_key, secret_key)
bucket_name = 'YOUR_BUCKET_NAME'
# to set the uploaded file rename to YYYYMMDD_HHMMSS_filename
# if the filename was "test.jpg", then the new filename will be "20160101_083054_test.jpg"
# SEE MORE: http://developer.qiniu.com/article/kodo/kodo-developer/up/vars.html#magicvar
policy = {"saveKey": "$(year)$(mon)$(day)_$(hour)$(min)$(sec)_$(fname)"}
# in the source of qiniu/auth.py, the function upload_token takes 5 arguments:
# bucket：your bucket_name
# key: the filename you want to set, None means set as ths "saveKey" above
# expires: expires time (second)
# policy: the options to upload,see more: http://developer.qiniu.com/article/developer/security/put-policy.html
#
# def upload_token(self, bucket, key=None, expires=3600, policy=None, strict_policy=True):
token = q.upload_token(bucket_name, None, 3600, policy)
# return as json
self.write(json.dumps({"uptoken":token}))
def generate_upload_token(prefix):
'''
prefix: 'head' or 'content'
return: (token, key)
'''
# modify default upload zone
qiniu.config.set_default(default_zone=qiniu.config.zone1)
# access two keys
access_key = current_app.config['QINIU_ACCESS_KEY']
secret_key = current_app.config['QINIU_SECRET_KEY']
# auth obj
q = Auth(access_key, secret_key)
# upload bucket name
bucket_name = current_app.config['QINIU_BUCKET_NAME']
# achieve file ext name
try:
match = re.finditer(r'.([0-9a-zA-Z]+)$', localfile)
ext = match[-1].group(1)
except:
ext = 'jpg'
# cloud filename
# key = generate_upload_filename(ext, prefix=prefix)
# generate token
token = q.upload_token(bucket_name, None, 3600)
return token
def upload_qiniu_by_path(access_key, secret_key, bucket_name, key_prefix,
pool_number, path, delete=False):
q = Auth(access_key, secret_key)
mime_type = "text/plain"
params = {'x:a': 'a'}
pool = Pool(pool_number)
for dirpath, dirnames, filenames in os.walk(path):
print(dirpath)
if len(filenames) > 0:
for filename in filenames:
if filename.startswith('.'):
continue
localfile = os.path.join(dirpath, filename)
key = os.path.join(key_prefix, localfile.replace(path, '')[1:])
token = q.upload_token(bucket_name, key)
pool.spawn(
down,
token=token,
key=key,
localfile=localfile,
mime_type=mime_type,
delete=delete
)
class Qiniu(BaseStorage):
def __init__(self, bucket, access_key, secret_key, cdn_host, host=None, timeout=5):
self.bucket = bucket
self.access_key = access_key
self.secret_key = secret_key
self.host = host
self.cdn_host = cdn_host
self.timeout = timeout
self.auth = Auth(self.access_key, self.secret_key)
set_default(connection_timeout=self.timeout, connection_retries=0)
@property
def token(self):
return self.auth.upload_token(self.bucket)
def set(self, k, v, mimetype=None, **kwargs):
ret, info = put_data(self.token, k, v, mime_type=mimetype)
return bool(ret)
def get(self, k):
url = 'http://%s/%s' % (self.host, k)
resp = requests.get(url, timeout=5)
if resp.status_code == requests.codes.ok:
return resp.content, resp.headers['content-type']
return (None, None)
def cdn_url(self, ident):
return 'http://{}/{}'.format(self.cdn_host, ident)
def upload_photo():
"""上传照片到七牛，并返回私有链接地址"""
from qiniu import Auth
from qiniu import put_file
global config
progress_handler = lambda progress, total: progress
photo_path = http_get("http://127.0.0.1:9876/photo/shot").content
# Upload to qiniu
mime_type = "image/jpeg"
auth = Auth(str(config["qiniu"]["api_key"]), str(config["qiniu"]["secret"]))
print auth
filename = os.path.basename(photo_path)
print "filename: ", filename, type(filename)
token = auth.upload_token(str(config["qiniu"]["bucket"]))
print token
ret, info = put_file(token, filename, photo_path, {}, mime_type, progress_handler=progress_handler)
print "uploaded: ", ret, info
try:
os.remove(photo_path)
except Exception:
pass
# Return URL
base_url = "{}/{}".format(str(config["qiniu"]["domain"]), filename)
return auth.private_download_url(base_url, expires=3600)
def upload(origin_file_path):
# 构建鉴权对象
q = Auth(config.access_key, config.secret_key)
# 要上传的空间
bucket_name = 'md-doc'
localfile = conwebp.convert(origin_file_path)
# 上传到七牛后保存的文件名
dest_prefix = time.strftime("%Y%m%d%H%M%S", time.localtime())
dest_name = dest_prefix + "_" + os.path.basename(localfile)
# 上传文件到七牛后， 七牛将文件名和文件大小回调给业务服务器。
policy = {
'callbackBody': 'filename=$(fname)&filesize=$(fsize)'
}
token = q.upload_token(bucket_name, dest_name, 3600, policy)
ret, info = put_file(token, dest_name, localfile)
if ret is not None:
print("Upload Success,url=", config.domin + dest_name)
else:
print("info=", info)
print("ret=", ret)
assert ret['key'] == dest_name
assert ret['hash'] == etag(localfile)
def upload_to_qiniu(AK, SK, BUCKET_NAME,FILE_OBJ,FILE_NAME,):
'''
上传文件到七牛云，并返回 文件hash
BUCKET_NAME 七牛资源空间名
FILE_OBJ 文件二进制流
FILE_NAME 文件保存到七牛云上的文件名
'''
q = Auth(AK, SK)
token = q.upload_token(BUCKET_NAME, FILE_NAME, 3600)
# ret
# 一个dict变量，类似 {"hash": "<Hash string>", "key": "<Key string>"}
# info
"""七牛HTTP请求返回信息类
该类主要是用于获取和解析对七牛发起各种请求后的响应包的header和body。
Attributes:
status_code: 整数变量，响应状态码
text_body: 字符串变量，响应的body
req_id: 字符串变量，七牛HTTP扩展字段，参考 http://developer.qiniu.com/docs/v6/api/reference/extended-headers.html
x_log: 字符串变量，七牛HTTP扩展字段，参考 http://developer.qiniu.com/docs/v6/api/reference/extended-headers.html
error: 字符串变量，响应的错误内容
"""
ret, info = put_data(token, FILE_NAME, FILE_OBJ)
if info.status_code:
if ret['hash'] == etag_stream(FILE_OBJ):
return ret['hash']
return None
return None
def storage(file_data):
try:
#构建鉴权对象
q = Auth(access_key, secret_key)
#要上传的空间
bucket_name = 'ihome'
#上传到七牛后保存的文件名
# key = 'my-python-logo.png';
#生成上传 Token，可以指定过期时间等
token = q.upload_token(bucket_name)
#要上传文件的本地路径
# localfile = './sync/bbb.jpg'
# ret, info = put_file(token, key, localfile)
ret, info = put_data(token, None, file_data)
except Exception as e:
logging.error(e)
raise e
print(ret)
print("*"*16)
print(info)
# assert ret['key'] == key
# assert ret['hash'] == etag(localfile)
print(type(info))
print(info.status_code)
if 200 == info.status_code:
return ret["key"]
else:
raise Exception("上传失败")
def loop_qiniu():
while True:
for f in os.listdir(UPLOAD_FOLDER):
if 'tmp' not in f.split('_')[-1]:
os.remove(os.path.join(UPLOAD_FOLDER, f))
# print 'jump out and for one more time'
elif 'tmp0' == f.split('_')[-1]:
continue
elif 'tmp' == f.split('_')[-1]:
print 'start handle %s' % f
f_path = os.path.join(UPLOAD_FOLDER, f)
f_path_new = os.path.join(UPLOAD_FOLDER, f[:-4])
key = f[:-4]
q = Auth(access_key, secret_key)
token = q.upload_token(Bucket, key, 3600)
local_file = f_path
ret, _ = put_file(token, key, local_file)
try:
assert ret['key'] == key
except TypeError:
print 'ret has error'
continue
os.rename(f_path, f_path_new)
print 'end handle %s' % key
print time.strftime("%Y/%y/%d %H:%M:%S", time.localtime(time.time()))
else:
print '<----'
print u'为考虑到的情况'
print time.strftime("%Y/%y/%d %H:%M:%S", time.localtime(time.time()))
print '---->'
print 'pass this time while error', time.strftime("%Y/%y/%d %H:%M:%S", time.localtime(time.time()))
def upload(local_file_path, upload_path):
"""
上传操作
:param local_file_path: 本地图片地址
:param upload_path: 上传地址
:return: image_url: 返回外部链接
"""
# 构建鉴权对象
q = Auth(ACCESS_KEY, SECRET_KEY)
# 生成上传Token, 可以制定过期时间等
token = q.upload_token(BUCKET_NAME, upload_path, 3600)
put_file(token, upload_path, local_file_path)
image_url = BUCKET_URL + upload_path
return image_url
def sendToken(request):
if request.method == 'GET':
access_key = 'uFy_2nTo_c-fCDvigBum8ZnwvFZPwRceTAbw7zVS'
secret_key = '6rGh9INqH0vQWj4BXc0yEfPsz1dLyvUk0H8JtNPe'
# 构建鉴权对象
q = Auth(access_key, secret_key)
# 要上传的空间
bucket_name = 'studyapp'
# 上传到七牛后保存的文件名
key = str(uuid.uuid4()) + '.' + str(
request.GET.get('key')).split('.')[-1]
# 生成上传 Token，可以指定过期时间等 一天
token = q.upload_token(bucket_name, key, 3600)
return JsonResponse({"token": token, "filename": key})
class QiniuAttaDriver(BaseAttaDriver):
TOKEN = None
TOKEN_CREATE = None
EXPIRE_TIME = 3600
def __init__(self, ak, sk, bucket_domain):
self.ak = ak
self.sk = sk
self.auth = Auth(self.ak, self.sk)
self.bucket_domain = bucket_domain
def _get_auth_token(self, bucket_name):
expired = False
if self.TOKEN:
if (datetime.now() - self.TOKEN_CREATE).total_seconds() >= 3600:
expired = True
else:
expired = True
if expired:
self.TOKEN_CREATE = datetime.now()
self.TOKEN = self.auth.upload_token(
bucket_name,
expires=self.EXPIRE_TIME
)
return self.TOKEN
def _get_atta_name(self, atta):
note, atta = atta.split('/')[-2:]
return '%s:%s' % (note, atta)
def get_atta_by_path(self, atta, bucket_name):
url = 'http://%s/%s' % (
self.bucket_domain, self._get_atta_name(atta))
private_url = self.auth.private_download_url(url, expires=3600)
r = requests.get(private_url)
return r.raw
def get_atta_url_by_path(self, atta, bucket_name):
url = 'http://%s/%s' % (
self.bucket_domain, self._get_atta_name(atta))
private_url = self.auth.private_download_url(url, expires=3600)
return private_url
def save_atta_by_path(self, atta, bucket_name):
token = self._get_auth_token(bucket_name)
ret, info = put_file(token, self._get_atta_name(atta), atta)
print(ret, info)
return (ret, info)
def upload_to_qiniu(filename, filepath):
"""上传到七牛云"""
# 构建鉴权对象
qn_auth = Auth(config.QN_AK, config.QN_SK)
# 生成上传 Token，可以指定过期时间等
token = qn_auth.upload_token(config.QN_BUCKET_NAME, filename, 3600)
# 要上传文件的本地路径
put_file(token, filename, filepath)
url = '%s/%s' % (config.QN_BASE_URL, filename)
return url
class BackupTool(object):
__LOCAL_FILE_DIRECTORY = configs.DATABASE_BACKUP_FILE_DIRECTORY
__KEY = 'celerysoft-science-%s.sql'
__DATETIME_FORMAT = '%Y%m%d'
__qiniu_instance = None
def __init__(self):
self.__qiniu_instance = Auth(configs.QINIU_ACCESS_KEY,
configs.QINIU_SECRET_KEY)
self.__qiniu_bucket_name = configs.QINIU_BUCKET_NAME_FOR_BACKUP_DATABASE
def execute(self):
self.__upload()
self.__delete_backup_30days_ago()
def __upload(self):
# 上传后保存的文件名
# celerysoft-science-20190227.sql
key = self.__KEY % datetime.now().strftime(self.__DATETIME_FORMAT)
# 生成上传 Token，可以指定过期时间等
token = self.__qiniu_instance.upload_token(self.__qiniu_bucket_name,
key, 3600)
# 要上传文件的本地路径
local_file = os.path.join(self.__LOCAL_FILE_DIRECTORY, key)
ret, info = put_file(token, key, local_file)
try:
assert ret['key'] == key
assert ret['hash'] == etag(local_file)
print('数据库备份上传到七牛成功')
except AssertionError:
print('数据库备份上传到七牛失败，请手动进行处理！！！')
def __delete_backup_30days_ago(self):
_30days_ago = datetime.now() - timedelta(days=20)
key = self.__KEY % _30days_ago.strftime(self.__DATETIME_FORMAT)
bucket = BucketManager(self.__qiniu_instance)
ret, info = bucket.stat(configs.QINIU_BUCKET_NAME_FOR_BACKUP_DATABASE,
key)
if ret is None or 'hash' not in ret:
print('30天前的备份不存在，不需要删除')
else:
ret, info = bucket.delete(self.__qiniu_bucket_name, key)
try:
assert ret == {}
except AssertionError:
print('删除30天前的备份文件失败，请手动删除')
def save_data(self, stream, filename=None):
# 构建鉴权对象
auth = Auth(self._access_key, self._secret_key)
# 上传到七牛后保存的文件名
key = filename
# 生成上传 Token，可以指定过期时间等
token = auth.upload_token(self._bucket_name)
ret, info = put_data(token, key, stream)
print(info)
try:
assert ret['key'] == key
except Exception as e:
current_app.logger.info(e)
return False
return True
def uploadimg(img_name):
from qiniu import Auth, put_file, etag
import qiniu.config
access_key = 'hf_OTa2nV0Taho84tpokRzn6Gm58mrjwu5QOPHGw'
secret_key = '-uwYx2tXAsUpSssc5YRH026F8qlzt_h5qCpC3OFK'
q = Auth(access_key, secret_key)
bucket_name = 'idup'
key = 'math-problem-proj/' + img_name.split('/')[-1]
# 2592000s refers to 30d
token = q.upload_token(bucket_name, key, 2592000)
localfile = img_name
ret, info = put_file(token, key, localfile)
print(info)
assert ret['key'] == key
assert ret['hash'] == etag(localfile)
def upload(local_file, remote_name, ttl=3600):
print(local_file, remote_name, ttl)
#构建鉴权对象
q = Auth(ACCESS_KEY, SECRET_KEY)
#生成上传 Token，可以指定过期时间等
token = q.upload_token(BUCKET_NAME, remote_name, ttl)
ret, info = put_file(token,
remote_name,
local_file,
progress_handler=progress_handler)
print(info)
assert ret['key'] == remote_name
assert ret['hash'] == etag(local_file)
def qiniuToken(request):
data = request.data
filename = data.get('filename', None)
result = {}
access_key = '8Z2OZ-sHyK5W22Nm-nUlsLgonJnOE9iKWue4i3CX'
secret_key = 'LnWzZ7HFosZAOH6VMbCjEgyRHFP4tgZctftC5eXM'
# 构建鉴权对象
q = Auth(access_key, secret_key)
# 要上传的空间
bucket_name = 'piggancat'
token = q.upload_token(bucket_name, filename, 3600)
result['token'] = token
result['file'] = filename
return Response(data=result, status=status.HTTP_200_OK)
def upload_cdn(filepath):
access_key = config['access_key']
secret_key = config['secret_key']
bucket_name = config['bucket_name']
if not access_key or not secret_key or not bucket_name:
print('cdn配置不全，请执行 upm config set access_key [mykey]')
exit(0)
return
q = Auth(access_key, secret_key)
filename = path.basename(filepath)
token = q.upload_token(bucket_name, filename, 3600)
ret, info = put_file(token, filename, filepath)
assert ret['key'] == filename
assert ret['hash'] == etag(filepath)
def upload(local_file, key, flag=True):
# 构建鉴权对象
q = Auth(access_key, secret_key)
# 生成上传 Token，可以指定过期时间等，上传空间、文件名
token = q.upload_token(bucket_name, key, 3600)
ret, info = put_file(token, key, local_file)
# print(info)
# print(ret)
assert ret['key'] == key
assert ret['hash'] == etag(local_file)
print('')
if flag:
add_to_clipboard('')
def upload_storage(file_name, data, bucket_name=None):
bucket = get_bucket(bucket_name)
ak = app.config['qiniu.storage.access_key']
sk = app.config['qiniu.storage.secert_key']
domain = app.config['qiniu.storage.domain_name']
q = Auth(ak, sk)
token = q.upload_token(bucket, file_name)
ret, info = put_data(token, file_name, data)
logging.info("ret:%s,info:%s", ret, info)
return '%s/%s' % (domain, file_name)
class Qiniu:
def __init__(self, access_key, secret_key, bucket_name: str):
self._access_key = access_key
self._secret_key = secret_key
self._auth = Auth(access_key, secret_key)
self._bucket = bucket_name
@retry(tries=5, delay=0.5, jitter=0.1, logger=logging)
def upload_file(self, key, localfile):
token = self._auth.upload_token(self._bucket, key)
ret, info = put_file(token, key, localfile)
if ret: # ret possibly is None
assert ret['key'] == key
assert ret['hash'] == etag(localfile)
return info
def upload_pic(pic):
# 需要填写你的 Access Key 和 Secret Key
access_key = 'yV4GmNBLOgQK-1Sn3o4jktGLFdFSrlywR2C-hvsW'
secret_key = 'bixMURPL6tHjrb8QKVg2tm7n9k8C7vaOeQ4MEoeW'
# 构建鉴权对象
q = Auth(access_key, secret_key)
# 要上传的空间
bucket_name = 'ihome'
token = q.upload_token(bucket_name)
ret, info = put_data(token, None, pic)
if info and info.status_code != 200:
raise Exception("上传文件到七牛失败")
return ret.get('key')
def upload_qiniu(uid):
# 构建鉴权对象
q = Auth(access_key, secret_key)
# 上传后保存的文件名
filename = keys.AVATAR_KEY % uid
# 生成上传 Token, 可以指定过期时间
token = q.upload_token(bucket_name, filename, 3600)
# 要上传文件的本地路径
filepath = os.path.join(settings.BASE_DIR, settings.MEDIAS_ROOT, filename)
ret, info = put_file(token, filename, filepath)
if info.status_code == 200:
return True
return False
def get(self, request, *args, **kwargs):
#需要填写你的 Access Key 和 Secret Key
access_key = settings.QINIU_ACCESS_KEY
secret_key = settings.QINIU_SECRET_KEY
#构建鉴权对象
q = Auth(access_key, secret_key)
#要上传的空间
bucket_name = 'bs_angel'
key = None
# 生成上传 Token，可以指定过期时间等
token = q.upload_token(bucket_name, key, 3600)
res = {'code': 200, 'msg': 'success', 'data': {'token': token}}
return Response(res)
def upload_pic(f1):
# f1表示接收的浏览器传递的文件对象 为啥要用get
access_key = current_app.config.get('QINIU_AK')
secret_key = current_app.config.get('QINIU_SK')
# 空间名称
bucket_name = current_app.config.get('QINIU_BUCKET')
# 构建鉴权对象 ---> 其实就是身份认证
q = Auth(access_key, secret_key)
# 生成上传 Token
token = q.upload_token(bucket_name)
# 上传文件数据，ret是字典，键为hash、key，值为新文件名，info是response对象
ret, info = put_data(token, None, f1.read())
# 返回七牛云给出的文件名
return ret.get('key')
def storage_by_file():
"""通过文件上传"""
# #构建鉴权对象
q = Auth(ACCESS_KEY, SECRET_KEY)
#上传到七牛后保存的文件名
key = 'my-flask-logo.png'
#生成上传 Token，可以指定过期时间等
token = q.upload_token(BUCKET_NAME, key, 3600)
#要上传文件的本地路径
localfile = TEST_IAMGE_FILE
ret, info = put_file(token, key, localfile)
print(ret)
print(info.status_code)
return ret['key']
def storage(file_data):
# 构建鉴权对象
q = Auth(access_key, secret_key)
# 要上传的空间
bucket_name = 'home-image-flask'
# 上传后保存的文件名
# key = 'my-python-logo.png'
# 生成上传 Token，可以指定过期时间等
token = q.upload_token(bucket_name, None, 3600)
ret, info = put_data(token, None, file_data)
if info.status_code == 200:
return ret.get('key')
else:
raise Exception('上传图片失败')
class Qiniu:
def __init__(self, bucket_name, base_url):
self.bucket_name = bucket_name
self.base_url = base_url
self.q = Auth(settings.QINIU_AK, settings.QINIU_SK)
def put(self, name, path):
token = self.q.upload_token(self.bucket_name, name)
ret, info = put_file(token, name, path)
print('ret:', ret)
print('info:', info)
if 'key' in ret:
remote_url = '/'.join([self.base_url, ret['key']])
return remote_url
def upload(file, qiniu):
access_key = qiniu.access_key
secret_key = qiniu.secret_key
q = Auth(access_key, secret_key)
# bucket_name = 'testbast'
bucket_name = qiniu.bucket_name
key = file.split('\\')[-1]
# 生成token
token = q.upload_token(bucket_name, key, 3600)
ret, info = put_file(token, key, file)
print("文件上传成功")
return key
def updateFile(filePath, uri):
q = Auth(access_key, secret_key)
bucket_name = defaultBucketName
bucket = BucketManager(q)
key = getKeyFromUri(uri)
# delete
ret, info = bucket.delete(bucket_name, key)
# upload
token = q.upload_token(bucket_name, key)
ret, info = put_file(token, key, filePath)
if 'key' not in ret:
return None
retFileUri = ('%s/%s') % (defaultBucketUriBase, key)
logging.debug('upload qiniu file uri:[%r]' % (retFileUri))
return retFileUri
def upload(cls, file):
q = Auth(current_app.config['QINIU_ACCESS_KEY'],
current_app.config['QINIU_SECRET_KEY'])
token = q.upload_token(current_app.config['QINIU_BUCKET'])
# 如果需要对上传的图片命名，就把第二个参数改为需要的名字
# 如果需要对上传的图片命名，就把第二个参数改为需要的名字
ret1, ret2 = put_data(token, None, data=file)
print('ret1:', ret1)
print('ret2:', ret2)
# 判断是否上传成功
if ret2.status_code != 200:
raise Exception('文件上传失败')
return ret1.get('key')
def upload_file_online(self, mime_type, data, suffix):
'''
上传文件到七牛
:param file_path:本地服务器的文件路径
:return: 上传后的uri
'''
access_key = config.QINIU_ACCESS_KEY
secret_key = config.QINIU_SECRET_KEY
q = Auth(access_key, secret_key)
bucket_name = config.QINIU_BUCKET_NAME # 空间名
key = self.get_file_name_online(data, suffix)
mime_type = mime_type
token = q.upload_token(bucket_name, key)
put_data(token, key, data, mime_type=mime_type, check_crc=True)
return key
def upload_img(screenshotpath, img_name):
q = Auth(access_key, secret_key)
bucket_name = ConfigInit.qiniu_house
# 上传后保存的文件名
key = img_name
# 生成上传 Token，可以指定过期时间等
token = q.upload_token(bucket_name, key, 3600)
# 要上传文件的本地路径
localfile = screenshotpath
try:
put_file(token, key, localfile)
logger.info('上传图片成功')
return ConfigInit.qiniu_domain + img_name
except Exception as e:
logger.info('上传图片失败', e)
def storage_image(data):
"""用于将图片上传到七牛用"""
if not data:
return None
q = Auth(access_key, secret_key)
# 指定的储存名字
token = q.upload_token(bucket_name)
ret, info = put_data(token, None, data)
if info.status_code != 200:
raise Exception('七牛上传文件失败')
return ret.get('key')
def get_upload_token(self, key, bucket='aizou'):
"""
获得七牛的上传凭证
:param key:
:param bucket:
"""
from qiniu import Auth
if not self.ak or not self.sk:
# 获得上传权限
section = conf.global_conf.get('qiniu', {})
self.ak = section['ak']
self.sk = section['sk']
q = Auth(self.ak, self.sk)
return q.upload_token(bucket, key)
def storage(file_data):
q= Auth(access_key, secret_key)
# 要上传的空间
bucket_name =""
token = q.upload_token(bucket_name, key, 360)
localfile = './sync/bbb.jpg'
ret, info = put_data(token, None, localfile)
if info.status_code == 200:
# 表示上传成功，返回文件名
return ret.get("key")
else:
# 上传失败
raise Exception("上传七牛失败")
def storage_image(data):
# 将图片上传到七牛云
if not data:
return None
q = Auth(access_key,secret_key)
#指定的存储名字
token = q.upload_token(bucket_name)
ret, info = put_data(token, None, data)
# print ret,info
if info.status_code != 200:
raise Exception("七牛上传文件失败")
return ret.get("key")
def storage(file_data):
#构建鉴权对象
q = Auth(access_key, secret_key)
#要上传的空间
bucket_name = 'yashe'
#生成上传 Token，可以指定过期时间等
token = q.upload_token(bucket_name, None, 3600)
#要上传文件的本地路径
ret, info = put_data(token, None, file_data)
if info.status_code == 200:
return ret.get('key')
else:
raise Exception('上传七牛失败')
