def write_source_file(dataloader_path, src_id, uploadedfile):
"""Writes the a dataloader source into a file from web request file upload."""
rootpath = os.path.join(dataloader_path, src_id, 'source/')
filename = werkzeug.secure_filename(uploadedfile.filename)
if not os.path.exists(rootpath):
os.makedirs(rootpath, DIRMASK)
filepath = os.path.join(rootpath, filename)
uploadedfile.save(filepath)
return rootpath, filepath
python类secure_filename()的实例源码
def upload_img():
#http://flask.pocoo.org/docs/0.10/patterns/fileuploads/
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
try:
filename = secure_filename(file.filename)
if len(filename) > 30:
filename = filename[0:30]+'~.'+filename.split('.')[-1]
new_id = get_last_id() + 1
new_filename = filename
new_url = short_url.encode_url(new_id)
img_path = new_url+'.'+filename.split('.')[-1]
file.save(os.path.join(UPLOAD_FOLDER, img_path))
g.db.execute("INSERT INTO pics (id, filename, url, imgpath) VALUES (?, ?, ?, ?)", (new_id, new_filename, new_url, img_path))
g.db.commit()
save_thumbnail(img_path)
#return redirect(url_for('upload_img', filename=filename))
return redirect('/show/'+new_url)
except Exception as e:
return str(e)
else:
return "Wrong file!"
else:
recent = recentlyUploaded()
return render_template('index.html', STATIC_DIR = STATIC_DIR, TEMPLATES_DIR=TEMPLATES_DIR, recent = recent,)
def search_page():
query = request.args.get('s')
page = request.args.get('p')
if not query:
return render_template('search.html', allow_upload=app.config['ALLOW_UPLOAD'], count_pdf=count_pdf())
try:
page = abs(int(page))
except:
page = 0
query = query.lower()
query = unicodedata.normalize('NFKD', query).encode('ASCII', 'ignore')
words = query.split()[:5] #max 5 words for querying...
words = map(secure_filename, words)
query = " ".join(words)
words = map(lemmatize, words)
if not words:
return render_template('search.html')
rows, speed, next_button = get_results(words, page)
if next_button:
next_button = page + 1
return render_template('results.html', user_request=query, rows=rows, speed=speed, next_button=next_button)
def return_pdf(pdf_name):
try:
return redirect(url_for('static', filename=app.config['PDF_DIR'] + secure_filename(pdf_name)))
except:
abort(404)
def upload():
file = request.files['file']
if file:
filename = secure_filename(file.filename)
temp_dir = tempfile.mkdtemp(dir=current_app.config['UPLOAD_DIR'])
tdir = os.path.split(temp_dir)[1]
full_name = os.path.join(temp_dir, filename)
file.save(full_name)
result = logic.check_uploaded_file(file.mimetype, full_name)
if result:
os.remove(full_name)
return jsonify(**result)
return jsonify(result='ok', file=os.path.join(tdir, filename))
return jsonify(error='no file')
def upload_backup(self,handler):
path='./backups/'
id=handler.filename.split('.tar.gz')[0]
filename = secure_filename(handler.filename)
handler.save(os.path.join(path+filename))
import tarfile,pickle
#~ with app.app_context():
#~ dict=r.table('backups').get(id).run(db.conn)
#~ r.table('backups').get(id).update({'status':'Uncompressing backup'}).run(db.conn)
#~ path=dict['path']
with tarfile.open(path+handler.filename, "r:gz") as tar:
tar.extractall(path)
tar.close()
#~ with app.app_context():
#~ r.table('backups').get(id).update({'status':'Loading data..'}).run(db.conn)
with open(path+id+'.rethink', 'rb') as isard_rethink_file:
isard_rethink = pickle.load(isard_rethink_file)
with app.app_context():
log.info(r.table('backups').insert(isard_rethink, conflict='update').run(db.conn))
with app.app_context():
r.table('backups').get(id).update({'status':'Finished uploading'}).run(db.conn)
try:
os.remove(path+id+'.json')
os.remove(path+id+'.rethink')
except OSError as e:
log.error(e)
pass
def process():
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
filedir = os.path.join(app.config['UPLOAD_FOLDER'], filename)
file.save(filedir)
task = populate.apply_async(args=[filedir])
return jsonify({'location': url_for('taskstatus', task_id=task.id)})
else:
flash('Please upload datasheet of excel format')
return redirect(url_for('index'))
def analyze():
# Combine all characters from all chapters into one long list
import collections
val = collections.OrderedDict()
for item in sorted(request.args):
if item.startswith('ner_'):
if not int(item.replace('ner_', '').split('_')[0]) in val:
val[int(item.replace('ner_', '').split('_')[0])] = collections.OrderedDict()
val[int(item.replace('ner_', '').split('_')[0])][int(item.replace('ner_', '').split('_')[1])] = request.args.get(item)
all_characters = []
name = secure_filename(request.args.get('filename').split('.')[0])
input_characters = ast.literal_eval(urllib.unquote(request.args.get('characters').decode('utf8')))
aura = ast.literal_eval(urllib.unquote(request.args.get('aura').decode('utf8')))
counter = 1
for char in val:
characters = []
for i in val[char]:
if val[char][i].strip():
all_characters.append(val[char][i])
characters.append(val[char][i])
visualize_ners.render_chapter(0, name + "_" + str(counter), characters)
counter += 1
visualize_ners.render_chapter(0, name + '_all', all_characters)
rnd = str(random.random())
return render_template('analyze.html', rnd=rnd, output=name, counter=counter, aura=aura)
def uploader():
if request.method == 'POST':
f = request.files['file']
f.save(secure_filename(f.filename))
return 'file uploaded successfully'
def upload_file():
import tasks
print('Uploading File Request')
if tasks.uploaded == False:
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(os.getcwd(), filename))
_extract_and_install(filename, True)
tasks.uploaded = True
return make_response("Uploaded file", 200)
else:
return make_response("Cannot upload another file as the Scoring Pipeline has already been initialized", 500)
def _save_file_to_uploads(file):
if file and MemeUploader._allowed_file(file.filename):
# Save file
original_filename = secure_filename(file.filename)
ext = original_filename.split('.')[1]
filename = str(uuid.uuid4()) + '.' + ext
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
return filename
return None
def upload():
global tags
tags = None
if request.method == 'POST':
file = request.files['image']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
print(filename)
return redirect(url_for('view_uploaded_file', filename=filename))
return render_template('upload.html')
def file_upload():
""" Uploads images dropped on the web editor's markdown box to static/images
and notifies editors by email
"""
upload_folder = 'images'
title = request.form['title']
files = request.files
uploadedFiles = []
if files:
for img_file in files.values():
filename = secure_filename(title + "_" + img_file.filename).lower()
dst_folder = os.path.join(current_app.static_folder, upload_folder)
if is_allowed_image_format(img_file):
try:
img_file.save(os.path.join(dst_folder, filename))
send_from_directory(dst_folder, filename)
uploadedFiles += [url_for("static", filename=os.path.join(upload_folder, filename))]
except Exception as e:
error_msg = u"ERROR during image upload: {}".format(str(e))
logger.error(error_msg)
return json.dumps({'error_msg': error_msg, 'success': False})
elif is_pdf(filename):
from PyPDF2 import PdfFileReader
try:
src_pdf = PdfFileReader(img_file)
filename = os.path.splitext(filename)[0]
num_pages = src_pdf.getNumPages()
for page_num in range(num_pages):
page_png = pdf_page_to_png(src_pdf, page_num)
page_name = u"{filename}_{page_num}.jpg".format(**locals())
page_png.save(filename=os.path.join(dst_folder, page_name))
uploadedFiles += [url_for("static", filename=os.path.join(upload_folder, page_name))]
except Exception as e:
error_msg = u"ERROR during pdf upload: {}".format(str(e))
logger.error(error_msg)
return json.dumps({'error_msg': error_msg, 'success': False})
return json.dumps({'links': uploadedFiles, 'success': True})
def upload_file():
if request.method == 'GET':
return render_template('upload_file.html')
if request.method == 'POST':
if bool(request.files):
if os.environ['passed'] != "True":
return "Methods is not allowed."
file = request.files['file']
if file.filename == '':
return "File cannot be empty."
if file and allowed_file(file.filename, 'fc'):
filename = secure_filename(file.filename)
file_path = os.path.join(app.config['FC_UPLOAD_FOLDER'],
filename)
file.save(file_path)
try:
Flux = robot()
except:
return 'FLUX connection temporarily not available.'
Flux.upload_file(file_path, '/SD/Recent/webUpload.fc',
process_callback=upload_callback)
Flux.select_file('/SD/Recent/webUpload.fc')
Flux.start_play()
Flux.close()
os.environ['passed'] = "False"
while os.environ['passed'] != "False":
time.sleep(0.1)
return 'success'
else:
return "File type must is fc."
elif bool(request.form):
password = request.form['password']
if password != os.environ['password']:
return "password is different from FLUX's."
os.environ['passed'] = "True"
while os.environ['passed'] != "True":
time.sleep(0.1)
return 'passed'
def upload_file():
if request.method == 'POST':
file = request.files['file']
print (str(file.filename))
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
file_url = url_for('uploaded_file', filename=filename)
return html + '<br><img src=' + file_url + '>'
return html
def upload_file():
f = request.files['file']
f.save(secure_filename('1'))
return "uploaded"
def uploadFileToServer(uploadFile, musicItem):
filename = secure_filename(uploadFile.filename)
uploadFile.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
return filename
#API Routes
def classify_upload():
try:
# We will save the file to disk for possible data collection.
imagefile = flask.request.files['imagefile']
filename_ = str(datetime.datetime.now()).replace(' ', '_') + \
werkzeug.secure_filename(imagefile.filename)
filename = os.path.join(UPLOAD_FOLDER, filename_)
imagefile.save(filename)
path, extension = os.path.splitext(filename)
if extension == '.png':
im = Image.open(filename)
filename = "%s.jpg" % path
im.save(filename)
logging.info('Saving to %s.', filename)
image = exifutil.open_oriented_im(filename)
except Exception as err:
logging.info('Uploaded image open error: %s', err)
return flask.render_template(
'index.html', has_result=True,
result=(False, 'Cannot open uploaded image.')
)
names, probs, time_cost, accuracy = app.clf.classify_image(
open(os.path.join(filename), "rb").read())
return flask.render_template(
'index.html', has_result=True, result=[True, zip(names, probs), '%.3f' % time_cost],
imagesrc=embed_image_html(image)
)
def upload_file():
if request.method=='POST':
for k in request.files:
file = request.files[k]
print(file)
image_urls = []
if file and allowed_file(file.filename):
filename=secure_filename(file.filename)
file.save(os.path.join(app.config['IMAGE_FOLDER'],filename))
image_urls.append("images/%s"%filename)
return jsonify({"code":1,"image_urls":image_urls})
#????????????????static???????
def upload(activity, act, current_user):
form = Forms.UploadFile()
filename = None
if form.validate_on_submit():
ext_name = secure_filename(form.works.data.filename).split('.')[-1]
print(current_user.name)
filename = "{}_{}_{}.{}".format(act.title, current_user.stu_code, current_user.name, ext_name)
# try:
directory = 'uploads/{}/'.format(activity)
if not os.path.exists(directory):
os.makedirs(directory)
print(filename)
form.works.data.save(directory + filename)
file_size = "{0}k".format(os.path.getsize(directory + filename) / 1000)
data = UploadHistory(current_user.sid, activity, file_size)
db.session.add(data)
db.session.commit()
# except Exception as err:
# flash("??:" + str(err))
# return jsonify(success=False,status="??:" + str(err))
print("flash upload success")
return jsonify(success=True,status="????!")
# flash("????!", 'info')
else:
if request.method == "POST":
return jsonify(success=False,status="????????????????????????")
# print("validdate fail")
# flash("validdate fail")
last_time = UploadHistory.query.filter_by(sid=current_user.sid, activity=activity).order_by(UploadHistory.fid.desc()
).first()
if not last_time:
last_time_msg = '???????'
else:
last_time_msg = '??????: {0} , ??: {1}'.format(last_time.time[:-7], last_time.size)
return render_template('upload.html', user=current_user, form=form, filename=filename, l_s_m=last_time_msg, act=act)
