Beispiel #1
0
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools


left_hand_pizzicati_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        arpeggio=indicatortools.Arpeggio(),
        clef_spanner=consort.AttachmentExpression(
            attachments=consort.ClefSpanner('treble'),
            selector=selectortools.Selector().by_leaf(),
            ),
        ),
    pitch_handler=consort.AbsolutePitchHandler(
        logical_tie_expressions=(
            consort.ChordExpression("cs' b' g'' ef'''"),
            consort.ChordExpression("fs e' c'' gs''"),
            consort.ChordExpression("f ef' b' g''"),
            consort.ChordExpression("fs e' c'' gs''"),
            consort.ChordExpression("c' bf' fs'' d'''"),
            consort.ChordExpression("cs' b' g'' ef'''"),
            consort.ChordExpression("f ef' b' g''"),
            consort.ChordExpression("fs e' c'' gs''"),
            consort.ChordExpression("d' c'' gs'' e'''"),
            ),
        ),
    rhythm_maker=rhythmmakertools.IncisedRhythmMaker(
        incise_specifier=rhythmmakertools.InciseSpecifier(
            fill_with_notes=False,
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import durationtools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools

left_hand_glissandi_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        glissando=consort.AttachmentExpression(
            attachments=consort.Glissando(
                allow_repeat_pitches=False,
                allow_ties=False,
                parenthesize_repeated_pitches=True,
            ),
            selector=selectortools.Selector().by_leaf().append_callback(
                consort.AfterGraceSelectorCallback())), ),
    grace_handler=consort.GraceHandler(
        counts=(0, 1, 2, 0, 0, 0),
        only_if_preceded_by_nonsilence=True,
    ),
    pitch_handler=consort.AbsolutePitchHandler(
        deviations=(0, 0, 0, 0, 0.5, 0),
        forbid_repetitions=True,
        grace_expressions=(
            consort.HarmonicExpression('P4'),
            consort.HarmonicExpression('M3'),
            consort.HarmonicExpression('P5'),
        ),
        pitch_specifier=consort.PitchSpecifier(
            pitch_segments=(
                "a c' a a c'",
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from ersilia.materials import abbreviations


string_pointillist_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        mordents=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('mordent'),
            selector=selectortools.Selector()
                .by_logical_tie(pitched=True)
                [0]
            ),
        dynamic_expressions=consort.DynamicExpression(
            start_dynamic_tokens='ppp',
            only_first=True,
            ),
        text_spanner=consort.AttachmentExpression(
            attachments=consort.AttachmentExpression(
                attachments=abbreviations.make_text_spanner('pizz.'),
                selector=selectortools.Selector().by_leaf(),
                ),
            selector=selectortools.Selector().by_leaf(),
            ),
        ),
    color='darkyellow',
    labels=[],
    pitch_handler=consort.PitchClassPitchHandler(
        forbid_repetitions=True,
        pitch_specifier=abbreviations.agitato_pitch_specifier,
        register_specifier=consort.RegisterSpecifier(
Beispiel #4
0
 attachment_handler=consort.AttachmentHandler(
     accent=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('accent'),
         selector=selectortools.Selector()
             .by_logical_tie(pitched=True)
             .by_duration('>', (1, 16), preprolated=True)
             [0]
         ),
     chords=consort.AttachmentExpression(
         attachments=(
             consort.ChordExpression(
                 chord_expr=pitchtools.PitchSegment([
                     ersilia.Percussion.WOOD_BLOCK_5,
                     ersilia.Percussion.WOOD_BLOCK_4,
                     ]),
                 ),
             None,
             consort.ChordExpression(
                 chord_expr=pitchtools.PitchSegment([
                     ersilia.Percussion.WOOD_BLOCK_4,
                     ersilia.Percussion.WOOD_BLOCK_3,
                     ]),
                 ),
             consort.ChordExpression(
                 chord_expr=pitchtools.PitchSegment([
                     ersilia.Percussion.WOOD_BLOCK_3,
                     ersilia.Percussion.WOOD_BLOCK_2,
                     ]),
                 ),
             None,
             consort.ChordExpression(
                 chord_expr=pitchtools.PitchSegment([
                     ersilia.Percussion.WOOD_BLOCK_2,
                     ersilia.Percussion.WOOD_BLOCK_1,
                     ]),
                 ),
             ),
         is_destructive=True,
         selector=selectortools.Selector()
             .by_logical_tie(pitched=True)
             .by_duration('>', (1, 16), preprolated=True)
         ),
     dynamic_expression=consort.DynamicExpression(
         division_period=2,
         start_dynamic_tokens='p fp',
         stop_dynamic_tokens='f',
         unsustained=True,
         ),
     staccato=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('staccato'),
         selector=selectortools.Selector()
             .by_logical_tie(pitched=True)
             .by_duration('<=', (1, 16), preprolated=True)
             [0],
         ),
     staff_lines_spanner=spannertools.StaffLinesSpanner([-4, -2, 0, 2, 4]),
     text_spanner=consort.AttachmentExpression(
         attachments=abbreviations.make_text_spanner('blocks'),
         selector=selectortools.select_pitched_runs(),
         ),
     tremolo=consort.AttachmentExpression(
         attachments=spannertools.StemTremoloSpanner(),
         selector=selectortools.Selector()
             .by_logical_tie(pitched=True)
             .by_duration('>', (1, 16), preprolated=True)
         ),
     ),
Beispiel #5
0
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import pitchtools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from abjad.tools import spannertools


piano_tremolo_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        dynamic_expressions=consort.DynamicExpression(
            start_dynamic_tokens='fp',
            dynamic_tokens="p mf p p mf pp",
            division_period=2,
            ),
        octavation=consort.OctavationExpression(),
        stem_tremolo_spanner=consort.AttachmentExpression(
            attachments=spannertools.StemTremoloSpanner(),
            selector=selectortools.select_pitched_runs(),
            ),
        ),
    color='red',
    labels=[
        'pedaled',
        'piano tremolo',
        ],
    pitch_handler=consort.AbsolutePitchHandler(
        deviations=[0, -2, 0, 0, 2, 0, 3],
        logical_tie_expressions=(
            consort.ChordExpression(
                chord_expr=pitchtools.IntervalSegment([-7, -3, 0, 5, 6, 12]),
Beispiel #6
0
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools

left_hand_dietro_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        clef_spanner=consort.AttachmentExpression(
            attachments=consort.ClefSpanner(
                clef='percussion',
                overrides={
                    'note_head__style': 'cross',
                },
            ),
            selector=selectortools.Selector().by_leaf(),
        ), ),
    pitch_handler=consort.AbsolutePitchHandler(logical_tie_expressions=(
        consort.ChordExpression("g b"),
        consort.ChordExpression("b d'"),
        consort.ChordExpression("d' f'"),
    ), ),
    rhythm_maker=rhythmmakertools.NoteRhythmMaker(
        tie_specifier=rhythmmakertools.TieSpecifier(
            tie_across_divisions=False, ), ),
)
Beispiel #7
0
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from abjad.tools import spannertools
from ersilia.materials import abbreviations

wind_tremolo_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        outer_accents=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('accent'),
            selector=selectortools.select_pitched_runs()[0],
        ),
        inner_accents=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('accent'),
            selector=selectortools.Selector().by_logical_tie().by_duration(
                '==', (1, 8), preprolated=True).with_next_leaf()),
        dynamic_expressions=consort.DynamicExpression(
            division_period=2,
            dynamic_tokens='p ppp mp',
            start_dynamic_tokens='fp',
            stop_dynamic_tokens='mf ppp',
        ),
        trill_spanner=consort.AttachmentExpression(
            attachments=spannertools.ComplexTrillSpanner('M2'),
            selector=selectortools.select_pitched_runs(),
        ),
    ),
    color='red',
    labels=[],
    pitch_handler=consort.PitchClassPitchHandler(
        deviations=[0, 1],
        pitch_application_rate='phrase',
        pitch_specifier=abbreviations.agitato_pitch_specifier,
Beispiel #8
0
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import pitchtools
from abjad.tools import rhythmmakertools


left_hand_diads_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(),
    pitch_handler=consort.AbsolutePitchHandler(
        deviations=(0, 0, 0, 0, 0.5, 0),
        forbid_repetitions=True,
        logical_tie_expressions=(
            consort.ChordExpression(chord_expr=(0, 8)),
            consort.ChordExpression(chord_expr=(0, 5)),
            consort.ChordExpression(chord_expr=(0, 8)),
            consort.ChordExpression(chord_expr=(0, 8)),
            consort.ChordExpression(chord_expr=(0, 5)),
            consort.ChordExpression(chord_expr=(0, 8)),
            consort.ChordExpression(chord_expr=(0, 5)),
            consort.ChordExpression(chord_expr=(0, 5)),
            consort.ChordExpression(chord_expr=(0, 10)),
            consort.ChordExpression(chord_expr=(0, 8)),
            consort.ChordExpression(chord_expr=(0, 8)),
            consort.ChordExpression(chord_expr=(0, 10)),
            ),
        pitch_specifier=consort.PitchSpecifier(
            pitch_segments=(
                "a c' c' a a c' a a g a c' c'",
                "a c' c' c' gs g c'",
                "a c' c' a a c' a g fs a a c' c'",
                ),
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import indicatortools
from abjad.tools import patterntools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from abjad.tools import spannertools

string_low_pedal_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        accents=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('accent'),
            selector=selectortools.Selector().by_logical_tie().get_slice(
                start=1, apply_to_each=False)[0]),
        dynamic_expressions=consort.DynamicExpression(
            division_period=2,
            dynamic_tokens='p ppp',
            start_dynamic_tokens='niente',
            stop_dynamic_tokens='niente',
        ),
        glissando=consort.Glissando(),
    ),
    color=None,
    labels=[],
    minimum_phrase_duration=(3, 2),
    pitch_handler=consort.PitchClassPitchHandler(
        pitch_application_rate='phrase',
        deviations=[0, 0, 0, 0.5],
        pitch_specifier='d f d g f d f',
        register_specifier=consort.RegisterSpecifier(base_pitch='C4', ),
        register_spread=0,
Beispiel #10
0
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from abjad.tools import spannertools
from ersilia.materials import abbreviations

shaker_sporadic_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        dynamic_expression=consort.DynamicExpression(
            dynamic_tokens='ppp',
            transitions=['constante'],
        ),
        percussion_staff=abbreviations.percussion_staff,
        staccati=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('staccato'),
            selector=selectortools.Selector().by_logical_tie(
                pitched=True).by_duration('<=', (1, 16), preprolated=True)[0],
        ),
        text_spanner=consort.AttachmentExpression(
            attachments=abbreviations.make_text_spanner('shaker'),
            selector=selectortools.Selector().by_leaf(),
        ),
        tremolo=consort.AttachmentExpression(
            attachments=spannertools.StemTremoloSpanner(),
            selector=selectortools.Selector().by_logical_tie(
                pitched=True).by_duration('>', (1, 16), preprolated=True)),
    ),
    color='blue',
    labels=['shakers'],
    pitch_handler=consort.AbsolutePitchHandler(pitches_are_nonsemantic=True, ),
    rhythm_maker=rhythmmakertools.TaleaRhythmMaker(
        extra_counts_per_division=[0, 0, 1],
        division_masks=[
 attachment_handler=consort.AttachmentHandler(
     accents_short=consort.AttachmentExpression(
         attachments=[
             [
                 indicatortools.Articulation('accent'),
                 indicatortools.Articulation('staccatissimo'),
             ],
         ],
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '==', (1, 16), preprolated=True).by_contiguity().by_length(
                     '==', 1).by_leaf()[0]),
     accents_long=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('accent'),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '>', (1, 16), preprolated=True).by_contiguity().by_length(
                     '==', 1).by_leaf()[0]),
     dynamic_expressions=consort.DynamicExpression(
         division_period=2,
         dynamic_tokens='mf mp fff',
         start_dynamic_tokens='f',
         stop_dynamic_tokens='p mp mf',
     ),
     flutter_tongue=consort.AttachmentExpression(
         attachments=abbreviations.make_text_spanner('Flz.'),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '>', (1, 16), preprolated=True).by_contiguity().by_leaf()),
     slur=consort.AttachmentExpression(
         attachments=spannertools.Slur(),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '==', (1, 16), preprolated=True).by_contiguity().by_length(
                     '>', 1).by_pattern(pattern=patterntools.Pattern(
                         indices=[0],
                         period=2,
                     ), ).by_leaf()),
     staccati=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('staccato'),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '==', (1, 16), preprolated=True).by_contiguity().by_length(
                     '>', 1).by_pattern(pattern=patterntools.Pattern(
                         indices=[0, 2],
                         period=3,
                     ), ).by_leaf()),
     stem_tremolo_spanner=consort.AttachmentExpression(
         attachments=spannertools.StemTremoloSpanner(),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '>', (1, 16), preprolated=True).by_contiguity().by_leaf()),
 ),
Beispiel #12
0
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import rhythmmakertools


wind_low_pedal_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        dynamic_expressions=consort.DynamicExpression(
            division_period=2,
            dynamic_tokens='p ppp',
            start_dynamic_tokens='niente',
            stop_dynamic_tokens='niente',
            )
        ),
    color=None,
    labels=[],
    minimum_phrase_duration=(3, 2),
    pitch_handler=consort.AbsolutePitchHandler(
        pitch_specifier='D2 F2 D2 G2 F2 D2 F2',
        ),
    rhythm_maker=rhythmmakertools.NoteRhythmMaker(
        tie_specifier=rhythmmakertools.TieSpecifier(
            tie_across_divisions=True,
            ),
        ),
    )
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import rhythmmakertools
from abjad.tools import scoretools
from ersilia.materials import abbreviations

guitar_pointillist_harmonics_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        dynamic_expressions=consort.DynamicExpression(
            dynamic_tokens='p mp', ), ),
    color=None,
    labels=[],
    pitch_handler=consort.PitchClassPitchHandler(
        forbid_repetitions=True,
        leap_constraint=6,
        logical_tie_expressions=[
            consort.HarmonicExpression('P4'),
            consort.HarmonicExpression('P5'),
            consort.HarmonicExpression('P8'),
            consort.HarmonicExpression('P5'),
        ],
        pitch_specifier=abbreviations.agitato_pitch_specifier,
        register_specifier=consort.RegisterSpecifier(
            base_pitch='E2',
            phrase_inflections=consort.RegisterInflection.zigzag(
                6).reverse().align(),
            segment_inflections=consort.RegisterInflection.descending(
                width=12).align()),
    ),
    rhythm_maker=consort.CompositeRhythmMaker(
        default=rhythmmakertools.EvenDivisionRhythmMaker(
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools

piano_arm_cluster_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        accents=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('accent'),
            selector=selectortools.Selector().by_logical_tie(pitched=True)[0],
        ),
        dynamic_expressions=consort.AttachmentExpression(
            attachments=indicatortools.Dynamic('fff'),
            selector=selectortools.Selector().by_logical_tie(pitched=True)[0]),
    ),
    color='yellow',
    labels=['piano arm cluster'],
    pitch_handler=consort.AbsolutePitchHandler(logical_tie_expressions=[
        consort.KeyClusterExpression(staff_space_width=19, ),
    ]),
    rhythm_maker=rhythmmakertools.IncisedRhythmMaker(
        incise_specifier=rhythmmakertools.InciseSpecifier(
            fill_with_notes=False,
            prefix_counts=[1],
            prefix_talea=[1],
            talea_denominator=8,
        ), ),
)
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import durationtools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools

left_hand_stasis_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        trill_spanner=consort.AttachmentExpression(
            attachments=(
                consort.ConsortTrillSpanner(interval='+m3'),
                consort.ConsortTrillSpanner(interval='+P4'),
                consort.ConsortTrillSpanner(interval='+m3'),
            ),
            selector=selectortools.Selector().by_leaf(),
        ), ),
    minimum_phrase_duration=durationtools.Duration(1, 4),
    pitch_handler=consort.AbsolutePitchHandler(
        deviations=(0, 0, 0.5),
        pitch_specifier="gs'",
    ),
    rhythm_maker=rhythmmakertools.NoteRhythmMaker(
        duration_spelling_specifier=rhythmmakertools.DurationSpellingSpecifier(
            forbid_meter_rewriting=True, ), ),
)
 attachment_handler=consort.AttachmentHandler(
     dynamic_expressions=consort.DynamicExpression(
         division_period=2,
         dynamic_tokens='mp fff',
         start_dynamic_tokens='f p',
         stop_dynamic_tokens='p f',
     ),
     harmonics=consort.AttachmentExpression(
         attachments=consort.HarmonicExpression('P4'),
         is_destructive=True,
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration('==', (1, 16),
                                       preprolated=True).by_pattern(
                                           pattern=patterntools.Pattern(
                                               indices=[2, 4],
                                               period=5,
                                           ), )),
     slur=consort.AttachmentExpression(
         attachments=spannertools.Slur(),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '==', (1, 16),
                 preprolated=True).by_contiguity().by_length('>',
                                                             1).by_leaf()),
     staccati=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('staccato'),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '==', (1, 16),
                 preprolated=True).by_contiguity().by_leaf()),
     accents=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('accent'),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '>', (1, 16),
                 preprolated=True).by_contiguity().by_leaf()[0]),
     trill_spanner=consort.AttachmentExpression(
         attachments=[
             spannertools.ComplexTrillSpanner('+m3'),
             spannertools.ComplexTrillSpanner('+P4'),
         ],
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '>', (1, 16), preprolated=True).by_contiguity().by_leaf()),
 ),
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from ersilia.materials import abbreviations

pitch_pipe_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        accents=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('accent'),
            selector=selectortools.Selector().by_logical_tie().get_slice(
                start=1, apply_to_each=False)[0]),
        dynamic_expressions=consort.DynamicExpression(
            division_period=2,
            dynamic_tokens='p ppp mf',
            start_dynamic_tokens='niente fp',
        ),
        inhale_exhale=consort.AttachmentExpression(
            attachments=[
                markuptools.Markup(
                    'exhale', Up).italic().smaller().pad_around(0.5).box(),
                markuptools.Markup(
                    'inhale', Up).italic().smaller().pad_around(0.5).box(),
                markuptools.Markup(
                    'inhale', Up).italic().smaller().pad_around(0.5).box(),
            ],
            selector=selectortools.select_pitched_runs()[0],
        ),
        percussion_staff=abbreviations.percussion_staff),
    color='blue',
    labels=['pitch pipes'],
    pitch_handler=consort.AbsolutePitchHandler(pitches_are_nonsemantic=True, ),
    rhythm_maker=rhythmmakertools.EvenDivisionRhythmMaker(
        denominators=[8],
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import scoretools
from abjad.tools import selectortools

wind_continuo_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        dynamic_expressions=consort.DynamicExpression(
            division_period=2,
            dynamic_tokens='p mp mf',
            start_dynamic_tokens='niente',
            stop_dynamic_tokens='niente',
        ),
        staccati=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('staccato'),
            selector=selectortools.select_pitched_runs(),
        ),
    ),
    color=None,
    labels=[],
    pitch_handler=consort.PitchClassPitchHandler(
        deviations=[0, 2, 0, 3, 0, 3, 0, 2, 0, 5, 0, 3, 0, 5, 0, 8, 7],
        pitch_specifier="d' f' df'",
        pitch_application_rate='division',
        register_specifier=consort.RegisterSpecifier(base_pitch='C4', ),
    ),
    rhythm_maker=rhythmmakertools.EvenDivisionRhythmMaker(
        burnish_specifier=rhythmmakertools.BurnishSpecifier(
            left_classes=[scoretools.Rest],
 attachment_handler=consort.AttachmentHandler(
     accents=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('accent'),
         selector=selectortools.Selector()
             .by_leaf()
             .by_run(scoretools.Note)
             .by_counts(
                 [3, 3, 4],
                 cyclic=True,
                 overhang=True,
                 fuse_overhang=True,
                 )
             [0],
         ),
     dynamic_expressions=consort.DynamicExpression(
         start_dynamic_tokens='p mp',
         only_first=True,
         ),
     slur=consort.AttachmentExpression(
         attachments=spannertools.Slur(),
         selector=selectortools.Selector()
             .by_leaf()
             .by_run(scoretools.Note)
             .by_counts(
                 [3, 3, 4],
                 cyclic=True,
                 overhang=True,
                 fuse_overhang=True,
                 )
         ),
     ),
Beispiel #20
0
from ersilia.materials import abbreviations

percussion_tom_fanfare_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        accent=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('accent'),
            selector=selectortools.Selector().by_logical_tie(
                pitched=True).by_duration('>', (1, 16), preprolated=True)[0]),
        dynamic_expression=consort.DynamicExpression(
            start_dynamic_tokens='p fp',
            stop_dynamic_tokens='f',
            unsustained=True,
        ),
        staccato=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('staccato'),
            selector=selectortools.Selector().by_logical_tie(
                pitched=True).by_duration('<=', (1, 16), preprolated=True)[0],
        ),
        staff_lines_spanner=spannertools.StaffLinesSpanner([-4, -2, 0, 2, 4]),
        text_spanner=consort.AttachmentExpression(
            attachments=abbreviations.make_text_spanner('toms'),
            selector=selectortools.select_pitched_runs(),
        ),
        tremolo=consort.AttachmentExpression(
            attachments=spannertools.StemTremoloSpanner(),
            selector=selectortools.Selector().by_logical_tie(
                pitched=True).by_duration('>', (1, 16), preprolated=True)),
    ),
    color='magenta',
    pitch_handler=consort.AbsolutePitchHandler(
        #logical_tie_expressions=[
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import scoretools
from abjad.tools import selectortools
from abjad.tools import spannertools

right_hand_pizzicati_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        bow_contact_points=consort.AttachmentExpression(
            attachments=(indicatortools.BowContactPoint(None), ),
            selector=selectortools.Selector().by_leaf().flatten(),
        ),
        bow_contact_spanner=spannertools.BowContactSpanner(),
        dynamic_expressions=consort.DynamicExpression(dynamic_tokens='mf', ),
        string_contact_points=consort.AttachmentExpression(
            attachments=indicatortools.StringContactPoint('pizzicato'),
            scope=scoretools.Voice,
            selector=selectortools.Selector().by_leaf()[0]),
        string_contact_spanner=consort.StringContactSpanner(),
    ),
    rhythm_maker=rhythmmakertools.IncisedRhythmMaker(
        incise_specifier=rhythmmakertools.InciseSpecifier(
            fill_with_notes=False,
            prefix_counts=(1, 1, 1, 1, 2, 1),
            prefix_talea=(1, ),
            suffix_talea=(1, ),
            suffix_counts=(0, ),
            talea_denominator=16,
        ), ),
 attachment_handler=consort.AttachmentHandler(
     accents=consort.AttachmentExpression(
         attachments=[[
             indicatortools.Articulation('accent'),
             indicatortools.Dynamic('fff'),
         ]],
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration('==', (1, 16), preprolated=True)[0],
     ),
     shimmer=consort.AttachmentExpression(
         attachments=[
             [
                 indicatortools.Articulation('accent'),
                 indicatortools.Dynamic('fp'),
             ],
         ],
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '>', (1, 16),
                 preprolated=True).by_leaf().by_length('==', 1)[0]),
     swell=consort.AttachmentExpression(
         attachments=spannertools.Hairpin('niente < f'),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration(
                 '>', (1, 16),
                 preprolated=True).by_leaf().by_length('>', 1)),
     text_spanner=consort.AttachmentExpression(
         attachments=abbreviations.make_text_spanner('snare'),
         selector=selectortools.select_pitched_runs(),
     ),
     tremolo=consort.AttachmentExpression(
         attachments=spannertools.StemTremoloSpanner(),
         selector=selectortools.Selector().by_logical_tie(
             pitched=True).by_duration('>', (1, 16), preprolated=True)),
 ),
Beispiel #23
0
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from ersilia.materials import abbreviations

wind_pointillist_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        dynamic_expressions=consort.DynamicExpression(
            start_dynamic_tokens='ppp',
            only_first=True,
        ),
        mordent=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('mordent'),
            selector=selectortools.Selector().by_logical_tie(pitched=True)[0]),
    ),
    color='darkyellow',
    labels=[],
    pitch_handler=consort.PitchClassPitchHandler(
        forbid_repetitions=True,
        pitch_specifier=abbreviations.agitato_pitch_specifier,
        register_specifier=consort.RegisterSpecifier(
            base_pitch='C4',
            phrase_inflections=consort.RegisterInflection.zigzag(
                6).reverse().align(),
            segment_inflections=consort.RegisterInflection.descending(
                width=6).align()),
    ),
    rhythm_maker=consort.CompositeRhythmMaker(
        default=rhythmmakertools.TaleaRhythmMaker(
Beispiel #24
0
guitar_strummed_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        damped=consort.AttachmentExpression(
            attachments=consort.LeafExpression(
                leaf=scoretools.Note("f'4"),
                attachments=[
                    lilypondnametools.LilyPondGrobOverride(
                        grob_name='NoteHead',
                        is_once=True,
                        property_path='transparent',
                        value=True,
                        ),
                    markuptools.Markup.musicglyph('scripts.coda'),
                    indicatortools.Articulation('accent'),
                    indicatortools.Dynamic('sfz'),
                    ],
                ),
            is_destructive=True,
            selector=selectortools.Selector()
                .by_logical_tie(pitched=True)
                .by_contiguity()
                .by_length('>', 1)
                .by_leaf()
                [-1]
            ),
        dynamic_expressions=consort.DynamicExpression(
            dynamic_tokens='p ppp p ppp mf p',
            only_first=True,
            ),
        laissez_vibrer=abbreviations.laissez_vibrer,
        ),
    pitch_handler=consort.AbsolutePitchHandler(
 attachment_handler=consort.AttachmentHandler(
     accents=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('accent'),
         selector=selectortools.Selector()
             .by_logical_tie(pitched=True)
             .by_duration('==', (1, 8), preprolated=True)
             [0],
         ),
     dynamic_expressions=consort.DynamicExpression(
         division_period=2,
         dynamic_tokens='mf mp fff',
         start_dynamic_tokens='f',
         stop_dynamic_tokens='mf',
         ),
     mordent=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('mordent'),
         selector=selectortools.Selector()
             .by_logical_tie(pitched=True)
             .by_duration('>=', (1, 8), preprolated=True)
             .by_class(scoretools.Note)
             [0],
         ),
     staccati=consort.AttachmentExpression(
         attachments=indicatortools.Articulation('staccato'),
         selector=selectortools.Selector()
             .by_logical_tie(pitched=True)
             .by_duration('==', (1, 16), preprolated=True)
             [0],
         ),
     tremoli=consort.AttachmentExpression(
         attachments=spannertools.StemTremoloSpanner(),
         selector=selectortools.Selector()
             .by_logical_tie(pitched=True)
             .by_duration('>=', (1, 8), preprolated=True)
             .by_class(scoretools.Chord)
             [0],
         ),
     ),
Beispiel #26
0
from abjad.tools import spannertools


wind_ostinato_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        dynamic_expressions=consort.DynamicExpression(
            dynamic_tokens='p',
            ),
        slur=consort.AttachmentExpression(
            attachments=spannertools.Slur(),
            selector=selectortools.Selector()
                .by_logical_tie(pitched=True)
                .by_duration('==', (1, 16), preprolated=True)
                .by_contiguity()
                .by_length('>', 1)
                .by_leaf()
            ),
        staccati=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('staccato'),
            selector=selectortools.Selector()
                .by_logical_tie(pitched=True)
                .by_duration('==', (1, 16), preprolated=True)
                .by_contiguity()
                .by_leaf()
                [-1]
            ),
        ),
    color='darkyellow',
    pitch_handler=consort.AbsolutePitchHandler(
        forbid_repetitions=True,
        pitch_specifier="d' f'",
Beispiel #27
0
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import rhythmmakertools

piano_pedals_music_setting = consort.MusicSetting(
    timespan_maker=consort.DependentTimespanMaker(
        hysteresis=(1, 4),
        include_inner_starts=True,
        include_inner_stops=False,
        inspect_music=True,
        labels=('pedaled', ),
        voice_names=(
            'Piano Upper Voice',
            'Piano Lower Voice',
        ),
    ),
    piano_pedals=consort.MusicSpecifier(
        attachment_handler=consort.AttachmentHandler(
            piano_pedal_spanner=consort.ComplexPianoPedalSpanner(
                include_inner_leaves=True, ), ),
        rhythm_maker=rhythmmakertools.SkipRhythmMaker(
            duration_spelling_specifier=rhythmmakertools.
            DurationSpellingSpecifier(forbid_meter_rewriting=True, ), ),
    ))
percussion_marimba_ostinato_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        clef_spanner=consort.ClefSpannerExpression(),
        deadstroke=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('stopped'),
            selector=selectortools.Selector().by_logical_tie(
                pitched=True).by_duration(
                    '==', (1, 16), preprolated=True).by_contiguity().by_length(
                        '==', 1).by_leaf()[0]),
        dynamic_expressions=consort.DynamicExpression(dynamic_tokens='p', ),
        slur=consort.AttachmentExpression(
            attachments=spannertools.Slur(),
            selector=selectortools.Selector().by_logical_tie(
                pitched=True).by_duration(
                    '==', (1, 16),
                    preprolated=True).by_contiguity().by_length('>',
                                                                1).by_leaf()),
        staccati=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('staccato'),
            selector=selectortools.Selector().by_logical_tie(
                pitched=True).by_duration(
                    '==', (1, 16), preprolated=True).by_contiguity().by_length(
                        '>', 1).by_leaf()[-1]),
        staff_lines_spanner=spannertools.StaffLinesSpanner([-4, -2, 0, 2, 4]),
        text_spanner=consort.AttachmentExpression(
            attachments=abbreviations.make_text_spanner('marimba'),
            selector=selectortools.select_pitched_runs(),
        ),
    ),
    color='darkyellow',
    pitch_handler=consort.AbsolutePitchHandler(
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from abjad.tools import spannertools
from ersilia.materials import abbreviations

guitar_tremolo_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        accents=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('accent'),
            selector=selectortools.select_pitched_runs().by_counts(
                [3], cyclic=True)[1],
        ),
        dynamic_expressions=consort.DynamicExpression(
            division_period=2,
            dynamic_tokens='pp mf p p mf mf pp',
            start_dynamic_tokens='fp niente',
            stop_dynamic_tokens='niente f',
        ),
        stem_tremolo_spanner=consort.AttachmentExpression(
            attachments=spannertools.StemTremoloSpanner(),
            selector=selectortools.select_pitched_runs(),
        ),
    ),
    color='red',
    pitch_handler=consort.AbsolutePitchHandler(
        logical_tie_expressions=[
            consort.ChordExpression(chord_expr=_, )
            for _ in abbreviations.guitar_chords
        ],
        pitch_specifier=consort.PitchSpecifier(
Beispiel #30
0
from abjad.tools import scoretools
from abjad.tools import selectortools
from abjad.tools import spannertools
from ersilia.materials import abbreviations


shaker_tremolo_music_specifier = consort.MusicSpecifier(
    attachment_handler=consort.AttachmentHandler(
        accents=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('accent'),
            selector=selectortools.Selector()
                .by_leaf()
                .by_run(scoretools.Note)
                [0],
            ),
        dynamic_expression=consort.DynamicExpression(
            dynamic_tokens='fp',
            ),
        percussion_staff=abbreviations.percussion_staff,
        text_spanner=consort.AttachmentExpression(
            attachments=abbreviations.make_text_spanner('shaker'),
            selector=selectortools.Selector().by_leaf(),
            ),
        tremolo_spanner=spannertools.StemTremoloSpanner(),
        ),
    color='blue',
    labels=['shakers'],
    pitch_handler=consort.AbsolutePitchHandler(
        pitches_are_nonsemantic=True,
        ),
    rhythm_maker=rhythmmakertools.NoteRhythmMaker(
        tie_specifier=rhythmmakertools.TieSpecifier(