def test_get_leaf_18():
"""
Does connect through asymmetrically nested tuplets.
"""
inner_tuplet = abjad.Tuplet((2, 3), "c'8 c'8 c'8")
contents = [abjad.Note("c'4"), inner_tuplet, abjad.Note("c'4")]
tuplet = abjad.Tuplet((2, 3), contents)
assert abjad.lilypond(tuplet) == abjad.String.normalize(
r"""
\times 2/3 {
c'4
\times 2/3 {
c'8
c'8
c'8
}
c'4
}
"""
)
assert abjad.get.leaf(tuplet[0], 1) is inner_tuplet[0]
assert abjad.get.leaf(inner_tuplet[-1], 1) is tuplet[-1]
assert abjad.get.leaf(tuplet[-1], -1) is inner_tuplet[-1]
assert abjad.get.leaf(inner_tuplet[0], -1) is tuplet[0]
def test_scoretools_Mutation_splice_03():
r'''Splices tuplet after tuplet.
'''
tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
voice = abjad.Voice([tuplet])
beam = abjad.Beam()
abjad.attach(beam, tuplet[:])
tuplet = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
result = abjad.mutate(voice[-1]).splice(
[tuplet],
grow_spanners=True,
)
assert format(voice) == abjad.String.normalize(r'''
\new Voice
{
\times 2/3 {
c'8
[
d'8
e'8
}
\times 2/3 {
c'8
d'8
e'8
]
}
}
''')
assert abjad.inspect(voice).is_well_formed()
assert result == voice[:]
def test_scoretools_Mutation_fuse_08():
r'''Fuses fixed-multiplier tuplets with same multiplier in score.
'''
tuplet_1 = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8")
beam = abjad.Beam()
abjad.attach(beam, tuplet_1[:])
tuplet_2 = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8 f'8 g'8")
slur = abjad.Slur()
abjad.attach(slur, tuplet_2[:])
voice = abjad.Voice([tuplet_1, tuplet_2])
assert format(voice) == abjad.String.normalize(r'''
\new Voice
{
\times 2/3 {
c'8
[
d'8
e'8
]
}
\tweak edge-height #'(0.7 . 0)
\times 2/3 {
c'8
(
d'8
e'8
f'8
g'8
)
}
}
''')
tuplets = voice[:]
abjad.mutate(tuplets).fuse()
assert format(voice) == abjad.String.normalize(r'''
\new Voice
{
\tweak edge-height #'(0.7 . 0)
\times 2/3 {
c'8
[
d'8
e'8
]
c'8
(
d'8
e'8
f'8
g'8
)
}
}
''')
assert abjad.inspect(voice).is_well_formed()
def test_get_leaf_07():
"""
Tuplets inside a voice.
"""
tuplet_1 = abjad.Tuplet((2, 3), "c'8 cs'8 d'8")
tuplet_2 = abjad.Tuplet((2, 3), "ef'8 e'8 f'8")
voice = abjad.Voice([tuplet_1, tuplet_2])
assert abjad.lilypond(voice) == abjad.String.normalize(
r"""
\new Voice
{
\times 2/3 {
c'8
cs'8
d'8
}
\times 2/3 {
ef'8
e'8
f'8
}
}
"""
)
assert abjad.get.leaf(tuplet_1[0], 1) is tuplet_1[1]
assert abjad.get.leaf(tuplet_1[1], 1) is tuplet_1[2]
assert abjad.get.leaf(tuplet_1[2], 1) is tuplet_2[0]
assert abjad.get.leaf(tuplet_1[1], -1) is tuplet_1[0]
assert abjad.get.leaf(tuplet_1[2], -1) is tuplet_1[1]
assert abjad.get.leaf(tuplet_2[0], -1) is tuplet_1[2]
def test_Inspection_leaf_07():
"""
Tuplets inside a voice.
"""
tuplet_1 = abjad.Tuplet((2, 3), "c'8 cs'8 d'8")
tuplet_2 = abjad.Tuplet((2, 3), "ef'8 e'8 f'8")
voice = abjad.Voice([tuplet_1, tuplet_2])
assert format(voice) == abjad.String.normalize(r"""
\new Voice
{
\times 2/3 {
c'8
cs'8
d'8
}
\times 2/3 {
ef'8
e'8
f'8
}
}
""")
assert abjad.inspect(tuplet_1[0]).leaf(1) is tuplet_1[1]
assert abjad.inspect(tuplet_1[1]).leaf(1) is tuplet_1[2]
assert abjad.inspect(tuplet_1[2]).leaf(1) is tuplet_2[0]
assert abjad.inspect(tuplet_1[1]).leaf(-1) is tuplet_1[0]
assert abjad.inspect(tuplet_1[2]).leaf(-1) is tuplet_1[1]
assert abjad.inspect(tuplet_2[0]).leaf(-1) is tuplet_1[2]
def test_Inspection_leaf_17():
"""
Does connect in sequence of alternating tuplets and notes.
"""
notes = [abjad.Note(i, abjad.Duration(1, 8)) for i in range(3)]
tuplet_1 = abjad.Tuplet((2, 3), notes)
notes = [abjad.Note(i, abjad.Duration(1, 8)) for i in range(4, 7)]
tuplet_2 = abjad.Tuplet((2, 3), notes)
voice = abjad.Voice([tuplet_1, abjad.Note(3, (1, 8)), tuplet_2])
assert format(voice) == abjad.String.normalize(r"""
\new Voice
{
\times 2/3 {
c'8
cs'8
d'8
}
ef'8
\times 2/3 {
e'8
f'8
fs'8
}
}
""")
assert abjad.inspect(tuplet_1[-1]).leaf(1) is voice[1]
assert abjad.inspect(voice[1]).leaf(1) is tuplet_2[0]
assert abjad.inspect(voice[1]).leaf(-1) is tuplet_1[-1]
assert abjad.inspect(tuplet_2[0]).leaf(-1) is voice[1]
def test_Inspection_leaf_18():
"""
Does connect through asymmetrically nested tuplets.
"""
inner_tuplet = abjad.Tuplet((2, 3), "c'8 c'8 c'8")
contents = [abjad.Note("c'4"), inner_tuplet, abjad.Note("c'4")]
tuplet = abjad.Tuplet((2, 3), contents)
assert format(tuplet) == abjad.String.normalize(r"""
\times 2/3 {
c'4
\times 2/3 {
c'8
c'8
c'8
}
c'4
}
""")
assert abjad.inspect(tuplet[0]).leaf(1) is inner_tuplet[0]
assert abjad.inspect(inner_tuplet[-1]).leaf(1) is tuplet[-1]
assert abjad.inspect(tuplet[-1]).leaf(-1) is inner_tuplet[-1]
assert abjad.inspect(inner_tuplet[0]).leaf(-1) is tuplet[0]
def test_scoretools_Inspection_get_leaf_07():
r'''Tuplets inside a voice.
'''
tuplet_1 = abjad.Tuplet((2, 3), "c'8 cs'8 d'8")
tuplet_2 = abjad.Tuplet((2, 3), "ef'8 e'8 f'8")
voice = abjad.Voice([tuplet_1, tuplet_2])
assert format(voice) == abjad.String.normalize(r'''
\new Voice
{
\times 2/3 {
c'8
cs'8
d'8
}
\times 2/3 {
ef'8
e'8
f'8
}
}
''')
assert abjad.inspect(tuplet_1[0]).get_leaf(1) is tuplet_1[1]
assert abjad.inspect(tuplet_1[1]).get_leaf(1) is tuplet_1[2]
assert abjad.inspect(tuplet_1[2]).get_leaf(1) is tuplet_2[0]
assert abjad.inspect(tuplet_1[1]).get_leaf(-1) is tuplet_1[0]
assert abjad.inspect(tuplet_1[2]).get_leaf(-1) is tuplet_1[1]
assert abjad.inspect(tuplet_2[0]).get_leaf(-1) is tuplet_1[2]
def test_Mutation_fuse_08():
"""
Fuses fixed-multiplier tuplets with same multiplier in score.
"""
tuplet_1 = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8")
abjad.beam(tuplet_1[:])
tuplet_2 = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8 f'8 g'8")
abjad.slur(tuplet_2[:])
voice = abjad.Voice([tuplet_1, tuplet_2])
assert format(voice) == abjad.String.normalize(r"""
\new Voice
{
\times 2/3 {
c'8
[
d'8
e'8
]
}
\tweak edge-height #'(0.7 . 0)
\times 2/3 {
c'8
(
d'8
e'8
f'8
g'8
)
}
}
"""), print(format(voice))
tuplets = voice[:]
abjad.mutate(tuplets).fuse()
assert format(voice) == abjad.String.normalize(r"""
\new Voice
{
\tweak edge-height #'(0.7 . 0)
\times 2/3 {
c'8
[
d'8
e'8
]
c'8
(
d'8
e'8
f'8
g'8
)
}
}
"""), print(format(voice))
assert abjad.inspect(voice).wellformed()
def test_scoretools_Mutation_fuse_09():
r'''Tuplets must carry same multiplier.
'''
tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
tuplet_2 = abjad.Tuplet((4, 5), "c'8 d'8 e'8 f'8 g'8")
tuplets = abjad.select([tuplet_1, tuplet_2])
assert pytest.raises(Exception, 'abjad.mutate(tuplets).fuse()')
def test_Staff___setitem___01():
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), "c'16 c'16 c'16 c'16"),
])
assert len(staff) == 5
assert abjad.wf.wellformed(staff)
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)
staff[1] = abjad.Chord([12, 13, 15], (1, 4))
assert len(staff) == 5
assert abjad.wf.wellformed(staff)
assert isinstance(staff[0], abjad.Note)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Skip)
assert isinstance(staff[4], abjad.Tuplet)
staff[0] = abjad.Rest((1, 4))
assert len(staff) == 5
assert abjad.wf.wellformed(staff)
assert isinstance(staff[0], abjad.Rest)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Skip)
assert isinstance(staff[4], abjad.Tuplet)
staff[-2] = abjad.Tuplet((2, 3), "c'8 c'8 c'8")
assert len(staff) == 5
assert abjad.wf.wellformed(staff)
assert isinstance(staff[0], abjad.Rest)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Tuplet)
assert isinstance(staff[4], abjad.Tuplet)
staff[-1] = abjad.Note(13, (1, 4))
assert len(staff) == 5
assert abjad.wf.wellformed(staff)
assert isinstance(staff[0], abjad.Rest)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Tuplet)
assert isinstance(staff[4], abjad.Note)
staff[-3] = abjad.Skip((1, 4))
assert len(staff) == 5
assert abjad.wf.wellformed(staff)
assert isinstance(staff[0], abjad.Rest)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Skip)
assert isinstance(staff[3], abjad.Tuplet)
assert isinstance(staff[4], abjad.Note)
def test_scoretools_Staff___setitem___01():
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 abjad.inspect(staff).is_well_formed()
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)
staff[1] = abjad.Chord([12, 13, 15], (1, 4))
assert len(staff) == 5
assert abjad.inspect(staff).is_well_formed()
assert isinstance(staff[0], abjad.Note)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Skip)
assert isinstance(staff[4], abjad.Tuplet)
staff[0] = abjad.Rest((1, 4))
assert len(staff) == 5
assert abjad.inspect(staff).is_well_formed()
assert isinstance(staff[0], abjad.Rest)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Skip)
assert isinstance(staff[4], abjad.Tuplet)
staff[-2] = abjad.Tuplet((2, 3), 3 * abjad.Note(0, (1, 8)))
assert len(staff) == 5
assert abjad.inspect(staff).is_well_formed()
assert isinstance(staff[0], abjad.Rest)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Tuplet)
assert isinstance(staff[4], abjad.Tuplet)
staff[-1] = abjad.Note(13, (1, 4))
assert len(staff) == 5
assert abjad.inspect(staff).is_well_formed()
assert isinstance(staff[0], abjad.Rest)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Chord)
assert isinstance(staff[3], abjad.Tuplet)
assert isinstance(staff[4], abjad.Note)
staff[-3] = abjad.Skip((1, 4))
assert len(staff) == 5
assert abjad.inspect(staff).is_well_formed()
assert isinstance(staff[0], abjad.Rest)
assert isinstance(staff[1], abjad.Chord)
assert isinstance(staff[2], abjad.Skip)
assert isinstance(staff[3], abjad.Tuplet)
assert isinstance(staff[4], abjad.Note)
def test_scoretools_Mutation_fuse_07():
r'''Fuses tuplets with same multiplier in score.
'''
tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
beam = abjad.Beam()
abjad.attach(beam, tuplet_1[:])
tuplet_2 = abjad.Tuplet((2, 3), "c'16 d'16 e'16")
slur = abjad.Slur()
abjad.attach(slur, tuplet_2[:])
voice = abjad.Voice([tuplet_1, tuplet_2])
assert format(voice) == abjad.String.normalize(r'''
\new Voice
{
\times 2/3 {
c'8
[
d'8
e'8
]
}
\times 2/3 {
c'16
(
d'16
e'16
)
}
}
''')
tuplets = voice[:]
abjad.mutate(tuplets).fuse()
assert format(voice) == abjad.String.normalize(r'''
\new Voice
{
\times 2/3 {
c'8
[
d'8
e'8
]
c'16
(
d'16
e'16
)
}
}
''')
assert abjad.inspect(voice).is_well_formed()
def test_get_timespan_21():
"""
Offsets work on nested tuplets.
"""
tuplet_1 = abjad.Tuplet((1, 2), "c'8 d'8 e'8 f'8")
contents = [abjad.Note("c'4"), tuplet_1, abjad.Note("c'4")]
tuplet = abjad.Tuplet((2, 3), contents)
assert abjad.get.timespan(tuplet[0]).start_offset == 0 * abjad.Offset(1, 6)
assert abjad.get.timespan(tuplet[1]).start_offset == 1 * abjad.Offset(1, 6)
assert abjad.get.timespan(tuplet[2]).start_offset == 2 * abjad.Offset(1, 6)
def test_Mutation_fuse_09():
"""
Tuplets must carry same multiplier.
"""
tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
tuplet_2 = abjad.Tuplet((4, 5), "c'8 d'8 e'8 f'8 g'8")
tuplets = abjad.select([tuplet_1, tuplet_2])
with pytest.raises(Exception):
abjad.mutate(tuplets).fuse()
def test_Mutation_fuse_07():
"""
Fuses tuplets with same multiplier in score.
"""
tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
abjad.beam(tuplet_1[:])
tuplet_2 = abjad.Tuplet((2, 3), "c'16 d'16 e'16")
abjad.slur(tuplet_2[:])
voice = abjad.Voice([tuplet_1, tuplet_2])
assert format(voice) == abjad.String.normalize(r"""
\new Voice
{
\times 2/3 {
c'8
[
d'8
e'8
]
}
\times 2/3 {
c'16
(
d'16
e'16
)
}
}
"""), print(format(voice))
tuplets = voice[:]
abjad.mutate(tuplets).fuse()
assert format(voice) == abjad.String.normalize(r"""
\new Voice
{
\times 2/3 {
c'8
[
d'8
e'8
]
c'16
(
d'16
e'16
)
}
}
"""), print(format(voice))
assert abjad.inspect(voice).wellformed()
def test_scoretools_Mutation_fuse_06():
r'''Fuses two unincorporated tuplets with same multiplier.
'''
tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
beam = abjad.Beam()
abjad.attach(beam, tuplet_1[:])
tuplet_2 = abjad.Tuplet((2, 3), "c'16 d'16 e'16")
slur = abjad.Slur()
abjad.attach(slur, tuplet_2[:])
assert format(tuplet_1) == abjad.String.normalize(r'''
\times 2/3 {
c'8
[
d'8
e'8
]
}
''')
assert format(tuplet_2) == abjad.String.normalize(r'''
\times 2/3 {
c'16
(
d'16
e'16
)
}
''')
tuplets = abjad.select([tuplet_1, tuplet_2])
new = abjad.mutate(tuplets).fuse()
assert format(new) == abjad.String.normalize(r'''
\times 2/3 {
c'8
[
d'8
e'8
]
c'16
(
d'16
e'16
)
}
''')
assert len(tuplet_1) == 0
assert len(tuplet_2) == 0
assert new is not tuplet_1 and new is not tuplet_2
assert abjad.inspect(new).is_well_formed()
def test_Mutation_fuse_06():
"""
Fuses two unincorporated tuplets with same multiplier.
"""
tuplet_1 = abjad.Tuplet((2, 3), "c'8 d'8 e'8")
abjad.beam(tuplet_1[:])
tuplet_2 = abjad.Tuplet((2, 3), "c'16 d'16 e'16")
abjad.slur(tuplet_2[:])
assert format(tuplet_1) == abjad.String.normalize(r"""
\times 2/3 {
c'8
[
d'8
e'8
]
}
"""), print(format(tuplet_1))
assert format(tuplet_2) == abjad.String.normalize(r"""
\times 2/3 {
c'16
(
d'16
e'16
)
}
"""), print(format(tuplet_2))
tuplets = abjad.select([tuplet_1, tuplet_2])
new = abjad.mutate(tuplets).fuse()
assert format(new) == abjad.String.normalize(r"""
\times 2/3 {
c'8
[
d'8
e'8
]
c'16
(
d'16
e'16
)
}
"""), print(format(new))
assert len(tuplet_1) == 0
assert len(tuplet_2) == 0
assert new is not tuplet_1 and new is not tuplet_2
assert abjad.inspect(new).wellformed()
def test_scoretools_Inspection_get_timespan_21():
r'''Offsets work on nested tuplets.
'''
tuplet_1 = abjad.Tuplet((1, 2), "c'8 d'8 e'8 f'8")
contents = [abjad.Note("c'4"), tuplet_1, abjad.Note("c'4")]
tuplet = abjad.Tuplet((2, 3), contents)
assert abjad.inspect(
tuplet[0]).get_timespan().start_offset == 0 * abjad.Offset(1, 6)
assert abjad.inspect(
tuplet[1]).get_timespan().start_offset == 1 * abjad.Offset(1, 6)
assert abjad.inspect(
tuplet[2]).get_timespan().start_offset == 2 * abjad.Offset(1, 6)
def test_get_timespan_19():
"""
Offsets works on sequential tuplets.
"""
voice = abjad.Voice([
abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8"),
abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8"),
abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8"),
])
assert abjad.get.timespan(voice[0]).start_offset == 0 * abjad.Offset(1, 4)
assert abjad.get.timespan(voice[1]).start_offset == 1 * abjad.Offset(1, 4)
assert abjad.get.timespan(voice[2]).start_offset == 2 * abjad.Offset(1, 4)
def test_scoretools_Inspection_get_timespan_09():
r'''Offset works on nested tuplets.
'''
tuplet_1 = abjad.Tuplet((2, 3), "c'8 c'8 c'8")
tuplet = abjad.Tuplet((2, 3),
[abjad.Note("c'4"), tuplet_1,
abjad.Note("c'4")])
offset = 0
durations = [(1, 6), (1, 18), (1, 18), (1, 18), (1, 6)]
leaves = abjad.select(tuplet).leaves()
for leaf, duration in zip(leaves, durations):
assert abjad.inspect(leaf).get_timespan().start_offset == offset
offset += abjad.Offset(*duration)
def test_scoretools_Tuplet___setattr___01():
r'''Slots constrain tuplet attributes.
'''
tuplet = abjad.Tuplet(abjad.Multiplier(2, 3), "c'8 d'8 e'8")
assert pytest.raises(AttributeError, "tuplet.foo = 'bar'")
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_scoretools_Mutation_swap_06():
r'''Trying to move parentage, children and spanners from components
that are not parent-contiguous raises exception.
'''
voice = abjad.Voice("{ c'8 d'8 } { e'8 f'8 } { g'8 a'8 }")
leaves = abjad.select(voice).leaves()
beam = abjad.Beam()
abjad.attach(beam, leaves)
assert format(voice) == abjad.String.normalize(r'''
\new Voice
{
{
c'8
[
d'8
}
{
e'8
f'8
}
{
g'8
a'8
]
}
}
''')
tuplet = abjad.Tuplet((2, 3), [])
statement = 'abjad.mutate([voice[0], voice[2]]).swap(tuplet)'
assert pytest.raises(Exception, statement)
def retrograde(self, material_name):
"""Retrograde components in container."""
selection = abjad.Selection(self.container[:]).components(
abjad.Container)
for container in selection:
if container.name is not None and material_name in container.name:
items = abjad.Selection(container).items
# print(container.components)
new_container = abjad.Container(name=container.name)
for item in reversed(items):
for comp in reversed(item.components):
if isinstance(comp, abjad.Tuplet):
new_tuplet = abjad.Tuplet(
multiplier=comp.multiplier,
denominator=comp.denominator)
for it in reversed(comp.components):
new_tuplet.append(it)
new_container.append(new_tuplet)
elif isinstance(comp, abjad.Container):
new_sub_container = abjad.Container()
for it in reversed(comp.components):
new_sub_container.append(it)
new_container.append(new_sub_container)
else:
new_container.append(comp)
for i, item in enumerate(container):
container.remove(container[i])
container.append(new_container)
def multiply_by(n, note):
new_n = deepcopy(note)
new_n.written_duration /= 4
tup = abj.Tuplet(abj.Multiplier(2, n), [])
for varied_note in vary(new_n, n):
tup.append(varied_note)
return tup
def test_Mutation_swap_06():
"""
Trying to move parentage, children from components that are not
parent-contiguous raises exception.
"""
voice = abjad.Voice("{ c'8 d'8 } { e'8 f'8 } { g'8 a'8 }")
leaves = abjad.select(voice).leaves()
abjad.beam(leaves)
assert format(voice) == abjad.String.normalize(r"""
\new Voice
{
{
c'8
[
d'8
}
{
e'8
f'8
}
{
g'8
a'8
]
}
}
""")
tuplet = abjad.Tuplet((2, 3), [])
with pytest.raises(Exception):
abjad.mutate([voice[0], voice[2]]).swap(tuplet)
def card_4():
# beaming still needs to be fixed
div = (1, 8)
trip = [abjad.Note(n, div) for n in ("G4", "Ab4", "G4")]
notes = [abjad.Tuplet((2, 3), trip)]
notes += [abjad.Note('F#4', (1, 8)), abjad.Rest('r8')]
return notes
def recurse(node, tuplet_duration):
basic_prolated_duration = \
tuplet_duration / node._get_contents_duration()
basic_written_duration = \
basic_prolated_duration.equal_or_greater_power_of_two
tuplet = abjad.Tuplet(1, [])
for child in node.children:
if isinstance(child, type(self)):
tuplet.extend(
recurse(
child, child.preprolated_duration *
basic_written_duration))
else:
leaves = child(basic_written_duration)
tuplet.extend(leaves)
if 1 < len(leaves):
abjad.tie(leaves)
assert tuplet.multiplier == 1, repr(tuplet.multiplier)
contents_duration = abjad.inspect(tuplet).duration()
target_duration = tuplet_duration
multiplier = target_duration / contents_duration
tuplet.multiplier = multiplier
if tuplet.multiplier == 1:
return tuplet[:]
return [tuplet]
def _make_container(self, division):
import abjad
duration_specifier = self._get_duration_specifier()
forbidden_duration = \
duration_specifier.forbidden_duration
time_signature = abjad.TimeSignature(division)
implied_prolation = time_signature.implied_prolation
numerator, denominator = division.pair
denominator = abjad.mathtools.greatest_power_of_two_less_equal(
denominator)
assert abjad.mathtools.is_positive_integer_power_of_two(denominator)
exponent = self.exponent or 0
denominator_multiplier = 2 ** exponent
denominator *= denominator_multiplier
unit_duration = abjad.Duration(1, denominator)
if forbidden_duration is not None:
multiplier = 1
while forbidden_duration <= unit_duration:
unit_duration /= 2
multiplier *= 2
numerator *= multiplier
numerator *= denominator_multiplier
maker = abjad.NoteMaker()
notes = maker(numerator * [0], [unit_duration])
if implied_prolation == 1:
result = abjad.Container(notes)
else:
multiplier = implied_prolation
result = abjad.Tuplet(multiplier, notes)
return result
