def test_nested_child_sequences(make_note_config, note_sequence):
note_sequence_len = len(note_sequence)
child_sequence = NoteSequence.copy(_note_sequence(mn=make_note_config))
child_sequence_len = len(child_sequence)
child_child_sequence = NoteSequence.copy(
_note_sequence(mn=make_note_config))
child_child_sequence_len = len(child_child_sequence)
child_sequence.append_child_sequence(child_child_sequence)
note_sequence.append_child_sequence(child_sequence)
assert len(note_sequence.child_sequences) == 1
assert len(
note_sequence
) == note_sequence_len + child_sequence_len + child_child_sequence_len
def test_copy(note_sequence):
note_sequence[0].amplitude = AMP
note_sequence[1].amplitude = AMP + 1
new_note_sequence = NoteSequence.copy(note_sequence)
assert id(note_sequence) != id(new_note_sequence)
assert new_note_sequence[0].amplitude == note_sequence[0].amplitude
assert new_note_sequence[1].amplitude == note_sequence[1].amplitude
def __setitem__(self, index: int, note_sequence: NoteSequence) -> None:
validate_types(('index', index, int),
('note_sequence', note_sequence, NoteSequence))
if abs(index) >= len(self.note_seq_seq):
raise IndexError(
f'`index` out of range index: {index} len(note_seq_seq): {len(self.note_seq_seq)}'
)
self.note_seq_seq[index] = NoteSequence.copy(note_sequence)
def test_make_notes(make_note_config, note_sequence):
assert len(note_sequence) == 2
notes = note_sequence.notes()
assert notes
assert len(notes) == 2
child_sequence = NoteSequence.copy(_note_sequence(mn=make_note_config))
child_child_sequence = NoteSequence.copy(
_note_sequence(mn=make_note_config))
child_sequence.append_child_sequence(child_child_sequence)
note_sequence.append_child_sequence(child_sequence)
assert len(note_sequence) == 6
notes = note_sequence.notes()
assert len(notes) == 6
for note in notes:
assert note.amplitude == 0.0
def test_child_sequences(make_note_config, note_sequence):
child_sequence = NoteSequence.copy(note_sequence)
child_sequence[0].amplitude = AMP
init_len = len(note_sequence)
note_sequence.append_child_sequence(child_sequence)
assert len(note_sequence.child_sequences) == 1
assert len(note_sequence) == init_len + len(child_sequence)
child_sequence = note_sequence.child_sequences[0]
assert child_sequence[0].amplitude == AMP
# Add another note_sequence
child_sequence_2 = NoteSequence.copy(_note_sequence(mn=make_note_config))
note_sequence.append_child_sequence(child_sequence_2)
assert len(note_sequence.child_sequences) == 2
assert len(note_sequence
) == init_len + len(child_sequence) + len(child_sequence_2)
# NOTE: IF WE ADD A SEQUENCE TO ITSELF IT IS A CYCLE AND WE ARE IN INFINITE LOOP
# Validate that attempting to create a cycle by appending a note to be its own child raises
with pytest.raises(ValueError):
note_sequence.append_child_sequence(note_sequence)
def copy(other: 'NoteSequenceSequence'):
return NoteSequenceSequence(
[NoteSequence.copy(note_seq) for note_seq in other.note_seq_seq])
def test_eq(note_sequence):
new_note_sequence = NoteSequence.copy(note_sequence)
assert note_sequence == new_note_sequence
note_sequence[0].amplitude = AMP
assert note_sequence != new_note_sequence
