def create_aplication(): element_list = [common.random_id()] question = input("Is it accepted? ") element_list.append(question) student_check = True while student_check: id_ = 0 student_id = input("Enter the ID of the student: ") table = data_manager.get_data("Student/students.txt") for element in table: if element[id_] == student_id: element_list.append(student_id) student_check = False position_check = True while position_check: id_ = 0 position_id = input("Enter the ID of the position: ") table = data_manager.get_data("Positions/position.txt") for element in table: if element[id_] == position_id: element_list.append(position_id) position_check = False return element_list
def save_new_status(): status_title = request.get_json()['title'] board_id = request.get_json()['boardId'] board_statuses = data_manager.get_data({'key': 'id', 'value': board_id}, 'boards')[0]['status_ids'] try: if not data_manager.get_data({'key': 'title', 'value': status_title}, 'statuses'): data_manager.save_new_status(status_title) status_id = data_manager.get_data({'key': 'title', 'value': status_title}, 'statuses')[0]['id'] if status_id not in board_statuses: data_manager.add_status_to_board(board_id, status_id) except: return jsonify({'done': False, 'message': 'Database error'}) else: return jsonify({'done': True, 'message': 'Status added', 'result': status_id})
def route_new_comment(question_id: int, answer_id: int): if 'user_name' in session: if request.method == 'POST': new_comment = request.form data_manager.post_comment(new_comment, question_id, answer_id) return redirect('/question/' + question_id) questions = data_manager.get_data('question') answers = data_manager.get_data('answer') return render_template("comment.html", question_id=int(question_id), answer_id=int(answer_id), questions=questions, answers=answers) else: return redirect('/')
def create_position(): element_list = [common.random_id()] question = input("Describe the new position: ") element_list.append(question) while True: question = input("Number of seats: ") try: if int(question) > 0: element_list.append(question) break except: pass process = True while process: id_ = 0 company_id = input("Company ID for the position: ") table = data_manager.get_data("Company/company.txt") for element in table: if element[id_] == company_id: element_list.append(company_id) process = False return element_list
def update_authentication_password(form): data = get_data() def set_authentication_password(password): new_password = generate_password_hash(password=password, method='pbkdf2:sha256', salt_length=8) password_data = {"secret_password": new_password} data.update(password_data) update_data(data) try: authentication_password = data['secret_password'] except KeyError: authentication_password = None try: if authentication_password: if check_password_hash(authentication_password, form.old_password.data): set_authentication_password(form.new_password.data) return redirect(url_for('website_settings.menu', mode='admin')) else: flash("Incorrect authentication password.") return redirect( url_for('website_settings.authentication_configuration')) else: set_authentication_password(form.new_password.data) return redirect(url_for('website_settings.menu', mode='admin')) except (AttributeError, TypeError): return abort(400)
def train(): header, train, val, test, data_dict = get_data( N_CLASSES, MERGE_TAGS, SPLIT_RANDOMLY) print header weights, biases = get_vars() coord = tf.train.Coordinator() data_man_train, pred, cost, auc_op, update_auc_op = get_end_ops( train, data_dict, coord, weights, biases) data_man_val, pred_val, cost_val, auc_op_val, update_auc_op_val = get_end_ops( val, data_dict, coord, weights, biases) optimizer = tf.train.AdamOptimizer( learning_rate=LEARNING_RATE).minimize(cost) saver = tf.train.Saver() sess = tf.Session() sess.run(tf.initialize_all_variables()) sess.run(tf.initialize_local_variables()) threads = tf.train.start_queue_runners(sess=sess, coord=coord) data_man_train.start_threads(sess) data_man_val.start_threads(sess) if not os.path.exists(SAVE_DIR): os.mkdir(SAVE_DIR) try: print 'Starting training' step = 0 start = time.time() while True: sess.run(optimizer, feed_dict={keep_prob: DROPOUT}) if step % PRINT_EVERY == 0: loss, _ = sess.run( [cost, update_auc_op], feed_dict={keep_prob: 1}) print 'Step', step, 'Epochs', float(step) * BATCH_SIZE / len(train), \ 'Minibatch loss', loss, 'Time', time.time() - start if step % EVAL_EVERY == 0 and step != 0: total_loss = 0 for _ in range(len(val) / BATCH_SIZE): loss, _ = sess.run( [cost_val, update_auc_op_val], feed_dict={keep_prob: 1}) total_loss += loss auc, auc_val = sess.run([auc_op, auc_op_val]) print 'Train set AUC', auc print 'Validation set loss', total_loss / (len(val) / BATCH_SIZE), 'Validation set AUC', auc_val print '' saver.save(sess, SAVE_DIR + 'model', global_step=step) sess.run(tf.initialize_local_variables()) step += 1 except: pass finally: coord.request_stop() coord.join(threads) sess.close()
def display_q(): questions = data_manager.get_data('question') entries = questions sort_by = 'submission_time' if request.args.get('sort_by') == 'sorted_by' and request.args.get( 'asc_dsc') == 'asc' or request.args.get( 'sort_by') == 'sorted_by' and request.args.get( 'asc_dsc') == 'desc': entries = sorted(questions, key=lambda questions: questions[sort_by]) elif request.args.get('sort_by') is not None and request.args.get( 'asc_dsc') is not None: ascdsc = request.args.get('asc_dsc') sort_by = request.args.get('sort_by') if ascdsc == 'asc': entries = sorted(questions, key=lambda questions: questions[sort_by], reverse=False) elif ascdsc == 'desc': entries = sorted(questions, key=lambda questions: questions[sort_by], reverse=True) return render_template('list.html', questions=entries, sort_by=sort_by, asc_dsc=request.args.get('asc_dsc'))
def update_configuration(configuration, form, new_email=False, flash_message=None): data = get_data() try: keys = CONFIG_KEYS[configuration] except KeyError: return abort(400) else: new_data = { configuration: { key: form[key].data if key != 'support_email' and new_email is False else data[configuration]['support_email'] for key in keys } } new_configuration = new_data[configuration] keys_lst = list(new_configuration.keys()) values_lst = list(new_configuration.values()) log_changes(configuration=configuration, new_configuration=new_configuration, keys_lst=keys_lst, values_lst=values_lst) data.update(new_data) update_data(data) flash(flash_message) if flash_message else None return redirect(url_for('website_settings.menu', mode='admin'))
def get_social(): try: soc = get_data()["website_configuration"] return dict( social={ "twitter": soc["twitter_link"], "facebook": soc["facebook_link"], "github": soc["github_link"], "youtube": soc["youtube_link"], "linkedin": soc["linkedin_link"], "instagram": soc["instagram_link"], "dev": soc["dev_link"], "whatsapp": soc["whatsapp_link"], "reddit": soc["reddit_link"], "pinterest": soc["pinterest_link"], "telegram": soc["telegram_link"] }) except KeyError: return dict( social={ "twitter": "https://www.twitter.com", "github": "https://www.github.com", "facebook": "https://www.github.com", "instagram": "https://www.instagram.com", "youtube": "https://www.youtube.com", "linkedin": "https://www.linkedin.com", "dev": "https://dev.to", "whatsapp": "https://www.whatsapp.com", "reddit": "https://www.reddit.com", "pinterest": "https://www.pinterest.com", "telegram": "https://www.telegram.com" })
def edit_question(question_id, title, message): if request.method == 'POST': question_data = data_manager.get_data() title = request.form['Title'] message = request.form['Message'] data_manager.push_data(question_data) return redirect(f'/question_list/{question_id}') return render_template('add_edit_page.html', question_id=question_id)
def get_name(configuration=None): data = get_data() try: return dict(name=data["website_configuration"]["name"]) if configuration is None else \ data["website_configuration"]["name"] except (TypeError, IndexError, KeyError): return dict( name="Website" ) if configuration is None else data["website_configuration"]["name"]
def route_question(question_id): if 'user_name' in session: if request.method == 'GET': question = data_manager.get_data('question', question_id) answers = data_manager.get_data('answer', question_id=question_id) question_comments = data_manager.get_question_comments(question_id) answer_comments = data_manager.get_answer_comments(question_id) return render_template("question-only.html", question_id=int(question_id), question=question, answers=answers, question_comments=question_comments, answer_comments=answer_comments) elif request.method == 'POST': data_manager.delete_question(question_id) return redirect('/list') else: return redirect('/')
def is_page_valid(): valid = True try: support_email = get_data()["contact_configuration"]["support_email"] except KeyError: valid = False else: if support_email is None: valid = False return valid
def newsletter_functionality(configuration=None): try: config_data = get_data()["newsletter_configuration"] except KeyError: enabled = False else: try: enabled = config_data["enabled"] except KeyError: enabled = False return dict(newsletter_enabled=enabled) if not configuration else enabled
def get_background(configuration='website_configuration'): try: if configuration == 'website_configuration': return dict( background_image=get_data()[configuration]["background_image"]) else: try: background = get_data()[configuration]["background_image"] if background == '': return get_data( )["website_configuration"]["background_image"] return background except (KeyError, TypeError): try: return get_data( )["website_configuration"]["background_image"] except (KeyError, TypeError): return '' except (KeyError, TypeError): return dict(background_image="")
def get_route_status(route): try: data = get_data()["api_configuration"] except KeyError: return "unavailable" else: try: if data[route] is False: return "blocked" return True except KeyError: return "unavailable"
def get_page_elements(): try: contact_config = get_data()['contact_configuration'] except KeyError: heading = "Contact us" subheading = "We'll get to you as soon as we can." description = "Want to get in touch? Fill out the form below and we'll respond as soon as we can!" else: heading = contact_config.get('page_heading') subheading = contact_config.get('page_subheading') description = contact_config.get('page_description') return heading, subheading, description
def route_new_answer(question_id): if 'user_name' in session: if request.method == 'POST': new_user_answer = request.form data_manager.add_new_answer(new_user_answer, question_id) return redirect('/question/' + question_id) questions = data_manager.get_data('question') return render_template("answer.html", question_id=int(question_id), questions=questions) else: return redirect('/')
def check_position(table, id_): app_position_id = -1 app_student_id = -2 aplication_table = data_manager.get_data("Application/aplication.txt") student_table = data_manager.get_data("Student/students.txt") student_id = 0 result = [] for element in table: if id_ == element[student_id]: result.append(element) for elem in aplication_table: if elem[app_position_id] == id_: print("hi") for item in student_table: if item[student_id] == elem[app_student_id]: result.append(item) if result: return result return ["No such ID in the list."]
def get_subscription_page_elements(): try: subscription_page = get_data()['newsletter_configuration'] except KeyError: heading = "Subscribe to our newsletter!" subheading = "Enjoy all of our internet doses." else: heading = subscription_page.get('subscription_title', "Enjoy all of our internet doses.") subheading = subscription_page.get('subscription_subtitle', "Enjoy all of our internet doses.") return heading, subheading
def count_neighbor_average_array_and_save(dimension: int, id_indx: int, tag: str): ''' Use this function to count neighbour pixels' average intensities and save the csv file for ML process. Use show_data_info function to find out dimension, id_inx and tags, which exist. Parameters: ----------- dimension: 2 or 3. Dimension of phantom Euclidian space id_indx: 1,2,3,etc. id for phantom with certain porosity, blobiness and experiment parameters tag: 'test', 'train' or another This parameter controls conflicts if several csv files are generated for 1 phanom. Keep it different for staging different images with similar parameters results: -------- out: csv file See in the script's directory in the folder 'database' To open use data_manager.get_data(args) function ''' orig_phantom = dm.get_data(dimension, id_indx, tag, 'orig_phantom') proc_phantom = dm.get_data(dimension, id_indx, tag, 'processed_phantom') neighbor_pixel_average = count_neighbor_average_array(proc_phantom) data = { 'neighbor_average': np.concatenate(neighbor_pixel_average), 'proc_phantom_pixel_values': np.concatenate(proc_phantom), 'pixel_real_value': np.concatenate(orig_phantom) } csv_file = pd.DataFrame(data) dm.add_csv(dimension, id_indx, tag, csv_file)
def get_form_elements(configuration): try: requested_configuration = get_data()[configuration] except KeyError: return {} else: try: form_arguments = { key: requested_configuration[key] for key in requested_configuration } except KeyError: form_arguments = {} return form_arguments
def get_unsubscription_page_elements(): try: config_data = get_data()['newsletter_configuration'] except KeyError: heading = "Unsubscribe from our newsletter" subheading = "Not satisfied with our newsletter? Unsubscribe here." else: heading = config_data.get("unsubscription_title", "Unsubscribe from our newsletter") subheading = config_data.get( "unsubscription_subtitle", "Not satisfied with our newsletter? Unsubscribe here.") return heading, subheading
def display_question(question_id): answer = [] question_data = data_manager.get_data() answer_data = data_manager.get_data_answer() for i in question_data: if i[0] == question_id: question = i break for i in answer_data: if i[3] == question_id: answer.append(i) return render_template('question_page.html', question=question, answer=answer)
def list_questions(): sort_by = '' direction = '' if request.method == "POST": sort_by = request.form.get('sort') direction = request.form.get('direction') data = data_manager.sort_csv(sort_by, direction) else: data = data_manager.get_data() return render_template('list.html', data=data, sort_by=sort_by, direction=direction, searching=True)
def set_notification(category, email, name, action_user, action_reason): try: support_email = get_data()["contact-configuration"]["support_email"] except KeyError: msg = Message(f'Account set as {category}', sender=EMAIL, recipients=[email]) else: msg = Message(f'Account set as {category}', sender=EMAIL, recipients=[email, support_email]) msg.body = f"Hello {name}, this is an automatic email from {get_name('m')} to notify you of recent" \ f" events that occurred in regards to your account.\n\n" \ f'Your account was set as an {category} by {action_user}.\n\n' \ f'Reasoning by actioning staff member:\n\n{html2text(action_reason)}\n\n' \ f'Congratulations, if you have any inquires, contact us by replying to this email or via our website.' send_mail(msg)
def delete_company(table, id_): company_id = 0 tmp = [] position_id = -1 position_table = data_manager.get_data("Positions/position.txt") for field in position_table: if field[position_id] == id_: ui.print_result(["Can't delete a company with open position."]) return table for element in table: if element[company_id] != id_: tmp.append(element) return tmp
def make_db_query(criteria, table): if criteria: key = list(criteria.keys())[0] value = criteria[key] criteria = {"key": key, "value": value} try: query_result = data_manager.get_data(criteria, table) except: return jsonify({"done": False, "reason": "Database error"}) else: return jsonify({ "done": True, "message": "Successful query", "result": query_result })
def redirect_after_verification(user_id, password, redirect_to, salt, auth_func): if not User.query.get(user_id): return abort(400) try: contents = get_data() secret_password = contents['secret_password'] except (KeyError, TypeError, IndexError): flash("Authentication Password is not available. Deletion cannot be performed at this time.") return redirect(url_for('home.home_page', category='danger')) if check_password_hash(secret_password, password): token = serializer.dumps(current_user.email, salt=salt) link = url_for(redirect_to, token=token, email=current_user.email, user_id=user_id) return redirect(link) else: flash("Incorrect authorization code.") return redirect(url_for(f"verification.{auth_func}", user_id=user_id))
def handle_support_confirmation(token, email): load_token(token=token, salt='support-verify') if not any(email): return abort(400) config_data = get_data() try: if config_data["contact_configuration"]["support_email"] != email: config_data["contact_configuration"]["support_email"] = email update_data(config_data) flash("This email was successfully set as the support email.") return redirect(url_for('home.home_page', category='success')) else: flash("This email is already set as the support email.") return redirect(url_for('home.home_page', category='danger')) except KeyError: return abort(500)