def test__create_cycles(self):
patterns = [
[0],
[0, 1],
[0, 1, 2]
]
cycles = Handler._create_cycles(patterns)
for cycle in cycles:
self.assertIsInstance(cycle, Cycle)
def __init__(self,
music_maker=None,
height_envelope_patterns=None,
height_envelopes=None,
height_envelopes_release=None,
pressure_envelope_patterns=None,
pressure_envelopes=None,
staccato_patterns=None,
string_index_patterns=None,
tremolo_patterns=None,
jete_patterns=None,
sweep_patterns=None,
direction_patterns=None,
number_of_staff_lines=31,
show_rhythmic_notation=True):
EnvelopeHandler.__init__(
self,
music_maker=music_maker,
number_of_staff_lines=number_of_staff_lines,
show_rhythmic_notation=show_rhythmic_notation
)
self._height_envelope_patterns = \
Handler._create_cycles(height_envelope_patterns)
self._height_envelopes = height_envelopes
if height_envelopes_release is None:
self._height_envelopes_release = height_envelopes
else:
self._height_envelopes_release = height_envelopes_release
self._pressure_envelope_patterns = \
Handler._create_cycles(pressure_envelope_patterns)
self._pressure_envelopes = pressure_envelopes
self._staccato_patterns = Handler._create_cycles(staccato_patterns)
self._string_index_patterns = \
Handler._create_cycles(string_index_patterns)
self._tremolo_patterns = Handler._create_cycles(tremolo_patterns)
self._jete_patterns = Handler._create_cycles(jete_patterns)
self._sweep_patterns = Handler._create_cycles(sweep_patterns)
self._direction_patterns = Handler._create_cycles(direction_patterns)
def __init__(self,
music_maker=None,
height_envelope_patterns=None,
height_envelopes=None,
height_envelopes_release=None,
pressure_envelope_patterns=None,
pressure_envelopes=None,
staccato_patterns=None,
string_index_patterns=None,
tremolo_patterns=None,
jete_patterns=None,
sweep_patterns=None,
direction_patterns=None,
number_of_staff_lines=31,
show_rhythmic_notation=True):
EnvelopeHandler.__init__(self,
music_maker=music_maker,
number_of_staff_lines=number_of_staff_lines,
show_rhythmic_notation=show_rhythmic_notation)
self._height_envelope_patterns = \
Handler._create_cycles(height_envelope_patterns)
self._height_envelopes = height_envelopes
if height_envelopes_release is None:
self._height_envelopes_release = height_envelopes
else:
self._height_envelopes_release = height_envelopes_release
self._pressure_envelope_patterns = \
Handler._create_cycles(pressure_envelope_patterns)
self._pressure_envelopes = pressure_envelopes
self._staccato_patterns = Handler._create_cycles(staccato_patterns)
self._string_index_patterns = \
Handler._create_cycles(string_index_patterns)
self._tremolo_patterns = Handler._create_cycles(tremolo_patterns)
self._jete_patterns = Handler._create_cycles(jete_patterns)
self._sweep_patterns = Handler._create_cycles(sweep_patterns)
self._direction_patterns = Handler._create_cycles(direction_patterns)
def __init__(
self,
music_maker=None,
height_envelope_patterns=None,
height_envelopes=None,
height_envelopes_release=None,
pressure_envelope_patterns=None,
pressure_envelopes=None,
tremolo_patterns=None,
vibrato_patterns=None,
number_of_staff_lines=31,
show_rhythmic_notation=True,
):
EnvelopeHandler.__init__(self,
music_maker=music_maker,
number_of_staff_lines=number_of_staff_lines,
show_rhythmic_notation=show_rhythmic_notation)
self._height_envelope_patterns = \
Handler._create_cycles(height_envelope_patterns)
self._height_envelopes = height_envelopes
if height_envelopes_release is None:
self._height_envelopes_release = height_envelopes
else:
self._height_envelopes_release = height_envelopes_release
self._pressure_envelope_patterns = \
Handler._create_cycles(pressure_envelope_patterns)
self._pressure_envelopes = pressure_envelopes
self._tremolo_patterns = Handler._create_cycles(tremolo_patterns)
self._vibrato_patterns = Handler._create_cycles(vibrato_patterns)
def test__cycle_next(self):
patterns = [
[0],
[0, 1],
]
cycles = Handler._create_cycles(patterns)
next_cycle = Handler._cycle_next(cycles, 0)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 0)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 1)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 0)
def test__cycle_next(self):
patterns = [
[0],
[0, 1],
]
cycles = Handler._create_cycles(patterns)
next_cycle = Handler._cycle_next(cycles, 0)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 0)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 1)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 0)
def __init__(self,
music_maker=None,
air_pressure_envelope_patterns=None,
air_pressure_envelopes=None,
air_pressure_envelopes_release=None,
lip_pressure_envelope_patterns=None,
lip_pressure_envelopes=None,
consonant_patterns=None,
fluttertongue_patterns=None,
direction_patterns=None,
staccato_patterns=None,
vibrato_patterns=None,
vowel_patterns=None,
number_of_staff_lines=15,
show_rhythmic_notation=True):
EnvelopeHandler.__init__(self,
music_maker=music_maker,
number_of_staff_lines=number_of_staff_lines,
show_rhythmic_notation=show_rhythmic_notation)
self._air_pressure_envelope_patterns = \
Handler._create_cycles(air_pressure_envelope_patterns)
self._air_pressure_envelopes = air_pressure_envelopes
self._air_pressure_envelopes_release = air_pressure_envelopes_release
self._lip_pressure_envelope_patterns = \
Handler._create_cycles(lip_pressure_envelope_patterns)
self._lip_pressure_envelopes = lip_pressure_envelopes
self._consonant_patterns = Handler._create_cycles(consonant_patterns)
self._direction_patterns = Handler._create_cycles(direction_patterns)
self._fluttertongue_patterns = \
Handler._create_cycles(fluttertongue_patterns)
self._staccato_patterns = Handler._create_cycles(staccato_patterns)
self._vibrato_patterns = Handler._create_cycles(vibrato_patterns)
self._vowel_patterns = Handler._create_cycles(vowel_patterns)
class TestHandler(unittest.TestCase):
def setUp(self):
stages = (0, )
instrument = abjad.instrumenttools.Contrabass()
rhythm_makers = [abjad.rhythmmakertools.NoteRhythmMaker()]
time_signatures = [[
abjad.TimeSignature((4, 4)),
abjad.TimeSignature((4, 4))
]]
music_maker = MusicMaker(stages=stages,
instrument=instrument,
name='test',
rhythm_makers=rhythm_makers,
time_signatures=time_signatures)
self.handler = Handler(music_maker)
def test__add_stem_tremolo(self):
voice = abjad.Voice("c'1")
tie = abjad.inspect(voice[0]).get_logical_tie()
self.handler._add_stem_tremolo(tie, tremolo_flags=32)
prototype = abjad.StemTremolo(32)
self.assertEqual(
prototype,
abjad.inspect(voice[0]).get_indicator(prototype=prototype))
def test__add_gliss_skip(self):
note = abjad.Note("c'1")
self.handler._add_gliss_skip(note)
def test__attach_glissando(self):
note = abjad.Note("c'1")
self.handler._attach_glissando(note)
def test__create_cycles(self):
patterns = [[0, 1, 2, 3], [True, False]]
cycles = self.handler._create_cycles(patterns)
for cycle in cycles:
self.assertIsInstance(cycle, Cycle)
def test__get_consecutive_note_groups(self):
voice = abjad.Voice("c'4 c'4 r4 c'4")
groups = self.handler._get_consecutive_note_groups(voice)
self.assertEqual(len(groups[0]), 2)
self.assertEqual(len(groups[1]), 1)
def test__hidden_grace_after(self):
note = abjad.Note("c'1")
self.handler._hidden_grace_after(note)
grace_container = abjad.inspect(note).get_after_grace_container()
self.assertEqual(str(grace_container[0]),
str(abjad.Note(0, abjad.Duration(1, 16))))
def test__hide_and_skip_tied_notes(self):
voice = abjad.Voice("c'4 ~ c'16 r8.")
for tie in abjad.iterate(voice).by_logical_tie(pitched=True):
self.handler._hide_and_skip_tied_notes(tie)
def test__hide_note_head(self):
note = abjad.Note("c'1")
self.handler._hide_note_head(note)
chord = abjad.Chord("<c' e' g'>4")
self.handler._hide_note_head(chord)
def test__iterate_logical_ties(self):
voice = abjad.Voice("c'4 ~ c'16 c'8. c'2")
for tie, offset_start, offset_end, i, count in \
self.handler._iterate_logical_ties(voice):
self.assertIsInstance(tie, abjad.selectiontools.LogicalTie)
self.assertIsInstance(offset_start, float)
self.assertIsInstance(offset_end, float)
def test__make_circle_markup(self):
markup = self.handler._make_circle_markup(1)
self.assertIsInstance(markup, abjad.Markup)
def test__make_circle_outline_markup(self):
markup = self.handler._make_circle_outline_markup(1)
self.assertIsInstance(markup, abjad.Markup)
def test__make_half_circle_markup(self):
markup = self.handler._make_half_circle_markup(1)
self.assertIsInstance(markup, abjad.Markup)
def test__make_text_markup(self):
markup = self.handler._make_text_markup('x')
self.assertIsInstance(markup, abjad.Markup)
def test_markup_to_note_head(self):
note = abjad.Note("c'1")
markup = self.handler._make_text_markup('x')
self.handler._markup_to_notehead(note, markup)
def test__name_voices(self):
voice = abjad.Voice("c'1")
rhythm_voice = abjad.Voice("c'1")
self.handler._name_voices(voice, rhythm_voice)
def test_integer_to_roman_numeral(self):
self.assertEqual(Handler.integer_to_roman_numeral(1), 'I')
def test__create_cycles(self):
patterns = [[0], [0, 1], [0, 1, 2]]
cycles = Handler._create_cycles(patterns)
for cycle in cycles:
self.assertIsInstance(cycle, Cycle)
def test__create_cycles(self):
patterns = [[0], [0, 1], [0, 1, 2]]
cycles = Handler._create_cycles(patterns)
for cycle in cycles:
self.assertIsInstance(cycle, Cycle)
def test__cycle_next(self):
patterns = [
[0],
[0, 1],
]
cycles = Handler._create_cycles(patterns)
next_cycle = Handler._cycle_next(cycles, 0)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 0)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 1)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 0)
def test__create_cycles(self):
patterns = [[0], [0, 1], [0, 1, 2]]
cycles = Handler._create_cycles(patterns)
for cycle in cycles:
self.assertIsInstance(cycle, Cycle)
class TestHandler(unittest.TestCase):
def setUp(self):
stages = (0,)
instrument = abjad.instrumenttools.Contrabass()
rhythm_makers = [abjad.rhythmmakertools.NoteRhythmMaker()]
time_signatures = [
[abjad.TimeSignature((4, 4)), abjad.TimeSignature((4, 4))]
]
music_maker = MusicMaker(
stages=stages,
instrument=instrument,
name='test',
rhythm_makers=rhythm_makers,
time_signatures=time_signatures)
self.handler = Handler(music_maker)
def test__add_stem_tremolo(self):
voice = abjad.Voice("c'1")
tie = abjad.inspect(voice[0]).get_logical_tie()
self.handler._add_stem_tremolo(tie, tremolo_flags=32)
prototype = abjad.StemTremolo(32)
self.assertEqual(
prototype,
abjad.inspect(voice[0]).get_indicator(prototype=prototype)
)
def test__add_gliss_skip(self):
note = abjad.Note("c'1")
self.handler._add_gliss_skip(note)
def test__attach_glissando(self):
note = abjad.Note("c'1")
self.handler._attach_glissando(note)
def test__create_cycles(self):
patterns = [[0, 1, 2, 3], [True, False]]
cycles = self.handler._create_cycles(patterns)
for cycle in cycles:
self.assertIsInstance(cycle, Cycle)
def test__get_consecutive_note_groups(self):
voice = abjad.Voice("c'4 c'4 r4 c'4")
groups = self.handler._get_consecutive_note_groups(voice)
self.assertEqual(len(groups[0]), 2)
self.assertEqual(len(groups[1]), 1)
def test__hidden_grace_after(self):
note = abjad.Note("c'1")
self.handler._hidden_grace_after(note)
grace_container = abjad.inspect(note).get_after_grace_container()
self.assertEqual(
str(grace_container[0]),
str(abjad.Note(0, abjad.Duration(1, 16)))
)
def test__hide_and_skip_tied_notes(self):
voice = abjad.Voice("c'4 ~ c'16 r8.")
for tie in abjad.iterate(voice).by_logical_tie(pitched=True):
self.handler._hide_and_skip_tied_notes(tie)
def test__hide_note_head(self):
note = abjad.Note("c'1")
self.handler._hide_note_head(note)
chord = abjad.Chord("<c' e' g'>4")
self.handler._hide_note_head(chord)
def test__iterate_logical_ties(self):
voice = abjad.Voice("c'4 ~ c'16 c'8. c'2")
for tie, offset_start, offset_end, i, count in \
self.handler._iterate_logical_ties(voice):
self.assertIsInstance(tie, abjad.selectiontools.LogicalTie)
self.assertIsInstance(offset_start, float)
self.assertIsInstance(offset_end, float)
def test__make_circle_markup(self):
markup = self.handler._make_circle_markup(1)
self.assertIsInstance(markup, abjad.Markup)
def test__make_circle_outline_markup(self):
markup = self.handler._make_circle_outline_markup(1)
self.assertIsInstance(markup, abjad.Markup)
def test__make_half_circle_markup(self):
markup = self.handler._make_half_circle_markup(1)
self.assertIsInstance(markup, abjad.Markup)
def test__make_text_markup(self):
markup = self.handler._make_text_markup('x')
self.assertIsInstance(markup, abjad.Markup)
def test_markup_to_note_head(self):
note = abjad.Note("c'1")
markup = self.handler._make_text_markup('x')
self.handler._markup_to_notehead(note, markup)
def test__name_voices(self):
voice = abjad.Voice("c'1")
rhythm_voice = abjad.Voice("c'1")
self.handler._name_voices(voice, rhythm_voice)
def test_integer_to_roman_numeral(self):
self.assertEqual(Handler.integer_to_roman_numeral(1), 'I')
def test__create_cycles(self):
patterns = [
[0],
[0, 1],
[0, 1, 2]
]
cycles = Handler._create_cycles(patterns)
for cycle in cycles:
self.assertIsInstance(cycle, Cycle)
def test__create_cycles(self):
patterns = [
[0],
[0, 1],
[0, 1, 2]
]
cycles = Handler._create_cycles(patterns)
for cycle in cycles:
self.assertIsInstance(cycle, Cycle)
def test__cycle_next(self):
patterns = [
[0],
[0, 1],
]
cycles = Handler._create_cycles(patterns)
next_cycle = Handler._cycle_next(cycles, 0)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 0)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 0)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 1)
next_cycle = Handler._cycle_next(cycles, 1)
self.assertEqual(next_cycle, 0)