def wrapper(*args, **kwargs):
try:
return func(*args[:-1] if len(args) > 1 else args, **kwargs)
except Exception as e:
print(traceback.format_exc())
self: GameList = args[0]
utils.show_error(text=str(e))
def sync(self, name, addr, rpc_port, stream_port):
if self.value != None:
self.close()
try:
value = krpc.connect(name=name,
address=addr,
rpc_port=rpc_port,
stream_port=stream_port)
self.value = value
self.name = name
self.addr = addr
self.rpc_port = rpc_port
self.stream_port = stream_port
self.connected = True
self.synced.emit()
show_info(
"Connection established.", "Successfully\
connected to %s." % addr, "Connected to %s as %s\
with rpc and stream ports respectively %s and %s" %
(addr, name, rpc_port, stream_port))
except (socket_error) as serr:
if serr.errno == errno.ECONNREFUSED:
show_error("Connection refused.", None, None)
else:
raise serr
except krpc.error.ConnectionError as cerr:
show_error("Connection Error.",
"Connection to krpc server raised error.", str(cerr))
def login():
if request.method == "POST":
email, password = request.form.get(
"email").strip().lower(), request.form.get("password")
attempted_user: models.Crab = models.Crab.query.filter_by(
email=email, deleted=False).first()
if attempted_user is not None:
if attempted_user.verify_password(password):
if not attempted_user.banned:
# Login successful
session["current_user"] = attempted_user.id
session[
"current_user_ts"] = attempted_user.register_timestamp
return redirect("/")
else:
return utils.show_error(
"The account you're attempting to access has been banned."
)
else:
return utils.show_error("Incorrect password.")
else:
return utils.show_error("No account with that email exists.")
elif session.get("current_user"):
return redirect("/")
else:
login_failed = request.args.get("failed") is not None
return render_template(
"login.html",
current_page="login",
hide_sidebar=True,
login_failed=login_failed,
)
def reset_password():
email = request.args.get("email")
token = request.args.get("token")
crab = models.Crab.get_by_email(email)
if crab:
if crab.verify_password_reset_token(token):
if request.method == "POST":
new_pass = request.form.get("password")
confirm_pass = request.form.get("confirm-password")
if new_pass == confirm_pass:
crab.change_password(new_pass)
crab.clear_password_reset_token()
return utils.show_message("Password changed successfully.",
redirect_url="/login")
else:
return utils.show_error("Passwords do not match.",
preserve_arguments=True)
elif session.get("current_user"):
return redirect("/")
else:
return render_template(
"reset-password.html",
current_page="reset-password",
hide_sidebar=True,
)
return utils.show_error(
"Password reset link is either invalid or expired.",
redirect_url="/login")
def open_file_browser(self, dialog_ui: Optional[Ui_Dialog] = None):
try:
if not dialog_ui:
return
# Get the starting path
start_path = dialog_ui.pathTextEdit.toPlainText()
if start_path:
start_path, _ = ntpath.split(start_path)
start_path += os.path.sep + "*"
else:
start_path = None
# Open the file browser and add the selected path to the path text field
new_path = easygui.fileopenbox(title="Remote Play Anything",
msg="Choose the game executable",
default=start_path,
filetypes=["*.exe"])
if not new_path:
return
# If no name is in the name field or the name field is unchanged, set it as the file name
curr_name = dialog_ui.nameTextEdit.toPlainText()
curr_path = dialog_ui.pathTextEdit.toPlainText()
curr_file_name = utils.get_file_name(curr_path)
if not curr_name or curr_file_name == curr_name:
new_name = utils.get_file_name(new_path)
dialog_ui.nameTextEdit.setPlainText(new_name)
# Then set the path field
dialog_ui.pathTextEdit.setPlainText(new_path)
except Exception as e:
utils.show_error(text=str(e))
def manage(self, *args):
"""
Handler to run kolibri manage to invoke a Django command
"""
call_args = manage_cli(self.opts, *args)
try:
subprocess.Popen(call_args).wait()
except Exception as error:
show_error(self.logger, error)
def move_up(self):
try:
current_row = self.game_list.currentRow()
self.game_list.removeItemWidget(self)
self.game_list.takeItem(current_row)
self.setSizeHint(self.game_item_widget.sizeHint())
self.game_list.insertItem(current_row - 1, self)
# self.game_list.setItemWidget(self, self.game_item_widget)
except Exception as e:
utils.show_error(text=e)
def developer():
current_user = utils.get_current_user()
access_tokens = models.AccessToken.query.filter_by(crab=current_user,
deleted=False).all()
developer_keys = models.DeveloperKey.query.filter_by(crab=current_user,
deleted=False).all()
if request.method == "POST":
action = request.form.get("user_action")
if action == "create_developer_key":
if len(developer_keys) < config.API_MAX_DEVELOPER_KEYS:
models.DeveloperKey.create(current_user)
return utils.show_message("Created new developer key.")
else:
return utils.show_error(
f"You are only allowed {config.API_MAX_DEVELOPER_KEYS} "
"developer keys.")
elif action == "create_access_token":
if len(access_tokens) < config.API_MAX_ACCESS_TOKENS:
models.AccessToken.create(current_user)
return utils.show_message("Created access token.")
else:
return utils.show_error(
f"You are only allowed {config.API_MAX_ACCESS_TOKENS} "
"access tokens.")
elif action == "delete_developer_key":
key_id = request.form.get("developer_key_id")
if key_id:
key = models.DeveloperKey.query.filter_by(id=key_id).first()
if key:
key.delete()
return utils.show_message("Developer key deleted.")
elif action == "delete_access_token":
key_id = request.form.get("access_token_id")
if key_id:
key = models.AccessToken.query.filter_by(id=key_id).first()
if key:
key.delete()
return utils.show_message("Access token deleted.")
# PRG pattern
return redirect(request.url)
else:
return render_template(
"developer.html",
access_tokens=access_tokens,
developer_keys=developer_keys,
)
def forgot_password():
email_sent = False
if request.method == "POST":
crab_email = request.form.get("email")
crab = models.Crab.get_by_email(crab_email)
if crab and config.MAIL_ENABLED:
token = crab.generate_password_reset_token()
# Send email
body = render_template("password-reset-email.html",
crab=crab,
token=token)
if mail.send_mail(crab_email,
subject="Reset your password",
body=body):
email_sent = True
else:
return utils.show_error(
"There was a problem sending your email. Please try again."
)
else:
# Crab not found, still displaying "email sent" for security
# purposes
email_sent = True
elif session.get("current_user"):
return redirect("/")
return render_template(
"forgot-password.html",
current_page="forgot-password",
hide_sidebar=True,
email_sent=email_sent,
)
def start_game(self):
game = self.get_selected_game()
if not game:
utils.show_error("No game selected",
"Please select a game from the list first!",
details=False)
return
# Check if file exists:
if not game.is_valid_path():
utils.show_error(
"Game not found",
"The path to the game is invalid! \nPlease check the path of the game.",
details=False)
return
# Run the game with steam overlay enabled
cmd = game.get_file()
if game.parameters:
cmd += " " + game.parameters
try:
os.chdir(game.get_dir())
subprocess.Popen(cmd)
except WindowsError as e:
error = str(e)
if " 740]" in error:
ctypes.windll.shell32.ShellExecuteW(None, "runas", game.path,
game.parameters, None, 1)
else:
utils.show_error(text=error.replace("%1", game.name),
details=False)
def before_request():
# Check if remote address is banned
if utils.is_banned(request.remote_addr):
if request.endpoint != "static":
return abort(403)
# Make sure cookies are still valid
if session.get("current_user"):
crab_id = session.get("current_user")
crab = models.Crab.get_security_overview(crab_id)
current_user_ts = session.get("current_user_ts")
# Account deleted or banned
if crab is None or crab.banned or crab.deleted:
# Force logout
session["current_user"] = None
if crab and crab.banned:
return utils.show_error(
"The account you were logged into has been banned.",
"/login")
return utils.show_error(
"The account you were logged into no longer exists.", "/login")
# Potential database rollback or exploit
elif int(crab.register_time.timestamp()) != current_user_ts:
if current_user_ts:
# Force logout
session["current_user"] = None
return utils.show_error(
"Your cookies are invalidated or corrupted. Please attempt"
" to log in again.",
"/login",
)
else:
session["current_user_ts"] = crab.register_timestamp
# Persist session after browser is closed
session.permanent = True
def delete_account():
current_user = utils.get_current_user()
if request.method == "POST":
password = request.form.get("password")
if current_user.verify_password(password):
current_user.delete()
session["current_user"] = None
return redirect("/account-deleted")
else:
return utils.show_error("Password incorrect",
preserve_arguments=True)
else:
if current_user:
return render_template("delete-account.html",
current_page="delete-account",
hide_sidebar=True)
else:
return redirect("/")
for i in range(opts.iterations):
test_start = datetime.utcnow()
logger.info('{n} - Running test {test_name}'.format(
n=i + 1, test_name=test.__name__))
# Actual test execution:
try:
test.run(es.base_url, opts.learners)
except AttributeError:
logger.error(
'{} is not a correct module to run tests'.format(
test.__name__))
# Clean temp files and quit velox:
es.do_clean(True)
except Exception as error:
show_error(
logger, error,
'when trying to run {}'.format(test.__name__))
tests_durations[test.__name__].append(
calculate_duration(test_start))
es.do_clean()
duration = calculate_duration(start_date)
logger.info('::Duration {}'.format(duration))
logger.info('Tests finished')
if tests_durations:
logger.info('These are the tests durations:')
logger.info(tests_durations)
except Exception as error:
show_error(logger, error)
def _update(self, vessels):
if type(vessels) is RPCError:
show_error('RPCError received in vessels stream', '', str(vessels))
elif self.value is None or len(self.value) is not len(vessels):
self.value = vessels
self.updated.emit(self.value)
csvFileName = sys.argv[2].strip()
try:
# Try to open eventlogger database
connection = sqlite3.connect(dbFileName)
# Try to open csv file for writing
csvFd = open(csvFileName, 'wb')
with connection, csvFd:
cursor = connection.cursor()
writer = csv.writer(csvFd, delimiter='\t', quotechar='"', quoting=csv.QUOTE_ALL)
sql = 'SELECT `start_time`, `remote_uid`, `free_text` FROM `Events` WHERE `event_type_id` = 7'
for record in cursor.execute(sql):
startTime, phoneNumber, textMessage = record
startDateTime = datetime.fromtimestamp(startTime).strftime('%Y-%m-%d %H:%M:%S')
phoneNumber = phoneNumber.encode('utf-8')
textMessage = textMessage.encode('utf-8')
writer.writerow([startTime, startDateTime, phoneNumber, textMessage])
# Close database connection
connection.close()
# Close csv file
csvFd.close()
except sqlite3.Error, err:
utils.show_error('SQLite said: %s' % err)
except IOError, err:
utils.show_error('Could not open csv file for writing: %s' % err)
def _update(self, value):
if type(value) is RPCError:
show_error('RPCError received in ut stream', '', str(value))
else:
self.value = value
self.updated.emit(self.value)
def file_too_big(_e):
return utils.show_error("Image must be smaller than 5 megabytes.")
def signup():
if config.REGISTRATION_ENABLED:
if request.method == "POST":
# Validate data
form = request.form
email = form.get("email").strip().lower()
username = form.get("username").strip()
display_name = form.get("display-name").strip()
password = form.get("password").strip()
confirm_password = form.get("confirm-password").strip()
form_items = {
k: v
for k, v in request.form.items() if "password" not in k
}
if utils.validate_email(email):
username_available, username_reason = utils.validate_username(
username)
if username_available:
if password == confirm_password:
if password:
if captcha.verify():
# Use referral code if available
referral_code = form.get(
"referral-code").strip()
referrer = None
if referral_code:
referrer = models.ReferralCode.use(
referral_code)
# Create user account
models.Crab.create_new(
username=username,
email=email,
password=password,
display_name=display_name,
referrer=referrer,
address=request.remote_addr,
)
# "Log in"
current_user = models.Crab.query.filter_by(
username=username,
deleted=False,
banned=False,
).first()
session["current_user"] = current_user.id
session[
"current_user_ts"] = current_user.register_timestamp
# Redirect on success
return redirect("/signupsuccess")
else:
return utils.show_error(
"Captcha verification failed",
new_arguments=form_items,
)
else:
return utils.show_error(
"Password cannot be blank",
new_arguments=form_items,
)
else:
return utils.show_error(
"Passwords do not match",
new_arguments=form_items,
)
else:
return utils.show_error(username_reason,
new_arguments=form_items)
else:
return utils.show_error(
"An account with that email address already exists",
new_arguments=form_items,
)
elif session.get("current_user"):
return redirect("/")
else:
signup_failed = request.args.get("failed") is not None
error_msg = request.args.get("error_msg")
return render_template(
"signup.html",
current_page="signup",
hide_sidebar=True,
signup_failed=signup_failed,
error_msg=error_msg,
referral_code=request.args.get("referral-code"),
)
else:
return render_template(
"registration-closed.html",
current_page="registration-closed",
hide_sidebar=True,
)
vCards.append(vCardString)
record = cursor.next()
# Write vcard strings
for vCard in vCards:
try:
parsedVCard = vobject.readOne(vCard)
except Exception as err:
print >> sys.stderr, "Failed to parse vCard data: %s\nvCard data:\n%s" % (err, vCard)
continue
# Not all entries have a n(ame) attribute
if hasattr(parsedVCard, 'n'):
vCardName = slugify.slugify(unicode(parsedVCard.n.value))
# Construct file name
vCardName = '%s/%s.vcf' % (vcardsDir, vCardName)
# Open vcard for writing
with open(vCardName, 'w') as fd:
fd.write(vCard)
fd.close()
except OSError, err:
utils.show_error('Could not create \'%s\' folder: %s' % (vcardsDir, err))
except db.DBError, err:
utils.show_error('BerkeleyDB said: %s' % err)
except IOError, err:
utils.show_error('Could not open csv file \'%s\' for writing: %s' % (vCardName, err))
batch_size=512,
validation_data=[
users_items_matrix_train_zero,
users_items_matrix_validate
],
verbose=2,
callbacks=[
EarlyStopping(monitor='val_loss',
min_delta=1e-4,
patience=3,
verbose=2,
mode='auto')
])
# Show model loss
show_error(hist_Deep_AE, 10)
# Show RMSE metric
show_rmse(hist_Deep_AE, 10)
# Predict the model on test set
predict_deep = Deep_AE.predict(users_items_matrix_train_zero)
# Evaluate the model on test set and log metrics with the prefix 'test_'
with experiment.test():
loss, test_result_deep = Deep_AE.evaluate(users_items_matrix_train_zero,
users_items_matrix_test)
metrics = {'masked_rmse_loss': loss, 'masked_rmse_test': test_result_deep}
experiment.log_metrics(metrics)
# Dictionary to store model hyper-parameters
hyper_params = {