Beispiel #1
0
    def test_str_with_modifiers(self):
        note = Note('d', OctaveType.GREAT, 16)
        note.add_modifier(NoteModifier.TIE)
        self.assertEqual('d,16~', str(note))

        note.add_modifier(NoteModifier.DOT)
        self.assertEqual('d,16.~', str(note))
Beispiel #2
0
    def test_add_modifier_dot_removes_double_dot(self):
        note = Note('c')
        note.add_modifier(NoteModifier.DOUBLE_DOT)
        note.add_modifier(NoteModifier.DOT)

        self.assertTrue(NoteModifier.DOT in note.modifiers)
        self.assertTrue(NoteModifier.DOUBLE_DOT not in note.modifiers)
Beispiel #3
0
    def test_add_remove_modifier(self):
        note = Note('c')
        note.add_modifier(NoteModifier.DOT)
        self.assertTrue(NoteModifier.DOT in note.modifiers)

        note.remove_modifier(NoteModifier.DOT)
        self.assertTrue(NoteModifier.DOT not in note.modifiers)
Beispiel #4
0
    def test_split_to_bars_with_dot(self):
        self.generator.set_bar_count(2)
        self.generator.set_shortest_note_duration(16)

        with_dot = Note('e', base_duration=4)
        with_dot.add_modifier(NoteModifier.DOT)

        data: List[Writeable] = [
            Note('c', base_duration=2),
            Note('d'), with_dot,
            Note('f', base_duration=8),
            Note('c', base_duration=2),
            Rest()
        ]

        with_tie = Note('e', base_duration=4)
        with_tie.add_modifier(NoteModifier.TIE)

        expected: List[List[Writeable]] = [[
            Note('c', base_duration=2),
            Note('d'), with_tie
        ],
                                           [
                                               Note('e', base_duration=8),
                                               Note('f', base_duration=8),
                                               Note('c', base_duration=2),
                                               Rest()
                                           ]]

        bars: List[List[Writeable]] = self.generator.split_to_bars(data)
        self.assertEqual(expected, bars)
Beispiel #5
0
    def test_modifiers_order(self):
        note = Note('c')
        note.add_modifier(NoteModifier.TIE)
        note.add_modifier(NoteModifier.DOT)

        self.assertEqual(2, len(note.modifiers))
        self.assertEqual(NoteModifier.TIE, note.modifiers[1])
        self.assertEqual(NoteModifier.DOT, note.modifiers[0])
Beispiel #6
0
    def test_get_duration_with_double_dot(self):
        note = Note('c', base_duration=4)
        note.add_modifier(NoteModifier.DOUBLE_DOT)
        lengths = [64, 32, 16]

        for length in lengths:
            self.assertEqual(length / 4 + length / 8 + length / 16,
                             note.get_duration(length))
Beispiel #7
0
    def get_random_note(self, longest_duration: Optional[int] = None) -> Note:
        """
        Wygeneruj nutę z losowymi parametrami o pewnej maksymalnej długości podanej w parametrze.

        Args:
            longest_duration:   Najdłuższa możliwa wartość rytmiczna, która może wystąpić podana w ilości
                                shortest_note_duration.
                                Jeśli nie podano, skrypt zakłada że nuta o każdej długości jest dozwolona.

        Returns:
            Nuta z losowymi parametrami o maksymalnej długości wynoszącej longest_duration
        """
        # Jeśli nie był podany parametr najdłuższej możliwej wartości rytmicznej, to zakładamy że nuta o każdej długości
        # jest dozwolona do wygenerowania
        if longest_duration is None:
            longest_duration = self.shortest_note_duration

        available_mods = []

        base_note = np.random.choice(Note.base_notes)
        octave = OctaveType.random()
        base_duration = self.get_random_duration(
            longest_duration=longest_duration)
        has_mod = np.random.choice([True, False])

        note = Note(note=base_note, octave=octave, base_duration=base_duration)

        # Jeśli długość nuty jest najkrótsza jaką możemy uzyskać, to nie możemy dodać modyfikatora wydłużającego,
        # gdyż kropka lub podwójna kropka doda mniejszą wartość rytmiczną
        if base_duration >= self.shortest_note_duration:
            has_mod = False

        # Jeśli dostępne miejsce jest większej lub równej długości niż potencjalna nuta z kropką, to do dostępnych
        # modyfikatorów możemy dodać przedłużenie w postaci kropki
        if longest_duration >= note.get_duration(
                self.shortest_note_duration) * 1.5:
            available_mods.append(NoteModifier.DOT)

        # Jeśli dostępne miejsce jest większej lub równej długości niż potencjalna nuta z podwójną kropką, to do
        # dostępnych modyfikatorów możemy dodać przedłużenie w postaci podwójnej kropki.
        # Sprawdzamy również, czy nie jest to przedostatnia dostępna wartość rytmiczna. Jeśli tak jest, to nie możemy
        # dodać podwójnej kropki, gdyż skutkowałoby to dodaniem nuty o połowę mniejszej wartości rytmicznej niż
        # dozwolona
        if longest_duration >= note.get_duration(self.shortest_note_duration) * 1.75 \
                and note.base_duration > 2 * self.shortest_note_duration:
            available_mods.append(NoteModifier.DOUBLE_DOT)

        if has_mod and len(available_mods) > 0:
            note.add_modifier(np.random.choice(available_mods))

        return note
Beispiel #8
0
    def test_split_to_bars_break(self):
        self.generator.set_bar_count(2)
        self.generator.set_shortest_note_duration(16)
        notes: List[Writeable] = [
            Note('c'),
            Note('c', base_duration=2),
            Note('c', base_duration=2),
            Note('c', base_duration=2),
            Rest()
        ]

        with_tie = Note('c')
        with_tie.add_modifier(NoteModifier.TIE)

        expected: List[List[Writeable]] = [[
            Note('c'), Note('c', base_duration=2), with_tie
        ], [Note('c'), Note('c', base_duration=2),
            Rest()]]

        bars: List[List[Writeable]] = self.generator.split_to_bars(notes)

        self.assertEqual(expected, bars)
Beispiel #9
0
    def test_add_modifier_unique(self):
        note = Note('c')
        note.add_modifier(NoteModifier.DOT)
        note.add_modifier(NoteModifier.DOT)

        self.assertEqual(1, len(note.modifiers))