# -*- 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,
        ), ),
)
from abjad.tools import indicatortools
from abjad.tools import patterntools
from abjad.tools import rhythmmakertools
from abjad.tools import scoretools
from abjad.tools import selectortools
from abjad.tools import spannertools
from ersilia.materials import abbreviations
import consort


piano_agitato_music_specifier = consort.MusicSpecifier(
    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)
# -*- 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


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(
示例#4
0
    tempo=indicatortools.Tempo((1, 4), 72),
)

### ATTACHMENTS ###

intermittent_trills = armilla.materials.intermittent_trills

### MUSIC SPECIFIERS ###

rh_circular = new(
    armilla.materials.right_hand_circular_music_specifier,
    attachment_handler__stem_tremolo_spanner=consort.AttachmentExpression(
        attachments=(
            None,
            spannertools.StemTremoloSpanner(),
        ),
        selector=selectortools.Selector().by_leaf().by_counts(
            [5, 1, 4, 2, 6, 3],
            cyclic=True,
        )),
)

lh_glissandi = new(
    armilla.materials.left_hand_glissandi_music_specifier,
    pitch_handler__pitch_specifier=consort.PitchSpecifier(
        pitch_segments=(
            "a c' a a c'",
            "c' ef' g c' c' ef'",
            "a' c'' a' c'' c'' g' a'",
        ),
        ratio=(1, 1, 2),
示例#5
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(
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


guitar_continuo_music_specifier = consort.MusicSpecifier(
    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)
# -*- 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,
        ), ),
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],
            left_counts=[1, 1, 0, 0, 0, 1, 0],
            right_classes=[scoretools.Rest],
示例#9
0
# -*- encoding: utf-8 -*-
import consort
import ersilia
from abjad.tools import indicatortools
from abjad.tools import patterntools
from abjad.tools import pitchtools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from abjad.tools import spannertools
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(),
# -*- 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,
from abjad.tools import spannertools
from ersilia.materials import abbreviations

string_agitato_music_specifier = consort.MusicSpecifier(
    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(
### SEGMENT MAKER ###

segment_maker = armilla.ArmillaSegmentMaker(
    desired_duration_in_seconds=30,
    discard_final_silence=True,
    name='Far Sorr',
    repeat=False,
    tempo=indicatortools.Tempo((1, 4), 36),
)

### ATTACHMENTS ###

dietro_ponticello = consort.AttachmentExpression(
    attachments=indicatortools.StringContactPoint('dietro ponticello'),
    scope=scoretools.Voice,
    selector=selectortools.Selector().by_leaf(),
)
intermittent_accents = armilla.materials.intermittent_accents
intermittent_circular = armilla.materials.intermittent_circular
intermittent_glissandi = armilla.materials.intermittent_glissandi
intermittent_tremoli = armilla.materials.intermittent_tremoli

### MUSIC SPECIFIERS ###

lh_diads = new(
    armilla.materials.left_hand_diads_music_specifier,
    minimum_phrase_duration=durationtools.Duration(1, 4),
)
lh_dietro = new(
    armilla.materials.left_hand_dietro_music_specifier,
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
from ersilia.materials import abbreviations

wind_agitato_music_specifier = consort.MusicSpecifier(
    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',
### SEGMENT MAKER ###

segment_maker = armilla.ArmillaSegmentMaker(
    desired_duration_in_seconds=60,
    discard_final_silence=False,
    name='The Long Dune (ii)',
    repeat=False,
    tempo=indicatortools.Tempo((1, 4), 36),
)

### ATTACHMENTS ###

dietro_ponticello = consort.AttachmentExpression(
    attachments=indicatortools.StringContactPoint('dietro ponticello'),
    scope=scoretools.Voice,
    selector=selectortools.Selector().by_leaf(),
)
dynamics_a = dynamic_expressions = consort.DynamicExpression(
    dynamic_tokens='p mf p ppp f p ff', )
dynamics_b = dynamic_expressions = consort.DynamicExpression(
    dynamic_tokens='f p f mf ff p fff f fff mf fff', )
intermittent_accents = armilla.materials.intermittent_accents
intermittent_circular = armilla.materials.intermittent_circular
intermittent_glissandi = armilla.materials.intermittent_glissandi
intermittent_tremoli = armilla.materials.intermittent_tremoli

### MUSIC SPECIFIERS ###

lh_dietro = new(
    armilla.materials.left_hand_dietro_music_specifier,
示例#15
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, ), ),
)
# -*- encoding: utf-8 -*-
import consort
import ersilia
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

percussion_snare_interruption_music_specifier = consort.MusicSpecifier(
    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(
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import indicatortools
from abjad.tools import markuptools
from abjad.tools import pitchtools
from abjad.tools import selectortools
from abjad.tools import spannertools

laissez_vibrer = consort.AttachmentExpression(
    attachments=[
        [
            indicatortools.LaissezVibrer(),
            markuptools.Markup(
                'L.V', Up).caps().tiny().pad_around(0.5).box().pad_around(0.5)
        ],
    ],
    selector=selectortools.Selector().by_logical_tie(
        pitched=True).by_contiguity().by_length('==', 1).by_leaf()[0])

black_keys_spanner = spannertools.make_solid_text_spanner_with_nib(
    markuptools.Markup.flat().vcenter(), )

chromatic_keys_spanner = spannertools.make_solid_text_spanner_with_nib(
    markuptools.Markup.concat([
        markuptools.Markup.natural(),
        markuptools.Markup.hspace(0.1),
        markuptools.Markup.flat(),
    ]).vcenter(), )

white_keys_spanner = spannertools.make_solid_text_spanner_with_nib(
    markuptools.Markup.natural().vcenter(), )
示例#18
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,
            ),
示例#19
0
# -*- 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
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',
示例#20
0
from abjad.tools import indicatortools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
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',
# -*- 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 ersilia.materials import abbreviations

piano_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_class(
                scoretools.Note).by_logical_tie()[0]),
        tenuti=consort.AttachmentExpression(
            attachments=indicatortools.Articulation('tenuto'),
            selector=selectortools.Selector().by_logical_tie(pitched=True)[0]),
    ),
    color='darkyellow',
    labels=['pedaled'],
    pitch_handler=consort.PitchClassPitchHandler(
        logical_tie_expressions=(
            None,
            consort.ChordExpression([-2, 3]),
            consort.ChordExpression([0, 3]),
            None,
            consort.ChordExpression([-4, 5]),
        ),
示例#22
0
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import selectortools


intermittent_glissandi = consort.AttachmentExpression(
    attachments=consort.Glissando(
        allow_repeat_pitches=False,
        allow_ties=False,
        parenthesize_repeated_pitches=True,
        ),
    selector=selectortools.Selector()
        .by_leaf()
        [:-1]
        .append_callback(consort.AfterGraceSelectorCallback())
        .by_counts(
            [-3, 4, -2, 3, -1, 4],
            cyclic=True,
            overhang=True,
            fuse_overhang=True,
            rotate=True,
            ),
    )
示例#23
0
import ersilia
from abjad.tools import patterntools
from abjad.tools import pitchtools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
from abjad.tools import indicatortools
from abjad.tools import spannertools
from ersilia.materials import abbreviations


percussion_temple_block_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]
            ),
        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,
# -*- encoding: utf-8 -*-
import consort
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

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]),
示例#25
0
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]),
                ),
            consort.ChordExpression(
                chord_expr=pitchtools.IntervalSegment([-7, -3, 0, 1, 5, 12]),
# -*- 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, ), ),
)
# -*- 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'",
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import indicatortools
from abjad.tools import markuptools
from abjad.tools import patterntools
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],
        ),
# -*- encoding: utf-8 -*-
import consort
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
示例#30
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,