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_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_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_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_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 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 __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_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 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 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('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 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('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 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 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 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 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 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 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 test_notes__natural_majors(self):
expected = ('A', 'B', 'C♯', 'D', 'E', 'F♯', 'G♯')
self.assertEqual(expected, Key('A').scale.notes)
expected = ('B', 'C♯', 'D♯', 'E', 'F♯', 'G♯', 'A♯')
self.assertEqual(expected, Key('B').scale.notes)
expected = ('C', 'D', 'E', 'F', 'G', 'A', 'B')
self.assertEqual(expected, Key('C').scale.notes)
expected = ('D', 'E', 'F♯', 'G', 'A', 'B', 'C♯')
self.assertEqual(expected, Key('D').scale.notes)
expected = ('E', 'F♯', 'G♯', 'A', 'B', 'C♯', 'D♯')
self.assertEqual(expected, Key('E').scale.notes)
expected = ('F', 'G', 'A', 'B♭', 'C', 'D', 'E')
self.assertEqual(expected, Key('F').scale.notes)
expected = ('G', 'A', 'B', 'C', 'D', 'E', 'F♯')
self.assertEqual(expected, Key('G').scale.notes)
def test_note_names__flats(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('G♭').note_names
expected = ('G♭', 'A♭', 'B♭', 'C♭', 'D♭', 'E♭', 'F')
self.assertEqual(expected, names)
from typing import List, Optional
import numpy as np
from config import Config
from models import Key
fps: int = 0
frame_shape: tuple = (-1, -1)
is_image: bool = False
zone_bounds: Optional[np.ndarray] = Config.zone_bounds
mask_area: Optional[np.ndarray] = Config.mask_area
keys = [ # generated by profile 3
# Key("C0", is_calibrated=True, color=(255, 54, 201), line=[(339, 397), (344, 410)]),
Key("C#0", is_calibrated=True, color=(255, 54, 201), line=[(339, 397), (344, 410)]),
Key("D0", is_calibrated=True, color=(255, 107, 148), line=[(352, 397), (357, 412)]),
Key("D#0", is_calibrated=True, color=(255, 161, 94), line=[(364, 396), (369, 409)]),
Key("E0", is_calibrated=True, color=(255, 214, 41), line=[(377, 395), (382, 411)]),
Key("F0", is_calibrated=True, color=(255, 13, 242), line=[(388, 392), (394, 411)]),
Key("F#0", is_calibrated=True, color=(255, 66, 189), line=[(399, 391), (405, 408)]),
Key("G0", is_calibrated=True, color=(255, 120, 135), line=[(410, 392), (415, 406)]),
Key("G#0", is_calibrated=True, color=(255, 173, 82), line=[(421, 393), (426, 407)]),
Key("A0", is_calibrated=True, color=(255, 227, 28), line=[(432, 393), (438, 409)]),
Key("A#0", is_calibrated=True, color=(255, 25, 230), line=[(444, 394), (450, 411)]),
Key("B0", is_calibrated=True, color=(255, 79, 176), line=[(456, 394), (460, 407)]),
Key("C1", is_calibrated=True, color=(255, 133, 122), line=[(467, 391), (473, 409)]),
Key("C#1", is_calibrated=True, color=(255, 186, 69), line=[(479, 391), (486, 412)]),
Key("D1", is_calibrated=True, color=(255, 240, 15), line=[(491, 391), (497, 408)]),
Key("D#1", is_calibrated=True, color=(255, 38, 217), line=[(503, 390), (509, 407)]),
Key("E1", is_calibrated=True, color=(255, 92, 163), line=[(515, 388), (523, 412)]),
def test_notes__sharp(self):
key_notes = Key('C#').scale.notes
expected_notes = (C_sharp, D_sharp, E_sharp, F_sharp, G_sharp, A_sharp, B_sharp)
self.assertEqual(expected_notes, key_notes)
splits=[0.7, 0.15, 0.15])
else:
raise Exception('Incorrect model name')
train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, shuffle=True)
val_loader = torch.utils.data.DataLoader(val_set, batch_size=32)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=32)
print('loader : ', train_loader)
# Initialize the model
if args.model == 'artist':
model = Artist()
elif args.model == 'popularity':
model = Popularity()
elif args.model == 'key':
model = Key()
else:
raise Exception('Incorrect model name')
if args.cuda:
model.cuda()
# Loss function
if args.model == 'popularity':
loss = torch.nn.MSELoss()
else:
loss = torch.nn.CrossEntropyLoss()
# Optimizer
optimizer = optim.Adam(model.parameters(), lr=args.lr)
def test_notes__natural(self):
key_notes = Key('C').scale.notes
expected = (C, D, E, F, G, A, B)
self.assertEqual(expected, key_notes)
