def test_login_token_expired(test_app, dummy_user):
email_address = dummy_user.email_address
_, user_id = save(dummy_user)
token = '123456'
token_hash, token_salt = hash_plaintext(token)
recovery_token = RecoveryToken(
for_user_id=user_id,
token_hash=token_hash,
token_salt=token_salt,
expires_on=datetime.datetime.utcnow() - datetime.timedelta(hours=1)
)
_, recovery_token_id = save(recovery_token)
data = {
'email_address': email_address,
'token': token
}
response = test_app.post_json('/auth/recover-account/login', data,
expect_errors=True)
unaltered_recovery_token = get_recovery_token_by_id(recovery_token_id)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert not response.headers.get('Set-Cookie')
assert not unaltered_recovery_token.used
assert response.json == {
'message': {
'token': [INVALID_CREDENTIALS_ERROR]
}
}
def test_patch_user_reset_password(test_app_with_authenticated_user_id):
test_app, user_id = test_app_with_authenticated_user_id
recovery_token = RecoveryToken(
for_user_id=user_id,
token_hash='fake',
token_salt='fake',
used=True
)
save(recovery_token)
data = {
'password': '******'
}
response = test_app.patch_json('/user/me', data)
updated_user = get_user_by_id(user_id)
assert response.status_code == HTTPStatus.OK
assert updated_user.active_recovery_token is None
assert not compare_plaintext_to_hash(
'testing123',
updated_user.password_hash,
updated_user.password_salt
)
def test_login_token_expired(dummy_request, dummy_user):
email_address = dummy_user.email_address
_, user_id = save(dummy_user)
token = '123456'
token_hash, token_salt = hash_plaintext(token)
recovery_token = RecoveryToken(
for_user_id=user_id,
token_hash=token_hash,
token_salt=token_salt,
expires_on=datetime.datetime.utcnow() - datetime.timedelta(hours=1)
)
_, recovery_token_id = save(recovery_token)
data = {
'email_address': email_address,
'token': token
}
auth_manager = AuthWithRecoveryTokenManager(dummy_request)
with pytest.raises(HTTPBadRequest) as bad_request:
auth_manager.login(data)
unaltered_recovery_token = get_recovery_token_by_id(recovery_token_id)
assert not unaltered_recovery_token.used
assert bad_request.value.json == {
'message': {
'token': [auth_manager.invalid_credentials_error]
}
}
def login(self, login_data: dict):
super().login(login_data)
user = get_user_by_email_address(login_data['email_address'])
user.active_recovery_token.used = True
user.set_verified()
save(user)
def test_login_token_incorrect(dummy_request, dummy_user):
email_address = dummy_user.email_address
_, user_id = save(dummy_user)
token_hash, token_salt = hash_plaintext('123456')
recovery_token = RecoveryToken(
for_user_id=user_id,
token_hash=token_hash,
token_salt=token_salt
)
_, recovery_token_id = save(recovery_token)
data = {
'email_address': email_address,
'token': 'wrong1'
}
auth_manager = AuthWithRecoveryTokenManager(dummy_request)
with pytest.raises(HTTPBadRequest) as bad_request:
auth_manager.login(data)
unaltered_recovery_token = get_recovery_token_by_id(recovery_token_id)
assert not unaltered_recovery_token.used
assert bad_request.value.json == {
'message': {
'token': [auth_manager.invalid_credentials_error]
}
}
def train(numEpochs, trainLoader, model, optimizer, criterion, inp_dim,
batchSize, use_cuda, devLoader, devbatchSize):
for epoch in range(numEpochs):
loss = trainEpoch(epoch, 20000000, trainLoader, model, optimizer,
criterion, inp_dim, batchSize, use_cuda, devLoader,
devbatchSize)
dev_loss = 0
n_correct = 0
n_total = 0
for idx, (dev_data, dev_target) in enumerate(devLoader):
sd1, sd2 = dev_data
# pdb.set_trace()
devbatchSize, _ = sd1.shape
sd1 = sd1.transpose(0, 1).contiguous().view(
-1, inp_dim, devbatchSize).transpose(1, 2)
sd2 = sd2.transpose(0, 1).contiguous().view(
-1, inp_dim, devbatchSize).transpose(1, 2)
if (use_cuda):
sd1, sd2, dev_target = Variable(sd1.cuda()), Variable(
sd2.cuda()), Variable(dev_target.cuda())
else:
sd1, sd2, dev_target = Variable(sd1), Variable(sd2), Variable(
dev_target)
dev_output = model(sd1, sd2)
dev_loss += criterion(dev_output, dev_target)
n_correct += (torch.max(dev_output, 1)[1].view(
dev_target.size()) == dev_target).sum()
n_total += devbatchSize
dev_acc = (100. * n_correct.data[0]) / n_total
print('Epoch: {} - Dev Accuracy: {}'.format(epoch, dev_acc))
save(model, optimizer, loss, 'quoraTrainedEpoch.pth', dev_loss,
dev_acc)
def in_pause_menu(self):
self.current_menu = pause_menu
self.draw_menu()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
elif event.type == pygame.KEYUP:
key = event.key
if key == K_1 or key == K_ESCAPE:
return 'in_game'
elif key == K_2:
file_name = input("save file name: ")
save(file_name, self.current_board)
print("done!")
elif key == K_3:
file_name = input("load file name: ")
board = load(file_name)
if board:
print("done")
self.current_board = board
return 'in_pause_menu'
else:
print('error loading file')
elif key == K_4:
return 'in_main_menu'
def test_save_load_work(self):
board1 = Board(level_difficulty=5, random_levels=False)
save('test_file', board1)
board2 = load('test_file')
self.assertEqual(pickle.dumps(board1), pickle.dumps(board2))
self.assertIsNone(load('no_such_file_i_hope_:)'))
def test_save_rollback(mocker, db_session, dummy_user):
mocker.patch('{{cookiecutter.project_slug}}.models.persist', side_effect=Exception('test'))
with pytest.raises(Exception):
save(dummy_user)
user = db_session.query(User).get(dummy_user.id)
assert user is None
def request_verification_token(self):
validate({}, VerifyUserSchema(self.context))
self._invalidate_any_current_verification_token(self.context)
self.context.active_verification_token = self._send_verification_token(
self.context)
save(self.context)
raise HTTPCreated
def _save_recovery_token(for_user: User, token: str):
token_hash, token_salt = hash_plaintext(token)
recovery_token = RecoveryToken(
token_hash=token_hash,
token_salt=token_salt,
for_user=for_user
)
save(recovery_token)
def trainEpoch(epoch, break_val, trainLoader, model, optimizer, criterion,
inp_dim, batchSize, use_cuda, devLoader, devbatchSize):
print("Epoch start - ", epoch)
for batch_idx, (data, target) in enumerate(trainLoader):
#pdb.set_trace()
s1, s2 = data
batchSize, _ = s1.shape
s1 = s1.transpose(0, 1).contiguous().view(-1, inp_dim,
batchSize).transpose(1, 2)
s2 = s2.transpose(0, 1).contiguous().view(-1, inp_dim,
batchSize).transpose(1, 2)
if (use_cuda):
s1, s2, target = Variable(s1.cuda()), Variable(
s2.cuda()), Variable(target.cuda())
else:
s1, s2, target = Variable(s1), Variable(s2), Variable(target)
optimizer.zero_grad()
output = model(s1, s2)
# pdb.set_trace()
loss = criterion(output, target)
loss.backward()
optimizer.step()
if batch_idx == break_val:
return
if batch_idx % 100 == 0:
dev_loss = 0
n_correct = 0
n_total = 0
for idx, (dev_data, dev_target) in enumerate(devLoader):
sd1, sd2 = dev_data
# pdb.set_trace()
devbatchSize, _ = sd1.shape
sd1 = sd1.transpose(0, 1).contiguous().view(
-1, inp_dim, devbatchSize).transpose(1, 2)
sd2 = sd2.transpose(0, 1).contiguous().view(
-1, inp_dim, devbatchSize).transpose(1, 2)
if (use_cuda):
sd1, sd2, dev_target = Variable(sd1.cuda()), Variable(
sd2.cuda()), Variable(dev_target.cuda())
else:
sd1, sd2, dev_target = Variable(sd1), Variable(
sd2), Variable(dev_target)
dev_output = model(sd1, sd2)
dev_loss += criterion(dev_output, dev_target)
n_correct += (torch.max(dev_output, 1)[1].view(
dev_target.size()) == dev_target).sum()
n_total += devbatchSize
break
dev_acc = (100. * n_correct.data[0]) / n_total
print(
'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tDev Loss: {:.6f}\tDev Acc(1Batch): {:.6f}'
.format(epoch, batch_idx * len(data), len(trainLoader.dataset),
100. * batch_idx / len(trainLoader), loss.data[0],
dev_loss.data[0], dev_acc))
save(model, optimizer, loss, 'quoraTrained.pth', dev_loss, dev_acc)
return loss
def export():
try:
job = request.args.get('job')
if not job:
raise Exception()
jobs = db.get(job)
if not jobs:
raise Exception()
save(jobs, job)
return redirect("/")
except:
return redirect("/")
def test_load_user_email_already_exists(dummy_user):
data = {
'email_address': '{{cookiecutter.test_email_address}}',
'password': '******'
}
save(dummy_user)
with pytest.raises(ValidationError) as validation_error:
UserSchema().load(data)
assert validation_error.value.messages == {
'email_address': ['A user with this email address already exists.']
}
def trainEpoch(epoch, break_val, trainLoader, model, optimizer, criterion,
inp_dim, batchSize, use_cuda, devLoader, devbatchSize):
print("Epoch start - ", epoch)
for batch_idx, (data, target) in enumerate(trainLoader):
#pdb.set_trace()
s1, s2 = data
batchSize, _ = s1.shape
s1 = s1.transpose(0, 1).contiguous().view(-1, inp_dim,
batchSize).transpose(1, 2)
s2 = s2.transpose(0, 1).contiguous().view(-1, inp_dim,
batchSize).transpose(1, 2)
if (use_cuda):
s1, s2, target = Variable(s1.cuda()), Variable(
s2.cuda()), Variable(target.cuda())
else:
s1, s2, target = Variable(s1), Variable(s2), Variable(target)
optimizer.zero_grad()
output = model(s1, s2)
# pdb.set_trace()
loss = criterion(output, target)
loss.backward()
optimizer.step()
# print("loss backward")
if batch_idx == break_val:
return
if batch_idx % 100 == 0:
dev_loss = 0
for idx, (dev_data, dev_target) in enumerate(devLoader):
sd1, sd2 = dev_data
# pdb.set_trace()
devbatchSize, _ = sd1.shape
sd1 = sd1.transpose(0, 1).contiguous().view(
-1, inp_dim, devbatchSize).transpose(1, 2)
sd2 = sd2.transpose(0, 1).contiguous().view(
-1, inp_dim, devbatchSize).transpose(1, 2)
if (use_cuda):
sd1, sd2, dev_target = Variable(sd1.cuda()), Variable(
sd2.cuda()), Variable(dev_target.cuda())
else:
sd1, sd2, dev_target = Variable(sd1), Variable(
sd2), Variable(dev_target)
dev_output = model(sd1, sd2)
dev_loss = criterion(dev_output, dev_target)
break
print(
'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tDev: {:.6f}'.
format(epoch, batch_idx * len(data), len(trainLoader.dataset),
100. * batch_idx / len(trainLoader), loss.data[0],
dev_loss.data[0]))
save(model, optimizer, loss, 'compTrainerNLIonQuora.pth', dev_loss)
def show_result(frame):
global faces
global subjects
global status
global face_encoding_list
face_locations = face_recognition.face_locations(frame,number_of_times_to_upsample=number_of_times_to_upsample)
try:
for face in faces:
face_encoding = face_recognition.face_encodings(face,num_jitters=num_jitters)[0]
face_encoding_list.append(face_encoding)
except IndexError:
print("I wasn't able to locate any faces in at least one of the images. Check the image files. Aborting...")
quit()
print("I found {} face(s) in this photograph.".format(len(face_locations)))
img = frame.copy()
for face_location in face_locations:
# Print the location of each face in this image
top, right, bottom, left = face_location
print("A face is located at pixel location Top: {}, Left: {}, Bottom: {}, Right: {}".format(top, left, bottom, right))
# You can access the actual face itself like this:
face_image = frame[top:bottom, left:right]
face_encoding1 = face_recognition.face_encodings(face_image,num_jitters=num_jitters)
if len(face_encoding1) > 0 :
face_encoding = face_encoding1[0]
results = face_recognition.compare_faces(face_encoding_list, face_encoding , tolerance = tolerance)
if True in results:
index1 = results.index(True)
colour_2 = colour_f(status[index1])
draw_rectangle2(img, (left,top,right,bottom),colour_2)
draw_text(img,subjects[index1] , left, top-5)
print(subjects[index1])
print(status[index1])
else :
print("not found")
draw_rectangle2(img, (left,top,right,bottom),(255,255,255))
draw_text(img,"No Match" ,left, top-5)
else:
draw_rectangle2(img, (left,top,right,bottom),(255,255,255))
draw_text(img,"Error 1" ,left, top-5)
save(frame,"before")
save(img,"after")
cv2.imshow("face_detected",img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def test_post_user_email_already_exists(test_app, dummy_user):
data = {
'email_address': '{{cookiecutter.test_email_address}}',
'password': '******'
}
save(dummy_user)
response = test_app.post_json('/user', data, expect_errors=True)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.json == {
'message': {
'email_address': ['A user with this email address already exists.']
}
}
def test_patch_user_success(test_app_with_authenticated_user_id):
test_app, user_id = test_app_with_authenticated_user_id
token = '123456'
token_hash, token_salt = hash_plaintext(token)
verification_token = VerificationToken(
token_hash=token_hash,
token_salt=token_salt,
for_user_id=user_id
)
_, token_id = save(verification_token)
data = {
'password': '******',
'current_password': '******',
'verification_token': token
}
response = test_app.patch_json('/user/me', data)
updated_user = get_user_by_id(user_id)
updated_verification_token = get_verification_token_by_id(token_id)
assert response.status_code == HTTPStatus.OK
assert not compare_plaintext_to_hash(
'testing123',
updated_user.password_hash,
updated_user.password_salt
)
assert updated_user.verified
assert updated_verification_token.invalidated
assert updated_verification_token.used
def show_result(frame):
global faces
global status
predictions = predict(frame,
model_path="trained_knn_model.clf",
distance_threshold=distance_threshold)
for name, (top, right, bottom, left) in predictions:
print("- Found {} at ({}, {})".format(name, left, top))
# Display results overlaid on an image
save(frame, "before")
frame = show_prediction_labels_on_image(frame, predictions)
save(frame, "after")
cv2.imshow("face_detected", frame)
cv2.waitKey(0)
cv2.destroyAllWindows()
def test_login_wrong_credentials(dummy_request, dummy_user, email_address,
password):
save(dummy_user)
auth_manager = AuthWithPasswordManager(dummy_request)
with pytest.raises(HTTPBadRequest) as bad_request:
auth_manager.login({
'email_address': email_address,
'password': password
})
assert bad_request.value.json == {
'message': {
'password': ["Email address or password incorrect"]
}
}
def test_get_authenticated_user(dummy_user):
_, user_id = save(dummy_user)
mock_request = Mock()
type(mock_request).authenticated_userid = PropertyMock(
return_value=user_id)
assert get_authenticated_user(mock_request).id == user_id
def mainAct(pl):
clear()
choice = pMenu([
'hunt',
'move',
'heal',
'party',
'shop',
'dex',
'bank',
pl.name,
'save',
'leave',
])
if choice == 'hunt':
if not pl.countawake():
clear()
print pl.name + ' is out of usable pokemon!'
xxx = raw_input('\n\npress enter')
else:
hunt(pl)
if choice == 'party':
party(pl)
if choice == pl.name:
clear()
print 'Status\n\n'
print pl.name + ' $' + str(pl.money)
for bt in pl.balls:
if pl.balls[bt] > 0:
print bt + ': ' + str(pl.balls[bt])
print '\n'
raw_input('enter to return')
return 0
if choice == 'shop':
shop(pl)
if choice == 'heal':
heal(pl)
if choice == 'dex':
dexui(pl)
if choice == 'bank':
bank(pl)
if choice == 'save':
save(pl)
if choice == 'leave':
return 1
if choice == 'move':
move(pl)
def test_delete(db_session, dummy_user):
_, dummy_user_id = save(dummy_user)
def get_user():
return db_session.query(User).get(dummy_user_id)
delete(get_user())
assert get_user() is None
def test_get_verification_token_by_id(dummy_user):
verification_token = VerificationToken(
token_hash='fake',
token_salt='fake',
for_user=dummy_user
)
_, token_id = save(verification_token)
assert get_verification_token_by_id(token_id).id == token_id
def test_patch_user_already_verified(test_app_with_authenticated_user_id):
test_app, user_id = test_app_with_authenticated_user_id
user = get_user_by_id(user_id)
user.verified = True
save(user)
data = {
'verification_token': '123456'
}
response = test_app.patch_json('/user/me', data, expect_errors=True)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.json == {
'message': {
'verification_token': ["This user is already verified."]
}
}
def test_get_recovery_token_by_id(dummy_user):
recovery_token = RecoveryToken(
token_hash='fake',
token_salt='fake',
for_user=dummy_user
)
_, recovery_token_id = save(recovery_token)
assert get_recovery_token_by_id(recovery_token_id).id == recovery_token_id
def test_login_success(dummy_request, dummy_user):
user, _ = save(dummy_user)
AuthWithPasswordManager(dummy_request).login({
'email_address': user.email_address,
'password': '******'
})
assert dummy_request.response.status_code == HTTPStatus.OK
assert 'auth_tkt' in dummy_request.response.headers['Set-Cookie']
def test_login_success(test_app, dummy_user):
user, _ = save(dummy_user)
response = test_app.post_json('/auth/login', {
'email_address': user.email_address,
'password': '******'
})
assert response.status_code == HTTPStatus.OK
assert 'auth_tkt' in response.headers['Set-Cookie']
def test_logout_success(dummy_request, dummy_user):
user, user_id = save(dummy_user)
token = '123456'
token_hash, token_salt = hash_plaintext(token)
recovery_token = RecoveryToken(
for_user_id=user_id,
token_hash=token_hash,
token_salt=token_salt
)
save(recovery_token)
auth_manager = AuthWithRecoveryTokenManager(dummy_request)
auth_manager.login({
'email_address': user.email_address,
'token': token
})
auth_manager.logout()
assert 'auth_tkt=;' in dummy_request.response.headers['Set-Cookie']
def test_logout_success(dummy_request, dummy_user):
user, _ = save(dummy_user)
auth_manager = AuthWithPasswordManager(dummy_request)
auth_manager.login({
'email_address': user.email_address,
'password': '******'
})
auth_manager.logout()
assert 'auth_tkt=;' in dummy_request.response.headers['Set-Cookie']
def test_delete_rollback(mocker, db_session, dummy_user):
mocker.patch('{{cookiecutter.project_slug}}.models._delete', side_effect=Exception('test'))
_, dummy_user_id = save(dummy_user)
def get_user():
return db_session.query(User).get(dummy_user_id)
with pytest.raises(Exception):
delete(get_user())
assert get_user() is not None
def test_request_verification_token_already_verified(
test_app_with_authenticated_user_id
):
test_app, user_id = test_app_with_authenticated_user_id
user = get_user_by_id(user_id)
user.verified = True
save(user)
response = test_app.post_json(
'/user/me/request-verification-token',
{},
expect_errors=True
)
assert response.status_code == HTTPStatus.BAD_REQUEST
assert response.json == {
'message': {
'_schema': ["This user is already verified."]
}
}
def in_next_level_menu(self):
self.current_menu = next_level_menu
self.draw_menu()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
elif event.type == pygame.KEYUP:
key = event.key
if key == K_1 or key == K_ESCAPE:
self.current_board = Board(
self.current_board.level_difficulty + 1,
self.current_board.random_levels)
return 'in_game'
elif key == K_2:
file_name = input("save file name: ")
save(file_name, self.current_board)
print("done!")
elif key == K_3:
return 'in_main_menu'
def saveAs():
global fileParams, fileTxt, filesExistent
# FIRST CREATES THE FILES
filePathAndName = tkFileDialog.asksaveasfile(mode='w', defaultextension=".params")
if filePathAndName:
# Extracting the path and name
pathFiles, fileParams = os.path.split(filePathAndName.name)
fileName, _ = os.path.splitext(fileParams)
# Create Files name strings
fileTxt = pathFiles+"/"+fileName+".txt"
fileParams = pathFiles+"/"+fileName+".params"
# Create aditional txt file
createTxt(fileTxt)
# if the network is already trained, save the info
if 'network' in globals() and 'parameters' in globals() :
save()
else:
print "Files succesfully created"
filesExistent = True