def upload_wav():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit a empty part without filename
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
session_id = str(uuid.uuid4())
s3_key = 'user_data/' + session_id + '.wav'
data_to_s3(file, s3_key)
snapi_logger.info("file saved to {}".format(s3_key))
new_inference(
session_id=session_id,
voice_profile_id=int(request.form.get('chosen_vprofile')),
)
return render_template('play.html', session_id=session_id)
return render_template('upload_wav.html', voice_profiles=CURRENT_VOICE_PROFILES)
def upload_file():
if request.method == 'POST':
# request.file <class 'werkzeug.datastructures.FileStorage'>
# request.url is http://127.0.0.1:5000/
# check if the post request has the file part
if 'file' not in request.files:
log = 'no file field in request.'
return render_template('fail.html', log = log)
# print(request.files['file'])
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
log = 'Empty filename.'
return render_template('fail.html', log = log)
if file and util.allowed_file(file.filename):
# get filename in a safe way
filename = secure_filename(file.filename)
# check if the data folder exists, if not create one
if os.path.exists(app.config['UPLOAD_FOLDER']) == False:
os.makedirs(app.config['UPLOAD_FOLDER'])
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
return render_template('success.html',filename=filename)
elif request.method == 'GET':
return render_template('index.html')
def install_apk(serial_number):
"""
if GET -- display upload form
if POST -- do upload of apk
upload file to web server, xfer to rpc server, then install, and display success
1. resolve rpc server that hosts this device
2. sanitize filename
3. save
4. base64 file and send to adb rpc server
a. rpc server names file randomly and returns this name
5. send install cmd to rpc server with the random file name it chose
TODO check if install returnd err and report msg into install_error.html
"""
adb, rpc_ip_addr, rpc_port = util.get_jsonrpc_server_instance_device(serial_number)
if util.is_valid_jsonrpc_instance(adb):
#if POST (sending data from form) -- upload file to appropriate Container
if request.method == 'POST':
file = request.files['file']
if file and util.allowed_file(file.filename):
filename = secure_filename(util.get_filename_with_ts(file.filename))
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
apk_name_on_container = adb.upload_apk(util.get_base64_from_binary_file(filename))
#send install cmd
#todo: come up with workaround that allows me to keep optional parameters in rpc
adb.install(serial_number, apk_name_on_container, False, True, False, True, True)
return render_template('install_success.html', filename=file.filename, serial_number=serial_number)
else:
return render_template('upload_error.html', filename=file.filename)
#if GET -- just render the upload page
return render_template('upload.html')
else:
return render_template('device_or_container_not_found.html', serial_number=serial_number)
def upload_file():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename, ALLOWED_EXTENSIONS):
if not os.path.exists(UPLOAD_FOLDER):
os.mkdir(UPLOAD_FOLDER)
filename = secure_filename(file.filename)
filename = os.path.join(app.config['UPLOAD_FOLDER'], filename)
file.save(filename)
session['flowchart'] = filename
return redirect(url_for('draw_flowchart'))
return render_template("upload.html")
def upload():
if request.method == 'POST':
# request.file <class 'werkzeug.datastructures.FileStorage'>
# request.url is http://127.0.0.1:5000/
# check if the post request has the file part
if 'file' not in request.files:
log = 'no file field in request.'
return render_template('fail.html', log=log)
# print(request.files['file'])
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
# This part should use flash to output information
log = 'Empty filename.'
return render_template('fail.html', log=log)
if file and util.allowed_file(file.filename):
# get filename in a safe way
filename = secure_filename(file.filename)
app.config['_FILE'] = UPLOAD_FOLDER + filename
app.config['filename'] = filename
print(filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
column_names, data_part = util.preview_csv(
app.config['UPLOAD_FOLDER'] + filename, 3)
return render_template('upload2.html',
column_names=column_names,
data_part=data_part,
filename=app.config['filename'])
elif request.method == 'GET':
app.config['_DATA_COLS'] = ""
app.config['_DATE_COL'] = ""
return render_template('upload.html')
def post_csv():
# request.file <class 'werkzeug.datastructures.FileStorage'>
# request.url is http://127.0.0.1:5000/
# check if the post request has the file part
if 'file' not in request.files:
log = 'no file field in request.'
return render_template('fail.html', log=log)
# print(request.files['file'])
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
log = 'Empty filename.'
return render_template('fail.html', log=log)
if file and util.allowed_file(file.filename):
# get filename in a safe way
filename = secure_filename(file.filename)
# check if the data folder exists, if not create one
if os.path.exists(app.config['UPLOAD_FOLDER']) == False:
os.makedirs(app.config['UPLOAD_FOLDER'])
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
column_names, data_part = util.preview_csv(
app.config['UPLOAD_FOLDER'] + filename)
app.config['COL_NAMES'] = column_names
return render_template('success.html',
column_names=column_names,
data_part=data_part)
def upload_file():
if request.method == 'POST':
# request.file <class 'werkzeug.datastructures.FileStorage'>
# request.url is http://127.0.0.1:5000/
# check if the post request has the file part
if 'file' not in request.files:
log = 'no file field in request.'
return render_template('fail.html', log=log)
# print(request.files['file'])
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
log = 'Empty filename.'
return render_template('fail.html', log=log)
if file and util.allowed_file(file.filename):
# get filename in a safe way
filename = secure_filename(file.filename)
# check if the data folder exists, if not create one
if os.path.exists(app.config['UPLOAD_FOLDER']) == False:
os.makedirs(app.config['UPLOAD_FOLDER'])
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
return render_template('success.html', filename=filename)
elif request.method == 'GET':
return render_template('index.html')
def process_image():
image_recieved = request.get_json()
filename = secure_filename(image_recieved['filename'])
imgdata = base64.b64decode(image_recieved['data'])
if (not imgdata) and (filename == '') and (not allowed_file(filename)):
return jsonify({'message': "Invalid Image.", 'code': 400})
# code: 400 for bad request
with open(os.path.join(app.config['UPLOAD_FOLDER'],
filename), 'wb') as f:
f.write(imgdata)
# use this as image path for model
filepath_for_model = convertToJpg(app, filename)
response = {}
'''
model_response = Call_Model(filepath_for_model) #call model functionality
response['message'] = model_response #add model response to response obj
response['further_details'] = ... # add further details about result as needed
response['code'] = 200 #succesfull response
'''
response['message'] = "Model Prediction." # for sake of testing
response['code'] = 200
return jsonify(response)
def upload_file_own():
if request.method == 'POST' or request.method == 'GET':
if 'file' not in request.files:
flash('No file part', "danger")
return redirect(request.url)
file = request.files['file']
if file.filename == '':
flash('No selected file', "danger")
return redirect("home")
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
afile = session["username"] + "/" + filename
f = request.files['file']
f.save(os.path.join("temp", filename))
blob = os.path.getsize(os.path.join("temp", filename)) #f.read()
print(blob)
blob = (blob / (1024 * 1024))
available, _ = getStorageSpace()
if available + blob <= total_space:
#f.save(os.path.join(app.config['UPLOAD_FOLDER'], afile))
src = os.path.join("temp", filename)
dest = os.path.join(app.config['UPLOAD_FOLDER'], afile)
copyfile(src, dest)
os.remove(src)
flash('File Uploaded Successfully', "success")
return redirect("home")
else:
flash(
'Free Tier Complete, Your Current File Upload exceeds the limit of {}'
.format(total_space), "danger")
return redirect("home")
return render_template("home.html")
def upload_file():
if request.method == 'POST':
if 'file' not in request.files:
log = 'no file field in request.'
return render_template('homepage.html', log = log)
file = request.files['file']
if file.filename == '':
log = 'Empty filename.'
return render_template('homepage.html', log = log)
if file and util.allowed_file(file.filename):
if os.path.exists(app.config['UPLOAD_FOLDER']) == False:
os.makedirs(app.config['UPLOAD_FOLDER'])
file.save(os.path.join(app.config['UPLOAD_FOLDER'], file.filename))
newimage = Memes(id = db.session.query(Memes).count() + 1, name = file.filename, up = 0, down = 0, date = datetime.now())
db.session.add_all([newimage])
db.session.commit()
path = 'http://127.0.0.1:5000/dankmemes/' + file.filename
return render_template('homepage.html', image_file = path, ups = 0, downs = 0, date = datetime.now())
elif request.method == 'GET':
if not database_exists(app.config['SQLALCHEMY_DATABASE_URI']):
db.drop_all()
db.create_all()
memelist = os.listdir(app.config['UPLOAD_FOLDER'])
index = 0
for x in range(len(memelist)):
image = Memes(id = x, name = memelist[x], up = 0, down = 0, date = datetime.now())
index += 1
db.session.add(image)
db.session.commit()
rand = random.randrange(0, db.session.query(Memes).count())
row = db.session.query(Memes)[rand]
path = 'http://127.0.0.1:5000/dankmemes/' + row.name
return render_template('homepage.html', image_file = path, ups = row.up, downs = row.down, date = row.date)
async def get_open_api_endpoint(
legacy_parser: bool = True,
grayscale_image: bool = True,
gaussian_blur: bool = False,
rotate_image: bool = False,
file: UploadFile = File(...),
api_key: APIKey = Depends(get_api_key)):
if file.filename == "":
printer.error("No filename exist")
raise HTTPException(
status_code=415, detail="Invalid image send"
)
if file and util.allowed_file(file.filename):
print(file.filename)
filename = secure_filename(file.filename)
output = os.path.join(util.get_work_dir() + UPLOAD_FOLDER, filename)
printer.info("Store file at: " + output)
with open(output, "wb") as buffer:
shutil.copyfileobj(file.file, buffer)
if PRINT_DEBUG_OUTPUT:
items = []
item = namedtuple("item", ("article", "sum"))
items.append(item("Brot", "1.33"))
items.append(item("Kaffee", "5.33"))
receipt_data = {"storeName": "DebugStore",
"receiptTotal": "15.10",
"receiptDate": "09.25.2020",
"receiptCategory": "grocery",
"receiptItems": items}
json_compatible_item_data = jsonable_encoder(receipt_data)
return JSONResponse(content=json_compatible_item_data)
printer.info("Parsing image")
receipt = process_receipt(config, filename, rotate=rotate_image, grayscale=grayscale_image,
gaussian_blur=gaussian_blur)
printer.print_receipt(receipt)
receipt_data = {"storeName": receipt.market,
"receiptTotal": receipt.sum,
"receiptDate": json.dumps(receipt.date, default=util.json_serial),
"receiptCategory": "grocery",
"receiptItems": receipt.items}
json_compatible_item_data = jsonable_encoder(receipt_data)
return JSONResponse(content=json_compatible_item_data)
else:
raise HTTPException(
status_code=415, detail="Invalid image send"
)
def upload_file(org_id):
"""
Allows an organization member to upload a file for an organization.
"""
form = FileForm()
organization = Organization.query.filter_by(id=org_id).first()
if request.method == "POST":
file = request.files['file']
if (file and allowed_file(file.filename) and form.course_id.data and
request.form.get('date')):
exists = Folder.query.filter_by(
organization_id=org_id,
term=form.term.data,
year=form.year.data
).first()
folder_id = 0
if exists:
folder_id = exists.id
else:
folder = Folder(organization_id=organization.id,
top=False,
term=form.term.data,
year=form.year.data)
db.session.add(folder)
db.session.commit()
folder_id = folder.id
# Parse date and create a datetime object
date_inp = map(int, request.form['date'].split('/'))
month = date_inp[0]
day = date_inp[1]
year = date_inp[2]
date = datetime.datetime(year, month, day, 0, 0, 0)
filename = secure_filename(file.filename)
f = File(file_name=filename, author_id=g.user.id,
organization_id=org_id, folder_id=folder_id,
course_tag=form.course_tag.data,
course_id=form.course_id.data,
class_date=date)
db.session.add(f)
db.session.commit()
file.save(f.full_path + f.file_name)
return redirect(url_for('display_org', org_id=org_id))
else:
return render_template('upload.html', form=form,
organization=organization)
def edit_class():
form = request.form
files = request.files
user = util.verify_headers(request.headers)
name = form.get("name", None)
classroom_id = form.get("classId", None)
description = form.get("description", None)
classroom_pfp = files.get("classroom-pfp", None)
try:
Image.open(classroom_pfp)
except:
classroom_pfp = None
user = (asyncio.run(client.get_user(user)))
user_id = user.id
classroom = classroom_db.find_one({"id": int(classroom_id)})
if len(name.replace(" ", "")) == 0 or not name:
return "Invalid Name"
if classroom == None or user_id not in classroom["teachers"]:
return abort(404)
if classroom_pfp != None and not util.allowed_file(classroom_pfp.filename):
return "Invalid File Type"
if len(description.replace(" ", "")) == 0:
description = "A " + util.langs[
classroom["language"]]["name"] + " classroom"
if not classroom_pfp:
cloud_img_url = classroom["classroom_pfp_url"]
else:
filename = classroom_id + "." + classroom_pfp.filename.split(".")[1]
Image.open(classroom_pfp).convert("RGB").save(filename)
r = cloudinary.uploader.upload(filename,
folder="classrooms/",
public_id=classroom_id,
overwrite=True,
resource_type="image")
cloud_img_url = r["url"].replace("http://", "https://")
os.remove(filename)
classroom_db.update_one({"id": int(classroom_id)}, {
"$set": {
"name": name,
"description": description,
"classroom_pfp_url": cloud_img_url
}
})
return f"/classroom/{classroom_id}/teachers"
def edit_review(review_id):
review_to_edit = con.get_info_for_review(review_id)
book_id = con.get_book_id_by_review_id(review_id)['book_id']
if request.method == "POST":
review_to_edit['subject'] = request.form['subject']
review_to_edit['message'] = request.form['message']
filename = review_to_edit['image']
if 'rating' in request.form.keys():
review_to_edit['review_rating'] = request.form['rating']
if 'file' in request.files.keys():
file = request.files['file']
if file and utl.allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
con.edit_review_database(review_id, review_to_edit, filename)
con.edit_review_database(review_id, review_to_edit, filename)
return redirect(f'/books/{book_id}/info')
return render_template('edit_review.html', review_to_edit=review_to_edit)
def write_review(book_id):
reviews = con.get_book_reviews(book_id)
selected_book_id = con.get_book_by_id(book_id)['book_id']
session_username = session['username']
reviewer_member_id = con.get_member_id_by_username(
session_username)['member_id']
reviewed_book_id = book_id
if request.method == 'POST':
filename = "no image"
file = request.files['file']
if file and utl.allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
review = request.form
con.add_review_to_database(reviewed_book_id, reviewer_member_id,
review, filename)
return redirect(url_for('get_book_info', book_id=book_id))
return render_template('review.html',
selected_book_id=selected_book_id,
reviews=reviews)
def upload_file():
if request.method == 'POST' or request.method == 'GET':
if 'file' not in request.files:
flash('No file part', "danger")
return redirect(request.url)
file = request.files['file']
if file.filename == '':
flash('No selected file', "danger")
return redirect("home")
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
f = request.files['file']
#saveToLocal(f,filename)
s3 = boto3.resource('s3')
object = s3.Object(S3_BUCKET,
"{}/{}".format(session['username'], filename))
object.put(Body=f)
flash('File Uploaded Successfully', "success")
return redirect("home")
return render_template("home.html")
def upload():
if not session.get('id'):
return redirect('/')
#get the uploaded file or redirect to http://host/
if 'file' in request.files:
f = request.files['file']
else:
return redirect("/")
#allowed_file checks that the extension is in util.FORMATS
if allowed_file(f.filename):
#save the file internally in the \temp folder and record a timeout for the file
key, file_name = record_and_save(f)
#if the metadata is valid, process the file
file_path = os.path.join("temp", key, file_name)
if metadata_are_valid(file_path):
library.add_song(file_path, delete = True)
os.rmdir(os.path.join('temp', key))
return redirect("/")
else: #get additional info from uploader
return redirect("/edit_upload?key=%s&filename=%s" % (key, file_name))
else:
print f.filename
return redirect("/?error=extension")
def infer():
"""
Receive images, process them and return JSON
:return:
"""
if request.method == 'POST':
files = {}
response = []
for key, file in request.files.items():
if file and allowed_file(file.filename):
buf = file.read()
img = load_image(buf)
files[key] = {file.filename: img}
else:
response += [{
"status_code": "ERROR",
"status_msg": "wrong file type",
'filename': file.filename,
'fieldname': key
}]
response += [batch_inference(files)]
return jsonify({"results": response}), 201
else:
s_title = "Binary Hashcode Computation"
s_version = "0.3"
return """
<!doctype html>
<title>%s</title>
<h2>%s</h2>
<I>Version: %s</I>
<form action="#" method=post enctype=multipart/form-data>
<p><input type=file name=file>
<br /><br /><input type=submit value="Compute code">
</form>
<hr>
<p></p>
""" % (s_title, s_title, s_version)
def post_csv():
if 'proceed' in request.form:
print('yes!')
# request.file <class 'werkzeug.datastructures.FileStorage'>
# request.url is http://127.0.0.1:5000/api/post_csv
# check if the post request has the file part
# print("entered post")
if 'file' not in request.files:
log = 'no file field in request.'
return render_template('fail.html', log=log)
# print(request.files['file'])
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
log = 'Empty filename.'
return render_template('fail.html', log=log)
# print ("filename is not empty")
if file and util.allowed_file(file.filename):
# get filename in a safe way
print("filename")
filename = secure_filename(file.filename)
# print(filename)
# check if the data folder exists, if not create one
# print(UPLOAD_FOLDER)
if os.path.exists(app.config['UPLOAD_FOLDER']) == False:
# print("folder does not exist")
os.makedirs(app.config['UPLOAD_FOLDER'])
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
g.filename = filename
session['filename'] = filename
return render_template('index.html', filename=filename)
print("Not CSV")
log = 'Not CSV.'
# return False
return render_template('index.html', log=log)
def clone():
form = request.form
files = request.files
user = util.verify_headers(request.headers)
clone_class_id = form.get("classId", None)
name = form.get("name", None)
description = form.get("description", None)
classroom_pfp = files.get("classroom-pfp", None)
try:
Image.open(classroom_pfp)
except:
classroom_pfp = None
classroom_id = str(util.next_id(classroom_db.find()))
user = (asyncio.run(client.get_user(user)))
user_id = user.id
user_username = user.name
user_pfp = user.avatar
if clone_class_id: return abort(404)
if len(name.replace(" ", "")) == 0 or not name:
return "Invalid Name"
if classroom_pfp != None and not util.allowed_file(classroom_pfp.filename):
return "Invalid File Type"
clone_classroom = classroom_db.find_one({"id": int(clone_class_id)})
language = clone_classroom["language"]
if len(description.replace(" ", "")) == 0:
description = "A " + util.langs[
language.lower()]["name"] + " classroom"
if not classroom_pfp:
cloud_img_url = clone_classroom["classroom_pfp_url"]
else:
filename = classroom_id + "." + classroom_pfp.filename.split(".")[1]
Image.open(classroom_pfp).convert("RGB").save(filename)
r = cloudinary.uploader.upload(filename,
folder="classrooms/",
public_id=classroom_id,
overwrite=True,
resource_type="image")
cloud_img_url = r["url"].replace("http://", "https://")
os.remove(filename)
assignments = []
assignment_ids = []
next_id = util.next_id(assignment_db.find())
loops = 0
for assignment_id in clone_classroom["assignments"]:
assignment = dict(assignment_db.find_one({"id": assignment_id}))
del assignment["_id"]
assignment["id"] = next_id + loops
assignment["submissions"] = {}
assignments.append(assignment)
assignment_ids.append(next_id + loops)
loops += 1
assignment_db.insert_many(assignments)
classroom_db.insert_one({
"id": int(classroom_id),
"owner_id": user_id,
"owner_username": user_username,
"owner_pfp": user_pfp,
"created": time.time(),
"name": name,
"language": language.lower(),
"description": description,
"classroom_pfp_url": cloud_img_url,
"teachers": [user_id],
"students": [],
"assignments": assignment_ids,
"studentInviteLink": None,
"studentInviteCode": None,
"teacherInviteLink": None,
"teacherInviteCode": None
})
user_db.update_one({"id": user_id},
{"$addToSet": {
"classrooms": int(classroom_id)
}})
return f"/classroom/{classroom_id}/teachers"
def rec():
if request.method == 'POST':
if 'proportion' not in request.form:
return redirect(request.url)
proportion = 1
try:
proportion = float(request.form['proportion'])
except ValueError:
return redirect(request.url)
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
lines = recognize_printed_text("a433d6de318d4cf783be944b527f85d4",
file.stream)
print(lines)
output = []
for line in lines:
words = regex.split(line)
for x in range(0, len(words)):
try:
curr_word = words[x]
number = None
if '/' in curr_word:
temp = curr_word.split('/')
if len(temp) == 2:
try:
numer = int(temp[0]) * proportion
denom = int(temp[1])
number = numer / denom
output.append(number)
except:
pass
elif '-' in curr_word:
temp = curr_word.split('-')
if len(temp) == 2:
try:
numer = int(temp[0])
denom = int(temp[1])
output.append(
str(numer) + '-' + str(denom))
except:
pass
else:
number = float(words[x])
if number < 100 and (x >= len(words) - 1
or words[x + 1]
not in WORDS_TO_IGNORE):
number *= proportion
output.append(number)
except ValueError:
output.append(curr_word)
return str(output)
return "Hellow Rec!"
def main():
if not os.path.exists('upload'):
os.mkdir('upload')
n = app.config['N']
if request.method == "POST":
if 'csvinput' in request.files:
f = request.files['csvinput']
if f and allowed_file(f.filename):
input_file = secure_filename(f.filename)
f.save(input_file)
else:
raise Exception('Not valid filename!')
session['input_encoding'] = try_utf8(input_file)
preview_input = read_n_lines(input_file, n,
session['input_encoding'])
pattern = r'\d\d-\d\d\d\d'
result = re.match(pattern, input_file)
order = result.group(0) if result else None
tiraz, perso_mest, bad_data, trouble = consistency(
input_file, session['input_encoding'])
if bad_data:
preview_input = trouble
session['order'] = order
session['input_file'] = input_file
session['output_encoding'] = ''
return render_template('index.html',
preview_input=preview_input,
perso_mest=perso_mest,
status='done',
tiraz=tiraz)
elif "calculation" in request.form:
form = request.form
session['places'] = places = int(form['places'])
session['pile'] = pile = int(form['pile'])
input_file = session['input_file']
input_encoding = session['input_encoding']
output_file = os.path.splitext(input_file)[0] + '_' + str(
places) + 'x' + str(pile) + '.csv'
session['output_file'] = output_file
preview_input = read_n_lines(input_file, n,
session['input_encoding'])
tiraz, perso_mest, pile_size, izdeliy_v_privertke, full_pile_amount, hvost_izdeliy, \
hvost_listov, dummy = privertka(input_file, output_file, pile, places, input_encoding)
preview_output = read_n_lines(output_file, n,
app.config['OUTPUT_ENCODING'])
return render_template('index.html',
preview_input=preview_input,
preview_output=preview_output,
places=places,
pile_size=pile_size,
tiraz=tiraz,
perso_mest=perso_mest,
izdeliy_v_privertke=izdeliy_v_privertke,
full_pile_amount=full_pile_amount,
hvost_izdeliy=hvost_izdeliy,
hvost_listov=hvost_listov,
dummy=dummy,
status='')
elif "download" in request.form:
output_file = session['output_file']
return send_file(output_file, as_attachment=True)
# elif "markirovka" in request.form:
# form = request.form
# pachka = int(form[''])
# _ = perekladka(input_file, pachka)
else:
session.pop('username', None)
session['state'] = 'init'
return render_template('index.html')
def make_class():
form = request.form
files = request.files
user = util.verify_headers(request.headers)
name = form.get("name", None)
language = form.get("language", None)
description = form.get("description", None)
classroom_pfp = files.get("classroom-pfp", None)
try:
Image.open(classroom_pfp)
except:
classroom_pfp = None
classroom_id = str(util.next_id(classroom_db.find()))
user = asyncio.run(client.get_user(user))
user_id = user.id
user_username = user.name
user_pfp = user.avatar
if len(name.replace(" ", "")) == 0 or not name:
return "Invalid Name"
if language.lower() not in util.langs:
return "Invalid Language"
if classroom_pfp != None and not util.allowed_file(classroom_pfp.filename):
return "Invalid File Type"
if len(description.replace(" ", "")) == 0:
description = "A " + util.langs[
language.lower()]["name"] + " classroom"
if not classroom_pfp:
cloud_img_url = "https://res.cloudinary.com/codingcactus/image/upload/v1611481743/classrooms/repl_logo_p9bqek.png"
else:
filename = classroom_id + "." + classroom_pfp.filename.split(".")[1]
Image.open(classroom_pfp).convert("RGB").save(filename)
r = cloudinary.uploader.upload(filename,
folder="classrooms/",
public_id=classroom_id,
overwrite=True,
resource_type="image")
cloud_img_url = r["url"].replace("http://", "https://")
os.remove(filename)
classroom_db.insert_one({
"id": int(classroom_id),
"owner_id": user_id,
"owner_username": user_username,
"owner_pfp": user_pfp,
"created": time.time(),
"name": name,
"language": language.lower(),
"description": description,
"classroom_pfp_url": cloud_img_url,
"teachers": [user_id],
"students": [],
"assignments": [],
"studentInviteLink": None,
"studentInviteCode": None,
"teacherInviteLink": None,
"teacherInviteCode": None
})
user_db.update_one({"id": user_id},
{"$addToSet": {
"classrooms": int(classroom_id)
}})
return f"/classroom/{classroom_id}/teachers"
def upload_file():
if request.method == 'POST':
username = request.form["username"]
if username is None or len(username) == 0:
return render_template("index.html")
file = request.files['upload_file']
if file and util.allowed_file(file.filename):
filename = secure_filename(file.filename)
dirpath = os.path.join(app.config['UPLOAD_TEST_FOLDER'], username)
align_dirpath = os.path.join(
app.config['UPLOAD_TEST_ALIGN_FOLDER'], username)
align_filepath = os.path.join(align_dirpath, filename)
shutil.rmtree(app.config['UPLOAD_TEST_FOLDER'])
shutil.rmtree(app.config['UPLOAD_TEST_ALIGN_FOLDER'])
os.mkdir(app.config['UPLOAD_TEST_FOLDER'])
os.mkdir(app.config['UPLOAD_TEST_ALIGN_FOLDER'])
os.mkdir(dirpath)
filepath = os.path.join(dirpath, filename)
file.save(filepath)
des = 'tmp/%s' % util.get_uuid()
src = 'tmp/%s' % util.get_uuid()
shutil.copytree(dirpath, os.path.join(src, username))
net.align_dataset(des, src, 0.25, True, 32, 160)
shutil.copytree(os.path.join(des, username),
os.path.join('uploads/test_align', username))
shutil.rmtree(src)
shutil.rmtree(des)
res = net.classify(False, 'CLASSIFY',
app.config['UPLOAD_TEST_ALIGN_FOLDER'], 20, 10,
'20170512-110547/20170512-110547.pb',
'classifiers/%s_classifier.pkl' % username,
1000, 160)
if res[0][1] == username and res[0][2] >= 0.90:
# generate a random filename
pic_name = util.get_uuid() + '.png'
pic_align_name = util.get_uuid() + '.png'
des_path = os.path.join(
os.path.join(app.config['UPLOAD_FOLDER'], username),
pic_name)
align_des_path = os.path.join(
os.path.join(app.config['UPLOAD_TRAIN_ALIGN_FOLDER'],
username), pic_align_name)
shutil.move(filepath, des_path)
shutil.move(
align_filepath.split('.')[0] + '.png', align_des_path)
return render_template(
'index.html',
# img_path='uploads/train/%s/%s' % (username, pic_name),
img_align_path=align_des_path,
username=username,
prob=res[0][2])
else:
return render_template(
'index.html',
img_path=filepath,
# img_align_path='uploads/test_align/%s/%s' %(username, filename),
err_msg='not the {} picture'.format(username))
else:
return render_template('index.html')
def recognize():
"""
处理上传文件并识别车牌号码
:return: dict
"""
if not check_uploaded_file1('photo', request.files):
return make_api_response(2, '未找到匹配的图片')
photo = request.files.get('photo')
if not check_uploaded_file2(photo.filename):
return make_api_response(2, '未接收到任何图片，请重新上传图片')
if not (photo and allowed_file(photo.filename)):
return make_api_response(2, '上传的文件格式无效。')
relative_path = save_photo(photo)
photo_path = Path(relative_path)
if not photo_path.is_file():
return make_api_response(2, '图片文件上传失败')
if not check_uploaded_file3(relative_path):
return make_api_response(2, '图片大小为0，请重新上传图片')
image = Image.open(relative_path)
img_dpi = "%dx%d" % (image.size[0], image.size[1])
img_format = image.format
img_size = "%dKB" % (os.path.getsize(relative_path) / 1024)
start = time.clock()
# 识别车牌号码
image = cv2.imread(relative_path)
if image is None:
return make_api_response(status=1,
msg='OpenCV读取图片失败',
result_photo=photo_path.name,
img_dpi=img_dpi,
img_format=img_format,
img_size=img_size)
result_list = HyperLPR_PlateRecogntion(image)
elapsed = "%.2fs" % (time.clock() - start)
if not (result_list and len(result_list)
== 1) or not (result_list[0] and len(result_list[0]) == 3):
return make_api_response(status=1,
msg='操作成功，但未找到有效车牌号',
result_photo=photo_path.name,
img_dpi=img_dpi,
img_format=img_format,
img_size=img_size,
used_time=elapsed)
plate = result_list[0][0]
confidence = result_list[0][1]
location = result_list[0][2]
top_left_x = location[0]
top_left_y = location[1]
top_right_x = location[2]
top_right_y = location[1]
bottom_right_x = location[2]
bottom_right_y = location[3]
bottom_left_x = location[0]
bottom_left_y = location[3]
rectangle_point_locations = [(top_left_x, top_left_y),
(top_right_x, top_right_y),
(bottom_right_x, bottom_right_y),
(bottom_left_x, bottom_left_y)]
result_photo = mark_photo(relative_path, (top_left_x, top_left_y),
(bottom_right_x, bottom_right_y))
return make_api_response(status=0,
msg='车牌号码识别成功......',
plate=plate,
confidence=float(confidence),
result_photo=Path(result_photo).name,
location=rectangle_point_locations,
img_dpi=img_dpi,
img_format=img_format,
img_size=img_size,
used_time=elapsed)
type=str,
help='Directory containing keyframes'
)
args = parser.parse_args()
image_dir = args.images_dir
es_index = args.es_index
pathes = []
print("""Reading images...""")
for root, dirs, files in os.walk(image_dir):
for filename in files:
if (allowed_file(filename)):
path = os.path.join(os.path.relpath(root, image_dir), filename)
print ("Adding " + path)
pathes.append(path)
# pathes = pathes[:10000]
num_files_total = len(pathes)
print("""%d images found.""" % (num_files_total,))
# ES index
if not es_index.islower():
raise ("Index needs to be lowercase")
# Init threads
threads = []
