def get_users_priv_cubes():
user = generate_user()
cube = generate_cube()
info = generate_info()
r = remote(*ADDR)
register(r, user, cube, info)
users_list = list_users(r)
priv_cubes = {}
base_cube_inversed = Cube().move("U R' U' F'")
for server_user in users_list:
if server_user == user:
continue
server_user_pub_cube = get_users_pub_cube(r, server_user)
priv_cubes[server_user] = [
Cube(server_user_pub_cube).multiply(base_cube_inversed.pow(i))
for i in range(7)
]
_exit(r)
r.close()
return priv_cubes
def test_register_already_registered_user(app):
"""Ensure a new user cannot be registered if name already taken."""
# ensure db is empty to start width
assert len(User.query.all()) == 0
assert len(Log.query.all()) == 0
testUser = ['John', 'Doe', 'jdoe', 'password']
with app.test_client() as client:
# register a user
register(client, *testUser)
assert len(User.query.all()) == 1
assert len(Log.query.all()) == 0
# try to register again
response = register(client, *testUser)
data = json.loads(response.data.decode())
assert data['status'] == 'fail'
assert data['message'] != 'Successfully registered.'
assert not data.get('access_token')
assert response.content_type == 'application/json'
assert response.status_code == 417
assert data['error'] == f'User name "{testUser[2]}" is already taken.'
assert len(User.query.all()) == 1
assert len(Log.query.all()) == 0
def register():
if request.method == "GET":
return render_template("register.html", link="/login", state="Login")
else:
uname = request.form['username']
pword = request.form['password']
button = request.form['button']
age = request.form['age']
gender = request.form['gender']
if button == "cancel":
return render_template("register.html",
link="/login",
state="Login")
if utils.validuname(uname):
error = "Username already exists. Please try again."
return render_template("register.html", err=error)
if uname == "" or pword == "" or age == "" or gender == "":
error = "All fields must be filled in. Please try again."
return render_template("register.html",
err=error,
link="/login",
state="Login")
else:
utils.register(uname, pword, age, gender)
return render_template("login.html", link="/login", state="Login")
def req_data(self, seq, param, session): # request and parse data
utils.register(**param)
# return {'status':1}
print('register success')
send_data = Send_Data()
send_data.run() #transfer data
return {'status': 1}
def facebook_authorized(resp):
next_url = request.args.get('next') or url_for('home')
if resp is None or 'access_token' not in resp:
return redirect(next_url)
session['logged_in'] = True
session['facebook_token'] = (resp['access_token'], '')
data = facebook.get('/me').data
url = ""
username = data['name']
url = data['id']
session['username'] = username
utils.register(session['username'],url)
return redirect(next_url)
def register():
username = request.form.get('user')
password = request.form.get('pwd')
sex = request.form.get('sex')
age = request.form.get('age')
phone = request.form.get('phone')
email = request.form.get('email')
num = utils.register(username, password)
print num
if num == 1:
res = {'code': 0, 'msg': ''}
res['code'] = 1
res['msg'] = "username is already "
return render_template('zhuc.html', res=res)
elif num == 2:
res = {'code': 0, 'msg': ''}
res['code'] = 1
res['msg'] = "password < 6 "
return render_template('zhuc.html', res=res)
else:
sex = int(sex)
age = int(age)
phone = int(phone)
role = 0
a = utils.inster_db(username, password, sex, age, phone, email, role)
if a == 0:
res = {'code': 0, 'msg': ''}
res['msg'] = "reguster is ok "
return render_template('login.html', res=res)
def register():
if request.method == "GET":
return render_template("register.html")
error = utils.register(request.form["username"], request.form["password"])
if not error:
session["username"] = request.form["username"]
return redirect("/")
else:
return fail("register", error)
def register():
if request.method == "GET":
return render_template("register.html")
error = utils.register(request.form["username"], request.form["password"])
if not error:
session["username"] = request.form["username"]
return redirect("/")
else:
return fail("register", error)
def register():
params = request.get_json()
_auth = params['auth_token']
decoded = jwt.decode(_auth, verify=False)
company = decoded['company']
response = utils.register(company)
print('Inside register')
print(response)
#return _auth
return json.dumps(response)
def user_register():
user_info = request.get_json(force=True)
if not 'username' in user_info or not 'password' in user_info or not 'email' in user_info:
return render_template('json.html',
content=jsonify({
"result": False,
"msg": "Missing parameters"
}))
return render_template('json.html',
content=jsonify(utils.register(user_info)))
def get_users_data():
user = generate_user()
cube = generate_cube()
info = generate_info()
r = remote(*ADDR)
register(r, user, cube, info)
users_list = list_users(r)
ciphercubes = {}
for server_user in users_list:
server_ciphercubes = get_users_ciphercubes(r, server_user)
if server_ciphercubes is None:
continue
server_ciphercubes = [tuple(map(Cube.from_str, x)) for x in loads(b64decode(server_ciphercubes.decode()))]
server_pub_cube = get_users_pub_cube(r, server_user)
ciphercubes[server_user] = server_pub_cube, server_ciphercubes
return ciphercubes
def register():
if request.method == "GET":
return render_template("register.html", link = "/login", state = "Login")
else:
uname = request.form['username']
pword = request.form['password']
button = request.form['button']
age = request.form['age']
gender = request.form['gender']
if button == "cancel":
return render_template("register.html", link = "/login", state = "Login")
if utils.validuname(uname):
error = "Username already exists. Please try again."
return render_template("register.html", err = error)
if uname == "" or pword == "" or age == "" or gender == "":
error = "All fields must be filled in. Please try again."
return render_template("register.html", err = error, link = "/login", state = "Login")
else:
utils.register(uname, pword, age, gender)
return render_template("login.html", link = "/login", state = "Login")
def __init__(self, tgsname, realm, kdcfile):
"""Initializes the Authentication server protocol with a name, realm, and KDC db file"""
self.clients = {}
self.session = CreateAndGetSession(kdcfile)
try:
tgs = self.session.query(KDC).filter_by(id=1).one()
except:
tgs = register(kdcfile, tgsname, Random.new().read(32), realm)
if tgs.name != tgsname or tgs.realm != realm or tgs.id != 1:
raise Exception("TGS must be id 1 and match the name and realm the server was constructed with")
self.tgs = tgs
def register():
if request.method == 'POST':
data = {k: v[0] for k, v in dict(request.form).items()}
res = utils.register(data)
if res['code'] == 0:
return redirect('/login/')
elif res['code'] == 1:
return render_template('register.html', res=res)
else:
res = {'msg': ''}
return render_template("register.html", res=res)
def register():
if (request.method == "GET"):
return render_template("register.html")
username, password = (request.form["username"].encode("utf8"), request.form["password"].encode("utf8"))
if (!username or !password):
return render_template("register.html", error="empty")
error = utils.register(request.form["username"], request.form["password"])
if (error == "exists"):
return render_template("register.html", error="taken")
db[username.lower()] = password
session["username"] = username
return redirect("/")
def register():
if request.method == "GET":
return render_template("register.html")
elif not utils.loggedIn():
username = request.form["username"]
if utils.register(username, "none"):
session["username"] = username
return redirect(url_for("home"))
else:
return error()
else:
return redirect(url_for("home"))
def test_login_registered_user(app):
"""Ensure a registered user can log in."""
# ensure db is empty to start width
assert len(User.query.all()) == 0
assert len(Log.query.all()) == 0
testUser = ['John', 'Doe', 'jdoe', 'password']
with app.test_client() as client:
register(client, *testUser)
response = login(client, *testUser[2:])
data = json.loads(response.data.decode())
assert data['status'] == 'success'
assert data['message'] == 'Successfully logged in.'
assert data.get('access_token')
assert response.content_type == 'application/json'
assert response.status_code == 202
assert not data['error']
assert len(User.query.all()) == 1
assert len(Log.query.all()) == 1
def register():
if request.method == "GET": # What people see when they click "Login"
if 'user' in session and session['user']:
print session['user']
return redirect("/home")
return render_template("register.html")
else:
form = request.form.copy().to_dict()
username = form['username'] or ""
password = form['password'] or ""
confmpwd = form['confmpwd'] or ""
if utils.register(username, password, confmpwd):
session['user'] = username
return 'success'
return 'fail'
def register():
if request.method == "GET":
return render_template("register.html")
elif request.form['button'] == "Cancel":
return redirect(url_for('login'))
else:
username = request.form["username"].encode("ascii","ignore")
password = request.form["password"].encode("ascii","ignore")
x = utils.register(username, password)
if x == 0:
return render_template("register.html",error="Username must be at least 4 characters.")
if x == 1:
return render_template("register.html",error="Password must be at least 6 characters.")
if x == 2:
return render_template("register.html",error="This username already exists.")
session["username"] = username
return redirect("/")
def register():
if request.method == "GET":
return render_template("register.html")
elif not utils.loggedIn():
username = request.form["username"]
password = request.form["password"]
passRetype = request.form["passRetype"]
security = request.form["security"]
answer = request.form["answer"]
if utils.register(username, password, passRetype, security, answer):
return redirect(url_for("home"))
else:
return error()
else:
return redirect(url_for("home"))
def register():
if request.method == "GET":
if 'username' in session:
return render_template("register.html",username = session["username"])
else:
return render_template("register.html")
else:
username = request.form["username"].encode("ascii", "ignore")
password = request.form["password"].encode("ascii", "ignore")
confirmpassword = request.form["cpassword"].encode("ascii", "ignore")
if password == confirmpassword:
if utils.register(username, password):
return redirect("/login")
else:
return redirect("/register")
else:
return render_template("register.html")
def register():
if "username" in session:
return redirect(url_for("/"))
if request.method == "GET":
return render_template("register.html")
elif "username" not in session:
firstname = request.form["first"]
lastname = request.form["last"]
username = request.form["username"]
password = request.form["password"]
email = request.form["email"]
if utils.register(username, password, firstname, lastname, email):
session["username"] = username
return redirect(url_for("profile"))
else:
return redirect(url_for("register"))
else:
return redirect(url_for("register"))
def register():
if "username" in session:
return redirect(url_for("search"))
if request.method == "GET":
return render_template("register.html")
if "username" not in session:
username = request.form["username"]
password = request.form["password"]
confirm = request.form["confirm"]
securityq = request.form["securityq"]
securitya = request.form["securitya"]
if utils.register(username, password, confirm, securityq, securitya):
session["username"] = username
return redirect(url_for("search"))
else:
return redirect(url_for("register"))
else:
return redirect(url_for("search"))
def register():
if request.method == 'POST':
if request.form['type'] == 'signup':
username, userpwd = request.form['username'], request.form[
'password']
user = utils.register(username, userpwd, 20, 'China')
if user and user.name:
return json.dumps({
"result": 1,
"msg": "Register Succeed!",
"content": {
"username": username
}
})
else:
return json.dumps({
"result": -1,
"error": "invalid username or password"
})
elif request.form['type'] == 'signin':
username, userpwd = request.form['account'], request.form[
'password']
user = utils.login(username, userpwd)
if user and user.name:
global curr_user
curr_user = user
login_succeed = True
else:
login_succeed = False
if login_succeed:
return json.dumps({
"result": 1,
"msg": "Login Succeed!",
"content": {
"username": username
}
})
else:
return json.dumps({
"result": -1,
"msg": "Username or password wrong!",
"content": {}
})
def test_register_user(app):
"""Ensure a new user can be added to the database."""
# ensure db is empty to start width
assert len(User.query.all()) == 0
assert len(Log.query.all()) == 0
testUser = ['John', 'Doe', 'jdoe', 'password']
with app.test_client() as client:
response = register(client, *testUser)
data = json.loads(response.data.decode())
assert data['status'] == 'success'
assert data['message'] == 'Successfully registered.'
assert not data.get('access_token')
assert response.content_type == 'application/json'
assert response.status_code == 201
assert not data['error']
assert len(User.query.all()) == 1
assert len(Log.query.all()) == 0 # no log should be written
def post(self):
'''This function handles the signup form and vlidates user input.'''
username = self.request.get('username')
password = self.request.get('password')
verify = self.request.get('verify')
email = self.request.get('email')
# check the input and return dict of errors
errors = validate(username, password, verify, email)
if len(errors) != 0:
self.render_response(self.tempate, params=None, **errors)
else:
u = register(username, password, email)
u.put()
self.login(u)
self.redirect_to('home')
def register():
if request.method == "GET":
return render_template("register.html")
elif request.form['button'] == "Cancel":
return redirect(url_for('login'))
else:
username = request.form["username"].encode("ascii", "ignore")
password = request.form["password"].encode("ascii", "ignore")
x = utils.register(username, password)
if x == 0:
return render_template(
"register.html",
error="Username must be at least 4 characters.")
if x == 1:
return render_template(
"register.html",
error="Password must be at least 6 characters.")
if x == 2:
return render_template("register.html",
error="This username already exists.")
session["username"] = username
return redirect("/")
def register():
if request.method=="GET":
return render_template("register.html")
username = request.form['name']
password = request.form['password']
confirmPW = request.form['confirm']
nickname = request.form['nickname']
#print username
#print password
#print confirmPW
#print nickname
if not username or not password or not confirmPW: #not all of the fields are filled
#print "Please fill in all of the fields."
return render_template("register.html", message = "Please fill in all of the fields.")
elif password != confirmPW: #if the two pw's don't match
#print "Your passwords do not match."
return render_template("register.html", message = "Your passwords do not match.")
elif utils.register(username, password, nickname): #if username is taken
session["username"] = username
print "success!"
return redirect("/") #send user back home
else:
#print "Username already taken. Please find another."
return render_template("register.html", message = "Username already taken.")
def register():
FileManager.register()
Properties.register()
Types.register()
utils.register()
def val(model, val_data, config, epoch, best_acc, best_sen, best_val_epoch,
best_model_state_dict, ret_dict, data_name, num_fold):
with torch.no_grad():
model.eval()
score_list = []
comatrix_list = []
i = 0
for val_batch in tqdm(val_data):
val_batch['ct_mask'] = val_batch['ct_mask'].cuda()
val_batch['CTs'] = val_batch['CTs'].cuda()
score, _ = model(val_batch)
confusion_matrix = meter.ConfusionMeter(config.num_classes)
confusion_matrix.add(score.detach().cpu(),
val_batch['labels'].cpu())
comatrix_list.append(confusion_matrix.value())
if i == 0:
scores = score.detach().cpu()
labels = val_batch['labels'].cpu()
else:
scores = torch.cat((scores, score.detach().cpu()), axis=0)
labels = torch.cat((labels, val_batch['labels'].cpu()), axis=0)
i += 1
model.train()
cm_all = np.array(comatrix_list).sum(axis=0)
print('Epoch ', epoch + 1)
print('%s confusion matrix: ' % (data_name))
print(cm_all)
acc_epoch = (float(cm_all[0, 0]) + float(cm_all[1, 1])) / cm_all.sum()
spec_epoch = float(cm_all[0, 0]) / (
cm_all[0, 0] + cm_all[0, 1]) # TN：val_cm[0, 0], FP：val_cm[0, 1],
sen_epoch = float(cm_all[1, 1]) / (
cm_all[1, 0] + cm_all[1, 1]) # FN：val_cm[1, 0], TP：val_cm[1, 1]
precision_epoch = float(cm_all[1, 1]) / (cm_all[0, 1] + cm_all[1, 1])
print('%s accuracy: %.3f' % (data_name, acc_epoch))
print('%s sensitivity: %.3f' % (data_name, sen_epoch))
print('%s specificity: %.3f' % (data_name, spec_epoch))
print('%s precision: %.3f' % (data_name, precision_epoch))
if acc_epoch >= best_acc and data_name == 'val':
best_model_state_dict = deepcopy(model.state_dict())
best_acc = acc_epoch
best_sen = sen_epoch
best_val_epoch = epoch
ret_dict['sens'] = sen_epoch
ret_dict['specs'] = spec_epoch
ret_dict['accs'] = best_acc
ret_dict['precisions'] = precision_epoch
ret_dict['preds'] = scores.detach().cpu().numpy()
ret_dict['labels'] = labels.cpu().numpy()
# save model
root = './checkpoints/%s/fold%d' % (check_dir, num_fold)
if not os.path.exists(root):
os.mkdir(root)
torch.save(best_model_state_dict, '%s/acc%.3f-sen%.3f@epoch%d.pth' % \
(root, best_acc,best_sen,best_val_epoch+1))
# save config
with open('checkpoints/%s/config.pickle' % check_dir, 'wb') as fp:
pickle.dump(config, fp)
# save result
res_path = './res/%s/fold%d' % (check_dir, num_fold)
if not os.path.exists(res_path):
os.mkdir(res_path)
saved_val = register(
dump_file='./res/%s/fold%d/val_dataset1_acc%.3f-sen%.3f.pickle'
% (check_dir, num_fold, best_acc, best_sen))
saved_val.regis(ret_dict)
saved_val.dump()
return best_model_state_dict, best_acc, best_sen, best_val_epoch, ret_dict
# Tue Apr 30 01:26:14 PDT 2019
import utils as u
import asyncio
import json
import aiochan as ac
import requests
import sys
# get logger and register with utils
log = u.register("state_hub")
# define vars
ws = None
http_thread = None
port = 9003
http_port = 9005
task_library = {}
remote_port = 9004
# remote interface to run state_hub tasks
def run_task(id,arg=None) :
log.i("Requesting to run task with id: {}".format(id))
msg = { 'id' : id ,
'arg' : arg }
payload = { 'opts' : json.dumps(msg) }
r = requests.get('http://localhost:{}/run_task'.format(remote_port), params=payload)
log.i("Got result: {}".format(r.text))
return r.json()
def register_task(id,transition,se, info=None) :
global task_library
def test(model, train_class0_dataloader, train_class1_dataloader, test_dataloader, config, epoch, best_acc, best_sen, best_val_epoch, best_model_state_dict, ret_dict, num_fold):
comatrix_list=[]
ret_dict = {'accs': -1, 'sens':-1, 'specs':-1, 'precisions':-1, 'preds':None, 'labels':None}
support_data = {'labels': -1, 'data':-1, 'order':-1, 'domain':-1, 'CTs':-1, 'ct_mask':-1}
data_name = 'dataset3'
with torch.no_grad():
model.eval()
compute_class_score.eval()
data_zip = enumerate(zip(train_class0_dataloader, train_class1_dataloader))
for step, (data_class0, data_class1) in data_zip:
for key in data_class0.keys():
support_data[key] = torch.cat((data_class0[key], data_class1[key]), 0)
support_class = support_data['labels']
support_data['ct_mask'] = support_data['ct_mask'].cuda()
support_data['CTs'] = support_data['CTs'].cuda()
_, support_embed = model(support_data)
class_avg_vectors = compute_class_vector(support_embed, support_class, config.num_classes)
i = 0
for test_data in tqdm(test_dataloader):
class_test = test_data['labels']
test_data['ct_mask'] = test_data['ct_mask'].cuda()
test_data['CTs'] = test_data['CTs'].cuda()
_, test_embed = model(test_data)
class_score, test_tau = compute_class_score(class_avg_vectors[0].unsqueeze(0).repeat(test_embed.shape[0],1), class_avg_vectors[1].unsqueeze(0).repeat(test_embed.shape[0],1), test_embed)
confusion_matrix = meter.ConfusionMeter(config.num_classes)
confusion_matrix.add(class_score.detach().cpu(), class_test.cpu())
comatrix_list.append(confusion_matrix.value())
if i == 0:
scores = class_score
labels = class_test
else:
scores = torch.cat((scores,class_score),axis=0)
labels = torch.cat((labels,class_test),axis=0)
i = i+1
model.train()
compute_class_score.train()
print('Epoch ', epoch+1)
cm_all = np.array(comatrix_list).sum(axis=0)
print('Test confusion matrix on %s: ' % (data_name))
print(cm_all)
acc_epoch = (float(cm_all[0, 0])+float(cm_all[1, 1]))/cm_all.sum()
spec_epoch = float(cm_all[0, 0]) / (cm_all[0, 0] + cm_all[0, 1]) # TN：val_cm[0, 0], FP：val_cm[0, 1],
sen_epoch = float(cm_all[1, 1]) / (cm_all[1, 0] + cm_all[1, 1]) # FN：val_cm[1, 0], TP：val_cm[1, 1]
precision_epoch = float(cm_all[1, 1]) / (cm_all[0, 1] + cm_all[1, 1])
ret_dict['sens'] = sen_epoch
ret_dict['specs'] = spec_epoch
ret_dict['accs'] = acc_epoch
ret_dict['precisions'] = precision_epoch
ret_dict['preds'] = scores.detach().cpu().numpy()
ret_dict['labels'] = labels.cpu().numpy()
print('Test accuracy on %s: %.3f' % (data_name, acc_epoch))
print('Test sensitivity on %s: %.3f' % (data_name, sen_epoch))
print('Test specificity on %s: %.3f' % (data_name, spec_epoch))
print('Test precisionon on %s: %.3f' % (data_name, precision_epoch))
if acc_epoch>=best_acc:
best_model_state_dict = deepcopy(model.state_dict())
best_acc=acc_epoch
best_sen=sen_epoch
best_val_epoch=epoch
ret_dict['sens'] = sen_epoch
ret_dict['specs'] = spec_epoch
ret_dict['accs'] = best_acc
ret_dict['precisions'] = precision_epoch
ret_dict['preds'] = scores.detach().cpu().numpy()
ret_dict['labels'] = labels.cpu().numpy()
# save model
root = './checkpoints/%s/%d' % (check_dir, num_fold)
if not os.path.exists(root):
os.mkdir(root)
torch.save(best_model_state_dict, '%s/acc%.3f_sen%.3f@epoch%d.pth' % \
(root, best_acc,best_sen,epoch+1))
# save config
with open('checkpoints/%s/config.pickle' % check_dir, 'wb') as fp:
pickle.dump(config, fp)
saved_val = register(dump_file='./res/'+check_dir+'/acc%.3f-sen%.3f@epoch%d.pickle' % \
(best_acc, best_sen, epoch+1))
saved_val.regis(ret_dict)
saved_val.dump()
return best_model_state_dict, best_acc, best_sen, best_val_epoch, ret_dict
def req_data(self, seq, param, session): # request and parse data
utils.register(**param)
transfer = Transfer()
res_data = transfer.run() #transfer data
print('success')
return res_data
