def new(in_args):
if len(in_args) != 1:
print("Incorrect number of arguments!")
return
name = in_args[0]
note = Note(name)
open_notes[name] = note
def appointment_info(bid):
# Make sure that it can be converted to an int
try:
bid = int(bid)
except ValueError as e:
abort(404)
booking = system.booking_system.get_booking_by_id(bid, current_user)
if booking:
patient = booking.user
if request.method == "POST":
form = NoteForm(request.form)
if form.validate():
# Most of this stuff should really be in HealthCareSystem
date = datetime.now()
new_note = Note(copy(current_user), form.note.data,
form.medication.data, date)
system.add_patient_note(new_note, patient)
else:
flash(form.lerrors)
return render_template(
"appointment.html",
booking=booking,
patient=patient,
note=form.note.data,
medication=form.medication.data,
)
# If GET request
# Rather hacky way to create "newlines" in HTML, but probably the least hacky.
return render_template("appointment.html",
booking=booking,
patient=patient)
# If booking not found
abort(404)
def __init__(self):
self._current_note = None
self._heard_note = None
self._listening = Settings.START_LISTENING_AT_STARTUP
self._autonext = Settings.START_AUTONEXT_AT_STARTUP
#-- self._start_octave = Settings.DEFAULT_BASE_NOTE_OCTAVE
# MAIN WINDOW
self._main_window = MainWindow(flute_teacher=self)
# SCALE MANAGER AND ARPEGGIATOR
self._scale_manager = ScaleManager(
scale_name=Settings.DEFAULT_SCALE_NAME,
base_note=Note(letter=Settings.DEFAULT_BASE_NOTE_LETTER,
alteration=Settings.DEFAULT_BASE_NOTE_ALTERATION,
octave=Settings.DEFAULT_BASE_NOTE_OCTAVE),
mode=Settings.DEFAULT_SCALE_MODE)
self._arpeggiator = Arpeggiator(
self._scale_manager,
kind=Settings.DEFAULT_ARPEGGIATOR_KIND,
n_octaves=Settings.DEFAULT_ARP_N_OCTAVES)
self.next_note()
# NOTE RECOGNITION
self._hear_ai = HearAI()
if self._autonext:
self.set_autonext(True)
if self._listening:
self.start_listening()
def generate_note(self):
# allowed_pitch = [36, 38, 42, 46, 41, 45, 48, 51, 49]
new_note = Note(random.randrange(0, 24),
round_down(round(uniform(0, 7.75), 2), 0.25),
0.25) # QUANTIZED MELO
# new_note = Note(sample(allowed_pitch, 1)[0], round_down(round(uniform(0, 7.75), 2), 0.25), 0.25) #QUANTIZED
# new_note = Note(random.sample(allowed_pitch, 1)[0], round(random.uniform(0, 7.75), 2), 0.25) #UNQUANTIZED
if new_note not in self.sequence:
self.sequence.append(GeneDrum(new_note))
def test_provider_notes():
provider = system.user_manager.get_HP_by_name('toby')
date = '2019-05-20'
year, month, day = date.split("-")
booking_date = datetime(int(year), int(month), int(day))
time1 = time(9, 30)
booking_datetime = datetime.combine(booking_date, time1)
new_note = Note(provider, "Concurrent Despacito", "Despacito",
booking_datetime)
assert (new_note.medication == "Despacito")
def next_state(self, position):
# print( type(self.current_state.transitions_list[1].destination_state))
size_possible_transition = len(self.current_state.transitions_list) - 1
random_state = random.randint(0, size_possible_transition)
key_timestamp = self.current_state.transitions_list[random_state].original_state.value / 8
key_duration = self.current_state.transitions_list[random_state].symbol / 8
self.current_state = self.current_state.transitions_list[random_state].destination_state
# return Note(random.randint(0, 24), position+key_timestamp, key_duration)
return Note(random.randint(0, 12), position + key_timestamp, key_duration)
def __init__(self, scale_name='Major', base_note=Note(), mode=1):
"""
:param scale_name: str
:param base_note: first note of the scale
:param mode: from 1 to 7
"""
self._scale = None
self._scale_name = scale_name
self._mode = mode
self._base_note = base_note
self._init_scale()
def _init_wholetone_scale(self):
_scale1 = ['C', 'D', 'E', 'F#', 'G#', 'A#']
_scale2 = ['C', 'D', 'E', 'Gb', 'Ab', 'Bb']
_scale3 = ['C#', 'D#', 'F', 'G', 'A', 'B']
_scale4 = ['Db', 'Eb', 'F', 'G', 'A', 'B']
_oct = self._base_note.octave
for _scale_str_list in [_scale1, _scale2, _scale3, _scale4]:
_note_str = "{}{}".format(self._base_note.letter,
self._base_note.alteration)
if _note_str in _scale_str_list:
_note_idx = _scale_str_list.index(_note_str)
_scale_part1 = [
Note.from_str("{}{}".format(n, _oct))
for n in _scale_str_list[_note_idx:]
]
_scale_part2 = [
Note.from_str("{}{}".format(n, _oct)).get_8va()
for n in _scale_str_list[:_note_idx]
]
print('full wholetone mode computed ok')
self._scale = _scale_part1 + _scale_part2
break
def get_last_note(self, alteration):
"""
(f0, note, name) with:
f0: FFT main frequency
note: corresponding note if found (with respect to A4=440Hz)
name: name of the note
"""
f0 = self.last_rec_f0()
if f0 is None:
return None
note_a4_index = self._get_a4index(f0)
if note_a4_index is None:
return None
found_note = Note.from_a440(note_a4_index, str(alteration))
print('Hearing:', found_note.to_str())
return found_note
from src.Note import Note
from src.ScaleManager import ScaleManager
from src.Arpeggiator import Arpeggiator
if __name__ == '__main__':
sm = ScaleManager()
print('C Major UP: ', end='')
sm._set_scale('Major', Note('C', 4), mode=0)
sm.set_arp(Arpeggiator.UP)
while not sm.is_arp_done():
print(sm.next_arp_note().to_str(), end='')
if not sm.is_arp_done():
print(', ', end='')
print()
print('C Major UP-DOWN: ', end='')
sm._set_scale('Major', Note('C', 4), mode=0)
sm.set_arp(Arpeggiator.UP_DOWN)
while not sm.is_arp_done():
print(sm.next_arp_note().to_str(), end='')
if not sm.is_arp_done():
print(', ', end='')
print()
print('C Major THIRDS-UP: ', end='')
sm._set_scale('Major', Note('C', 4), mode=0)
sm.set_arp(Arpeggiator.THIRDS_UP)
while not sm.is_arp_done():
print(sm.next_arp_note().to_str(), end='')
if not sm.is_arp_done():
class ScaleManager:
VALID_MODES = {
'Major': {
1: 'I - Ionian',
2: 'II - Dorian',
3: 'III - Phrygian',
4: 'IV - Lydian',
5: 'V - Mixolydian',
6: 'VI - Aeolian (Minor)',
7: 'VII - Locrian'
},
'Minor': None,
'Melodic Minor': {
1: 'I - Melodic minor',
2: 'II - Dorian b2 / Phrygian #6',
3: 'III -Lydian augmented',
4: 'IV - Lydian b6',
5: 'V - Mixolydian b6',
6: 'VI - Eolian b2',
7: 'VII - Alterate'
},
'Harmonic minor': {
1: 'I - Harmonic minor',
2: 'II - Locrian #6',
3: 'III - Ionian augmented',
4: 'IV - Dorian #4 / Ukrainian dorian',
5: 'V - Mixolydian b2 b6 / Phrygian Dominant',
6: 'VI - Lydian #2',
7: 'VII - Alterate bb7'
},
'Pentatonic': {
1: 'I - Pentatonic Major',
5: 'V - Pentatonic Minor'
},
'Whole-tone': None,
'Chromatic': None
}
# VALID_SCALES = {
# 'Major': {
# '': ('C', 'D', 'E', 'F', 'G', 'A', 'B'),
# '#': ('C', 'D', 'F', 'G', 'A'),
# 'b': ('D', 'E', 'G', 'A', 'B')
# },
# 'Minor': {
# '': ('C', 'D', 'E', 'F', 'G', 'A', 'B'),
# '#': ('C', 'D', 'F', 'G', 'A'),
# 'b': ('D', 'E', 'G', 'A', 'B')
# },
# 'Whole-tone': {
# '': ('C', 'D', 'E', 'F', 'G', 'A', 'B'),
# '#': ('C', 'D', 'F', 'G', 'A'),
# 'b': ('D', 'E', 'G', 'A', 'B')
# },
# 'Chromatic': {
# '': ('C', 'D', 'E', 'F', 'G', 'A', 'B'),
# '#': ('C', 'D', 'F', 'G', 'A'),
# 'b': ('D', 'E', 'G', 'A', 'B')
# }
# }
MAJOR_INTERVALS = (Intervals.SECOND_MAJOR, Intervals.SECOND_MAJOR,
Intervals.SECOND_MINOR, Intervals.SECOND_MAJOR,
Intervals.SECOND_MAJOR, Intervals.SECOND_MAJOR,
Intervals.SECOND_MINOR)
MINOR_INTERVALS = (
Intervals.SECOND_MAJOR, # C -> D
Intervals.SECOND_MINOR, # D -> Eb
Intervals.SECOND_MAJOR, # Eb -> F
Intervals.SECOND_MAJOR, # F -> G
Intervals.SECOND_MINOR, # G -> Ab
Intervals.SECOND_MAJOR, # Ab -> Bb
Intervals.SECOND_MAJOR # Bb -> C
)
MINOR_HARMONIC_INTERVALS = (
Intervals.SECOND_MAJOR, # C -> D
Intervals.SECOND_MINOR, # D -> Eb
Intervals.SECOND_MAJOR, # Eb -> F
Intervals.SECOND_MAJOR, # F -> G
Intervals.SECOND_MINOR, # G -> Ab
Intervals.SECOND_AUGMENTED, # Ab -> B
Intervals.SECOND_MINOR # B -> C
)
MINOR_MELODIC_INTERVALS = (
Intervals.SECOND_MAJOR, # C -> D
Intervals.SECOND_MINOR, # D -> Eb
Intervals.SECOND_MAJOR, # Eb -> F
Intervals.SECOND_MAJOR, # F -> G
Intervals.SECOND_MAJOR, # G -> A
Intervals.SECOND_MAJOR, # A -> B
Intervals.SECOND_MINOR # B -> C
)
PENTATONIC_INTERVALS = (
Intervals.SECOND_MAJOR, # C -> D
Intervals.SECOND_MAJOR, # D -> E
Intervals.THIRD_MINOR, # E -> G
Intervals.SECOND_MAJOR, # G -> A
Intervals.THIRD_MINOR # A -> C
)
def __init__(self, scale_name='Major', base_note=Note(), mode=1):
"""
:param scale_name: str
:param base_note: first note of the scale
:param mode: from 1 to 7
"""
self._scale = None
self._scale_name = scale_name
self._mode = mode
self._base_note = base_note
self._init_scale()
def _init_scale(self):
if not self._is_valid_scale():
print('ERROR: not valid scale "{} {} - mode {}"'.format(
str(self._base_note), self._scale_name, self._mode))
exit(0)
print('ScaleManager: setting scale {} {} - mode {}'.format(
str(self._base_note), self._scale_name, self._mode))
if self._scale_name == 'Major':
self._init_7deg_scale(ScaleManager.MAJOR_INTERVALS,
allow_modes=True)
elif self._scale_name == 'Minor':
self._init_7deg_scale(ScaleManager.MINOR_INTERVALS,
allow_modes=False)
elif self._scale_name == 'Melodic Minor':
self._init_7deg_scale(ScaleManager.MINOR_MELODIC_INTERVALS,
allow_modes=True)
elif self._scale_name == 'Harmonic Minor':
self._init_7deg_scale(ScaleManager.MINOR_HARMONIC_INTERVALS,
allow_modes=True)
elif self._scale_name == 'Pentatonic':
self._init_pentatonic_scale()
elif self._scale_name == 'Whole-tone':
self._init_wholetone_scale()
elif self._scale_name == 'Chromatic':
self._init_chromatic_scale()
else:
print('ERROR: unknown scale "{}"'.format(self._scale_name))
exit(0)
def _is_valid_scale(self):
_letter = self._base_note.letter
_alt = str(self._base_note.alteration)
# if self._scale_name not in ScaleManager.VALID_SCALES.keys():
# return False
# if _alt not in ScaleManager.VALID_SCALES[self._scale_name]:
# return False
# if _letter not in ScaleManager.VALID_SCALES[self._scale_name][_alt]:
# return False
_available_modes = ScaleManager.VALID_MODES[self._scale_name]
if _available_modes is not None:
if self._mode not in _available_modes.keys():
return False
return True
def _init_7deg_scale(self, scale_intervals, allow_modes=False):
if allow_modes:
_mode_idx = self._mode - 1
mode_intervals = scale_intervals[
_mode_idx:] + scale_intervals[:_mode_idx]
else:
mode_intervals = scale_intervals
current_note = self._base_note
self._scale = [current_note]
for next_scale_note, interval in zip(mode_intervals[1:],
mode_intervals[:-1]):
next_note = current_note.add_interval(interval)
self._scale.append(next_note)
current_note = next_note
def _init_pentatonic_scale(self):
scale_intervals = ScaleManager.PENTATONIC_INTERVALS
_mode_idx = self._mode - 1
mode_intervals = scale_intervals[
_mode_idx:] + scale_intervals[:_mode_idx]
current_note = self._base_note
self._scale = [current_note]
for next_scale_note, interval in zip(mode_intervals[1:],
mode_intervals[:-1]):
next_note = current_note.add_interval(interval)
self._scale.append(next_note)
current_note = next_note
def _init_wholetone_scale(self):
_scale1 = ['C', 'D', 'E', 'F#', 'G#', 'A#']
_scale2 = ['C', 'D', 'E', 'Gb', 'Ab', 'Bb']
_scale3 = ['C#', 'D#', 'F', 'G', 'A', 'B']
_scale4 = ['Db', 'Eb', 'F', 'G', 'A', 'B']
_oct = self._base_note.octave
for _scale_str_list in [_scale1, _scale2, _scale3, _scale4]:
_note_str = "{}{}".format(self._base_note.letter,
self._base_note.alteration)
if _note_str in _scale_str_list:
_note_idx = _scale_str_list.index(_note_str)
_scale_part1 = [
Note.from_str("{}{}".format(n, _oct))
for n in _scale_str_list[_note_idx:]
]
_scale_part2 = [
Note.from_str("{}{}".format(n, _oct)).get_8va()
for n in _scale_str_list[:_note_idx]
]
print('full wholetone mode computed ok')
self._scale = _scale_part1 + _scale_part2
break
def _init_chromatic_scale(self):
_scale_sharps = [
'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'
]
_scale_flats = [
'C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B'
]
_oct = self._base_note.octave
for _scale_str_list in [_scale_sharps, _scale_flats]:
_note_str = "{}{}".format(self._base_note.letter,
self._base_note.alteration)
if _note_str in _scale_str_list:
_note_idx = _scale_str_list.index(_note_str)
_scale_part1 = [
Note.from_str("{}{}".format(n, _oct))
for n in _scale_str_list[_note_idx:]
]
_scale_part2 = [
Note.from_str("{}{}".format(n, _oct)).get_8va()
for n in _scale_str_list[:_note_idx]
]
print('full wholetone mode computed ok')
self._scale = _scale_part1 + _scale_part2
break
def get_scale(self, add_octave=0):
_sc = self._scale
for i in range(add_octave):
_sc = [note.get_8va() for note in _sc]
return _sc
# def get_mode(self, mode=1, add_octave=0):
# _scale = self.get_scale(add_octave=add_octave)
# _mode = mode-1
# _part_a = _scale[_mode:]
# _part_b = [n.get_8va() for n in _scale[:_mode]]
# return _part_a + _part_b
def set_scale(self, name, mode):
self._scale_name = name
self._mode = mode
self._init_scale()
def set_basenote(self, letter, alteration):
self._base_note = Note(letter, self._base_note.octave, alteration)
self._init_scale()
def set_octave(self, octave=4):
self._base_note = self._base_note.get_8va(octave -
self._base_note.octave)
self._init_scale()
def get_octave(self):
return self._base_note.octave
def set_basenote(self, letter, alteration):
self._base_note = Note(letter, self._base_note.octave, alteration)
self._init_scale()