def test_rhythmmakertools_TaleaRhythmMaker_tie_split_notes_02():

    talea = rhythmmakertools.Talea(
        counts=[5],
        denominator=16,
        )
    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        )

    divisions = [(3, 16), (5, 8), (4, 8), (7, 16)]
    result = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    measures = abjad.mutate(staff).replace_measure_contents(result)

    assert format(staff) == abjad.String.normalize(
        r'''
        \new Staff
        {
            {   % measure
                \time 3/16
                c'8.
                ~
            }   % measure
            {   % measure
                \time 5/8
                c'8
                c'4
                ~
                c'16
                [
                c'8.
                ~
                ]
            }   % measure
            {   % measure
                \time 4/8
                c'8
                c'4
                ~
                c'16
                [
                c'16
                ~
                ]
            }   % measure
            {   % measure
                \time 7/16
                c'4
                c'8.
            }   % measure
        }
        '''
        )

    assert abjad.inspect(staff).is_well_formed()
Esempio n. 2
0
def test_rhythmmakertools_TieSpecifier_01():

    divisions = [(3, 8), (5, 16), (1, 4), (5, 16)]
    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        burnish_specifier=rhythmmakertools.BurnishSpecifier(
            left_classes=[abjad.Rest, abjad.Note],
            left_counts=[1],
        ),
        extra_counts_per_division=[0, 1, 1],
        talea=rhythmmakertools.Talea(
            counts=[1, 2, 3],
            denominator=16,
        ),
        tie_specifier=rhythmmakertools.TieSpecifier(
            tie_across_divisions=True, ),
    )
    selections = rhythm_maker(divisions)
    staff = abjad.Staff(selections)

    assert format(staff) == abjad.String.normalize(r'''
        \new Staff
        {
            \tweak text #tuplet-number::calc-fraction-text
            \times 1/1 {
                r16
                c'8
                [
                c'8.
                ~
                ]
            }
            \tweak text #tuplet-number::calc-fraction-text
            \times 5/6 {
                c'16
                [
                c'8
                c'8.
                ]
            }
            \times 4/5 {
                r16
                c'8
                [
                c'8
                ~
                ]
            }
            \tweak text #tuplet-number::calc-fraction-text
            \times 1/1 {
                c'16
                [
                c'16
                c'8
                c'16
                ]
            }
        }
        ''')
def test_rhythmmakertools_DurationSpecifier_01():
    r'''DurationSpecifier does not leave parent references.
    '''

    beam_specifier = rhythmmakertools.BeamSpecifier(
        beam_each_division=True,
        beam_divisions_together=False,
        use_feather_beams=False,
        )

    duration_specifier = rhythmmakertools.DurationSpecifier(
        decrease_monotonic=True,
        forbid_meter_rewriting=False,
        rewrite_meter=True,
        spell_metrically='unassignable',
        )

    logical_tie_masks = [abjad.silence([0], 2)]

    talea = rhythmmakertools.Talea(counts=[1, 2, 3, 4], denominator=16)

    maker = rhythmmakertools.TaleaRhythmMaker(
        beam_specifier=beam_specifier,
        duration_specifier=duration_specifier,
        logical_tie_masks=logical_tie_masks,
        talea=talea,
        )

    divisions = [abjad.TimeSignature((3, 8)), abjad.TimeSignature((2, 4)), abjad.TimeSignature((5, 16))]

    result = maker(divisions)

    staff = abjad.Staff(result)

    assert format(staff) == abjad.String.normalize(
        r"""
        \new Staff
        {
            r16
            c'16
            ~
            [
            c'16
            ]
            r8.
            c'4
            r16
            c'16
            ~
            [
            c'16
            ]
            r16
            r8
            c'8.
        }
        """)
def test_rhythmmakertools_BurnishSpecifier_outer_divisions_only_02():

    burnish_specifier = rhythmmakertools.BurnishSpecifier(
        left_classes=[-1],
        right_classes=[-1],
        left_counts=[1],
        right_counts=[1],
        outer_divisions_only=True,
        )

    talea = rhythmmakertools.Talea(
        counts=[1],
        denominator=4,
        )

    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        burnish_specifier=burnish_specifier,
        extra_counts_per_division=[2],
        )

    divisions = [(3, 16), (3, 8)]
    selections = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(selections)

    assert format(staff) == abjad.String.normalize(
        r'''
        \new Staff
        {
            {   % measure
                \time 3/16
                \tweak text #tuplet-number::calc-fraction-text
                \times 3/5 {
                    r4
                    c'16
                    ~
                }
            }   % measure
            {   % measure
                \time 3/8
                \tweak text #tuplet-number::calc-fraction-text
                \times 3/4 {
                    c'8.
                    c'4
                    r16
                }
            }   % measure
        }
        '''
        ), format(staff)
Esempio n. 5
0
def test_rhythmmakertools_TaleaRhythmMaker___call___02():

    talea = rhythmmakertools.Talea(
        counts=[-1, 4, -2, 3],
        denominator=16,
    )
    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        extra_counts_per_division=[3, 4],
        split_divisions_by_counts=[6],
    )

    divisions = [(2, 8), (5, 8)]
    result = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(result)

    assert format(staff) == abjad.String.normalize(r'''
        \new Staff
        {
            {   % measure
                \time 2/8
                \times 4/7 {
                    r16
                    c'4
                    r8
                }
            }   % measure
            {   % measure
                \time 5/8
                \tweak text #tuplet-number::calc-fraction-text
                \times 1/1 {
                    c'8
                    ~
                }
                \times 2/3 {
                    c'16
                    r16
                    c'4
                    r8
                    c'16
                    ~
                }
                \tweak text #tuplet-number::calc-fraction-text
                \times 1/1 {
                    c'8
                }
            }   % measure
        }
        ''')
Esempio n. 6
0
def test_rhythmmakertools_TaleaRhythmMaker_read_talea_once_only_01():

    maker = rhythmmakertools.TaleaRhythmMaker(
        read_talea_once_only=True,
        talea=rhythmmakertools.Talea(
            counts=[1, 2, 3, 4],
            denominator=16,
        ),
    )

    divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
    string = 'maker(divisions)'
    assert pytest.raises(Exception, string)
def test_rhythmmakertools_BurnishSpecifier_outer_divisions_only_04():

    burnish_specifier = rhythmmakertools.BurnishSpecifier(
        left_classes=[-1],
        right_classes=[-1],
        left_counts=[1],
        right_counts=[2],
        outer_divisions_only=True,
        )

    talea = rhythmmakertools.Talea(
        counts=[1],
        denominator=8,
        )

    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        burnish_specifier=burnish_specifier,
        extra_counts_per_division=[],
        )

    divisions = [(8, 8)]
    selections = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(selections)

    assert format(staff) == abjad.String.normalize(
        r'''
        \new Staff
        {
            {   % measure
                \time 8/8
                r8
                c'8
                [
                c'8
                c'8
                c'8
                c'8
                ]
                r8
                r8
            }   % measure
        }
        '''
        ), format(staff)
     forbid_repetitions=True,
     pitch_specifier=abbreviations.agitato_pitch_specifier,
     register_specifier=consort.RegisterSpecifier(
         base_pitch='G3',
         phrase_inflections=consort.RegisterInflection
             .zigzag(3)
             .reverse()
             .align(),
         segment_inflections=consort.RegisterInflection
             .descending(width=3)
             .align()
         ),
     ),
 rhythm_maker=consort.CompositeRhythmMaker(
     default=rhythmmakertools.TaleaRhythmMaker(
         extra_counts_per_division=[0, 0, 1],
         talea=rhythmmakertools.Talea(
             counts=[1, -1, 1, -2, 1, -3],
             denominator=16,
             ),
         ),
     last=rhythmmakertools.IncisedRhythmMaker(
         incise_specifier=rhythmmakertools.InciseSpecifier(
             fill_with_notes=False,
             prefix_counts=[1],
             prefix_talea=[1],
             talea_denominator=16,
             ),
         ),
     ),
 )
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import durationtools
from abjad.tools import rhythmmakertools


sparse_timespan_maker = consort.TaleaTimespanMaker(
    initial_silence_talea=rhythmmakertools.Talea(
        counts=[1, 0, 3, 2, 4, 5, 1, 2],
        denominator=8,
        ),
    playing_talea=rhythmmakertools.Talea(
        counts=[2, 3, 2, 2, 3],
        denominator=8,
        ),
    playing_groupings=[1],
    repeat=True,
    silence_talea=rhythmmakertools.Talea(
        counts=[4, 8, 6],
        denominator=8,
        ),
    step_anchor=Right,
    synchronize_groupings=False,
    synchronize_step=False,
    timespan_specifier=consort.TimespanSpecifier(
        minimum_duration=durationtools.Duration(1, 8),
        ),
    )
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import rhythmmakertools

sustained_timespan_maker = consort.TaleaTimespanMaker(
    initial_silence_talea=rhythmmakertools.Talea(
        counts=(5, 0),
        denominator=8,
    ),
    playing_talea=rhythmmakertools.Talea(
        counts=(5, 7, 4, 5),
        denominator=8,
    ),
    playing_groupings=(5, 6, 4, 8, 9),
    silence_talea=rhythmmakertools.Talea(
        counts=(3, 5, 3, 2, 5, 3),
        denominator=8,
    ),
)
Esempio n. 11
0
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import durationtools
from abjad.tools import rhythmmakertools

tutti_timespan_maker = consort.TaleaTimespanMaker(
    fuse_groups=True,
    playing_talea=rhythmmakertools.Talea(
        counts=(4, 5, 4, 3, 7, 6),
        denominator=8,
    ),
    playing_groupings=(3, 4, 2, 2, 3, 5),
    repeat=True,
    silence_talea=rhythmmakertools.Talea(
        counts=(3, 4, 2, 5, 6, 9),
        denominator=4,
    ),
    step_anchor=Right,
    synchronize_groupings=True,
    synchronize_step=True,
    timespan_specifier=consort.TimespanSpecifier(
        minimum_duration=durationtools.Duration(1, 4), ),
)
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import durationtools
from abjad.tools import rhythmmakertools

synchronized_timespan_maker = consort.TaleaTimespanMaker(
    padding=durationtools.Duration(1, 8),
    playing_talea=rhythmmakertools.Talea(
        counts=(1, 1, 2, 1, 2, 2, 3),
        denominator=8,
    ),
    playing_groupings=(1, 2),
    silence_talea=rhythmmakertools.Talea(
        counts=(3, 4, 5, 2, 7, 9),
        denominator=8,
    ),
    synchronize_step=True,
    timespan_specifier=consort.TimespanSpecifier(minimum_duration=0, ),
)
def test_rhythmmakertools_BeamSpecifier_beam_each_division_01():
    r'''Beam each cell with a multipart beam spanner.
    '''

    talea = rhythmmakertools.Talea(
        counts=[1, 1, 1, -1, 2, 2],
        denominator=32,
        )

    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        extra_counts_per_division=[3, 4],
        )

    divisions = [(2, 16), (5, 16)]
    selections = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(selections)
    score = abjad.Score([staff])
    abjad.setting(score).autoBeaming = False

    assert format(staff) == abjad.String.normalize(
        r'''
        \new Staff
        {
            {   % measure
                \time 2/16
                \times 4/7 {
                    c'32
                    [
                    c'32
                    c'32
                    ]
                    r32
                    c'16
                    [
                    c'32
                    ~
                    ]
                }
            }   % measure
            {   % measure
                \time 5/16
                \tweak text #tuplet-number::calc-fraction-text
                \times 5/7 {
                    c'32
                    [
                    c'32
                    c'32
                    c'32
                    ]
                    r32
                    c'16
                    [
                    c'16
                    c'32
                    c'32
                    c'32
                    ]
                    r32
                    c'32
                }
            }   % measure
        }
        '''
        )
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import durationtools
from abjad.tools import rhythmmakertools


sparse_timespan_maker = consort.TaleaTimespanMaker(
    initial_silence_talea=rhythmmakertools.Talea(
        counts=(1, 0),
        denominator=8,
        ),
    padding=durationtools.Duration(1, 8),
    playing_talea=rhythmmakertools.Talea(
        counts=(1, 1, 2),
        denominator=8,
        ),
    playing_groupings=(1, 2, 1, 2, 2, 3),
    silence_talea=rhythmmakertools.Talea(
        counts=(1, 1, 1, 2, 1, 1, 2),
        denominator=8,
        ),
    timespan_specifier=consort.TimespanSpecifier(
        minimum_duration=0,
        ),
    )
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import durationtools
from abjad.tools import rhythmmakertools

sustained_timespan_maker = consort.TaleaTimespanMaker(
    initial_silence_talea=rhythmmakertools.Talea(
        counts=(0, 2, 1),
        denominator=8,
    ),
    playing_talea=rhythmmakertools.Talea(
        counts=(4, 5, 4, 3, 7, 6),
        denominator=8,
    ),
    playing_groupings=(3, 4, 2, 2, 3, 5),
    repeat=True,
    silence_talea=rhythmmakertools.Talea(
        counts=(2, 1, 2, 1, 3, 7, 1, 2, 9),
        denominator=8,
    ),
    step_anchor=Right,
    synchronize_groupings=False,
    synchronize_step=False,
    timespan_specifier=consort.TimespanSpecifier(
        minimum_duration=durationtools.Duration(1, 8), ),
)
Esempio n. 16
0
def test_rhythmmakertools_BurnishSpecifier_02():

    burnish_specifier = rhythmmakertools.BurnishSpecifier(
        left_classes=[0],
        middle_classes=[abjad.Rest],
        right_classes=[0],
        left_counts=[2],
        right_counts=[1],
    )

    talea = rhythmmakertools.Talea(
        counts=[1, 1, 2, 4],
        denominator=32,
    )

    rhythm_maker = rhythmmakertools.TaleaRhythmMaker(
        talea=talea,
        extra_counts_per_division=[0],
        burnish_specifier=burnish_specifier,
    )

    divisions = [(5, 16), (6, 16)]
    selections = rhythm_maker(divisions)

    maker = abjad.MeasureMaker()
    measures = maker(divisions)
    staff = abjad.Staff(measures)
    abjad.mutate(staff).replace_measure_contents(selections)

    assert format(staff) == abjad.String.normalize(r'''
        \new Staff
        {
            {   % measure
                \time 5/16
                \tweak text #tuplet-number::calc-fraction-text
                \times 1/1 {
                    c'32
                    [
                    c'32
                    ]
                    r16
                    r8
                    r32
                    c'32
                }
            }   % measure
            {   % measure
                \time 6/16
                \tweak text #tuplet-number::calc-fraction-text
                \times 1/1 {
                    c'16
                    [
                    c'8
                    ]
                    r32
                    r32
                    r16
                    c'16
                }
            }   % measure
        }
        ''')
Esempio n. 17
0
    )

segment_maker.add_setting(
    timespan_identifier=[-1, 1],
    timespan_maker=consort.BoundaryTimespanMaker(
        labels='bamboo windchimes',
        division_masks=[
            rhythmmakertools.SilenceMask(
                pattern=patterntools.Pattern(
                    indices=[0, 1, 3],
                    period=5,
                    ),
                ),
            ],
        start_talea=rhythmmakertools.Talea(
            counts=[2, 3, 4],
            denominator=8,
            ),
        start_groupings=[3, 4, 3, 2],
        ),
    violin=ersilia.string_overpressure_music_specifier,
    viola=ersilia.string_overpressure_music_specifier
        .transpose(7)
        .rotate(1),
    cello=ersilia.string_overpressure_music_specifier
        .transpose(-7)
        .rotate(1),
    )

segment_maker.add_setting(
    timespan_identifier=[
        -5, 1,
        timespan_specifier=consort.TimespanSpecifier(minimum_duration=0, ),
    ),
    guitar_pp=ersilia.pitch_pipe_music_specifier,
    piano_pp=ersilia.pitch_pipe_music_specifier,
    percussion_pp=ersilia.pitch_pipe_music_specifier,
    bass_pp=ersilia.pitch_pipe_music_specifier,
)

### INTERRUPT ###

segment_maker.add_setting(
    timespan_identifier=[-1, 1, -1, 1],
    timespan_maker=consort.BoundaryTimespanMaker(
        labels=['pitch pipes'],
        stop_talea=rhythmmakertools.Talea(
            counts=[2, 9, 3, 1],
            denominator=4,
        ),
    ),
    percussion=new(
        ersilia.percussion_snare_interruption_music_specifier,
        rhythm_maker__first__incise_specifier__prefix_talea=[1],
        rhythm_maker__first__incise_specifier__prefix_counts=[1],
    ),
    silenced_contexts=segment_maker.score_template.all_voice_names,
)

segment_maker.add_setting(
    timespan_identifier=timespantools.Timespan(0, (1, 4)),
    piano_rh=new(
        ersilia.piano_arm_cluster_music_specifier,
        attachment_handler__laissez_vibrer=abbreviations.laissez_vibrer,