def test_Parentage_logical_voice_10():
"""
Measure and leaves must carry same logical voice signature.
"""
staff = abjad.Staff(r"""
{
\time 2/8
c'8
d'8
}
e'8
f'8
""")
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
{
\time 2/8
c'8
d'8
}
e'8
f'8
}
""")
assert (abjad.inspect(
staff[0]).parentage().logical_voice() == abjad.inspect(
staff[-1]).parentage().logical_voice())
assert (abjad.inspect(
staff[0]).parentage().logical_voice() == abjad.inspect(
staff[0][0]).parentage().logical_voice())
assert (abjad.inspect(
staff[0][0]).parentage().logical_voice() == abjad.inspect(
staff[-1]).parentage().logical_voice())
def test_scoretools_Mutation_replace_measure_contents_05():
r'''Populate measures even when not enough total measures.
'''
maker = abjad.MeasureMaker()
measures = maker([(1, 8), (1, 8)])
staff = abjad.Staff(measures)
notes = [
abjad.Note("c'16"),
abjad.Note("d'16"),
abjad.Note("e'16"),
abjad.Note("f'16"),
abjad.Note("g'16"),
abjad.Note("a'16")
]
try:
abjad.mutate(staff).replace_measure_contents(notes)
except StopIteration:
pass
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
{ % measure
\time 1/8
c'16
d'16
} % measure
{ % measure
e'16
f'16
} % measure
}
''')
assert abjad.inspect(staff).is_well_formed()
def test_auto_rewrite_meter_06():
staff = abjad.Staff(r"\time 3/4 c'8 d'4 e'4 f'8 "
r"\time 5/8 g'4 a'4 r8 "
r"\time 6/8 b'4 c''4 r4 "
r"\time 4/4 d''8 e''4 f''8 g''16 a''4 r8.")
abjad.mutate.auto_rewrite_meter(staff)
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
\time 3/4
c'8
d'4
e'4
f'8
\time 5/8
g'4
a'8
~
a'8
r8
\time 6/8
b'4
c''8
~
c''8
r4
\time 4/4
d''8
e''4
f''8
g''16
a''8.
~
a''16
r8.
}
""")
def test_Score_add_double_bar_lines_before_time_signatures_08():
staff = abjad.Staff(r"R1 "
r"\time 3/4 c'2. "
r"\time 4/4 d'1 "
r"e'1 "
r"\time 6/4 f'2. g'2. "
r"\time 2/4 a'2")
abjad.attach(abjad.BarLine('.|:'), staff[0])
abjad.attach(abjad.BarLine(':|.'), staff[1])
abjad.attach(abjad.BarLine('|'), staff[3])
abjad.attach(abjad.BarLine('!'), staff[5])
score = auxjad.Score([staff])
score.add_double_bar_lines_before_time_signatures()
assert abjad.lilypond(score) == abjad.String.normalize(r"""
\new Score
<<
\new Staff
{
R1
\bar ".|:"
\time 3/4
c'2.
\bar ":|."
\time 4/4
d'1
e'1
\bar "||"
\time 6/4
f'2.
g'2.
\bar "!"
\time 2/4
a'2
}
>>
""")
def test_lilypondparsertools_LilyPondParser__indicators__MetronomeMark_01():
target = abjad.Score([abjad.Staff([abjad.Note(0, 1)])])
mark = abjad.MetronomeMark(textual_indication="As fast as possible")
abjad.attach(mark, target[0][0], context='Staff')
assert format(target) == abjad.String.normalize(r'''
\new Score
<<
\new Staff
{
\tempo "As fast as possible"
c'1
}
>>
''')
parser = abjad.lilypondparsertools.LilyPondParser()
result = parser(format(target))
assert format(target) == format(result) and target is not result
leaves = abjad.select(result).leaves()
leaf = leaves[0]
marks = abjad.inspect(leaf).get_indicators(abjad.MetronomeMark)
assert len(marks) == 1
def test_scoretools_Inspection_get_indicators_04():
staff = abjad.Staff("c'8 d'8 e'8 f'8")
comment_1 = abjad.LilyPondComment('comment 1')
abjad.attach(comment_1, staff[0])
comment_2 = abjad.LilyPondComment('comment 2')
abjad.attach(comment_2, staff[0])
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
% comment 1
% comment 2
c'8
d'8
e'8
f'8
}
'''), format(staff)
indicators = abjad.inspect(staff[0]).get_indicators(abjad.LilyPondComment)
assert comment_1 in indicators
assert comment_2 in indicators
assert len(indicators) == 2
def test_Tuplet_timespan_01():
staff = abjad.Staff(r"c'4 d'4 \times 2/3 { e'4 f'4 g'4 }")
assert abjad.lilypond(staff) == abjad.String.normalize(
r"""
\new Staff
{
c'4
d'4
\times 2/3
{
e'4
f'4
g'4
}
}
"""
)
assert abjad.get.timespan(staff) == abjad.Timespan(0, 1)
assert abjad.get.timespan(staff[0]) == abjad.Timespan(0, (1, 4))
assert abjad.get.timespan(staff[1]) == abjad.Timespan((1, 4), (1, 2))
assert abjad.get.timespan(staff[-1]) == abjad.Timespan((1, 2), 1)
def test_LeafLooper_21():
random.seed(55126)
container = abjad.Container(r"c'4 d'4 e'4 f'4 g'4 a'4 b'4 c''4 d''4")
looper = auxjad.LeafLooper(container,
window_size=2,
max_steps=4,
)
notes = looper.output_n(4)
staff = abjad.Staff(notes)
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
{
\time 2/4
c'4
d'4
g'4
a'4
a'4
b'4
c''4
d''4
}
""")
def test_scoretools_Container___setitem___13():
r'''Replaces three spanned leaves with three different leaves.
'''
staff = abjad.Staff("c'8 d'8 e'8 f'8")
beam = abjad.Beam()
abjad.attach(beam, staff[:])
notes = [abjad.Note("b'8"), abjad.Note("a'8"), abjad.Note("g'8")]
staff[1:3] = notes
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
c'8
[
b'8
a'8
g'8
f'8
]
}
''')
assert abjad.inspect(staff).is_well_formed()
def test_LilyPondParser__spanners__Hairpin_06():
"""
With direction.
"""
maker = abjad.NoteMaker()
target = abjad.Staff(maker([0] * 5, [(1, 4)]))
start_hairpin = abjad.StartHairpin("<", direction=abjad.Up)
abjad.attach(start_hairpin, target[0])
stop_hairpin = abjad.StopHairpin()
abjad.attach(stop_hairpin, target[2])
hairpin = abjad.StartHairpin(">", direction=abjad.Down)
abjad.attach(hairpin, target[2])
dynamic = abjad.Dynamic("ppp")
abjad.attach(dynamic, target[-1])
assert format(target) == abjad.String.normalize(
r"""
\new Staff
{
c'4
^ \<
c'4
c'4
\!
_ \>
c'4
c'4
\ppp
}
"""
)
parser = abjad.parser.LilyPondParser()
result = parser(format(target))
assert format(target) == format(result) and target is not result
def test_scoretools_Staff___copy___01():
r'''Staves (shallow) copy grob abjad.overrides and context abjad.settings
but not components.
'''
staff_1 = abjad.Staff("c'8 d'8 e'8 f'8")
abjad.override(staff_1).note_head.color = 'red'
abjad.setting(staff_1).tuplet_full_length = True
staff_2 = copy.copy(staff_1)
assert format(staff_2) == abjad.String.normalize(
r'''
\new Staff
\with
{
\override NoteHead.color = #red
tupletFullLength = ##t
}
{
}
'''
)
def test_Staff_engraver_removals_01():
staff = abjad.Staff("c'8 d'8 e'8 f'8")
staff.remove_commands.append("Time_signature_engraver")
staff.remove_commands.append("Bar_number_engraver")
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
\with
{
\remove Time_signature_engraver
\remove Bar_number_engraver
}
{
c'8
d'8
e'8
f'8
}
"""
)
assert abjad.inspect(staff).wellformed()
def test_Phaser_20():
random.seed(98451)
container = abjad.Container(r"c'4 d'4 e'4 f'4")
phaser = auxjad.Phaser(
container,
step_size=(1, 4),
forward_bias=0.5,
)
notes = phaser.output_n(5)
staff = abjad.Staff(notes)
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
\time 4/4
c'4
d'4
e'4
f'4
d'4
e'4
f'4
c'4
c'4
d'4
e'4
f'4
f'4
c'4
d'4
e'4
c'4
d'4
e'4
f'4
}
""")
def test_Phaser_19():
container = abjad.Container(r"\time 3/4 c'4 d'4 e'4")
phaser = auxjad.Phaser(
container,
step_size=(1, 8),
omit_time_signatures=True,
)
notes = phaser.output_n(3)
staff = abjad.Staff(notes)
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
c'4
d'4
e'4
c'8
d'4
e'4
c'8
d'4
e'4
c'4
}
""")
def test_LilyPondParser__indicators__Dynamic_01():
target = abjad.Staff(abjad.Note(-12, (1, 2)) * 6)
dynamic = abjad.Dynamic("ppp")
abjad.attach(dynamic, target[0])
dynamic = abjad.Dynamic("mp")
abjad.attach(dynamic, target[1])
dynamic = abjad.Dynamic("rfz")
abjad.attach(dynamic, target[2])
dynamic = abjad.Dynamic("mf")
abjad.attach(dynamic, target[3])
dynamic = abjad.Dynamic("spp")
abjad.attach(dynamic, target[4])
dynamic = abjad.Dynamic("ff")
abjad.attach(dynamic, target[5])
string = r"""\new Staff { c2\ppp c\mp c2\rfz c\mf c2\spp c\ff }"""
parser = abjad.parser.LilyPondParser()
result = parser(string)
assert format(target) == format(result) and target is not result
for x in result:
dynamics = abjad.inspect(x).indicators(abjad.Dynamic)
assert len(dynamics) == 1
def test_mutate__split_leaf_by_durations_01():
"""
Splits note into assignable notes.
Does tie split notes.
"""
staff = abjad.Staff("c'8 [ d'8 e'8 ]")
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
c'8
[
d'8
e'8
]
}
"""), print(abjad.lilypond(staff))
abjad.mutate._split_leaf_by_durations(staff[1], [abjad.Duration(1, 32)])
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
c'8
[
d'32
~
d'16.
e'8
]
}
"""), print(abjad.lilypond(staff))
assert abjad.wf.wellformed(staff)
def test_scoretools_Container___setitem___10():
r'''Sets leaf between spanned compoennts.
'''
staff = abjad.Staff("c'8 d'8 e'8 f'8")
beam = abjad.Beam()
abjad.attach(beam, staff[:])
note = abjad.Note("g'8")
staff[2:2] = [note]
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
c'8
[
d'8
g'8
e'8
f'8
]
}
''')
assert abjad.inspect(staff).is_well_formed()
def test_lilypondparsertools_LilyPondParser__functions__transpose_03():
maker = abjad.NoteMaker()
target = abjad.Staff([
abjad.Container(maker(["cs'", "ds'", "es'", "fs'"], (1, 4))),
abjad.Container(maker(["df'", "ef'", "f'", "gf'"], (1, 4)))
])
assert format(target) == abjad.String.normalize(r'''
\new Staff
{
{
cs'4
ds'4
es'4
fs'4
}
{
df'4
ef'4
f'4
gf'4
}
}
''')
string = r'''music = \relative c' { c d e f }
\new Staff {
\transpose c cs \music
\transpose c df \music
}
'''
parser = abjad.lilypondparsertools.LilyPondParser()
result = parser(string)
assert format(target) == format(result) and target is not result
def test_reposition_clefs_12():
staff = abjad.Staff(r"c'1 | d'1")
abjad.attach(abjad.Clef('treble'), staff[0])
abjad.attach(abjad.Clef('treble'), staff[1])
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
{
\clef "treble"
c'1
\clef "treble"
d'1
}
""")
abjad.mutate(staff[:]).reposition_clefs()
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
{
\clef "treble"
c'1
d'1
}
""")
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___46():
r'''Override LilyPond TextSpanner grob.
'''
staff = abjad.Staff("c'8 c'8 c'8 c'8")
text_spanner = abjad.TextSpanner()
abjad.attach(text_spanner, staff[:])
abjad.override(text_spanner).text_spanner.font_shape = 'italic'
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
\override TextSpanner.font-shape = #'italic
c'8
\startTextSpan
c'8
c'8
\revert TextSpanner.font-shape
c'8
\stopTextSpan
}
''')
assert abjad.inspect(staff).is_well_formed()
def test_Staff___delitem___03():
staff = abjad.Staff([
abjad.Note("c'4"),
abjad.Rest((1, 4)),
abjad.Chord([2, 3, 4], (1, 4)),
abjad.Skip((1, 4)),
abjad.Tuplet((4, 5), 4 * abjad.Note(0, (1, 16))),
])
assert len(staff) == 5
assert isinstance(staff[0], abjad.Note)
assert isinstance(staff[1], abjad.Rest)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Skip)
assert isinstance(staff[4], abjad.Tuplet)
del (staff[3])
assert len(staff) == 4
assert isinstance(staff[0], abjad.Note)
assert isinstance(staff[1], abjad.Rest)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Tuplet)
del (staff[-2])
assert len(staff) == 3
assert isinstance(staff[0], abjad.Note)
assert isinstance(staff[1], abjad.Rest)
assert isinstance(staff[2], abjad.Tuplet)
del (staff[2])
assert len(staff) == 2
assert isinstance(staff[0], abjad.Note)
assert isinstance(staff[1], abjad.Rest)
del (staff[0])
assert len(staff) == 1
assert isinstance(staff[0], abjad.Rest)
del (staff[-1])
assert len(staff) == 0
def test_Mutation_split_20():
"""
Splits leaf at non-assignable, non-power-of-two offset.
"""
staff = abjad.Staff("c'4")
notes = staff[:1]
result = abjad.mutate(notes).split([abjad.Duration(5, 24)], )
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
\times 2/3 {
c'4
~
c'16
~
c'16
}
}
"""), print(format(staff))
assert abjad.inspect(staff).wellformed()
def test_mutate_split_15():
"""
Splits leaf at non-assignable, non-power-of-two offset.
"""
staff = abjad.Staff("c'4")
notes = staff[:1]
abjad.mutate.split(notes, [abjad.Duration(5, 24)])
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
\times 2/3 {
c'4
~
c'16
~
c'16
}
}
"""), print(abjad.lilypond(staff))
assert abjad.wf.wellformed(staff)
def test_Fader_07():
random.seed(44126)
container = abjad.Container(r"\times 2/3 {c'8 d'8 e'8} d'2.")
fader = auxjad.Fader(container)
notes = fader.output_all()
staff = abjad.Staff(notes)
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
\times 2/3
{
\time 4/4
c'8
d'8
e'8
}
d'2.
\times 2/3
{
r8
d'8
e'8
}
d'2.
\times 2/3
{
r8
d'8
r8
}
d'2.
r4
d'2.
R1
}
""")
def test_LilyPondParser__indicators__TimeSignature_01():
target = abjad.Score([abjad.Staff([abjad.Note(0, 1)])])
time_signature = abjad.TimeSignature((8, 8))
abjad.attach(time_signature, target[0][0])
assert format(target) == abjad.String.normalize(r"""
\new Score
<<
\new Staff
{
\time 8/8
c'1
}
>>
""")
parser = abjad.parser.LilyPondParser()
result = parser(format(target))
assert format(target) == format(result) and target is not result
leaves = abjad.select(result).leaves()
leaf = leaves[0]
time_signatures = abjad.inspect(leaf).indicators(abjad.TimeSignature)
assert len(time_signatures) == 1
def test_Fader_10():
random.seed(29862)
container = abjad.Container(r"c'8 d'8 e'8 f'8 g'8 a'8 b'8 c''8")
fader = auxjad.Fader(
container,
max_steps=3,
process_on_first_call=True,
)
notes = fader.output_n(3)
staff = abjad.Staff(notes)
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
\time 4/4
c'8
d'8
r8
f'8
g'8
a'8
b'8
c''8
r4.
f'8
g'8
a'8
b'8
c''8
r4.
f'8
r8
a'8
b'8
r8
}
""")
def test_Score_add_double_bar_lines_before_time_signatures_07():
staff = abjad.Staff(
r"\time 3/4 R1 * 3/4 \time 4/4 R1 * 2 \time 6/4 R1 * 6/4 \time 4/4 R1")
score = auxjad.Score([staff])
score.add_double_bar_lines_before_time_signatures()
assert abjad.lilypond(score) == abjad.String.normalize(r"""
\new Score
<<
\new Staff
{
\time 3/4
R1 * 3/4
\bar "||"
\time 4/4
R1 * 2
\bar "||"
\time 6/4
R1 * 3/2
\bar "||"
\time 4/4
R1
}
>>
""")
def test_Inspection_effective_staff_03():
"""
Staff changes work on the last note of a staff.
"""
staves = 2 * abjad.Staff("c'8 d'8 e'8 f'8")
staff_group = abjad.StaffGroup(staves)
staff_group.lilypond_type = "PianoStaff"
staff_group.is_simultaneous = True
staff_group[0].name = "RH"
staff_group[1].name = "LH"
staff_change = abjad.StaffChange(staff_group[1])
abjad.attach(staff_change, staff_group[0][-1])
assert format(staff_group) == abjad.String.normalize(r"""
\new PianoStaff
<<
\context Staff = "RH"
{
c'8
d'8
e'8
\change Staff = LH
f'8
}
\context Staff = "LH"
{
c'8
d'8
e'8
f'8
}
>>
""")
assert abjad.inspect(staff_group).wellformed()
def test_Inspection_indicators_04():
staff = abjad.Staff("c'8 d'8 e'8 f'8")
comment_1 = abjad.LilyPondComment("comment 1")
abjad.attach(comment_1, staff[0])
comment_2 = abjad.LilyPondComment("comment 2")
abjad.attach(comment_2, staff[0])
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
% comment 1
% comment 2
c'8
d'8
e'8
f'8
}
"""), format(staff)
indicators = abjad.inspect(staff[0]).indicators(abjad.LilyPondComment)
assert comment_1 in indicators
assert comment_2 in indicators
assert len(indicators) == 2
def test_mutate__split_leaf_by_durations_06():
"""
Returns three leaves with two tied.
"""
staff = abjad.Staff([abjad.Note("c'4")])
new_leaves = abjad.mutate._split_leaf_by_durations(staff[0],
[abjad.Duration(5, 32)])
assert isinstance(new_leaves, abjad.Selection)
assert all(isinstance(_, abjad.Note) for _ in new_leaves)
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
c'8
~
c'32
~
c'16.
}
"""), print(abjad.lilypond(staff))
assert abjad.wf.wellformed(staff)
