def user(username):
user = User.query.filter_by(username=username).first_or_404()
posts = [{
'author': user,
'body': 'Test post #1'
}, {
'author': user,
'body': 'Test post #2'
}]
if request.method == 'POST':
FileNotFound = None
try:
file = request.files['file']
filename = secure_filename(file.filename)
path_images = os.getcwd() + r'\tmp'
file.save(os.path.join(path_images, filename))
_resize(path_img=path_images + f'\\{filename}',
size=200,
user_id=user.id,
pics_before=User.count_pics(user_id=user.id))
print(user.id)
FileNotFound = False
except FileNotFoundError:
FileNotFound = True
finally:
request.close()
return render_template('user.html',
user=user,
posts=posts,
Error_FileNotFoundError=FileNotFound)
return render_template('user.html', user=user, posts=posts)
def put(self, id):
try:
user = Users.query.get(id)
if request.json.get('name'):
user.name = request.json.get('name')
if request.json.get('email') and Users.isMail(
request.json.get('email')):
user.email = request.json.get('email')
if request.json.get('password'):
user.password = Users.setPassword(request.json.get('password'))
db.session.add(user)
db.session.commit()
db.session.remove()
userschema = UserSchema(only=['id', 'name', 'email', 'password'])
get_users = Users.query.filter(Users.status == 1).order_by(
Users.id.desc()).all()
users_schema = UserSchema(many=True)
users = users_schema.dump(get_users)
db.session.remove()
request.close()
return {'response': 'Registro Actualizado', 'users': users}, 200
except:
request.close()
return {'response': ' El registro no existe'}, 400
def post(self):
code = request.json.get('code')
password = request.json.get('password')
if code and password:
user = Users.query.filter(Users.code == code).first()
if not user:
return {'error': 'El código es inválido'}, 401
if (user.status == 0):
return {
'error':
'El usuario ha sido dado de baja por el administrador'
}, 401
user.code = ''
user.password = Users.setPassword(password)
db.session.add(user)
db.session.commit()
db.session.remove()
request.close()
return {
'response': 'Su contraseña ha sido cambiada con éxito'
}, 200
else:
request.close()
return {'response': 'Faltan datos'}, 401
def get(self):
# import gc
# try:
name_img, id_img, hayImage = getImg()
if hayImage:
from tracking.neural_network import comenzar_auditoria
name=comenzar_auditoria([name_img])
# name_img, id_img = getImg()
print('id_img.......................',id_img)
# name = comenzar_auditoria([name_img])
updateImg(id_img)
# request.close()
gc.collect()
request.close()
return 'auditoria finalizada'
else:
return 'No hay imagen'
def get(self,id):
get_audit = Audits.query.filter(Audits.user_id == id).order_by(Audits.id.desc()).all()
audit_schema =AuditSchema(many=True)
audit = audit_schema.dump(get_audit)
db.session.remove()
request.close()
return make_response(jsonify(audit))
def get(self):
get_users = Users.query.filter(Users.status == 1).order_by(
Users.id.desc()).all()
users_schema = UserSchema(many=True)
users = users_schema.dump(get_users)
db.session.remove()
request.close()
return make_response(jsonify(users))
def get(self, id):
try:
user = Users.query.get(id)
db.session.remove()
request.close()
return {'user': user}
except:
request.close()
return {'response': ' El registro no existe'}
def get(self, search):
get_users = Users.query.filter(
Users.status == 1).filter((Users.name.ilike(f'%{search}%')) | (
Users.email.ilike(f'%{search}%'))).order_by(
Users.id.desc()).all()
users_schema = UserSchema(many=True)
users = users_schema.dump(get_users)
db.session.remove()
request.close()
return make_response(jsonify(users))
def signup(self):
password = request.form.get('password')
password_confirm = request.form.get('password-confirm')
if password == password_confirm:
if len(password) < 4:
return jsonify(
{"error":
"Password must be greater than four characters"}), 400
user = {
"_id":
uuid.uuid4().hex,
"username":
request.form.get('username'),
"email":
request.form.get('email'),
"password":
password,
"profile_pic":
'profile.png',
"twitter-consumer_key":
os.getenv('twitter-consumer_key'),
"twitter-consumer_secret":
os.getenv('twitter-consumer_secret'),
"twitter-access_token_key":
os.getenv('twitter-access_token_key'),
"twitter-access_token_secret":
os.getenv('twitter-access_token_secret'),
"ig-username":
os.getenv('ig-username'),
"ig-password":
os.getenv('ig-password')
}
user['password'] = pbkdf2_sha256.encrypt(user['password'])
request.close()
if db.users.find_one({"email": user['email']}):
return jsonify({
"error":
"Email address is already in use, please sign in"
}), 400
elif db.users.find_one({"username": user['username']}):
return jsonify({
"error":
"Username is already in use, please choose another"
}), 400
if db.users.insert_one(user):
return self.start_session(user)
elif password != password_confirm:
return jsonify(
{"error": "Passwords do not match, please try again"}), 400
else:
return jsonify({"error": "Signup failed"}), 400
def processjson():
body = request.get_json()
jsonContent = body["jsonContent"]
className = request.args.get('className')
generateTest = request.args.get('generateTest')
auraEnabled = request.args.get('auraEnabled')
parseMethod = request.args.get('parseMethod')
convertedContent = json2apex(className, generateTest, jsonContent,
auraEnabled, parseMethod)
return convertedContent
request.close()
def after_request_func(response):
"""
This function will run after a request, as long as no exceptions occur.
It must take and return the same parameter - an instance of response_class.
This is a good place to do some application cleanup.
"""
t = math.floor(time.time())
if t % 5 == 0:
request.close()
print("close", file=sys.stderr)
return response
def get(self):
user = Users.query.get(2)
db.session.remove()
request.close()
code = '111111'
return send_email('Recuperar Acceso',
sender='*****@*****.**',
recipients=['*****@*****.**'],
text_body=render_template('reset_password.txt',
code=code),
html_body=render_template('reset_password.html',
code=code))
def deployModelData():
global deploy_storage;
result = helpers.deployModel(request.files);
request.close();
result_json = json.dumps(result);
model_deploy_id = result["model_deploy_id"];
deploy_storage.deployCell(model_deploy_id);
deploy_logger.writeDown("A model deployed: \n {}".format(result_json));
return result_json;
def refresh_image(self):
if self.last_refresh_attempt + self.refresh_interval > datetime.datetime.now(
):
print "+++ImageUpdater+++: Skipping this update"
# Return right away if we need to wait longer
return
self.last_refresh_attempt = datetime.datetime.now()
attempt_num = 0
max_attempts = 3
success = False
while attempt_num < max_attempts and success == False:
attempt_num += 1
try:
# Grab the latest frame from the camera
print "+++ImageUpdater+++: Opening request"
request = urllib2.urlopen(self.camera_server + "/photo.jpg",
timeout=3)
print "+++ImageUpdater+++: Reading request"
data = request.read()
print "+++ImageUpdater+++: Encoding request"
encoded_str = base64.b64encode(data)
print "+++ImageUpdater+++: Closing request"
request.close()
success = True
except OSError as e:
print "+++ImageUpdater+++: Image read attempt {} failed: ".format(
attempt_num) + str(e)
except Exception as e:
print "+++ImageUpdater+++: Image read attempt {} failed: ".format(
attempt_num) + str(e)
if not success:
print "+++ImageUpdater+++: Failed to read new image"
else:
try:
# Upload the image to the cloud
print "+++ImageUpdater+++: Uploading request"
upload_result = upload("data:image/jpg;base64," + encoded_str)
print "+++ImageUpdater+++: upload returned"
if upload_result:
# If the upload was successful, save the result in last_image_url
self.last_image_url = upload_result['url']
self.last_update_time = datetime.datetime.now().strftime(
'%H:%M:%S')
except Exception as e:
print "+++ImageUpdater+++: Failed to upload image to cloud: " + str(
e)
success = False
return success
def URL_CHECKER(url):
try:
request = requests.get(url)
time.sleep(5)
if request.status_code == 200:
print('Web site exists')
request.close()
return True
else:
print('Web site does not exist')
request.close()
return False
except Exception as e:
print(e)
print("Error here")
return False
def upload():
file = request.files['inputFile']
# If no file selected
if file.filename == '':
return '<h1>No file selected</h1>'
# Filetype check
if file and allowed_file(file.filename):
# Read in values from CSV:
csvFile = file.read().decode().split('\n')
reader = csv.DictReader(csvFile, delimiter=',')
fields = ('first', 'last', 'position', 'email', 'location',
'ringCentral', 'workPhone', 'mobilePhone')
for row in reader:
# Find empty fields in CSV:
for val in fields:
if row[val] is "":
row[val] = None
# Schema Validation:
try:
new_employee = employee_schema.load(dict(row))
except ValidationError as err:
print(row['first'] + ' ' + row['last'] + '\n' +
str(err.messages))
continue
#TODO Update database from CSV
# Add new employee to session:
db.session.add(new_employee)
# Commit session to db:
db.session.commit()
request.close()
return '<h1>CSV Successfully Parsed</h1>'
# Invalid filetype
else:
return '<h1>Invalid filetype</h1>'
def post(self):
email = request.json.get('email')
if email:
user = Users.query.filter(Users.email == email).first()
if not user:
return {
'error': 'El correo electrónico no se encuentra registrado'
}, 401
if (user.status == 0):
return {
'error':
'El usuario ha sido dado de baja por el administrador'
}, 401
code = uuid.uuid4().hex[:4]
user.code = code
send_email('Recuperar Acceso',
sender='*****@*****.**',
recipients=[user.email],
text_body=render_template('reset_password.txt',
code=code),
html_body=render_template('reset_password.html',
code=code))
db.session.add(user)
db.session.commit()
db.session.remove()
request.close()
return {
'response':
'Se ha enviado un código de verificación a su correo electrónico, si no te aparece en tu bandeja de entrada por favor revisá los correos no deseados'
}, 200
else:
request.close()
return {'response': 'Faltan datos'}, 401
def delete(self,id):
try:
images = Audits.query.get(id)
user_id = images.user_id
db.session.delete(images)
db.session.commit()
get_audit = Audits.query.filter(Audits.user_id == user_id).order_by(Audits.id.desc()).all()
audit_schema =AuditSchema(many=True)
audit = audit_schema.dump(get_audit)
db.session.remove()
request.close()
return {'response': 'Registro Eliminado','images':audit},200
except:
request.close()
return {'response':' El registro no existe'},401
def post(self):
try:
user_id = get_jwt_identity()
try:
user = Users.query.get(user_id)
if request.json.get('name'):
user.name = request.json.get('name')
if request.json.get('email') and Users.isMail(
request.json.get('email')):
user.email = request.json.get('email')
if request.json.get('password'):
user.password = Users.setPassword(
request.json.get('password'))
db.session.add(user)
db.session.commit()
db.session.remove()
userschema = UserSchema(
only=['id', 'name', 'email', 'password'])
db.session.remove()
request.close()
return {'response': 'Sus datos han sido actualizados'}, 200
except:
request.close()
return {'response': ' El registro no existe'}, 401
except:
request.close()
return {'response': ' El registro no existe'}, 401
def delete(self, id):
try:
user = Users.query.get(id)
user.status = 0
db.session.add(user)
db.session.commit()
get_users = Users.query.filter(Users.status == 1).order_by(
Users.id.desc()).all()
users_schema = UserSchema(many=True)
users = users_schema.dump(get_users)
db.session.remove()
request.close()
return {'response': 'Registro Eliminado', 'users': users}, 200
except:
request.close()
return {'error': ' El registro no existe'}, 401
def post(self):
email = request.json.get('email')
password = request.json.get('password')
if email and password:
user = Users.query.filter(Users.email == email).first()
db.session.remove()
if not user:
return {
'error': 'El correo electrónico no se encuentra registrado'
}, 401
if (user.status == 0):
return {
'error':
'El usuario ha sido dado de baja por el administrador'
}, 401
authorized = user.checkPassword(password)
db.session.remove()
if not authorized:
return {'error': 'La contraseña es invalida'}, 401
expires = datetime.timedelta(days=30)
access_token = create_access_token(identity=str(user.id),
expires_delta=expires)
request.close()
return {
'token': access_token,
'name': user.name,
'email': user.email,
'id': user.id,
'total': user.images
}, 200
else:
request.close()
return {'response': 'Faltan datos'}, 401
request.close()
return {'response': 'Faltan datos'}, 401
def get(self):
try:
user_id = get_jwt_identity()
try:
user = Users.query.get(user_id)
data = {
'name': user.name,
'email': user.email,
}
db.session.remove()
request.close()
return data, 200
except:
request.close()
return {'response': ' El registro no existe'}, 401
except:
request.close()
return {'response': ' El registro no existe'}, 401
def post(self):
name = request.json.get('name')
email = request.json.get('email')
password = request.json.get('password')
if name and email and password:
if Users.isMail(email):
user = Users.query.filter(Users.email == email).first()
if user:
return {'error': 'El correo electrónico ya existe'}, 401
data = {
'name': name,
'email': email,
'code': '',
'password': Users.setPassword(password),
'status': 1,
'images': 0
}
users_schema = UserSchema()
user = users_schema.load(data)
users_schema.dump(user.create())
db.session.commit()
get_sampling = Sampling.query.filter(
Sampling.status == 0).limit(400).all()
sampling_schema = SamplingSchema(many=True)
sampling = sampling_schema.dump(get_sampling)
for row in sampling:
data = {
'user_id': user.id,
'sampling_id': row['id'],
'tag_id': 0,
'status': '0'
}
training_shema = TrainingSchema()
training = training_shema.load(data)
training_shema.dump(training.create())
db.session.commit()
samp = Sampling.query.get(row['id'])
samp.status = 1
db.session.add(samp)
db.session.commit()
get_users = Users.query.filter(Users.status == 1).order_by(
Users.id.desc()).all()
users_schema = UserSchema(many=True)
users = users_schema.dump(get_users)
db.session.remove()
request.close()
return {'response': 'Registro Exitoso', 'users': users}, 200
else:
request.close()
return {'error': 'Ingrese un correo valido'}, 401
else:
request.close()
return {'error': 'Faltan datos'}, 401
def condition(city,state):
#weather stuff
city = city.replace(" ","_")
url="http://api.wunderground.com/api/e67a9f7ffa697198/alerts/q/%s/%s.json"
url = url%(state, city)
request = urllib2.urlopen(url)
resultstring = request.read()
result = json.loads(resultstring)
if 'errors' in result:
return render_template("error.html")
else:
#getting the alert type
try:
atype = result['alerts'][0]['type']
except:
atype = "NONE"
request.close()
if atype in alert:
tag = alert[atype]
else:
#get forecast
url="http://api.wunderground.com/api/e67a9f7ffa697198/forecast/q/%s/%s.json"
url = url%(state, city)
request = urllib2.urlopen(url)
resultstring = request.read()
result = json.loads(resultstring)
try:
tag = result['forecast']['simpleforecast']['forecastday'][0]['conditions']
except:
flash('Invalid city and state')
return redirect(url_for('index'))
url = "http://api.wunderground.com/api/e67a9f7ffa697198/conditions/q/%s/%s.json"
url = url%(state, city)
try:
request = urllib2.urlopen(url)
except:
return render_template("error.html")
resultstring = request.read()
result = json.loads(resultstring)
temp = result['current_observation']['temperature_string']
#we can make this even more brolic if we do scrap more data like tempertaure (lows and highs), wind, humidity
#tumblr stuff
url="http://api.tumblr.com/v2/tagged?tag=%s&api_key=6qjbDDaQ4vUogvpFIZ2UoaHuo6ykn1vMpjRYOdYOPCQI6dBw4K"
tag2 = tag
if tag2 == "Partly Cloudy":
tag2 = "Cloudy"
if tag2 == "Cloudy" or tag2 == "Clear":
tag2 = tag2 + "skies"
url = url%(tag2)
try:
request = urllib2.urlopen(url)
except:
return render_template("error.html")
resultstring = request.read()
result = json.loads(resultstring)
pictures = []
for item in result['response']:
try:
pictures.append(item['photos'][0]['original_size']['url'])
except:
pass
request.close()
bgcolors = {'Cloudy':'darkgray', 'Partly Cloudy': 'gainsboro', 'Sunny':'yellow', 'Rain':'lightsteelblue', 'Snow':'snow', 'Clear':'lightskyblue', 'Windy':'whitesmoke', 'Thunderstorm':'gray'}
try:
color = bgcolors[tag]
except:
color = 'white'
return render_template("condition.html",tag=tag,pictures=pictures,temp=temp, color = color)
def index():
"""Render Home Page"""
obs_dict = {}
global aerisTemp
global respTypes
endpt1 = '/observations?p=charlotte%2Cnc'
endpt2 = '/observations/summary?p=charlotte%2Cnc'
aerisURL = "http://api.aerisapi.com/batch/charlotte,nc?requests=/observations,/observations/summary&client_id=" + CLIENT_ID + "&client_secret=" + CLIENT_SECRET
request = urllib.request.urlopen(aerisURL)
response = request.read()
info = json.loads(response)
if info['success']:
respTypes = info['response']['responses']
if respTypes[0]['request'] == endpt1:
resp = respTypes[0]
obs = resp['response']
ob = obs['ob']
obs_dict.update(timestamp = str(ob['timestamp']))
obs_dict.update(humidity = str(ob['humidity']))
obs_dict.update(isDay = str(ob['isDay']))
obs_dict.update(tempF = str(ob['tempF']))
obs_dict.update(weatherPrimaryCoded = str(ob['weatherPrimaryCoded']))
obs_dict.update(weatherShort = str(ob['weatherShort']))
if respTypes[1]['request'] == endpt2:
resp = respTypes[1]
ob_sum = resp['response']
periods = ob_sum[0]['periods']
aerisTemp = periods[0]['summary']['temp']['avgF']
precipMM = periods[0]['summary']['precip']['totalMM']
obs_dict.update(avgTempF = str(aerisTemp))
obs_dict.update(precipMM = str(precipMM))
else:
print("An error occurred: %s" % (info['error']['description']))
respTypes = {}
request.close()
query_statement1 = "SELECT Disaster, Total_CPI_Adjusted_Cost_Millions, Deaths FROM US_Disasters"
df_disasters = pd.read_sql_query(query_statement1, db.session.bind)
top10c = df_disasters.copy()
top10d = df_disasters.copy()
top10c.drop(['Deaths'], axis=1, inplace=True)
top10c.Total_CPI_Adjusted_Cost_Millions = top10c.Total_CPI_Adjusted_Cost_Millions.round()
top10c = top10c.nlargest(10, 'Total_CPI_Adjusted_Cost_Millions')
top10c['Cost_Sum_Totals'] = top10c.groupby(['Disaster'])['Total_CPI_Adjusted_Cost_Millions'].transform(sum)
top10c.drop(['Total_CPI_Adjusted_Cost_Millions'], axis=1, inplace=True)
newtop10c = top10c.drop_duplicates(subset=['Disaster'])
newtop10c['Percentage'] = (100*(newtop10c.Cost_Sum_Totals / newtop10c.Cost_Sum_Totals.sum())).round()
newtop10c.columns = ['label', 'total', 'value']
dataOpt1 = newtop10c.to_dict(orient='records')
top10d.drop(['Total_CPI_Adjusted_Cost_Millions'], axis=1, inplace=True)
top10d = top10d.nlargest(10, 'Deaths')
top10d['Death_Sum_Totals'] = top10d.groupby(['Disaster'])['Deaths'].transform(sum)
top10d.drop(['Deaths'], axis=1, inplace=True)
newtop10d = top10d.drop_duplicates(subset=['Disaster'])
newtop10d['Percentage'] = (100*(newtop10d.Death_Sum_Totals / newtop10d.Death_Sum_Totals.sum())).round()
newtop10d.columns = ['label', 'total', 'value']
dataOpt2 = newtop10d.to_dict(orient='records')
d = datetime.date.today()
searchDate = str(d.year) + '-' + f"{d:%m}" + '-' + f"{d:%d}"
result = db.session.query(CLTtemps).filter(CLTtemps.Date == searchDate)
for row in result.all():
temp2 = row.ForecastTemps
temp2 = (round(temp2,0))
tempDiff = abs(aerisTemp - temp2)
if tempDiff > 18: #18 is the current max on d3 gauge
difference = 18.5
else:
difference = tempDiff
return render_template("index.html", data=(obs_dict,dataOpt1,dataOpt2,difference,temp2))
def post(self):
try:
path=os.path.abspath(os.curdir+'/static/images/predictions/')
# for files in os.listdir(path):
# os.remove(path+'/'+files)
if request.files['file']:
f = request.files['file']
filename = secure_filename(f.filename)
points = filename.count(".")
extension = filename.split('.')
if (extension[points]!='png'):
request.close()
return {'error': 'El formato de la imagen ingresada no esta permitido (Tipo de Formatos permitidos: PNG)' }, 401
name = time.time()
name = int(name)
pick_name = str(name)+'.'+extension[points]
print('pick_name----------------',filename)
#save image
f.save(path+'/'+filename)
##get image size
size = os.stat(path+'/'+filename).st_size
# validate image size
if (size > (2 * 1024 * 1024)):
request.close()
os.remove(path+'/'+filename)
return {'error': 'La imagen es muy grande, el tamaño máximo permitido para la imagen es de 2 MB' }, 401
os.rename(path+'/'+filename, path+'/'+pick_name)
insertImg(pick_name)
return {'image': 'Todo Correcto' }, 401
# else:
# request.close()
# return {'error': 'Ha ocurrido un error con la imagen, por favor intentá con otra imagen' }, 401
else:
request.close()
return {'error':'Ingresá la imagen del terreno (Tipo de Formatos permitidos: PNG)'}, 401
except:
request.close()
return {'error':'Ha ocurrido un error por favor intentá más tarde'},401
def handle(request):
request, addr = request
PRINT("socket connected")
#Managing the connections until the proxy is initialized
while True:
PRINT(
"------------------------------------------------------------")
PRINT("socket is {}".format(request))
PRINT("registered is {}".format(MediaProxy.registered))
PRINT("connections are {}".format(MediaProxy.connections))
#Proxy not initialized by now
#size = bytearray_to_num(recvall(request,4))
#PRINT("We need to read " + str(size) + " bytes from " + str(request))
data = request.recv(128)
if data == b'':
return
#except Exception as e:
# print(e)
# return
PRINT("{} wrote: {}".format(addr, data))
to_send = None
if data == b"bye":
break
elif data == b'iamready':
for connection in MediaProxy.connections:
if addr[0] in connection['addrs']:
connection['ready'] = True
to_send = b'ok'
elif data == b'isready':
found = False
PRINT('inside isready with {}'.format(MediaProxy.connections))
for connection in MediaProxy.connections:
PRINT("{} in {} ? ".format(addr[0], connection['addrs']))
if addr[0] in connection['addrs']:
found = True
if connection['ready']:
to_send = b'yes'
else:
to_send = b'no'
if not found:
to_send = b'unconnected'
elif data.split(b" ")[0] == b"register":
data = data.decode("ascii")
user = uuid.uuid4().hex[0:8]
password = uuid.uuid4().hex[0:8]
to_send = bytearray("credentials " + user + ";" + password,
"ascii")
server_local_ip, server_local_port = None, None
try:
server_local_ip, server_local_port = data.split(" ")[1:]
except Exception as e:
print(e)
request.sendall(bytearray(str(e), "ascii"))
found = False
for usr in MediaProxy.registered:
if usr[2] == request:
to_send = b"already registered"
found = True
if not found:
MediaProxy.registered += [(user, password, request, addr,
(server_local_ip,
int(server_local_port)))]
elif b"connect" in data:
command, client_local_ip, client_local_port, user, password = None, None, None, None, None
try:
command, client_local_ip, client_local_port, user, password = data.decode(
"ascii").split(" ")
except Exception as e:
print(e)
request.sendall(bytearray(str(e), "ascii"))
proxy_session_initialized = False
to_send = b"sender not found"
found = False
for usr in MediaProxy.registered:
if usr[0] == user:
found = True
if usr[1] == password:
PRINT("user + password match")
to_send = b"connection established"
msg = bytearray(
"request {};{};{};{}".format(
client_local_ip, client_local_port,
addr[0], addr[1]), "ascii")
#usr[2].sendall(num_to_bytearray(len(msg)))
usr[2].sendall(msg)
msg = bytearray(
"address {};{};{};{}".format(
usr[4][0], usr[4][1], usr[3][0],
usr[3][1]), "ascii")
#request.sendall(num_to_bytearray(len(msg)))
request.sendall(msg)
time.sleep(1)
proxy_session_initialized = True
MediaProxy.connections += [{
'addrs': (addr[0], usr[3][0]),
'udpports':
None,
'ready':
False
}]
request.close()
usr[2].close()
else:
PRINT("incorrect password")
to_send = b"incorrect password"
break
if proxy_session_initialized:
continue
else:
to_send = data.upper()
#request.sendall(num_to_bytearray(len(to_send)))
request.sendall(to_send)
def get(self,path,name):
request.close()
return send_from_directory('static/images/'+path, name)
