def post(self):
'''method ['POST']'''
data = request.get_json()
if not data:
return {"message": "Fields cannot be empty"}, 400
username = data.get('username')
name = data.get('name')
email = data.get('email')
password = data.get('password')
confirm_password = data.get('confirm_password')
if not username or not name or not email or not password or not confirm_password:
return dict(message=
"name, username, email, password or confirm_password fields missing"), 400
v = Validate().validate_register(username, name, email, password, confirm_password)
if "message" in v:
return v, 400
admin = request.args.get('admin')
if UserModel.get_user_by_username(v["username"]):
return {"message": "Add user failed. Username already exists"}, 409
if UserModel.get_user_by_email(v["email"]):
return {"message": "Add user failed. Email entered already exists"}, 409
if admin is None:
my_user = UserModel(username=v["username"], name=v["name"],
email=v["email"], password=v["password"])
my_user.save()
return {"message": "User successfully added"}, 201
my_user = UserModel(username=v["username"], name=v["name"],
email=v["email"], password=v["password"], admin=True)
my_user.save()
return {"message": "Admin user successfully added"}, 201
def change_reset_password(reset, data):
'''helper method for change password through reset token'''
if not data:
return dict(message="Fields can't be empty"), 400
reset_password = data.get("reset_password")
new_password = data.get("new_password")
confirm_password = data.get("confirm_password")
if reset_password is None or new_password is None:
return dict(
message="reset password or new password fields missing"), 400
password = Validate().validate_password(new_password, confirm_password)
if "message" in password:
return password, 400
user_identity = get_jwt_identity()
user = UserModel.get_user_by_username(user_identity)
if check_password_hash(reset, reset_password) is True:
user.password = generate_password_hash(new_password)
user.reset_password = False
user.last_reset_password = datetime.now()
user.save()
#revoke reset token after successfully changing password
json_token_identifier = get_raw_jwt()['jti']
revoked_token = RevokedTokenModel(
json_token_identifier=json_token_identifier)
revoked_token.save()
return dict(message="password changed successfully"), 200
return dict(message="incorrect reset password"), 401
def pickRequest(self, dbUpdateObject, sessionObject, botResponse, item):
print botResponse + "Response 8"
validateObject = Validate()
info = self.messageSplit(botResponse)
print botResponse + "Response 9"
req_fields = dictonary.required_fields[info[1]].split('&')
bot_qry = dictonary.bot_query
func_map = dictonary.function_map
print botResponse + "Response 10"
for i in range(0, (len(req_fields) - 2)):
info[i + 2] = validateObject.validate(i, info[i + 2])
print botResponse + "Response 11"
if str(info[i + 2]) == '0' or info[i + 2] == 0.0 or str(
info[i + 2]) == '':
print botResponse + "Response 12"
print bot_qry[req_fields[i + 1]]
print item[1]
x = sessionObject.respond(bot_qry[req_fields[i + 1]], item[1])
print x
return x
temp = func_map[req_fields[len(req_fields) - 1]](
info, item[1], dbUpdateObject, sessionObject) ##########
print "Naman Agarwal\n\n" + temp + "\n\n"
dbUpdateObject.deletePendingRequest(item)
return temp
def start(self):
for callback_label in range(self.crawler.__ParseFuncCount__):
callback = self.crawler.__ParseFunc__[callback_label]
# 获取代理
proxy_list = self.crawler.get_proxies(callback)
# 验证可用性
Validate().valid_many(proxy_list, 'insert')
def read(self):
rule = self.rule
# 验证报文数据
Validate().analysis(sign=rule['sign'])
Common.im218_is_out_duty = False
Common.pwm_is_run = False
def check():
'''
定时检测数据库中代理的可用性
:return:
'''
while True:
m = MongoDB()
count = m.get_count()
if not count == 0:
logging.info('开始检测数据库中代理可用性>>>>>>>>')
proxies = m.get(count)
Validate().valid_many(proxies, 'check')
time.sleep(10 * 60)
def signup():
if request.method == 'POST':
username = request.form["username"]
password = request.form["passwd"]
confirm_password = request.form["confirmPasswd"]
validate = Validate()
validate.set_username_validators(min_length=4, max_length=12)
username_check = validate.validate_username(username.strip())
password_check = validate.validate_password(password, confirm_password)
if username_check == 'PASS' and password_check == 'PASS':
# Insert into database
global conn
params = (username, password)
conn.execute("INSERT INTO user (username, password) VALUES (?, ?)", params)
conn.commit()
session.permanent = True
session['user'] = username
return redirect(url_for('login', user=username))
elif username_check == 'USERNAME_NULL':
message = "username field is left blank"
elif username_check == 'USERNAME_LENGTH_VIOLATED':
message = "username length should be of min 4 and max 12 characters"
elif username_check == 'USERNAME_VIOLATED':
message = "username can consist of alphanumeric characters and cannot start with a digit"
elif password_check == 'PASSWD_UNMATCH':
message = "passwords do not match"
elif password_check == 'PASSWD_WEAK':
message = "weak password"
else:
message = "some error occurred"
return render_template('register.html', message=message)
else:
if user_authenticated():
return render_template('force_logout.html')
return render_template('register.html', message='')
def put(self):
'''Change a password'''
data = request.get_json()
claims = get_jwt_claims()
reset = claims["reset_password"].encode('ascii')
if reset != "false":
'''if reset password is not false call change_reset_password() helper method'''
return change_reset_password(reset, data)
if not data:
return dict(message="Fields cannot be empty"), 400
old_password = data.get("old_password")
new_password = data.get("new_password")
confirm_password = data.get("confirm_password")
if old_password is None or new_password is None:
return dict(
message="old_password or new_password fields missing"), 400
my_list = [old_password, new_password, confirm_password]
for i in my_list:
i = i.strip()
if not i:
return dict(message="enter valid data"), 400
password = Validate().validate_password(new_password, confirm_password)
if "message" in password:
return password
user_identity = get_jwt_identity()
user = UserModel.get_user_by_username(user_identity)
if check_password_hash(user.password, old_password) is True:
user.password = generate_password_hash(new_password)
user.last_change_password = datetime.now()
user.save()
return dict(message="password changed successfully"), 200
return dict(message="Incorrect password"), 401
def ProcessFile(inputfname, lasversion, minimumpointsdensity, displayheader,
cellsize, maxpercentcellsbelowdensity, activevalidations,
deletefiles, validatefilespath, csvresults, verbose):
Validate.version = lasversion
Validate.minimumpointsdensity = minimumpointsdensity
Validate.displayheader = displayheader
Validate.cellsize = cellsize
Validate.maxpercentcellsbelowdensity = maxpercentcellsbelowdensity
Validate.validatefilespath = validatefilespath
Validate.deletefiles = deletefiles
Validate.csvresults = csvresults
Validate.activevalidations = activevalidations
Validate.verbose = verbose
start = time.time()
failCount = 0
if (Validate.displayheader):
lidarutils.displayInfo(inputfname)
parameters = valParameters()
try:
validate = Validate(inputfname, parameters)
if 1 in validate.activevalidations:
failCount += validate.CheckLiDARFileSignature()
if 2 in validate.activevalidations:
failCount += validate.CheckFileVersion()
if 3 in validate.activevalidations:
failCount += validate.CheckNumberofReturns()
if 4 in validate.activevalidations:
failCount += validate.CheckReturnNumbers()
if 5 in validate.activevalidations:
failCount += validate.CheckMinMaxValues()
if (6 in validate.activevalidations) or (
7 in validate.activevalidations):
validate.CreateShpFileLAS()
catalogOk = validate.RunCatalog()
if catalogOk:
validate.CalcShapeFileArea()
if 6 in validate.activevalidations:
failCount += validate.CheckGlobalPointsDensity()
if 7 in validate.activevalidations:
if catalogOk:
failCount += validate.CheckMaxCellsBelowDensity()
if 8 in validate.activevalidations:
failCount += validate.CheckXtYtZt()
except:
if 'validate' in locals():
validate.TestFail('Exception: {0}'.format(traceback.format_exc()))
else:
print("Error {0} opening file {1}".format(traceback.format_exc(),
inputfname))
os._exit(0)
failcount += 1
if Validate.verbose > 0:
if failCount == 0:
print('All validations passed successfully.')
else:
print('{0} validation(s) failed.'.format(failCount))
print(validate.errorMessages)
print('File: {0},'.format(inputfname)),
print('{0} (elapsed time: {1:.2f}s)'.format(
'ok' if failCount == 0 else 'failed: ' +
validate.errorMessages.strip(),
time.time() - start))
validate.Close()
def battle(self):
self.max_health(self.trainer.pokemon_party)
if len(self.trainer.pokemon_party) == 0:
print("You have no pokemon")
else:
current_pokemon = 0
enemy_pokemon = 0
cp = 0
ep = 0
print("\033c")
print(f'\n{self.enemy.name} wants to battle')
# Check trainer and enemy still have pokemon to send out
while self.party_status(
self.trainer.pokemon_party) > 0 and self.party_status(
self.enemy.pokemon_party) > 0:
if current_pokemon > cp:
print(
f'{self.trainer.name} sent out {self.trainer.pokemon_party[current_pokemon].name}!\n'
)
cp += 1
elif enemy_pokemon > ep:
print(
f'{self.enemy.name} sent out {self.enemy.pokemon_party[enemy_pokemon].name}!\n'
)
ep += 1
else:
print(
f'{self.enemy.name} sent out {self.enemy.pokemon_party[enemy_pokemon].name}!\n'
)
print(
f'{self.trainer.name} sent out {self.trainer.pokemon_party[current_pokemon].name}!\n'
)
# Check current pokemon is not fainted
while self.trainer.pokemon_party[
current_pokemon].health > 0 and self.enemy.pokemon_party[
enemy_pokemon].health > 0:
# Pokemon attack options for user
t_party = self.trainer.pokemon_party
e_party = self.enemy.pokemon_party
count = 0
while len(t_party[current_pokemon].attacks) > count:
print(
f'{count + 1}. {t_party[current_pokemon].attacks[count].name}'
)
count += 1
user_input = Validate().range(
1, len(t_party[current_pokemon].attacks),
"Please choose a valid option",
"What would you like to do? ")
e_party[enemy_pokemon].health -= t_party[
current_pokemon].attacks[user_input - 1].damage
print("\033c")
print(
f'\n{t_party[current_pokemon].name} used {t_party[current_pokemon].attacks[user_input - 1].name}, the enemy {e_party[enemy_pokemon].name} now has {e_party[enemy_pokemon].health} HP'
)
# User attacks first, and if enemy pokemon is still alive, they will return with an attack
if self.alive(self.enemy.pokemon_party[enemy_pokemon]):
t_party[current_pokemon].health -= e_party[
current_pokemon].attacks[0].damage
print(
f'The enemy {e_party[enemy_pokemon].name} used {e_party[enemy_pokemon].attacks[0].name}, {t_party[current_pokemon].name} has {t_party[current_pokemon].health} HP\n'
)
# Check to see if pokemon fainted after attack sequence, change pokemon at the start of the loop
if self.alive(self.trainer.pokemon_party[current_pokemon]):
print(
f'Enemy {self.enemy.pokemon_party[enemy_pokemon].name} fainted!\n'
)
enemy_pokemon += 1
else:
print(
f'{self.trainer.pokemon_party[current_pokemon].name} fainted\n'
)
current_pokemon += 1
# After healthy pokemon check finishes, check to see whose pokemon party is still alive
if self.party_status(self.trainer.pokemon_party):
print(f'You defeated {self.enemy.name}!')
input("Press enter to continue")
else:
print(f'{self.enemy.name} defeated you!')
input("Press enter to continue")
def validate():
validate = Validate()
print "-----------------start to reflesh--------------------------"
validate.reflesh()
print "------------------start to update-------------------------"
validate.ping()
def main():
results = {}
results['mode'] = config['mode']
results['estimator'] = config['estimator_type']
start = time.time()
now = datetime.datetime.now()
ts = '{}-{}-{}-{}-{}'.format(now.year, now.month, now.day, now.hour,
now.minute)
print(ts)
criterion = losses.photometric_reconstruction_loss()
exp_loss = losses.explainability_loss()
Reconstructor = stn.Reconstructor().to(device)
loss = losses.Compute_Loss(Reconstructor,
criterion,
exp_loss,
exp_weight=config['exp_weight'])
model = mono_model_joint.joint_model(
num_img_channels=(6 + 2 * config['use_flow']),
output_exp=args.exploss,
dropout_prob=config['dropout_prob'],
mode=args.mode).to(device)
params = list(model.parameters())
optimizer = torch.optim.Adam(params,
lr=config['lr'],
weight_decay=config['wd']) #, amsgrad=True)
cudnn.benchmark = True
est_traj_stacked = {}
corr_pose_change_vecs_stacked = {}
corr_stacked = {}
losses_stacked = {}
best_val_loss, best_rot_seg_err, best_trans_err, most_loop_closure = {}, {}, {}, {}
best_rot_acc_epoch, best_trans_acc_epoch, best_loss_epoch, most_loop_closure_epoch = {}, {}, {}, {}
for key, dset in eval_dsets.items():
est_traj_stacked[key] = np.empty(
(0, eval_dsets[key].dataset.raw_gt_trials[0].shape[0], 4, 4))
losses_stacked[key] = np.empty(
(0, eval_dsets[key].dataset.raw_gt_trials[0].shape[0] - 1))
corr_pose_change_vecs_stacked[key] = np.empty(
(0, eval_dsets[key].dataset.raw_gt_trials[0].shape[0] - 1, 6))
corr_stacked[key] = np.copy(corr_pose_change_vecs_stacked[key])
best_val_loss[key], best_rot_seg_err[key], best_trans_err[
key], most_loop_closure[key] = 1e5, 1e5, 1e5, 0
for epoch in range(0, config['num_epochs']):
optimizer = exp_lr_scheduler(
model, optimizer, epoch, lr_decay_epoch=config['lr_decay_epoch']
) ## reduce learning rate as training progresses
train_loss = Train_Mono(device, model, Reconstructor,
dset_loaders['train'], loss, optimizer, epoch)
val_loss = Validate(device, model, Reconstructor, dset_loaders['val'],
loss)
#
if epoch == 0:
writer = SummaryWriter(comment="-val_seq-{}-test_seq-{}".format(
args.val_seq[0], args.test_seq[0]))
writer.add_scalars('', {
'train': train_loss,
'val': val_loss
}, epoch + 1)
for key, dset in eval_dsets.items():
print("{} Set, Epoch {}".format(key, epoch))
###plot images, depth map, explainability mask
img_array, disparity, exp_mask = test_depth_and_reconstruction(
device, model, Reconstructor, dset)
img_array = plot_img_array(img_array)
depth = plot_disp(disparity[-1])
writer.add_image(key + '/imgs', img_array, epoch + 1)
writer.add_image(key + '/depth', depth, epoch + 1)
if args.exploss:
exp_mask = plot_img_array(exp_mask)
writer.add_image(key + '/exp_mask', exp_mask, epoch + 1)
###plot trajectories
corr, gt_corr, corr_pose_change_vec, odom_pose_change_vec, gt_pose_change_vec, corr_traj, corr_traj_rot, est_traj, gt_traj, \
rot_seg_err, trans_err, cum_dist = test_trajectory(device, model, Reconstructor, dset, epoch)
corrections = plot_6_by_1(corr, title='Corrections')
correction_errors = plot_6_by_1(np.abs(corr - gt_corr),
title='6x1 Errors')
est_traj_img = plot_multi_traj(est_traj, 'Odom.', gt_traj, 'GT',
key + ' Set')
corr_traj_img = plot_multi_traj(corr_traj, 'corr.', gt_traj, 'GT',
key + ' Set')
corr_traj_rot_img = plot_multi_traj(corr_traj_rot, 'corr.',
gt_traj, 'GT', key + ' Set')
writer.add_image(key + '/corr_traj', corr_traj_img, epoch + 1)
writer.add_image(key + '/corr_traj (Rot. only)', corr_traj_rot_img,
epoch + 1)
writer.add_image(key + '/est_traj', est_traj_img, epoch + 1)
writer.add_image(key + '/correction_errors', correction_errors,
epoch + 1)
corr_stacked[key] = np.vstack(
(corr_stacked[key], corr.reshape((1, -1, 6))))
est_traj_stacked[key] = np.vstack(
(est_traj_stacked[key], corr_traj_rot.reshape((1, -1, 4, 4))))
# losses_stacked = np.vstack((losses_stacked, loss_per_img_pair.reshape((1,-1))))
corr_pose_change_vecs_stacked[key] = np.vstack(
(corr_pose_change_vecs_stacked[key],
corr_pose_change_vec.reshape((1, -1, 6))))
results[key] = {
'val_seq': args.val_seq,
'test_seq': args.test_seq,
'epochs': epoch + 1,
'est_traj': est_traj_stacked[key],
'corrections': corr_stacked[key],
'est_traj_reconstruction_loss': losses_stacked[key],
'corr_pose_vecs': corr_pose_change_vecs_stacked[key],
'odom_pose_vecs': odom_pose_change_vec,
'gt_traj': gt_traj,
}
if args.save_results and config['mode'] == 'online':
os.makedirs('results/online-mode/{}'.format(config['date']),
exist_ok=True)
if config['estimator_type'] == 'mono':
_, num_loop_closure, _ = find_loop_closures(
corr_traj, cum_dist)
if config['estimator_type'] == 'stereo':
_, num_loop_closure, _ = find_loop_closures(
corr_traj_rot, cum_dist)
print("{} Loop Closures detected".format(num_loop_closure))
##Save the best models
if val_loss < best_val_loss[key]:
best_val_loss[key] = val_loss
best_loss_epoch[key] = epoch
state_dict_loss = model.state_dict()
print("Lowest validation loss (saving model)")
if key == 'val':
torch.save(
state_dict_loss,
'results/online-mode/{}/{}-best-loss-val_seq-{}-test_seq-{}.pth'
.format(config['date'], ts, args.val_seq[0],
args.test_seq[0]))
if rot_seg_err < best_rot_seg_err[key]:
best_rot_seg_err[key] = rot_seg_err
best_rot_acc_epoch[key] = epoch
state_dict_acc = model.state_dict()
print("Lowest error (saving model)")
if key == 'val':
torch.save(
state_dict_acc,
'results/online-mode/{}/{}-best_rot_acc-val_seq-{}-test_seq-{}.pth'
.format(config['date'], ts, args.val_seq[0],
args.test_seq[0]))
if trans_err < best_trans_err[key]:
best_trans_err[key] = trans_err
best_trans_acc_epoch[key] = epoch
state_dict_trans = model.state_dict()
print("Lowest position error (saving model)")
if key == 'val':
torch.save(
state_dict_trans,
'results/online-mode/{}/{}-best_trans_acc-val_seq-{}-test_seq-{}.pth'
.format(config['date'], ts, args.val_seq[0],
args.test_seq[0]))
if num_loop_closure >= most_loop_closure[key]:
most_loop_closure[key] = num_loop_closure
most_loop_closure_epoch[key] = epoch
state_dict_loop_closure = model.state_dict()
print("Most Loop Closures detected ({})".format(
most_loop_closure[key]))
if key == 'val':
torch.save(
state_dict_loop_closure,
'results/online-mode/{}/{}-most_loop_closures-val_seq-{}-test_seq-{}.pth'
.format(config['date'], ts, args.val_seq[0],
args.test_seq[0]))
results[key]['best_rot_acc_epoch'] = best_rot_acc_epoch[key]
results[key]['best_trans_acc_epoch'] = best_trans_acc_epoch[
key]
results[key]['best_loss_epoch'] = best_loss_epoch[key]
results[key][
'best_loop_closure_epoch'] = most_loop_closure_epoch[key]
sio.savemat(
'results/online-mode/{}/{}-results-val_seq-{}-test_seq-{}'.
format(config['date'], ts, args.val_seq[0],
args.test_seq[0]), results)
f = open(
"results/online-mode/{}/{}-config.txt".format(
config['date'], ts), "w")
f.write(str(config))
f.close()
if config['mode'] == 'offline':
os.makedirs('results/offline-mode/{}'.format(config['date']),
exist_ok=True)
sio.savemat(
'results/offline-mode/{}/{}-results-val_seq-{}-test_seq-{}'.format(
config['date'], ts, args.val_seq[0], args.test_seq[0]),
results)
torch.save(
model.state_dict(),
'results/offline-mode/{}/{}-val_seq-{}-test_seq-{}.pth'.format(
config['date'], ts, args.val_seq[0], args.test_seq[0]))
duration = timeSince(start)
print("Training complete (duration: {})".format(duration))
from validate import Validate
if __name__ == '__main__':
Validate().detect_all()
#
# bikeshare.py - program to interactively explore bike share data across
# three U.S. cities.
#
from csv_data import CsvData
from data_stats import DataStats
from validate import Validate
from pretty_print import PrettyPrint
import bikeshare_functions as bike_funs
# Init all objects
print("Initializing program. Please wait.\n")
bikeshare_data = CsvData()
bikeshare_stats = DataStats(bikeshare_data.get_data())
validator = Validate()
pprint = PrettyPrint()
# Main loop
city_names = bikeshare_data.get_city_names()
# Intro
print("Hello. Let's explore some bike share data.")
while True:
# Get filter options
filter_options = bike_funs.get_filter_options(validator, city_names)
# Calculate stats
all_stats = bike_funs.calculate_stats(bikeshare_stats, filter_options)
url = get_URL()
profile = {}
if (url != ''):
profile = fs.scraping(url)
else:
profile["name"] = get_name()
get_information(profile)
view.clear()
view.show_info(profile)
finish = False
t = Combinations(profile)
info = t.info
op = menu('')
while (not finish):
if (op == '1'):
wg(info, profile)
message = 'Your wordlist is ready, the file is wordlist.txt'
op = menu(message)
elif (op == '2'):
Validate(info)
op = menu('')
else:
try:
os.remove("wordlist.txt")
except Exception:
finish = True
