def test_scoretools_Leaf__split_by_durations_04():
r'''Splits note into assignable notes.
Fractures spanners. Ties split notes.
'''
staff = abjad.Staff("c'8 [ d'8 e'8 ]")
halves = staff[1]._split_by_durations(
[abjad.Duration(1, 32)],
fracture_spanners=True,
tie_split_notes=True,
)
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
c'8
[
d'32
~
]
d'16.
[
e'8
]
}
''')
assert abjad.inspect(staff).is_well_formed()
def t_DURATION(self, t):
r"-?[1-9]\d*(/[1-9]\d*)?"
import abjad
parts = t.value.partition("/")
if not parts[2]:
t.value = abjad.Duration(int(parts[0]))
else:
numerator, denominator = int(parts[0]), int(parts[2])
fraction = abjad.NonreducedFraction(numerator, denominator)
preprolated_duration = abjad.Duration(fraction)
if fraction.numerator == preprolated_duration.numerator:
t.value = preprolated_duration
else:
t.value = fraction
return t
def test_LilyPondGrobNameManager___setattr___13():
"""
Override LilyPond abjad.MetronomeMark grob.
"""
staff = abjad.Staff("c'8 d'8 e'8 f'8")
score = abjad.Score([staff])
tempo = abjad.MetronomeMark(abjad.Duration(1, 4), 58)
abjad.attach(tempo, staff[0])
abjad.override(score).metronome_mark.color = "red"
assert format(score) == abjad.String.normalize(r"""
\new Score
\with
{
\override MetronomeMark.color = #red
}
<<
\new Staff
{
\tempo 4=58
c'8
d'8
e'8
f'8
}
>>
""")
assert abjad.inspect(score).wellformed()
def edit_second_violin_voice(score, durated_reservoir):
"""
Edits second violin voice.
"""
voice = score["Second Violin Voice"]
descents = durated_reservoir["Second Violin"]
last_descent = abjad.Selection(descents[-1])
copied_descent = abjad.mutate(last_descent).copy()
copied_descent = list(copied_descent)
copied_descent[-1].written_duration = abjad.Duration(1, 1)
copied_descent.append(abjad.Note("a2"))
for leaf in copied_descent:
articulation = abjad.Articulation("accent")
abjad.attach(articulation, leaf)
articulation = abjad.Articulation("tenuto")
abjad.attach(articulation, leaf)
voice.extend(copied_descent)
final_sustain = []
for _ in range(32):
final_sustain.append(abjad.Note("a1."))
final_sustain.append(abjad.Note("a2"))
final_sustain = abjad.Selection(final_sustain)
articulation = abjad.Articulation("accent")
abjad.attach(articulation, final_sustain[0])
articulation = abjad.Articulation("tenuto")
abjad.attach(articulation, final_sustain[0])
voice.extend(final_sustain)
abjad.tie(final_sustain)
voice.extend("r4 r2.")
def __init__(
self,
kernel_denominator=32,
maximum_run_length=None,
meters=None,
offset_counter=None,
):
import abjad
self._cached_offset_counters = {}
if maximum_run_length is not None:
maximum_run_length = int(maximum_run_length)
assert 0 < maximum_run_length
self._maximum_run_length = maximum_run_length
if offset_counter:
self._offset_counter = abjad.MetricAccentKernel.count_offsets(
offset_counter)
else:
self._offset_counter = {}
self._ordered_offsets = tuple(sorted(self.offset_counter))
meters = meters or ()
self._meters = tuple(abjad.Meter(_) for _ in meters)
self._kernel_denominator = abjad.Duration(kernel_denominator)
self._kernels = {}
for meter in self._meters:
kernel = meter.generate_offset_kernel_to_denominator(
self._kernel_denominator)
self._kernels[kernel] = meter
if self.kernels:
self._longest_kernel = sorted(
self._kernels,
key=lambda x: x.duration,
)[-1]
else:
self._longest_kernel = None
def _duration_to_time_signature(
duration,
denominators=None,
factor=None,
):
import abjad
duration = abjad.Duration(duration)
if denominators is not None:
if factor is not None:
denominators = [
d for d in denominators
if factor in abjad.mathtools.factors(d)
]
for desired_denominator in sorted(denominators):
nonreduced_fraction = abjad.NonreducedFraction(duration)
candidate_pair = \
nonreduced_fraction.with_denominator(desired_denominator)
if candidate_pair.denominator == desired_denominator:
return abjad.TimeSignature(candidate_pair)
if factor is not None:
if factor in abjad.mathtools.factors(duration.denominator):
return abjad.TimeSignature(duration)
else:
time_signature_numerator = factor * duration.numerator
time_signature_denominator = factor * duration.denominator
return abjad.TimeSignature(
(time_signature_numerator, time_signature_denominator))
else:
return abjad.TimeSignature(duration)
def test_contract_notes_05():
staff = abjad.Staff(r"\time 3/4 c'4 r2 "
r"\time 2/4 d'2 "
r"\time 3/4 e'2. "
r"\time 4/4 f'1")
auxjad.mutate.contract_notes(staff, abjad.Duration((1, 8)))
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
\time 3/4
c'8
r8
r2
\time 2/4
d'4.
r8
\time 3/4
e'2
~
e'8
r8
\time 4/4
f'2..
r8
}
""")
def test_Mutation_split_10():
"""
Splits voice at negative index.
"""
staff = abjad.Staff([abjad.Voice("c'8 d'8 e'8 f'8")])
voice = staff[0]
result = abjad.mutate([voice]).split([abjad.Duration(1, 4)])
left = result[0][0]
right = result[1][0]
assert format(left) == abjad.String.normalize(
r"""
\new Voice
{
c'8
d'8
}
"""
), print(format(left))
assert format(right) == abjad.String.normalize(
r"""
\new Voice
{
e'8
f'8
}
"""
), print(format(right))
assert format(voice) == abjad.String.normalize(
r"""
\new Voice
{
}
"""
), print(format(voice))
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
{
\new Voice
{
c'8
d'8
}
\new Voice
{
e'8
f'8
}
}
"""
), print(format(staff))
assert abjad.inspect(staff).wellformed()
def test_Mutation_split_15():
"""
Splits leaf at non-assignable, non-power-of-two offset.
"""
staff = abjad.Staff("c'4")
notes = staff[:1]
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_scoretools_Inspection_get_timespan_26():
r'''Offset seconds work with explicit metronome mark.
'''
staff = abjad.Staff("c'8 d'8 e'8 f'8")
mark = abjad.MetronomeMark(abjad.Duration(1, 8), 48)
abjad.attach(mark, staff[0], context='Staff')
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
\tempo 8=48
c'8
d'8
e'8
f'8
}
''')
start_offset = abjad.inspect(
staff[0]).get_timespan(in_seconds=True).start_offset
assert start_offset == abjad.Offset(0)
start_offset = abjad.inspect(
staff[1]).get_timespan(in_seconds=True).start_offset
assert start_offset == abjad.Offset(5, 4)
def test_remove_repeated_dynamics_08():
staff = abjad.Staff(r"c'4\pp r2. | R1 | c'1\pp")
auxjad.mutate.remove_repeated_dynamics(
staff[:],
reset_after_rests=True,
reset_after_duration=abjad.Duration(4, 4),
)
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
c'4
\pp
r2.
R1
c'1
\pp
}
""")
staff = abjad.Staff(r"c'4\pp r2. | R1 | c'1\pp")
auxjad.mutate.remove_repeated_dynamics(
staff[:],
reset_after_rests=True,
reset_after_duration=2,
)
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
c'4
\pp
r2.
R1
c'1
}
""")
def make_single_attack(duration,
*,
measures: typings.SliceTyping = None) -> RhythmCommand:
"""
Makes single attacks with ``duration``.
"""
duration = abjad.Duration(duration)
numerator, denominator = duration.pair
return RhythmCommand(
rmakers.stack(
rmakers.incised(
fill_with_rests=True,
outer_divisions_only=True,
prefix_talea=[numerator],
prefix_counts=[1],
talea_denominator=denominator,
),
rmakers.beam(),
rmakers.extract_trivial(),
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def test_scoretools_Leaf__split_by_durations_06():
r'''REGRESSION.
Splits note into tuplet monads and then fuses monads.
Does not fracture spanners. Ties split notes.
This test comes from #272 in GitHub.
'''
staff = abjad.Staff(r"\times 2/3 { c'8 [ d'8 e'8 ] }")
leaf = abjad.inspect(staff).get_leaf(0)
halves = leaf._split_by_durations([abjad.Duration(1, 20)])
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
\times 2/3 {
\times 4/5 {
c'16.
~
[
c'16
}
d'8
e'8
]
}
}
''')
assert abjad.inspect(staff).is_well_formed()
def test_scoretools_Leaf__split_by_durations_05():
r'''Adds tuplet.
Does not fracture spanners. Does not tie split notes.
'''
staff = abjad.Staff("c'8 [ d'8 e'8 ]")
halves = staff[1]._split_by_durations(
[abjad.Duration(1, 24)],
tie_split_notes=False,
)
assert format(staff) == abjad.String.normalize(r'''
\new Staff
{
c'8
[
\times 2/3 {
d'16
d'8
}
e'8
]
}
''')
assert abjad.inspect(staff).is_well_formed()
def test_scoretools_Rest___init___01():
r'''Initialize rest from LilyPond input string.
'''
rest = abjad.Rest('r8.')
assert rest.written_duration == abjad.Duration(3, 16)
def test_Inspection_bar_line_crossing_01():
"""
Works with partial.
"""
staff = abjad.Staff("c'8 d'8 e'4 f'8")
time_signature = abjad.TimeSignature((2, 8), partial=abjad.Duration(1, 8))
abjad.attach(time_signature, staff[0])
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
{
\partial 8
\time 2/8
c'8
d'8
e'4
f'8
}
"""
)
assert not abjad.inspect(staff[0]).bar_line_crossing()
assert not abjad.inspect(staff[1]).bar_line_crossing()
assert abjad.inspect(staff[2]).bar_line_crossing()
assert not abjad.inspect(staff[3]).bar_line_crossing()
def edit_second_violin_voice(score, durated_reservoir):
r'''Edits second violin voice.
'''
voice = score['Second Violin Voice']
descents = durated_reservoir['Second Violin']
last_descent = abjad.Selection(descents[-1])
copied_descent = abjad.mutate(last_descent).copy()
copied_descent = list(copied_descent)
copied_descent[-1].written_duration = abjad.Duration(1, 1)
copied_descent.append(abjad.Note('a2'))
for leaf in copied_descent:
articulation = abjad.Articulation('accent')
abjad.attach(articulation, leaf)
articulation = abjad.Articulation('tenuto')
abjad.attach(articulation, leaf)
voice.extend(copied_descent)
final_sustain = []
for _ in range(32):
final_sustain.append(abjad.Note('a1.'))
final_sustain.append(abjad.Note('a2'))
final_sustain = abjad.Selection(final_sustain)
articulation = abjad.Articulation('accent')
abjad.attach(articulation, final_sustain[0])
articulation = abjad.Articulation('tenuto')
abjad.attach(articulation, final_sustain[0])
voice.extend(final_sustain)
tie = abjad.Tie()
abjad.attach(tie, final_sustain)
voice.extend('r4 r2.')
def __call__(self, durations):
if abjad.get.duration(self.selections) == abjad.Duration(
sum(durations)):
if self.rewrite is True:
for i, shard in enumerate(
abjad.Selection(
self.selections).partition_by_durations(
durations)):
time_signature = durations[i]
inventories = [
x for x in enumerate(
abjad.Meter(time_signature.pair).
depthwise_offset_inventory)
]
if time_signature.denominator == 4:
abjad.Meter.rewrite_meter(
shard,
time_signature,
boundary_depth=inventories[-1][0],
rewrite_tuplets=False,
)
else:
abjad.Meter.rewrite_meter(
shard,
time_signature,
boundary_depth=inventories[-2][0],
rewrite_tuplets=False,
)
return self.selections
else:
message = (
f"sel: {abjad.get.duration(self.selections)}, dur: {sum(durations)}"
)
raise Exception(message)
def test_Leaf__split_by_durations_04():
"""
REGRESSION.
Splits note into tuplet monads and then fuses monads.
Ties split notes.
This test comes from #272 in GitHub.
"""
staff = abjad.Staff(r"\times 2/3 { c'8 [ d'8 e'8 ] }")
leaf = abjad.inspect(staff).leaf(0)
new_leaves = leaf._split_by_durations([abjad.Duration(1, 20)])
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
\times 2/3 {
\times 4/5 {
c'16.
[
~
c'16
}
d'8
e'8
]
}
}
"""), print(format(staff))
assert abjad.inspect(staff).wellformed()
def __init__(self, grace_duration=None):
import abjad
if grace_duration is None:
grace_duration = (1, 16)
grace_duration = abjad.Duration(grace_duration)
assert grace_duration.has_power_of_two_denominator
self._grace_duration = grace_duration
def change_octave(
nth_event: int,
n_octaves: int,
novent_line: lily.NOventLine,
change_main_pitches: bool = True,
change_acciaccatura_pitches: bool = True,
) -> None:
if change_main_pitches:
novent_line[nth_event].pitch = [
p + ji.JIPitch([n_octaves]) for p in novent_line[nth_event].pitch
]
if novent_line[nth_event].acciaccatura and change_acciaccatura_pitches:
novent_line[nth_event].acciaccatura.mu_pitches = tuple(
p + ji.JIPitch([n_octaves])
for p in novent_line[nth_event].acciaccatura.mu_pitches)
previous_abjad_note = novent_line[nth_event].acciaccatura.abjad
novent_line[nth_event].acciaccatura.abjad = abjad.Note(
abjad.NamedPitch(
name=previous_abjad_note.written_pitch.pitch_class.name,
octave=previous_abjad_note.written_pitch.octave.number +
n_octaves,
),
abjad.Duration(previous_abjad_note.written_duration),
)
def test_Leaf__split_by_durations_03():
"""
Adds tuplet.
Does not tie split notes.
"""
staff = abjad.Staff("c'8 [ d'8 e'8 ]")
new_leaves = staff[1]._split_by_durations(
[abjad.Duration(1, 24)],
tie_split_notes=False,
)
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
c'8
[
\times 2/3 {
d'16
d'8
}
e'8
]
}
"""), print(format(staff))
assert abjad.inspect(staff).wellformed()
def test_Leaf__split_by_durations_15():
"""
Grace notes are removed from second split leaf.
"""
note = abjad.Note("c'4")
grace = abjad.GraceContainer([abjad.Note(0, (1, 32))])
abjad.attach(grace, note)
new_leaves = note._split_by_durations([abjad.Duration(1, 16)])
staff = abjad.Staff(new_leaves)
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
\grace {
c'32
}
c'16
~
c'8.
}
"""), print(format(staff))
abjad.inspect(staff).wellformed()
def test_Leaf__split_by_durations_14():
"""
After grace notes are removed from first split leaf.
"""
note = abjad.Note("c'4")
grace = abjad.AfterGraceContainer([abjad.Note(0, (1, 32))])
abjad.attach(grace, note)
new_leaves = note._split_by_durations([abjad.Duration(5, 32)])
staff = abjad.Staff(new_leaves)
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
c'8
~
c'32
~
\afterGrace
c'16.
{
c'32
}
}
"""), print(format(staff))
abjad.inspect(staff).wellformed()
def test_Leaf__split_by_durations_13():
"""
After grace notes are removed from first split leaf.
"""
note = abjad.Note("c'4")
after_grace = abjad.AfterGraceContainer([abjad.Note(0, (1, 32))])
abjad.attach(after_grace, note)
new_leaves = note._split_by_durations([abjad.Duration(1, 8)])
staff = abjad.Staff(new_leaves)
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
c'8
~
\afterGrace
c'8
{
c'32
}
}
"""), print(format(staff))
assert abjad.inspect(new_leaves[0]).after_grace_container() is None
assert len(abjad.inspect(new_leaves[1]).after_grace_container()) == 1
abjad.inspect(staff).wellformed()
def test_LeafDynMaker_08():
pitches = [
0,
"d'",
'E4',
abjad.NumberedPitch(5),
abjad.NamedPitch("g'"),
abjad.NamedPitch('A4'),
]
durations = [
(1, 32),
'2/32',
abjad.Duration('3/32'),
abjad.Duration(0.125),
abjad.Duration(5, 32),
abjad.Duration(6 / 32),
]
dynamics = [
'p',
abjad.Dynamic('f'),
]
articulations = [
'>',
abjad.Articulation('-'),
abjad.Staccato(),
]
leaf_dyn_maker = auxjad.LeafDynMaker()
notes = leaf_dyn_maker(pitches, durations, dynamics, articulations)
staff = abjad.Staff(notes)
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
c'32
\p
- \accent
d'16
\f
- \tenuto
e'16.
\staccato
f'8
g'8
~
g'32
a'8.
}
""")
def test_mutate__split_leaf_by_durations_10():
"""
Split one leaf in score.
Ties after split.
"""
staff = abjad.Staff()
staff.append(abjad.Container("c'8 d'8"))
staff.append(abjad.Container("e'8 f'8"))
leaves = abjad.select(staff).leaves()
abjad.beam(leaves[:2])
abjad.beam(leaves[-2:])
abjad.slur(leaves)
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
{
c'8
[
(
d'8
]
}
{
e'8
[
f'8
)
]
}
}
"""), print(abjad.lilypond(staff))
abjad.mutate._split_leaf_by_durations(leaves[0], [abjad.Duration(1, 32)])
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
{
c'32
[
(
~
c'16.
d'8
]
}
{
e'8
[
f'8
)
]
}
}
"""), print(abjad.lilypond(staff))
assert abjad.wf.wellformed(staff)
def test_Container__split_by_duration_01():
staff = abjad.Staff()
staff.append(abjad.Container("c'8 d'8"))
staff.append(abjad.Container("e'8 f'8"))
leaves = abjad.select(staff).leaves()
abjad.beam(leaves[:2])
abjad.beam(leaves[-2:])
abjad.slur(leaves)
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
{
c'8
[
(
d'8
]
}
{
e'8
[
f'8
)
]
}
}
"""), print(format(staff))
halves = staff[0]._split_by_duration(
abjad.Duration(1, 32),
tie_split_notes=False,
)
assert format(staff) == abjad.String.normalize(r"""
\new Staff
{
{
c'32
[
(
}
{
c'16.
d'8
]
}
{
e'8
[
f'8
)
]
}
}
"""), print(format(staff))
assert abjad.inspect(staff).wellformed()
def from_tempo_scaled_durations(class_, durations, tempo=None):
r"""
Convert ``durations``, scaled by ``tempo``
into a ``QEventSequence``:
>>> tempo = abjad.MetronomeMark((1, 4), 174)
>>> durations = [(1, 4), (-3, 16), (1, 16), (-1, 2)]
>>> sequence = \
... abjadext.nauert.QEventSequence.from_tempo_scaled_durations(
... durations, tempo=tempo)
>>> for q_event in sequence:
... print(format(q_event, 'storage'))
...
abjadext.nauert.PitchedQEvent(
offset=abjad.Offset((0, 1)),
pitches=(
abjad.NamedPitch("c'"),
),
)
abjadext.nauert.SilentQEvent(
offset=abjad.Offset((10000, 29)),
)
abjadext.nauert.PitchedQEvent(
offset=abjad.Offset((17500, 29)),
pitches=(
abjad.NamedPitch("c'"),
),
)
abjadext.nauert.SilentQEvent(
offset=abjad.Offset((20000, 29)),
)
abjadext.nauert.TerminalQEvent(
offset=abjad.Offset((40000, 29)),
)
Returns ``QEventSequence`` instance.
"""
durations = [abjad.Duration(x) for x in durations]
assert isinstance(tempo, abjad.MetronomeMark)
durations = [
x for x in abjad.sequence(durations).sum_by_sign(sign=[-1]) if x
]
durations = [tempo.duration_to_milliseconds(_) for _ in durations]
offsets = abjad.mathx.cumulative_sums([abs(_) for _ in durations])
q_events = []
for pair in zip(offsets, durations):
offset = abjad.Offset(pair[0])
duration = pair[1]
# negative duration indicates silence
if duration < 0:
q_event = SilentQEvent(offset)
# otherwise use middle C
else:
q_event = PitchedQEvent(offset, [0])
q_events.append(q_event)
# insert terminating silence QEvent
q_events.append(TerminalQEvent(offsets[-1]))
return class_(q_events)
def __init__(self, written_duration=None):
import abjad
original_input = written_duration
if isinstance(written_duration, str):
string = f'{{ {written_duration} }}'
parsed = abjad.parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
written_duration = parsed[0]
if isinstance(written_duration, Leaf):
written_duration = written_duration.written_duration
elif written_duration is None:
written_duration = abjad.Duration(1, 4)
else:
written_duration = abjad.Duration(written_duration)
Leaf.__init__(self, written_duration)
if isinstance(original_input, Leaf):
self._copy_override_and_set_from_leaf(original_input)
