def search(input=""): search_form = SearchForm() key_number_list = [] keys = [] key_obj = Key() if "," in input: key_number_list = input.split(",") for num in key_number_list: key_list = key_obj.get_key_by_key_number(int(num)) for key in key_list: keys.append(key) else: key = key_obj.get_key_by_key_number(int(input)) for k in key: keys.append(k) if request.method == "POST": for key in keys: if key.available == True: selected_key = key_obj.query.get(key.id) selected_key.available = False db.session.add(selected_key) new_transaction = Transaction(user=current_user, key_id=key.id, time_stamp=datetime.datetime.now() + timedelta(hours=3)) db.session.add(new_transaction) db.session.commit() flash("ALL keys taken") return render_template("result_page.html", keys=keys, search_form=search_form) if request.method == "GET": return render_template("result_page.html", keys=keys, search_form=search_form)
def create_users(): for user in users: User.create(user['firstname'], user['lastname'], user['rfid_card'], user['admin']) for key in keys: Key.create(key['room'], key['rfid_chip'])
def test_note_names__non_standard_flats(self): names = Key('C♭ minor').note_names expected = ('C♭', 'D♭', 'E♭♭', 'F♭', 'G♭', 'A♭♭', 'B♭♭') self.assertEqual(expected, names) names = Key('F♭ minor').note_names expected = ('F♭', 'G♭', 'A♭♭', 'B♭♭', 'C♭', 'D♭♭', 'E♭♭') self.assertEqual(expected, names)
def test_note_names__sharps(self): names = Key('C♯').note_names expected = ('C♯', 'D♯', 'E♯', 'F♯', 'G♯', 'A♯', 'B♯') self.assertEqual(expected, names) names = Key('F♯').note_names expected = ('F♯', 'G♯', 'A♯', 'B', 'C♯', 'D♯', 'E♯') self.assertEqual(expected, names)
def test_note_names__non_standard_sharps(self): names = Key('B♯ minor').note_names expected = ('B♯', 'C♯♯', 'D♯', 'E♯', 'F♯♯', 'G♯', 'A♯') self.assertEqual(expected, names) names = Key('E♯ minor').note_names expected = ('E♯', 'F♯♯', 'G♯', 'A♯', 'B♯', 'C♯', 'D♯') self.assertEqual(expected, names)
def test_generate_notes(self): key_notes = Key('C# minor').scale.notes expected = (C_sharp, D_sharp, E, F_sharp, G_sharp, A, B) self.assertEqual(expected, key_notes) key_notes = Key('C#').scale.notes expected = (C_sharp, D_sharp, E_sharp, F_sharp, G_sharp, A_sharp, B_sharp) self.assertEqual(expected, key_notes)
def test_init__invalid(self): with self.assertRaises(InvalidQualityError): Key('A foo') with self.assertRaises(InvalidQualityError): Key('A major quack a doodle') with self.assertRaises(InvalidQualityError): Key('A 4000')
def test_key(self): # Divisible by 4: C major text = 'This is a sentence' key = Game(text).key self.assertEqual(Key('C'), key) # Divisible by 2: A minor text = 'It was a good sentence' key = Game(text).key self.assertEqual(Key('Am'), key)
def test_init(self): a_minor = Key('A minor') self.assertEqual(A, a_minor.tonic) a_minor = Key('Am') self.assertEqual(A, a_minor.tonic) a_minor = Key('A min') self.assertEqual(A, a_minor.tonic) a_minor = Key('Amin') self.assertEqual(A, a_minor.tonic)
def test_init(self): a_major = Key('A') self.assertEqual(A, a_major.tonic) a_major = Key('A major') self.assertEqual(A, a_major.tonic) a_major = Key('A maj') self.assertEqual(A, a_major.tonic) a_major = Key('Amaj') self.assertEqual(A, a_major.tonic)
def __parse_key(self, buf, algo, created, usage, expiry): fingerprint_match = key_fingerprint_regex.match(buf.readline()) if not fingerprint_match: return None fingerprint = fingerprint_match.group(1) uid_match = uid_regex.match(buf.readline()) if not uid_match: return None name = uid_match.group(1) desc = uid_match.group(2) email = uid_match.group(3) key = Key(fingerprint=fingerprint, algo=algo, created=created, usage=usage, expiry=expiry, email=email, name=name, description=desc) return key
def test_types(self): key_c = Key('C') self.assertEqual(IonianScale, key_c.ionian_mode.base_scale) self.assertTrue(isinstance(key_c.ionian_mode, Mode)) c_ionian_mode = Mode(C, IonianScale) self.assertEqual(IonianScale, c_ionian_mode.base_scale) self.assertTrue(isinstance(c_ionian_mode, Mode))
def test_note_names__natural(self): names = Key('A').note_names expected = ('A', 'B', 'C♯', 'D', 'E', 'F♯', 'G♯') self.assertEqual(expected, names) names = Key('B').note_names expected = ('B', 'C♯', 'D♯', 'E', 'F♯', 'G♯', 'A♯') self.assertEqual(expected, names) names = Key('C').note_names expected = ('C', 'D', 'E', 'F', 'G', 'A', 'B') self.assertEqual(expected, names) names = Key('D').note_names expected = ('D', 'E', 'F♯', 'G', 'A', 'B', 'C♯') self.assertEqual(expected, names) names = Key('E').note_names expected = ('E', 'F♯', 'G♯', 'A', 'B', 'C♯', 'D♯') self.assertEqual(expected, names) names = Key('F').note_names expected = ('F', 'G', 'A', 'B♭', 'C', 'D', 'E') self.assertEqual(expected, names) names = Key('G').note_names expected = ('G', 'A', 'B', 'C', 'D', 'E', 'F♯') self.assertEqual(expected, names)
def test_notes__natural__minors(self): names = Key('A minor').note_names expected = ('A', 'B', 'C', 'D', 'E', 'F', 'G') self.assertEqual(expected, names) names = Key('B minor').note_names expected = ('B', 'C♯', 'D', 'E', 'F♯', 'G', 'A') self.assertEqual(expected, names) names = Key('C minor').note_names expected = ('C', 'D', 'E♭', 'F', 'G', 'A♭', 'B♭') self.assertEqual(expected, names) names = Key('D minor').note_names expected = ('D', 'E', 'F', 'G', 'A', 'B♭', 'C') self.assertEqual(expected, names) names = Key('E minor').note_names expected = ('E', 'F♯', 'G', 'A', 'B', 'C', 'D') self.assertEqual(expected, names) names = Key('F minor').note_names expected = ('F', 'G', 'A♭', 'B♭', 'C', 'D♭', 'E♭') self.assertEqual(expected, names) names = Key('G minor').note_names expected = ('G', 'A', 'B♭', 'C', 'D', 'E♭', 'F') self.assertEqual(expected, names)
def create_user(): db.create_all() db.session.add( User(id=0, name='myuser', password='******', roles=["authenticated"])) db.session.add(Key(id=0, key='azerty', roles=["admin"])) db.session.commit()
def test_keys_with_natural_tonic(self): self.assert_key_modes_are_correct(Key('C')) self.assert_key_modes_are_correct(Key('D')) self.assert_key_modes_are_correct(Key('E')) self.assert_key_modes_are_correct(Key('F')) self.assert_key_modes_are_correct(Key('G')) self.assert_key_modes_are_correct(Key('A')) self.assert_key_modes_are_correct(Key('B'))
def test_keys_with_sharp_tonic(self): self.assert_key_modes_are_correct(Key('C#m')) self.assert_key_modes_are_correct(Key('D#m')) self.assert_key_modes_are_correct(Key('E#m')) self.assert_key_modes_are_correct(Key('F#m')) self.assert_key_modes_are_correct(Key('G#m')) self.assert_key_modes_are_correct(Key('A#m')) self.assert_key_modes_are_correct(Key('B#m'))
def test_keys_with_flat_tonic(self): self.assert_key_modes_are_correct(Key('Cbm')) self.assert_key_modes_are_correct(Key('Dbm')) self.assert_key_modes_are_correct(Key('Ebm')) self.assert_key_modes_are_correct(Key('Fbm')) self.assert_key_modes_are_correct(Key('Gbm')) self.assert_key_modes_are_correct(Key('Abm')) self.assert_key_modes_are_correct(Key('Bbm'))
def test_keys_with_natural_tonic(self): self.assert_key_modes_are_correct(Key('Cm')) self.assert_key_modes_are_correct(Key('Dm')) self.assert_key_modes_are_correct(Key('Em')) self.assert_key_modes_are_correct(Key('Fm')) self.assert_key_modes_are_correct(Key('Gm')) self.assert_key_modes_are_correct(Key('Am')) self.assert_key_modes_are_correct(Key('Bm'))
def generate_rsa_keys(): key = RSA.generate(2048) try: key_model = Key(device_id=request.get_json().get("device_id"), p_key=key.publickey().export_key().decode("UTF-8"), pr_key=key.exportKey().decode("UTF-8")) db.session.add(key_model) db.session.commit() return "Success", 200 except Exception as ServerError: return {"error": str(ServerError).split("\n")[0]}, 500
def test_note_names__flat(self): names = Key('A♭ minor').note_names expected = ('A♭', 'B♭', 'C♭', 'D♭', 'E♭', 'F♭', 'G♭') self.assertEqual(expected, names) names = Key('B♭ minor').note_names expected = ('B♭', 'C', 'D♭', 'E♭', 'F', 'G♭', 'A♭') self.assertEqual(expected, names) names = Key('D♭ minor').note_names expected = ('D♭', 'E♭', 'F♭', 'G♭', 'A♭', 'B♭♭', 'C♭') # D♭, E♭, F♭, G♭, A♭, B♭♭, and C♭. self.assertEqual(expected, names) names = Key('E♭ minor').note_names expected = ('E♭', 'F', 'G♭', 'A♭', 'B♭', 'C♭', 'D♭') self.assertEqual(expected, names) names = Key('G♭ minor').note_names expected = ('G♭', 'A♭', 'B♭♭', 'C♭', 'D♭', 'E♭♭', 'F♭') self.assertEqual(expected, names)
def change_key(): form = ChangeKeyForm() if request.method == 'POST': if form.validate_on_submit(): key = Key.get_by_id(1) key.key = generate_password_hash(form.ckey.data) key.save() flash('<script>alert("密码修改成功")</script>') return redirect(url_for('home')) else: flash('<script>alert("密码修改失败,请确保两次输入一致")</script>') return render_template('change_key.html', form=form)
def generate_and_store_random_key_pair(is_refresh_token_key=False): key_generator = KeyGenerator() key_file_writer = KeyFileWriter(key_generator) key = Key(is_refresh_token_key=is_refresh_token_key) try: db.session.add(key) db.session.commit() key_file_writer.write_keys_to_file(str(key.id)) except: db.session.rollback()
def create_key(): form = CreateKeyForm() search_form = SearchForm() company_list = current_user.list_all_company() # Remove Aurio Head company from the list for company in company_list: if company.name == "Aurio Head": company_list.remove(company) if request.method == "POST": key_obj = Key() key_obj.key_number = int(form.key_number.data) key_obj.available = True check_list = key_obj.get_all_key(current_user.company.id) if current_user.role == 3: key_obj.company_id = int(form.selected_company.data) elif current_user.role == 2: key_obj.company_id = current_user.company_id db.session.add(key_obj) db.session.commit() flash("Key have been created") return render_template("create_key.html", form=form, search_form=search_form, list=company_list) else: if current_user.role == 1: flash("You have no permission") return redirect(url_for("main")) else: return render_template("create_key.html", form=form, search_form=search_form, list=company_list)
def test_chords(self): text = 'This is a sentence' game = Game(text) chord_this, chord_is, chord_a, chord_sentence = game.chords # First chord should be the key's tonic self.assertEqual(Key('C'), game.key) self.assertEqual((C, E, G), chord_this) # Remaining chords should be calculated from letters self.assertEqual((D, G), chord_is) self.assertEqual((C, ), chord_a) self.assertEqual((G, B, A, E), chord_sentence)
def login(): if request.method == 'GET' and session.get('logged_in'): return redirect_back('home') form = KeyForm() if request.method == 'POST' and form.validate_on_submit(): key = form.key.data if check_password_hash(Key.get_by_id(1).key, key): session['logged_in'] = True flash('<script>alert("登陆认证成功")</script>') return redirect(url_for('home')) else: flash('<script>alert("密码验证失败")</script>') return render_template('login.html', form=form)
def add_url(url: str): """ Populate url info to a database Represent long operation that can takes significant amount of time What's why it's moved to a celery task :param url: link to a XML file :return: {'id': <id of created Url in DB>} """ xml_dict = parse_xml_file(url) url_object = Url(url=xml_dict['url'], processed=bool(not xml_dict['error_text']), error=xml_dict['error_text']) url_object.keys = [Key(value=key) for key in xml_dict['keys']] s.add(url_object) s.commit() # sleep(20) # uncomment this, if you want to test *real* async :) return {'id': url_object.id}
def paint_key_name(frame, key: Key, text_margin: int, offset: List = None): center_point = key.get_center_point() if center_point == (-1, -1): return draw_point = get_drawing_point_for_point_with_offset(center_point, offset) # Draw shadow cv2.putText(frame, key.name, (draw_point[0] + text_margin, draw_point[1] - text_margin), Config.font_family, Config.key_name_font_scale, (0, 0, 0), round(Config.key_name_font_thickness * 1.4), Config.line_type) # Draw text cv2.putText(frame, key.name, (draw_point[0] + text_margin, draw_point[1] - text_margin), Config.font_family, Config.key_name_font_scale, key.color, Config.key_name_font_thickness, Config.line_type)
def load_keys(): if Config.calibrating: keys.clear() if len(keys) > 0: return # Generate keys key_amount = Config.key_amount_to_calibrate for i in range(0, key_amount): color_diff = (i + 1) / key_amount * 6.3 color_diff %= 1 key_color = (255, 255 * color_diff, 255 - 255 * color_diff) note_name = Key.note_base_names[i % 12] + str(i // 12) keys.append(Key(note_name, color=key_color))
def get(self, key_id=None): ''' This would be a good candidate for caching, since most likely the keys will often be requested unless an application would cache the keys themselves to validate payloads ''' active_keys = Key.get_n_most_recent_keys(3) if key_id is None: response = {'keys': []} for key in active_keys: response['keys'].append( {key.id: KeyFileReader.get_public_key(str(key.id))}) else: if key_id not in [key.id for key in active_keys]: return jsonify({'message': f'Key with id {key_id} not found.'}), 404 response = {key_id: KeyFileReader.get_public_key(str(key_id))} return jsonify(response)
def get(self, request, available=None, taken=None, history=None): check_history = UserKeyLink.get_all_operations() if not check_history['errors'] or check_history['warnings']: history = [i for i in check_history['data'] if i.date_returned] check_taken_keys = UserKeyLink.get_all_operations() if not check_taken_keys['errors'] or check_taken_keys['warnings']: taken = [ i for i in check_taken_keys['data'] if not i.date_returned ] check_available_keys = Key.get_available_keys() if not check_available_keys['errors'] or check_available_keys[ 'warnings']: available = check_available_keys['data'] return render(request, 'keys/index.html', { 'available': available, 'taken': taken, 'history': history })
def test_helper_assertion_function(self): """ The helper function iterates through each mode, shifting the expected set of notes over 1 degree. For example, from Ionian to Dorian, the expected notes for C Minor shift from: ('C', 'D', 'E♭', 'F', 'G', 'A♭', 'B♭') to: ('D', 'E♭', 'F', 'G', 'A♭', 'B♭'. 'C') This test asserts that we are doing so correctly in the helper function. """ modal_scales = self.assert_key_modes_are_correct(Key('Cm')) expected = [ ('C', 'D', 'E♭', 'F', 'G', 'A♭', 'B♭'), ('D', 'E♭', 'F', 'G', 'A♭', 'B♭', 'C'), ('E♭', 'F', 'G', 'A♭', 'B♭', 'C', 'D'), ('F', 'G', 'A♭', 'B♭', 'C', 'D', 'E♭'), ('G', 'A♭', 'B♭', 'C', 'D', 'E♭', 'F'), ('A♭', 'B♭', 'C', 'D', 'E♭', 'F', 'G'), ('B♭', 'C', 'D', 'E♭', 'F', 'G', 'A♭'), ] self.assertEqual(expected, modal_scales)
def gen_new_key(request): key = Key() key.value = request.POST.get("answer", None) if key.value: key.save() return HttpResponse("Ok")