def zip_upload(self, zip_file, zip_name=None):
if not zip_name:
zip_name = str(uuid.uuid1())
mime_type = 'application/zip'
token = q.upload_token(qiniu_bucket_name, zip_name)
qiniu.put_data(token, zip_name, zip_file, mime_type=mime_type, check_crc=True)
return '%s/%s' % (qiniu_resource_url, zip_name)
def excel_upload(self, excel_file, excel_name=None):
if not excel_name:
excel_name = str(uuid.uuid1())
mime_type = 'application/ms-excel'
token = q.upload_token(qiniu_bucket_name, excel_name)
qiniu.put_data(token, excel_name, excel_file, mime_type=mime_type, check_crc=True)
return '%s/%s' % (qiniu_resource_url, excel_name)
def get_img_path(url):
img = requests.get(url)
md5 = hashlib.md5()
md5.update(img.content)
key = md5.hexdigest()
put_data(token, key, img.content)
return baseurl + '/' + key
def get_img_url(img):
print img
md5 = hashlib.md5()
md5.update(img)
key = md5.hexdigest()
put_data(token, key,img,mime_type='image/jpeg')
return baseurl + '/' + key
def image_upload(self, img_file, image_name=None):
if not image_name:
image_name = str(uuid.uuid1())
mime_type = 'image/jpg'
token = q.upload_token(qiniu_bucket_name, image_name)
qiniu.put_data(token, image_name, img_file, mime_type=mime_type, check_crc=True)
return '%s/%s' % (qiniu_resource_url, image_name)
def upload_file(data):
"""
上传文件
:param data: data文件数据
:return:
"""
key = other_config.prefix + hashlib.md5(data).hexdigest()
q = Auth(other_config.access_key, other_config.secret_key)
token = q.upload_token(other_config.bucket_name)
put_data(token, key, data)
return other_config.url + key
def test_putWithoutKey(self):
key = None
data = "hello bubby!"
token = self.q.upload_token(bucket_name)
ret, info = put_data(token, key, data)
print(info)
assert ret["hash"] == ret["key"]
data = "hello bubby!"
token = self.q.upload_token(bucket_name, "nokey2")
ret, info = put_data(token, None, data)
print(info)
assert ret is None
assert info.status_code == 403 # key not match
def test_put(self):
key = 'a\\b\\c"你好'
data = 'hello bubby!'
token = self.q.upload_token(bucket_name)
ret, info = put_data(token, key, data)
print(info)
assert ret['key'] == key
key = ''
data = 'hello bubby!'
token = self.q.upload_token(bucket_name, key)
ret, info = put_data(token, key, data, check_crc=True)
print(info)
assert ret['key'] == key
def test_putWithoutKey(self):
key = None
data = 'hello bubby!'
token = self.q.upload_token(bucket_name)
ret, info = put_data(token, key, data)
print(info)
assert ret['hash'] == ret['key']
data = 'hello bubby!'
token = self.q.upload_token(bucket_name, 'nokey2')
ret, info = put_data(token, None, data)
print(info)
assert ret is None
assert info.status_code == 403 # key not match
def test_put_crc(self):
key = ""
data = "hello bubby!"
token = self.q.upload_token(bucket_name, key)
ret, info = put_data(token, key, data, check_crc=True)
print(info)
assert ret["key"] == key
def img_downloaded(self, response):
from qiniu import put_data
if response.status not in [400, 403, 404]:
self.log('DOWNLOADED: %s' % response.url, log.INFO)
meta = response.meta
if not self.check_img(data=response.body):
return
else:
image = meta['item']['image']
key = image['url_hash']
image['key'] = key
bucket = 'aizou'
image['bucket'] = bucket
sc = False
self.log('START UPLOADING: %s <= %s' % (key, response.url), log.INFO)
uptoken = self.get_upload_token(key, bucket)
for idx in xrange(5):
ret, info = put_data(uptoken, key, response.body, check_crc=True)
if not ret:
self.log('UPLOADING FAILED #%d: %s, reason: %s' % (idx, key, info.error), log.INFO)
continue
else:
sc = True
break
if not sc:
raise IOError
self.log('UPLOADING COMPLETED: %s' % key, log.INFO)
# 统计信息
url = 'http://%s.qiniudn.com/%s?stat' % (bucket, key)
yield Request(url=url, meta={'item': meta['item']}, callback=self.parse_stat)
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 qiniu_upload_file(source, name):
token = q.upload_token(bucketname, name)
ret, info = put_data(token, name, source.stream)
print type(info.status_code), ret
if info.status_code == 200:
return domain + name
return None
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 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 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 uploadData(data):
if type(data) == QByteArray:
data = data.data()
from .secfg import qiniu_acckey, qiniu_seckey, qiniu_bucket_name
access_key = qiniu_acckey
secret_key = qiniu_seckey
bucket_name = qiniu_bucket_name
print(access_key, secret_key, bucket_name)
q = qiniu.Auth(access_key, secret_key)
# 由于本机时间错误，导致计算了出的token立即失效：
# text_body:{"error":"expired token"}
token = q.upload_token(bucket_name, expires=3600*24)
key = 'helloqt.png'
key = FileStore.md5sum(data)
# data = 'hello qiniu!'
# data = load_from_file(PATH)
print('uploading file:', key, token)
ret, info = qiniu.put_data(token, key, data)
if ret is not None:
print('upload file All is OK', ret)
url = 'http://7xn2rb.com1.z0.glb.clouddn.com/%s' % key
return url
else:
print(ret, '=====', info) # error message in info
return str(info)
def qiniu_upload_fileobj(obj, bucket_name, ext=None):
'''
把request.FILES里的文件对象上传到七牛
obj: 文件对象
bucket_name: 七牛的bucket
ext: 为七牛的key追加的扩展名，包含.符号
'''
if not ext:
ext = os.path.splitext(obj.name)[1]
full_name = '%s/%s%s' % (
datetime.datetime.now().strftime('%Y%m%d/%H%M%S'),
_key(10).lower(),
ext
)
q = qiniu.Auth(AK, SK)
token = q.upload_token(bucket_name, full_name)
data = ''
for chunk in obj.chunks():
data += chunk
ret, info = qiniu.put_data(token, full_name, data, mime_type=obj.content_type)
if ret:
return full_name
else:
logger.debug('qiniu upload err: %s', info)
def post(self, template_variables = {}):
template_variables = {}
# validate the fields
if("files" in self.request.files):
file_name = "%s" % uuid.uuid1()
file_raw = self.request.files["files"][0]["body"]
file_buffer = StringIO.StringIO(file_raw)
file = Image.open(file_buffer)
usr_home = os.path.expanduser('~')
file.save(usr_home+"/%s.png" % file_name, "PNG")
uptoken = q.upload_token("yx-img", "%s.png" % file_name)
data=open(usr_home+"/%s.png" % file_name)
ret, info = put_data(uptoken, "%s.png" % file_name, data)
os.remove(usr_home+"/%s.png" % file_name)
file_name = "http://objdsnsh2.bkt.clouddn.com/"+file_name+".png"
print file_name
self.write(lib.jsonp.print_JSON({
"files": [
{
"name": file_name,
}]
}))
def test_put(self):
key = 'a\\b\\c"hello'
data = 'hello bubby!'
token = self.q.upload_token(bucket_name)
ret, info = put_data(token, key, data)
print(info)
assert ret['key'] == key
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 upload(self, data, path):
token = q.upload_token(self.scope)
data.seek(0)
ret, _ = _q.put_data(token, path, data)
if ret:
return path, ret['hash']
raise UploadFailedError
def save(self, data, filename=None):
"""
保存
"""
auth = qiniu.Auth(self._access_key, self._secret_key)
token = auth.upload_token(self._bucket_name)
return qiniu.put_data(token, filename, data)
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 _save_to_qiniu(self):
import qiniu
output = BytesIO()
self._source.seek(0)
base64.encode(self._source, output)
self._source.seek(0)
output.seek(0)
hex_octet = lambda: hex(int(0x10000 * (1 + random.random())))[-4:]
key = ''.join(hex_octet() for _ in range_type(4))
key = '{0}.{1}'.format(key, self.extension)
data = {
'name': self._name,
'key': key,
'ACL': self._acl,
'mime_type': self._type,
'metaData': self._metadata,
}
response = client.post('/qiniu', data)
content = response.json()
self.id = content['objectId']
self._url = content['url']
uptoken = content['token']
ret, info = qiniu.put_data(uptoken, key, self._source)
if info.status_code != 200:
raise LeanCloudError(1, 'the file is not saved, qiniu status code: {0}'.format(info.status_code))
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 upload_binary_stream(self, key, data):
# key = ''
# data = 'hello bubby!'
token = self.q.upload_token(self.bucket_name, key)
ret, info = put_data(token, key, data, mime_type="application/octet-stream", check_crc=True)
# print(info)
assert ret['key'] == key
return self.get_download_url(key)
def _save_to_qiniu(self, uptoken, key):
import qiniu
self._source.seek(0)
ret, info = qiniu.put_data(uptoken, key, self._source)
self._source.seek(0)
if info.status_code != 200:
raise LeanCloudError(1, 'the file is not saved, qiniu status code: {0}'.format(info.status_code))
def test_hasRead_withoutSeek_retry(self):
key = 'withReadAndWithoutSeek_retry'
data = ReadWithoutSeek('I only have read attribute!')
set_default(default_zone=Zone('http://a', 'http://upload.qiniu.com'))
token = self.q.upload_token(bucket_name)
ret, info = put_data(token, key, data)
print(info)
assert ret is None
def test_hasRead_WithoutSeek_retry2(self):
key = 'withReadAndWithoutSeek_retry2'
data = urlopen("http://www.qiniu.com")
set_default(default_zone=Zone('http://a', 'http://upload.qiniu.com'))
token = self.q.upload_token(bucket_name, key)
ret, info = put_data(token, key, data)
print(info)
assert ret is not None
def upload_image(image_data):
q = qiniu.Auth(access_key, secret_key)
token = q.upload_token(bucket_name)
ret, info = qiniu.put_data(token, None, image_data)
if info.status_code == 200:
return ret.get("key")
else:
raise Exception('上传图片失败')
def qiniu_upload_file(self, access_key, secret_key, bucket_name, domain,
source_file, filename):
# 构建鉴权对象
q = Auth(access_key, secret_key)
token = q.upload_token(bucket_name, filename)
ret, info = put_data(token, filename, source_file)
if info.status_code == 200:
return domain + filename
return None
def qiniuSave(self, string, filename):
access_key = '_4TUdWfMQGZ5f2DFFmXbARs7pQLWmiPK-IFbSsw5'
secrect_key = '1x0lUvV11qxbWQO1G_XrMm6v-MSsDWJWNCJk2K67'
bucket_name = 'brpublic'
q = qiniu.Auth(access_key, secrect_key)
token = q.upload_token(bucket_name)
ret, info = qiniu.put_data(token, 'Saron/' + filename, string)
return ret
def upload(self, data, mime_type='application/octet-stream', key=None):
key = key if key else '{}{}_{}'.format(self.path, int(time.time()),
hashlib.md5(data).hexdigest())
ret, info = qiniu.put_data(self._token(key),
key,
data,
mime_type=mime_type)
if not ret:
return None
return '{}{}'.format(self.prefix_url, ret['key'])
def upload_data(data, key):
auth = qiniu.Auth(ACCESS_KEY, SECRET_KEY)
upToken = auth.upload_token(BUCKET_NAME, key)
retData, respInfo = qiniu.put_data(upToken,
key,
data,
mime_type="application/octet-stream",
check_crc=True)
#解析结果
return parseRet(retData, respInfo)
def qiniu_upload_file(source_file, save_file_name):
# 生成上传 Token，可以指定过期时间等
token = q.upload_token(bucket_name, save_file_name)
ret, info = put_data(token, save_file_name, source_file.stream)
print type(info.status_code), info
if info.status_code == 200:
return domain_prefix + save_file_name
return None
def save_file(url):
try:
req = urllib.request.Request(url)
res = urllib.request.urlopen(req)
filename = str(uuid.uuid4()).replace('-', '')
token = get_token(filename)
ret, _ = put_data(token, filename, data=res.read())
return ret.get('key')
except Exception as e:
return ''
def upload_by_qiniu(image_data):
q = Auth(current_app.config["QINIU_AK"], current_app.config["QINIU_SK"])
bucket_name = current_app.config["QINIU_BUCKETNAME"]
token = q.upload_token(bucket_name)
ret, info = put_data(token, None, image_data)
if info.status_code == 200:
return ret.get("key")
else:
raise Exception("上传七牛失败!")
return None
def data_upload(data, name, accesskey, secretkey, bucket):
auth = Auth(accesskey, secretkey)
token = auth.upload_token(bucket)
# 压缩文件
if 'compress' in params:
data = zlib.compress(data)
ret, info = put_data(token, name, data)
if ret is None:
return (False, info)
return (True, "success")
def test_withoutRead_withoutSeek_retry(self):
key = 'retry'
data = 'hello retry!'
set_default(default_zone=Zone('a', 'upload.qiniu.com'))
token = self.q.upload_token(bucket_name)
ret, info = put_data(token, key, data)
print(info)
assert ret['key'] == key
assert ret['hash'] == 'FlYu0iBR1WpvYi4whKXiBuQpyLLk'
qiniu.set_default(default_zone=qiniu.config.zone0)
def test_hasRead_hasSeek_retry(self):
key = 'withReadAndSeek_retry'
data = StringIO('hello retry again!')
set_default(default_zone=Zone('a', 'upload.qiniu.com'))
token = self.q.upload_token(bucket_name)
ret, info = put_data(token, key, data)
print(info)
assert ret['key'] == key
assert ret['hash'] == 'FuEbdt6JP2BqwQJi7PezYhmuVYOo'
qiniu.set_default(default_zone=qiniu.config.zone0)
def test_putData_without_fname(self):
if is_travis():
return
localfile = create_temp_file(30 * 1024 * 1024)
key = 'test_putData_without_fname'
with open(localfile, 'rb') as input_stream:
token = self.q.upload_token(bucket_name)
ret, info = put_data(token, key, input_stream)
print(info)
assert ret is not None
def upload_file(stream):
token = generate_upload_token()
# resp = requests.post('http://up-z2.qiniup.com/', data={
# 'token': token,
# 'file': stream
# })
# import ipdb
# ipdb.set_trace()
ret, info = put_data(token, key=None, data=stream)
return ret['key']
def _put_data(self, name, data):
"""upload data to qiniu cloud"""
name = self._normalize_name(self._clean_name(name))
token = self.auth.upload_token(self.bucket_name, name)
ret, info = put_data(token, name, data)
if ret is None or ret['key'] != name:
raise QiNiuError(info)
print(f'{name} ... ok')
self._clean_qiniu_cache_file()
return name
def storage(data):
try:
q = Auth(access_key, secret_key)
token = q.upload_token(bucket_name)
ret, info = put_data(token, None, data)
except Exception as e:
raise e
if info and info.status_code != 200:
raise Exception("上传文件失败")
return ret["key"]
def upload_data(self,
data,
mime_type='application/octet-stream',
ie=True): #using it to upload a data
key, token = self.upload_token(ie)
ret, info = put_data(token, key, data, mime_type=mime_type)
self.key = key
if ret['key'] != key: # key is the key of the updated data
raise Code.file_update_fail
return key
def upload_img(data):
q = qiniu.Auth(access_key, secret_key)
key = None # 上传文件名 不设置会自动生成随机名称
token = q.upload_token(bucket_name)
ret, info = qiniu.put_data(token, key, data)
if ret is not None:
return ret.get("key") # 取出上传的文件名
else:
raise Exception(info)
def test_withoutRead_withoutSeek_retry(self):
key = 'retry'
data = 'hello retry!'
set_default(default_up_host='a')
token = self.q.upload_token(bucket_name)
ret, info = put_data(token, key, data)
print(info)
assert ret['key'] == key
assert ret['hash'] == 'FlYu0iBR1WpvYi4whKXiBuQpyLLk'
qiniu.set_default(default_up_host=qiniu.config.UPAUTO_HOST)
def generateCard(id):
try:
card = Query(Card).get(id)
tid = card.get('temlate')
if (card.get('photo') is None):
msstream = BytesIO()
if tid == 1:
template(card, msstream)
elif tid == 2:
template2(card, msstream)
elif tid == 3:
template3(card, msstream)
elif tid == 4:
template4(card, msstream)
else:
template(card, msstream)
url = os.environ["QINIU_ACCESS_URL"]
access_key = os.environ["QINIU_ACCESS_KEY"]
secret_key = os.environ["QINIU_SECRET_KEY"]
#构建鉴权对象
q = Auth(access_key, secret_key)
#要上传的空间
bucket_name = 'card'
key = card.get('objectId')
token = q.upload_token(bucket_name)
ret, info = put_data(token, key, msstream.getvalue())
if (info.ok()):
metaData = {'owner': card.get('username')}
photo = Photo()
photo.set('mine_type', 'image/jpeg')
photo.set('key', key)
photo.set('name', key)
photo.set('url', url + '/' + key)
photo.set('provider', 'qiniu')
photo.set('metaData', metaData)
photo.set('bucket', bucket_name)
photo.save()
update = Card.create_without_data(id)
user = _User.create_without_data('590be679ac502e006cdc63c0')
update.set('user', user)
update.set('username', '569dil3zuypnrpjqwe97l3qkw')
update.set('photo', photo)
update.save()
return 'ok'
else:
return 'failed'
else:
return 'already'
except LeanCloudError as e:
if e.code == 101: # 服务端对应的 Class 还没创建
card = ''
return 'no class'
else:
raise e
return 'error'
def save_qiniu(data, image_name):
assess_key = os.environ.get('QINIUAK')
secret_key = os.environ.get('QINIUSK')
q = Auth(assess_key, secret_key)
bucket_name = 'bing-background-picture'
key = os.path.join(os.sep, date, image_name)
token = q.upload_token(bucket_name, key, 3600)
ret, info = put_data(token, key, data)
print info
def qiniu_upload_file(self, source_file, filename):
# 构建鉴权对象
q = Auth(self.oss_access_key_all, self.oss_secret_key_all)
token = q.upload_token(self.oss_bucket_name_all, filename)
domain_prefix = self.oss_domain_all
ret, info = put_data(token, filename, source_file)
if info.status_code == 200:
return domain_prefix + filename
return None
def upload_qiniu(name, data):
auth = Auth(options["-a"], options["-s"])
token = auth.upload_token(options["-b"])
# 压缩文件
if "-c" in options:
data = zlib.compress(data)
ret, info = put_data(token, name, data)
if ret is None:
raise Exception(info)
def upload_data(filestream, bucket_name):
# 生成上传凭证
q = Auth(access_key, secret_key)
suffix = filestream.name.split('.')[-1] # 后缀(jpg, png, gif)
filename = uuid.uuid4().hex + '.' + suffix.lower()
token = q.upload_token(bucket_name, filename)
# 上传文件
retData, respInfo = put_data(token, filename, filestream)
return filename, domain_prefix + filename
def put(self, name, data):
token = self.q.upload_token(self.bucket_name, name)
ret, info = put_data(token, name, data)
if 'key' in ret:
#获得完整的链接
remote_url = '/'.join([self.base_url, ret['key']])
#访问的链接
return remote_url
else:
return False
def _save(self, name, content):
try:
q = Auth(access_key, secret_key)
token = q.upload_token(bucket_name)
ret, info = put_data(token, None, content.read())
except Exception as e:
raise e
if info.status_code != 200:
raise Exception("上传图片失败")
return ret["key"]
def storage(data):
try:
q = Auth(access_key, secret_key)
token = q.upload_token(bucket_name)
ret, info = put_data(token, None, data)
print(ret, info)
except Exception as e:
raise e
if info.status_code != 200:
raise Exception('上传图片失败')
return ret['key']
def upload_file(data):
q = qiniu.Auth(access_key, secret_key)
token = q.upload_token(bucket_name)
ret, info = qiniu.put_data(token, None, data)
print(ret['key'])
if info.status_code != 200:
raise Exception('七牛上传失败')
return ret['key']
def qiniu_upload_file(source_file, save_file_name):
# 上传到七牛后保存的文件名
# key = 'my-python-logo.png';
# 生成上传 Token，可以指定过期时间等
token = q.upload_token(bucket_name, save_file_name)
ret, info = put_data(token, save_file_name, source_file.stream)
print(info)
if info.status_code == 200:
return domain_prefix + save_file_name
return None
def upload():
action = request.args.get('action')
result = {}
if action == 'config':
config_path = os.path.join(bp.static_folder or app.static_folder,
'ueditor', 'config.json')
with open(config_path, 'r', encoding='utf-8') as fp:
result = json.loads(re.sub(r'\/\*.*\*\/', '', fp.read()))
elif action in ['uploadimage', 'uploadvideo', 'uploadfile']:
image = request.files.get("upfile")
filename = image.filename
save_filename = _random_filename(filename)
result = {'state': '', 'url': '', 'title': '', 'original': ''}
if UEDITOR_UPLOAD_TO_QINIU:
if not sys.modules.get('qiniu'):
raise RuntimeError('没有导入qiniu模块！')
q = qiniu.Auth(UEDITOR_QINIU_ACCESS_KEY, UEDITOR_QINIU_SECRET_KEY)
token = q.upload_token(UEDITOR_QINIU_BUCKET_NAME)
'''
====================================================================
转化为二进制文件
====================================================================
'''
buffer = BytesIO()
image.save(buffer)
buffer.seek(0)
ret, info = qiniu.put_data(token, save_filename, buffer.read())
if info.ok:
result['state'] = "SUCCESS"
result['url'] = parse.urljoin(UEDITOR_QINIU_DOMAIN, ret['key'])
result['title'] = ret['key']
result['original'] = ret['key']
else:
image.save(os.path.join(UEDITOR_UPLOAD_PATH, save_filename))
result['state'] = "SUCCESS"
result['url'] = url_for('ueditor.files', filename=save_filename)
result['title'] = save_filename,
result['original'] = image.filename
elif action == 'uploadscrawl':
base64data = request.form.get("upfile")
img = base64.b64decode(base64data)
filename = _random_filename('xx.png')
filepath = os.path.join(UEDITOR_UPLOAD_PATH, filename)
with open(filepath, 'wb') as fp:
fp.write(img)
result = {
"state": "SUCCESS",
"url": url_for('files', filename=filename),
"title": filename,
"original": filename
}
return jsonify(result)
def image_storage(image_data):
#要上传文件的本地路径
# localfile = './11.jpg'
# ret, info = put_file(token, None, localfile)
ret, info = put_data(token, None, image_data)
#上传成功,返回图片名称,失败返回空
if info.status_code == 200:
return ret.get("key")
else:
return ""
