def test_lilypondproxytools_LilyPondGrobNameManager___setattr___44():
"""
Override LilyPond SystemStartBar grob.
"""
score = abjad.Score([abjad.StaffGroup([abjad.Staff("c'8 c'8 c'8 c'8 c'8 c'8 c'8 c'8")])])
abjad.override(score).system_start_bar.collapse_height = 0
abjad.override(score).system_start_bar.color = 'red'
assert format(score) == abjad.String.normalize(
r"""
\new Score
\with
{
\override SystemStartBar.collapse-height = #0
\override SystemStartBar.color = #red
}
<<
\new StaffGroup
<<
\new Staff
{
c'8
c'8
c'8
c'8
c'8
c'8
c'8
c'8
}
>>
>>
"""
)
def test_LilyPondGrobNameManager___setattr___09():
"""
Override LilyPond abjad.DynamicLineSpanner grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).dynamic_line_spanner.staff_padding = 2
abjad.override(staff).dynamic_line_spanner.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
\with
{
\override DynamicLineSpanner.Y-extent = #'(-1.5 . 1.5)
\override DynamicLineSpanner.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
"""
)
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___31():
"""
Override LilyPond RehearsalMark grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).rehearsal_mark.staff_padding = 2
abjad.override(staff).rehearsal_mark.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
\with
{
\override RehearsalMark.Y-extent = #'(-1.5 . 1.5)
\override RehearsalMark.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
"""
)
def test_LilyPondGrobNameManager___setattr___28():
"""
Override LilyPond Script grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).script.staff_padding = 2
abjad.override(staff).script.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
\with
{
\override Script.Y-extent = #'(-1.5 . 1.5)
\override Script.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
"""
)
def attach_glissandi(nucleus_voice):
selections = [[]]
leaves = abjad.iterate(nucleus_voice).leaves()
for leaf_index, leaf in enumerate(leaves):
if 641 <= leaf_index:
leaf_index += 2
string = letter_maker.nuclei[leaf_index]
if string == 0:
glissando = False
else:
result = letter_maker.get_body_pitch_shape_glissando(string)
pitch, shape, glissando = result
if glissando:
assert isinstance(leaf, abjad.Note), repr(leaf)
selections[-1].append(leaf)
elif not selections[-1] == []:
selections.append([])
if selections[-1] == []:
selections.pop()
selections = [abjad.select(_) for _ in selections]
for selection in selections:
next_leaf = abjad.inspect(selection[-1]).leaf(1)
if next_leaf is not None:
selection = selection + [next_leaf]
abjad.glissando(selection, allow_repeats=True)
triples = abjad.sequence(selection).nwise(n=3)
for left_note, middle_note, right_note in triples:
if not (left_note.written_pitch ==
middle_note.written_pitch ==
right_note.written_pitch):
continue
abjad.override(middle_note).note_head.transparent = True
grob_proxy = abjad.override(middle_note).glissando
grob_proxy.bound_details__left__padding = -1.2
def test_LilyPondGrobNameManager___setattr___15():
"""
Override LilyPond NonMusicalPaperColumn grob.
"""
score = abjad.Score([abjad.Staff("c'8 d'8 e'8 f'8")])
abjad.override(
score
).non_musical_paper_column.line_break_permission = False
abjad.override(
score
).non_musical_paper_column.page_break_permission = False
assert format(score) == abjad.String.normalize(
r"""
\new Score
\with
{
\override NonMusicalPaperColumn.line-break-permission = ##f
\override NonMusicalPaperColumn.page-break-permission = ##f
}
<<
\new Staff
{
c'8
d'8
e'8
f'8
}
>>
"""
)
assert abjad.inspect(score).wellformed()
def _configure_score(self):
bow_staff = self._score['Bow Staff']
abjad.override(bow_staff).staff_symbol.line_count = self.staff_line_count
if self.name in ('flight E', 'flight F', 'flight I'):
voice = self._score['Tempo Indicator Voice']
abjad.override(voice).text_script.staff_padding = 5
abjad.override(voice).text_spanner.staff_padding = 5.75
def test_LilyPondGrobNameManager___setattr___35():
"""
Override LilyPond StemTremolo grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).stem_tremolo.slope = 0.5
abjad.override(staff).stem_tremolo.staff_padding = 2
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
\with
{
\override StemTremolo.slope = #0.5
\override StemTremolo.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
"""
)
def configure_score(score):
"""
Configures score.
"""
# configure bell staff
bell_staff = score["Bell Staff"]
leaf = abjad.inspect(bell_staff).leaf(0)
clef = abjad.Clef("treble")
abjad.attach(clef, leaf)
bells = abjad.Instrument(
name="Campana in La", short_name="Camp.", pitch_range="[C4, C6]"
)
abjad.attach(bells, leaf)
mark = abjad.MetronomeMark((1, 4), (112, 120))
abjad.attach(mark, leaf)
# time_signature = abjad.TimeSignature((6, 4))
# abjad.attach(time_signature, leaf)
# configure first violin staff
first_violin_staff = score["First Violin Staff"]
leaf = abjad.inspect(first_violin_staff).leaf(0)
clef = abjad.Clef("treble")
abjad.attach(clef, leaf)
violin = abjad.Violin(
markup=abjad.Markup("Violin I"), short_markup=abjad.Markup("Vl. I")
)
abjad.attach(violin, leaf)
# configure second violin staff
second_violin_staff = score["Second Violin Staff"]
leaf = abjad.inspect(second_violin_staff).leaf(0)
clef = abjad.Clef("treble")
abjad.attach(clef, leaf)
violin = abjad.Violin(
markup=abjad.Markup("Violin II"), short_markup=abjad.Markup("Vl. II")
)
abjad.attach(violin, leaf)
# configure viola staff
leaf = abjad.inspect(score["Viola Staff"]).leaf(0)
clef = abjad.Clef("alto")
abjad.attach(clef, leaf)
viola = abjad.Viola()
abjad.attach(viola, leaf)
# configure cello staff
leaf = abjad.inspect(score["Cello Staff"]).leaf(0)
clef = abjad.Clef("bass")
abjad.attach(clef, leaf)
cello = abjad.Cello()
abjad.attach(cello, leaf)
# configure bass staff
leaf = abjad.inspect(score["Bass Staff"]).leaf(0)
clef = abjad.Clef("bass")
abjad.attach(clef, leaf)
contrabass = abjad.Contrabass(short_markup=abjad.Markup("Cb."))
abjad.attach(contrabass, leaf)
# configure score
vector = abjad.SpacingVector(0, 0, 8, 0)
abjad.override(score).vertical_axis_group.staff_staff_spacing = vector
abjad.override(score).staff_grouper.staff_staff_spacing = vector
abjad.override(score).staff_symbol.thickness = 0.5
scheme = abjad.Scheme("format-mark-box-numbers")
abjad.setting(score).mark_formatter = scheme
def test_LilyPondGrobNameManager___setattr___29():
"""
Override LilyPond SpacingSpanner grob.
"""
score = abjad.Score([])
abjad.override(score).spacing_spanner.strict_grace_spacing = True
abjad.override(score).spacing_spanner.strict_note_spacing = True
abjad.override(score).spacing_spanner.uniform_stretching = True
assert format(score) == abjad.String.normalize(
r"""
\new Score
\with
{
\override SpacingSpanner.strict-grace-spacing = ##t
\override SpacingSpanner.strict-note-spacing = ##t
\override SpacingSpanner.uniform-stretching = ##t
}
<<
>>
"""
)
assert not len(score)
def test_LilyPondGrobNameManager___setattr___41():
"""
Override LilyPond TrillPitchAccidental grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).trill_pitch_accidental.staff_padding = 2
abjad.override(staff).trill_pitch_accidental.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
\with
{
\override TrillPitchAccidental.Y-extent = #'(-1.5 . 1.5)
\override TrillPitchAccidental.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
"""
)
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___13():
"""
Override LilyPond abjad.DynamicText grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).dynamic_text.staff_padding = 2
abjad.override(staff).dynamic_text.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
\with
{
\override DynamicText.Y-extent = #'(-1.5 . 1.5)
\override DynamicText.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
"""
)
def __call__(
self,
logical_tie,
seed=0,
):
assert isinstance(logical_tie, selectiontools.LogicalTie)
if self.counts is None:
return
previous_leaf = logical_tie.head._get_leaf(-1)
if previous_leaf is None:
return
silence_prototype = (
abjad.Rest,
abjad.MultimeasureRest,
abjad.Skip,
)
if self.only_if_preceded_by_silence:
if not isinstance(previous_leaf, silence_prototype):
return
if self.only_if_preceded_by_nonsilence:
if isinstance(previous_leaf, silence_prototype):
return
grace_count = self.counts[seed]
if not grace_count:
return
leaf_to_attach_to = previous_leaf
leaves = []
notes = abjad.LeafMaker()([0], [(1, 16)] * grace_count)
leaves.extend(notes)
assert len(leaves)
grace_container = scoretools.AfterGraceContainer(leaves)
abjad.override(grace_container).flag.stroke_style = \
schemetools.Scheme('grace', force_quotes=True)
abjad.override(grace_container).script.font_size = 0.5
abjad.attach(grace_container, leaf_to_attach_to)
def test_LilyPondGrobNameManager___setattr___49():
"""
Override LilyPond VerticalAxis grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).vertical_axis_group.staff_padding = 2
abjad.override(staff).vertical_axis_group.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
\with
{
\override VerticalAxisGroup.Y-extent = #'(-1.5 . 1.5)
\override VerticalAxisGroup.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
"""
)
def test_LilyPondGrobNameManager___getattr___01():
"""
Getting unknown grob name raises exception.
"""
note = abjad.Note("c'8")
with pytest.raises(Exception):
abjad.override(note).foo
def make_text_spanner(text):
markup_contents = make_text_markup(text).contents
markup = markuptools.Markup(markup_contents)
text_spanner = consort.ComplexTextSpanner(markup=markup)
override(text_spanner).text_spanner.style = "dashed-line"
override(text_spanner).text_spanner.dash_fraction = 0.333
override(text_spanner).text_spanner.dash_period = 2.0
return text_spanner
def _format_altissimi_pitches(self):
pitch_staff = self._score['Pitch Staff']
for note in abjad.iterate(pitch_staff).by_class(abjad.Note):
if note.written_pitch == abjad.NamedPitch('C6'):
abjad.override(note).note_head.no_ledgers = True
style = abjad.schemetools.SchemeSymbol('do')
abjad.override(note).note_head.style = style
abjad.override(note).note_head.duration_log = 2
def _hide_leaf(leaf):
abjad.override(leaf).flag.transparent = True
abjad.override(leaf).dots.transparent = True
abjad.override(leaf).note_head.transparent = True
abjad.override(leaf).stem.transparent = True
abjad.override(leaf).stem_tremolo.transparent = True
abjad.override(leaf).beam.transparent = True
abjad.override(leaf).tie.transparent = True
abjad.override(leaf).rest.transparent = True
abjad.override(leaf).tuplet_bracket.transparent = True
abjad.override(leaf).tuplet_number.transparent = True
def _hidden_grace_after(leaf, attachments=[], grace_note=None):
if grace_note is None:
grace_note = abjad.Note(0, abjad.Duration(1, 16))
for attachment in attachments:
abjad.attach(attachment, grace_note)
Handler._hide_note_head(grace_note)
abjad.override(grace_note).stem.stencil = False
abjad.override(grace_note).beam.stencil = False
abjad.override(grace_note).flag.stencil = False
grace_container = abjad.scoretools.AfterGraceContainer([grace_note])
abjad.attach(grace_container, leaf)
def _make_illustration(self):
pitches, colors = self._get_pitches_and_colors()
notes = abjad.scoretools.make_notes(pitches, [(1, 4)])
for note, color in zip(notes, colors):
color = abjad.schemetools.SchemeColor('grey{}'.format(color))
abjad.override(note).note_head.color = color
expr = abjad.scoretools.make_piano_sketch_score_from_leaves(notes)
score = expr[0]
abjad.override(score).stem.transparent = True
abjad.override(score).rest.transparent = True
return score
def test_lilypondproxytools_LilyPondGrobNameManager___eq___01():
note_1 = abjad.Note("c'4")
abjad.override(note_1).note_head.color = 'red'
abjad.override(note_1).stem.color = 'red'
note_2 = abjad.Note("c'4")
abjad.override(note_2).note_head.color = 'red'
abjad.override(note_2).stem.color = 'red'
note_3 = abjad.Note("c'4")
abjad.override(note_3).note_head.color = 'red'
grob_override_component_plug_in_1 = abjad.override(note_1)
grob_override_component_plug_in_2 = abjad.override(note_2)
grob_override_component_plug_in_3 = abjad.override(note_3)
assert grob_override_component_plug_in_1 == grob_override_component_plug_in_1
assert grob_override_component_plug_in_1 == grob_override_component_plug_in_2
assert not grob_override_component_plug_in_1 == grob_override_component_plug_in_3
assert grob_override_component_plug_in_2 == grob_override_component_plug_in_1
assert grob_override_component_plug_in_2 == grob_override_component_plug_in_2
assert not grob_override_component_plug_in_2 == grob_override_component_plug_in_3
assert not grob_override_component_plug_in_3 == grob_override_component_plug_in_1
assert not grob_override_component_plug_in_3 == grob_override_component_plug_in_2
assert grob_override_component_plug_in_3 == grob_override_component_plug_in_3
def test_lilypondproxytools_LilyPondNameManager___eq___02():
note_1 = abjad.Note("c'4")
abjad.override(note_1).note_head.color = 'red'
abjad.override(note_1).note_head.thickness = 2
note_2 = abjad.Note("c'4")
abjad.override(note_2).note_head.color = 'red'
abjad.override(note_2).note_head.thickness = 2
note_3 = abjad.Note("c'4")
abjad.override(note_3).note_head.color = 'blue'
grob_proxy_1 = abjad.override(note_1).note_head
grob_proxy_2 = abjad.override(note_2).note_head
grob_proxy_3 = abjad.override(note_3).note_head
assert grob_proxy_1 == grob_proxy_1
assert grob_proxy_1 == grob_proxy_2
assert not grob_proxy_1 == grob_proxy_3
assert grob_proxy_2 == grob_proxy_1
assert grob_proxy_2 == grob_proxy_2
assert not grob_proxy_2 == grob_proxy_3
assert not grob_proxy_3 == grob_proxy_1
assert not grob_proxy_3 == grob_proxy_2
assert grob_proxy_3 == grob_proxy_3
def _populate_underlying_dynamics_voice(self):
if not self.notes:
return
underlying_dynamics_voice = self._score['Underlying Dynamics Voice']
durations = self._get_bow_location_durations()
skips = abjad.scoretools.make_skips(abjad.Duration(1), durations)
underlying_dynamics_voice.extend(skips)
if not self.underlying_dynamics:
return
for index, string in self.underlying_dynamics:
skip = underlying_dynamics_voice[index]
if string in ('<', '>'):
indicator = abjad.LilyPondCommand(
string,
format_slot='right',
)
elif string == '-|':
indicator = abjad.LilyPondCommand(
'<',
format_slot='right',
)
stencil = abjad.schemetools.Scheme('constante-hairpin')
abjad.override(skip).hairpin.stencil = stencil
elif string == '<!':
indicator = abjad.LilyPondCommand(
'<',
format_slot='right',
)
stencil = abjad.schemetools.Scheme('flared-hairpin')
abjad.override(skip).hairpin.stencil = stencil
elif string == '!>':
indicator = abjad.LilyPondCommand(
'>',
format_slot='right',
)
stencil = abjad.schemetools.Scheme('flared-hairpin')
abjad.override(skip).hairpin.stencil = stencil
else:
indicator = abjad.Dynamic(string)
abjad.attach(indicator, skip)
last_skip = skips[-1]
prototype = abjad.LilyPondCommand
if not abjad.inspect_(last_skip).has_indicator(prototype):
if not abjad.inspect_(last_skip).has_indicator(abjad.Dynamic):
indicator = abjad.LilyPondCommand(
'!',
format_slot='right',
)
abjad.attach(indicator, last_skip)
def __illustrate__(
self,
rhythm=None,
proportional_notation_duration=abjad.Duration(1, 16),
subtitle=None,
title=None,
):
r'''Illustrates rhythm-maker.
Returns LilyPond file.
'''
if rhythm is None:
rhythm = self()
tuplets, time_signatures = [], []
for selection, time_signature in rhythm:
tuplets.extend(selection)
time_signatures.append(time_signature)
lilypond_file = abjad.rhythmmakertools.make_lilypond_file(
tuplets,
time_signatures,
)
first_leaves = []
for tuplet in tuplets:
first_leaf = tuplet[0]
first_leaves.append(first_leaf)
for i, first_leaf in enumerate(first_leaves):
markup = abjad.Markup(str(i)).small()
abjad.attach(markup, first_leaf)
score = lilypond_file.score_block.items[0]
score.add_final_bar_line()
self._tweak_length_1_tuplets(score)
abjad.override(score).text_script.staff_padding = 4
abjad.override(score).time_signature.style = 'numbered'
abjad.override(score).tuplet_bracket.staff_padding = 3.5
pair = proportional_notation_duration.pair
moment = abjad.schemetools.SchemeMoment(pair)
abjad.set_(score).proportional_notation_duration = moment
assert abjad.inspect_(score).is_well_formed()
lilypond_file.layout_block.indent = 0
if subtitle is not None:
subtitle = abjad.Markup(subtitle)
lilypond_file.header_block.subtitle = subtitle
lilypond_file.header_block.tagline = abjad.Markup.null()
if title is not None:
title = abjad.Markup(title)
lilypond_file.header_block.title = abjad.Markup(title)
vector = layouttools.make_spacing_vector(0, 20, 0, 0)
lilypond_file.paper_block.markup_system_spacing = vector
return lilypond_file
def test_Rest___copy___03():
"""
Copy rest with LilyPond grob overrides and LilyPond context settings.
"""
rest_1 = abjad.Rest((1, 4))
abjad.override(rest_1).staff.note_head.color = "red"
abjad.override(rest_1).accidental.color = "red"
abjad.setting(rest_1).tuplet_full_length = True
rest_2 = copy.copy(rest_1)
assert isinstance(rest_1, abjad.Rest)
assert isinstance(rest_2, abjad.Rest)
assert format(rest_1) == format(rest_2)
assert rest_1 is not rest_2
def test_Chord___copy___03():
"""
Chord copies LilyPond grob overrides and LilyPond context settings.
"""
chord_1 = abjad.Chord("<ef' cs'' f''>4")
abjad.override(chord_1).staff.note_head.color = "red"
abjad.override(chord_1).accidental.color = "red"
abjad.setting(chord_1).tuplet_full_length = True
chord_2 = copy.copy(chord_1)
assert isinstance(chord_1, abjad.Chord)
assert isinstance(chord_2, abjad.Chord)
assert format(chord_1) == format(chord_2)
assert chord_1 is not chord_2
def test_Note___copy___03():
"""
Copy note with LilyPond grob abjad.overrides and LilyPond context settings.
"""
note_1 = abjad.Note(12, (1, 4))
abjad.override(note_1).staff.note_head.color = "red"
abjad.override(note_1).accidental.color = "red"
abjad.setting(note_1).tuplet_full_length = True
note_2 = copy.copy(note_1)
assert isinstance(note_1, abjad.Note)
assert isinstance(note_2, abjad.Note)
assert format(note_1) == format(note_2)
assert note_1 is not note_2
def test_Tuplet___copy___01():
tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
abjad.override(tuplet_1).note_head.color = "red"
assert format(tuplet_1) == abjad.String.normalize(
r"""
\override NoteHead.color = #red
\times 2/3 {
c'8
d'8
e'8
}
\revert NoteHead.color
"""
)
tuplet_2 = copy.copy(tuplet_1)
assert format(tuplet_2) == abjad.String.normalize(
r"""
\override NoteHead.color = #red
\times 2/3 {
}
\revert NoteHead.color
"""
)
assert not len(tuplet_2)
def test_Note___copy___05():
"""
Deepcopy orphan note.
"""
note = abjad.Note("c'4")
articulation = abjad.Articulation("staccato")
abjad.attach(articulation, note)
grace = abjad.GraceContainer("d'16")
abjad.attach(grace, note)
abjad.override(note).note_head.color = "red"
assert format(note) == abjad.String.normalize(
r"""
\grace {
d'16
}
\once \override NoteHead.color = #red
c'4
- \staccato
"""
)
new_note = copy.deepcopy(note)
assert not new_note is note
assert format(new_note) == format(note)
def test_LilyPondGrobNameManager___setattr___04():
"""
Override LilyPond BarNumber grob.
"""
score = abjad.Score([abjad.Staff("c'8 d'8 e'8 f'8")])
abjad.override(score).bar_number.color = "red"
assert format(score) == abjad.String.normalize(
r"""
\new Score
\with
{
\override BarNumber.color = #red
}
<<
\new Staff
{
c'8
d'8
e'8
f'8
}
>>
"""
)
assert abjad.inspect(score).wellformed()
def _handle_dynamics(self):
voice = self._score[f"{self.instrument_name}_Music_Voice"]
leaves = abjad.select(voice).leaves()
if not leaves:
return
music_durations = [abjad.inspect(_).duration() for _ in leaves]
maker = rmakers.multiplied_duration(abjad.Skip)
dynamics_skips = maker(music_durations)
dynamics_voice = self._score[f"{self.instrument_name}_Dynamics_Voice"]
dynamics_voice.extend(dynamics_skips)
for expression in self.dynamics:
index = expression[0]
string = expression[1]
leaf = dynamics_voice[index]
if string in ("<", ">"):
indicator = abjad.LilyPondLiteral("\\" + string, "after")
elif string == "-|":
indicator = abjad.LilyPondLiteral(r"\<", "after")
stencil = abjad.Scheme("constante-hairpin")
abjad.override(leaf).hairpin.stencil = stencil
elif string == "<!":
indicator = abjad.LilyPondLiteral(r"\<", "after")
stencil = abjad.Scheme("abjad-flared-hairpin")
abjad.override(leaf).hairpin.stencil = stencil
elif string == "!>":
indicator = abjad.LilyPondLiteral(r"\>", "after")
stencil = abjad.Scheme("abjad-flared-hairpin")
abjad.override(leaf).hairpin.stencil = stencil
else:
indicator = abjad.Dynamic(string)
abjad.attach(indicator, leaf)
if len(expression) == 3:
staff_padding = expression[2]
string = r"\override DynamicLineSpanner.staff-padding ="
string += f" {staff_padding}"
command = abjad.LilyPondLiteral(string)
abjad.attach(command, leaf)
last_leaf = dynamics_voice[-1]
prototype = abjad.LilyPondLiteral
if not abjad.inspect(last_leaf).has_indicator(prototype):
if not abjad.inspect(last_leaf).has_indicator(abjad.Dynamic):
indicator = abjad.LilyPondLiteral(r"\!", "after")
abjad.attach(indicator, last_leaf)
def test_LilyPondGrobNameManager___setattr___30():
"""
Override LilyPond SpanBar grob.
"""
score, treble, bass = abjad.Score.make_piano_score()
notes = [
abjad.Note("c'8"),
abjad.Note("d'8"),
abjad.Note("e'8"),
abjad.Note("f'8"),
]
treble.extend(notes)
notes = [
abjad.Note("c'8"),
abjad.Note("d'8"),
abjad.Note("e'8"),
abjad.Note("f'8"),
]
bass.extend(notes)
abjad.override(score).span_bar.color = "red"
abjad.attach(abjad.Clef("treble"), treble[0])
abjad.attach(abjad.Clef("bass"), bass[0])
assert format(score) == abjad.String.normalize(r"""
\new Score
\with
{
\override SpanBar.color = #red
}
<<
\new PianoStaff
<<
\context Staff = "Treble_Staff"
{
\clef "treble"
c'8
d'8
e'8
f'8
}
\context Staff = "Bass_Staff"
{
\clef "bass"
c'8
d'8
e'8
f'8
}
>>
>>
""")
assert abjad.inspect(score).wellformed()
def _hide_note_head(leaf):
def point_stencil():
return abjad.schemetools.Scheme('point-stencil')
if isinstance(leaf, abjad.scoretools.NoteHead):
leaf.tweak.stencil = point_stencil()
if isinstance(leaf, abjad.scoretools.Note):
abjad.override(leaf).note_head.stencil = point_stencil()
elif isinstance(leaf, abjad.scoretools.Chord):
for note_head in leaf.note_heads:
note_head.tweak.stencil = point_stencil()
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___07():
r'''Override LilyPond abjad.Clef grob.
'''
note = abjad.Note("c'4")
abjad.override(note).staff.clef.color = 'red'
assert format(note) == abjad.String.normalize(r'''
\once \override Staff.Clef.color = #red
c'4
''')
def _apply_position_and_span(staff, poses):
positions = cyc(poses)
for run in abjad.select(staff).runs():
span = abjad.StartTextSpan(
left_text=abjad.Markup(next(positions)).upright(),
right_text=abjad.Markup(next(positions)).upright(),
style="dashed-line-with-arrow",
)
abjad.attach(span, run[0])
abjad.attach(abjad.StopTextSpan(), run[-1])
abjad.override(staff).text_spanner.staff_padding = 0
def test_LilyPondGrobNameManager___setattr___06():
"""
Override LilyPond abjad.Clef grob.
"""
note = abjad.Note("c'4")
abjad.override(note).staff.clef.color = "red"
assert format(note) == abjad.String.normalize(r"""
\once \override Staff.Clef.color = #red
c'4
""")
def test_LilyPondGrobNameManager___delattr___01():
note = abjad.Note("c'4")
abjad.override(note).accidental.color = "red"
abjad.override(note).beam.positions = (-6, -6)
abjad.override(note).dots.thicknes = 2
assert format(note) == abjad.String.normalize(r"""
\once \override Accidental.color = #red
\once \override Beam.positions = #'(-6 . -6)
\once \override Dots.thicknes = #2
c'4
""")
del abjad.override(note).accidental
del abjad.override(note).beam
assert format(note) == abjad.String.normalize(r"""
\once \override Dots.thicknes = #2
c'4
""")
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___42():
r'''Override LilyPond Stem grob.
'''
note = abjad.Note(0, (1, 16))
abjad.override(note).stem.stroke_style = \
abjad.Scheme('grace', force_quotes=True)
assert format(note) == abjad.String.normalize(r'''
\once \override Stem.stroke-style = #"grace"
c'16
''')
def test_LilyPondGrobNameManager___setattr___37():
"""
Override LilyPond Tie grob.
"""
note = abjad.Note("c'4")
abjad.override(note).tie.color = "red"
assert format(note) == abjad.String.normalize(r"""
\once \override Tie.color = #red
c'4
""")
def test_lilypondproxytools_LilyPondGrobNameManager___delattr___01():
note = abjad.Note("c'4")
abjad.override(note).accidental.color = 'red'
abjad.override(note).beam.positions = (-6, -6)
abjad.override(note).dots.thicknes = 2
assert format(note) == abjad.String.normalize(r'''
\once \override Accidental.color = #red
\once \override Beam.positions = #'(-6 . -6)
\once \override Dots.thicknes = #2
c'4
''')
del (abjad.override(note).accidental)
del (abjad.override(note).beam)
assert format(note) == abjad.String.normalize(r'''
\once \override Dots.thicknes = #2
c'4
''')
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___38():
r'''Override LilyPond SpanBar grob.
'''
score, treble, bass = abjad.Score.make_piano_score()
notes = [
abjad.Note("c'8"),
abjad.Note("d'8"),
abjad.Note("e'8"),
abjad.Note("f'8")
]
treble.extend(notes)
notes = [
abjad.Note("c'8"),
abjad.Note("d'8"),
abjad.Note("e'8"),
abjad.Note("f'8")
]
bass.extend(notes)
abjad.override(score).span_bar.color = 'red'
abjad.attach(abjad.Clef('treble'), treble[0])
abjad.attach(abjad.Clef('bass'), bass[0])
assert format(score) == abjad.String.normalize(r'''
\new Score
\with
{
\override SpanBar.color = #red
}
<<
\new PianoStaff
<<
\context Staff = "Treble Staff"
{
\clef "treble"
c'8
d'8
e'8
f'8
}
\context Staff = "Bass Staff"
{
\clef "bass"
c'8
d'8
e'8
f'8
}
>>
>>
''')
assert abjad.inspect(score).is_well_formed()
def __illustrate__(self):
r"""
Illustrates pitch segment.
.. container:: example
>>> segment = abjad.PitchSegment("bf, aqs fs' g' bqf g'")
>>> abjad.show(segment) # doctest: +SKIP
.. docs::
>>> lilypond_file = segment.__illustrate__()
>>> abjad.f(lilypond_file[abjad.StaffGroup])
\new PianoStaff
<<
\context Staff = "Treble_Staff"
{
\clef "treble"
r1 * 1/8
r1 * 1/8
fs'1 * 1/8
g'1 * 1/8
r1 * 1/8
g'1 * 1/8
}
\context Staff = "Bass_Staff"
{
\clef "bass"
bf,1 * 1/8
aqs1 * 1/8
r1 * 1/8
r1 * 1/8
bqf1 * 1/8
r1 * 1/8
}
>>
Returns LilyPond file.
"""
import abjad
named_pitches = [abjad.NamedPitch(x) for x in self]
maker = abjad.NoteMaker()
notes = maker(named_pitches, [1])
result = abjad.Score.make_piano_score(leaves=notes, sketch=True)
score, treble_staff, bass_staff = result
for leaf in abjad.iterate(score).leaves():
leaf.multiplier = (1, 8)
abjad.override(score).rest.transparent = True
lilypond_file = abjad.LilyPondFile.new(score)
return lilypond_file
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___37():
r'''Override LilyPond SpacingSpanner grob.
'''
score = abjad.Score([])
abjad.override(score).spacing_spanner.strict_grace_spacing = True
abjad.override(score).spacing_spanner.strict_note_spacing = True
abjad.override(score).spacing_spanner.uniform_stretching = True
assert format(score) == abjad.String.normalize(r'''
\new Score
\with
{
\override SpacingSpanner.strict-grace-spacing = ##t
\override SpacingSpanner.strict-note-spacing = ##t
\override SpacingSpanner.uniform-stretching = ##t
}
<<
>>
''')
assert not len(score)
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___36():
r'''Override LilyPond SpacingSpanner grob on Abjad containers.
LilyPond SpacingSpanner lives at Score by default.
Abjad SpacingSpanner abjad.overrides usually
require context promotion.
'''
staff = abjad.Staff("abj: | 2/8 c'8 d'8 || 2/8 e'8 f'8 |")
leaves = abjad.select(staff).leaves()
beam = abjad.Beam()
abjad.attach(beam, leaves)
abjad.override(beam).score.spacing_spanner.strict_grace_spacing = True
abjad.override(beam).score.spacing_spanner.strict_note_spacing = True
abjad.override(beam).score.spacing_spanner.uniform_stretching = True
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
{ % measure
\time 2/8
\override Score.SpacingSpanner.strict-grace-spacing = ##t
\override Score.SpacingSpanner.strict-note-spacing = ##t
\override Score.SpacingSpanner.uniform-stretching = ##t
c'8
[
d'8
} % measure
{ % measure
e'8
\revert Score.SpacingSpanner.strict-grace-spacing
\revert Score.SpacingSpanner.strict-note-spacing
\revert Score.SpacingSpanner.uniform-stretching
f'8
]
} % measure
}
''')
assert abjad.inspect(staff).is_well_formed()
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___34():
r'''Override LilyPond Script grob.
'''
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).script.staff_padding = 2
abjad.override(staff).script.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(r'''
\new Staff
\with
{
\override Script.Y-extent = #'(-1.5 . 1.5)
\override Script.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
''')
def _copy_override_and_set_from_leaf(self, leaf):
import abjad
if getattr(leaf, '_lilypond_grob_name_manager', None) is not None:
self._lilypond_grob_name_manager = copy.copy(abjad.override(leaf))
if getattr(leaf, '_lilypond_setting_name_manager', None) is not None:
self._lilypond_setting_name_manager = copy.copy(
abjad.setting(leaf))
new_indicators = []
for indicator in leaf._indicator_wrappers:
new_indicator = copy.copy(indicator)
new_indicators.append(new_indicator)
for new_indicator in new_indicators:
abjad.attach(new_indicator, self)
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___21():
r'''Override LilyPond abjad.NoteColumn grob.
'''
note = abjad.Note("c'4")
abjad.override(note).note_column.ignore_collision = True
assert format(note) == abjad.String.normalize(r'''
\once \override NoteColumn.ignore-collision = ##t
c'4
''')
assert abjad.inspect(note).is_well_formed()
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___14():
r'''Override LilyPond abjad.DynamicTextSpanner grob.
'''
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).dynamic_text_spanner.staff_padding = 2
abjad.override(staff).dynamic_text_spanner.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(r'''
\new Staff
\with
{
\override DynamicTextSpanner.Y-extent = #'(-1.5 . 1.5)
\override DynamicTextSpanner.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
''')
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___60():
r'''Override LilyPond VerticalAxis grob.
'''
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).vertical_axis_group.staff_padding = 2
abjad.override(staff).vertical_axis_group.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(r'''
\new Staff
\with
{
\override VerticalAxisGroup.Y-extent = #'(-1.5 . 1.5)
\override VerticalAxisGroup.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
''')
def test_Rest___init___02():
"""
Initialize rest from other rest.
"""
rest_1 = abjad.Rest("r4", multiplier=(1, 2))
abjad.override(rest_1).Staff.NoteHead.color = "#red"
rest_2 = abjad.Rest(rest_1)
assert isinstance(rest_1, abjad.Rest)
assert isinstance(rest_2, abjad.Rest)
assert abjad.lilypond(rest_1) == abjad.lilypond(rest_2)
assert rest_1 is not rest_2
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___51():
r'''Override LilyPond TrillPitchAccidental grob.
'''
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).trill_pitch_accidental.staff_padding = 2
abjad.override(staff).trill_pitch_accidental.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(r'''
\new Staff
\with
{
\override TrillPitchAccidental.Y-extent = #'(-1.5 . 1.5)
\override TrillPitchAccidental.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
''')
def test_scoretools_Rest___init___02():
r'''Initialize rest from other rest.
'''
rest_1 = abjad.Rest('r4')
abjad.attach(abjad.Multiplier(1, 2), rest_1)
abjad.override(rest_1).staff.note_head.color = 'red'
rest_2 = abjad.Rest(rest_1)
assert isinstance(rest_1, abjad.Rest)
assert isinstance(rest_2, abjad.Rest)
assert format(rest_1) == format(rest_2)
assert rest_1 is not rest_2
def test_LilyPondGrobNameManager___setattr___34():
"""
Override LilyPond Stem grob.
"""
note = abjad.Note(0, (1, 16))
abjad.override(note).stem.stroke_style = abjad.Scheme("grace",
force_quotes=True)
assert format(note) == abjad.String.normalize(r"""
\once \override Stem.stroke-style = #"grace"
c'16
""")
def test_Rest___init___02():
"""
Initialize rest from other rest.
"""
rest_1 = abjad.Rest("r4", multiplier=(1, 2))
abjad.override(rest_1).staff.note_head.color = "red"
rest_2 = abjad.Rest(rest_1)
assert isinstance(rest_1, abjad.Rest)
assert isinstance(rest_2, abjad.Rest)
assert format(rest_1) == format(rest_2)
assert rest_1 is not rest_2
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___43():
r'''Override LilyPond StemTremolo grob.
'''
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).stem_tremolo.slope = 0.5
abjad.override(staff).stem_tremolo.staff_padding = 2
assert format(staff) == abjad.String.normalize(r'''
\new Staff
\with
{
\override StemTremolo.slope = #0.5
\override StemTremolo.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
''')
def configure_score(self, score):
r'''Configures `score`.
'''
moment = abjad.SchemeMoment((1, 56))
abjad.setting(score).proportional_notation_duration = moment
abjad.setting(score).tuplet_full_length = True
abjad.override(score).bar_line.stencil = False
abjad.override(score).bar_number.transparent = True
abjad.override(score).spacing_spanner.uniform_stretching = True
abjad.override(score).spacing_spanner.strict_note_spacing = True
abjad.override(score).time_signature.stencil = False
abjad.override(score).tuplet_bracket.padding = 2
abjad.override(score).tuplet_bracket.staff_padding = 4
scheme = abjad.Scheme('tuplet-number::calc-fraction-text')
abjad.override(score).tuplet_number.text = scheme
def _copy_with_indicators_but_without_children_or_spanners(self):
import abjad
new = type(self)(*self.__getnewargs__())
if getattr(self, '_lilypond_grob_name_manager', None) is not None:
new._lilypond_grob_name_manager = copy.copy(abjad.override(self))
if getattr(self, '_lilypond_setting_name_manager', None) is not None:
new._lilypond_setting_name_manager = copy.copy(abjad.setting(self))
for wrapper in self._get_annotation_wrappers():
new_wrapper = copy.copy(wrapper)
abjad.attach(new_wrapper, new)
for wrapper in self._get_indicators(unwrap=False):
new_wrapper = copy.copy(wrapper)
abjad.attach(new_wrapper, new)
return new
def test_LilyPondGrobNameManager___setattr___41():
"""
Override LilyPond TrillPitchAccidental grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).trill_pitch_accidental.staff_padding = 2
abjad.override(staff).trill_pitch_accidental.Y_extent = (-1.5, 1.5)
assert format(staff) == abjad.String.normalize(r"""
\new Staff
\with
{
\override TrillPitchAccidental.Y-extent = #'(-1.5 . 1.5)
\override TrillPitchAccidental.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
""")
def test_LilyPondGrobNameManager___setattr___35():
"""
Override LilyPond StemTremolo grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff).stem_tremolo.slope = 0.5
abjad.override(staff).stem_tremolo.staff_padding = 2
assert format(staff) == abjad.String.normalize(r"""
\new Staff
\with
{
\override StemTremolo.slope = #0.5
\override StemTremolo.staff-padding = #2
}
{
c'8
d'8
e'8
f'8
}
""")
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___33():
r'''Override LilyPond Script grob.
'''
note = abjad.Note("c'4")
articulation = abjad.Articulation('staccato')
abjad.attach(articulation, note)
abjad.override(note).script.color = 'red'
assert format(note) == abjad.String.normalize(r'''
\once \override Script.color = #red
c'4
-\staccato
''')
