def test_NoteHeadList_append_01():
"""
Append tweaked note-head to chord.
"""
chord = abjad.Chord("<c' d'>4")
note_head = abjad.NoteHead("b'")
abjad.tweak(note_head).style = "harmonic"
chord.note_heads.append(note_head)
assert format(chord) == abjad.String.normalize(r"""
<
c'
d'
\tweak style #'harmonic
b'
>4
""")
assert note_head._client is chord
def test_Chord___deepcopy___01():
"""
Chord deepchopies note-heads.
"""
chord_1 = abjad.Chord("<c' e' g'>4")
abjad.tweak(chord_1.note_heads[0]).color = "red"
chord_2 = copy.deepcopy(chord_1)
assert format(chord_1) == abjad.String.normalize(r"""
<
\tweak color #red
c'
e'
g'
>4
""")
assert format(chord_2) == abjad.String.normalize(r"""
<
\tweak color #red
c'
e'
g'
>4
""")
assert chord_2.note_heads[0]._client is chord_2
assert chord_2.note_heads[1]._client is chord_2
assert chord_2.note_heads[2]._client is chord_2
assert format(chord_1) == format(chord_2)
assert chord_1 is not chord_2
assert chord_1.note_heads[0] == chord_2.note_heads[0]
assert chord_1.note_heads[1] == chord_2.note_heads[1]
assert chord_1.note_heads[2] == chord_2.note_heads[2]
assert chord_1.note_heads[0] is not chord_2.note_heads[0]
assert chord_1.note_heads[1] is not chord_2.note_heads[1]
assert chord_1.note_heads[2] is not chord_2.note_heads[2]
def make_desordre_cell(pitches):
"""
Makes a Désordre cell.
"""
notes = [abjad.Note(pitch, (1, 8)) for pitch in pitches]
notes = abjad.Selection(notes)
abjad.beam(notes)
abjad.slur(notes)
clef = abjad.Dynamic('f')
abjad.attach(clef, notes[0])
dynamic = abjad.Dynamic('p')
abjad.attach(dynamic, notes[1])
# make the lower voice
lower_voice = abjad.Voice(notes)
lower_voice.name = 'RH Lower Voice'
command = abjad.LilyPondLiteral(r'\voiceTwo')
abjad.attach(command, lower_voice)
n = int(math.ceil(len(pitches) / 2.))
chord = abjad.Chord([pitches[0], pitches[0] + 12], (n, 8))
articulation = abjad.Articulation('>')
abjad.attach(articulation, chord)
# make the upper voice
upper_voice = abjad.Voice([chord])
upper_voice.name = 'RH Upper Voice'
command = abjad.LilyPondLiteral(r'\voiceOne')
abjad.attach(command, upper_voice)
# combine them together
container = abjad.Container([lower_voice, upper_voice])
container.is_simultaneous = True
# make all 1/8 beats breakable
leaves = abjad.select(lower_voice).leaves()
for leaf in leaves[:-1]:
bar_line = abjad.BarLine('')
abjad.attach(bar_line, leaf)
return container
def test_Chord___copy___04():
"""
Chord copies tweaked note-heads.
"""
chord_1 = abjad.Chord("<c' e' g'>4")
abjad.tweak(chord_1.note_heads[0]).color = "#red"
chord_2 = copy.copy(chord_1)
assert abjad.lilypond(chord_1) == abjad.String.normalize(r"""
<
\tweak color #red
c'
e'
g'
>4
""")
assert abjad.lilypond(chord_2) == abjad.String.normalize(r"""
<
\tweak color #red
c'
e'
g'
>4
""")
assert chord_2.note_heads[0]._client is chord_2
assert chord_2.note_heads[1]._client is chord_2
assert chord_2.note_heads[2]._client is chord_2
assert abjad.lilypond(chord_1) == abjad.lilypond(chord_2)
assert chord_1 is not chord_2
assert chord_1.note_heads[0] == chord_2.note_heads[0]
assert chord_1.note_heads[1] == chord_2.note_heads[1]
assert chord_1.note_heads[2] == chord_2.note_heads[2]
assert chord_1.note_heads[0] is not chord_2.note_heads[0]
assert chord_1.note_heads[1] is not chord_2.note_heads[1]
assert chord_1.note_heads[2] is not chord_2.note_heads[2]
def _construct_fretting_tablature(self, logical_tie, fret_combination):
string_ids = [6, 5, 4, 3, 2, 1]
staff_positions = [2, 5, 9, 12, 16, 19]
for i, leaf in enumerate(logical_tie):
# replace note with chord
chord = abjad.Chord(staff_positions, leaf.written_duration)
# first leaf
if i == 0:
# replace noteheads
for j, note_head in enumerate(chord.note_heads):
string = string_ids[j]
if fret_combination.includes_string(string):
fret_placement = \
fret_combination.get_fret_placement(string)
self._create_tablature_notehead(
note_head, fret_placement)
else:
self._hide_note_head(note_head)
else:
self._hide_note_head(chord)
abjad.mutate(leaf).replace(chord)
def test_remove_repeated_dynamics_03():
staff = abjad.Staff([
abjad.Note("c'2"),
abjad.Chord("<d' f'>2"),
abjad.Tuplet((2, 3), "g2 a2 b2"),
])
abjad.attach(abjad.Dynamic('ppp'), staff[0])
abjad.attach(abjad.Dynamic('ppp'), staff[1])
abjad.attach(abjad.Dynamic('ppp'), staff[2][0])
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
c'2
\ppp
<d' f'>2
\ppp
\times 2/3
{
g2
\ppp
a2
b2
}
}
""")
auxjad.mutate.remove_repeated_dynamics(staff[:])
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
c'2
\ppp
<d' f'>2
\times 2/3
{
g2
a2
b2
}
}
""")
def make_music(self, durations, denominator, divisions, pitches):
# make rhythm with one tuplet per division
stack = rmakers.stack(
rmakers.talea(
durations,
denominator,
extra_counts=None,
),
rmakers.beam(),
)
selection = stack(divisions)
# # attach time signature to first leaf in each tuplet
# assert len(divisions) == len(selection)
# for division, tuplet in zip(divisions, selection):
# time_signature = abjad.TimeSignature(division)
# leaf = abjad.select(tuplet).leaf(0)
# abjad.attach(time_signature, leaf)
#
# apply pitches
cyclic_tuple = abjad.CyclicTuple(pitches)
iterator = abjad.iterate(selection).logical_ties(pitched=True)
iterator = enumerate(iterator)
for index, logical_tie in iterator:
pitch = cyclic_tuple[index]
for old_leaf in logical_tie:
if isinstance(pitch, int):
old_leaf.written_pitch = pitch
elif isinstance(pitch, list):
new_leaf = abjad.Chord(pitch, old_leaf.written_duration)
indicators = abjad.inspect(old_leaf).indicators()
if indicators != None:
for indicator in indicators:
abjad.attach(indicator, new_leaf)
abjad.mutate(old_leaf).replace(new_leaf)
# remove trivial 1:1 tuplets
self.staff.extend(selection)
command = rmakers.extract_trivial()
command(selection)
def test_scoretools_Chord___copy___04():
r'''Chord copies tweaked note-heads.
'''
chord_1 = abjad.Chord("<c' e' g'>4")
chord_1.note_heads[0].tweak.color = 'red'
chord_2 = copy.copy(chord_1)
assert format(chord_1) == abjad.String.normalize(r'''
<
\tweak color #red
c'
e'
g'
>4
''')
assert format(chord_2) == abjad.String.normalize(r'''
<
\tweak color #red
c'
e'
g'
>4
''')
assert chord_2.note_heads[0]._client is chord_2
assert chord_2.note_heads[1]._client is chord_2
assert chord_2.note_heads[2]._client is chord_2
assert format(chord_1) == format(chord_2)
assert chord_1 is not chord_2
assert chord_1.note_heads[0] == chord_2.note_heads[0]
assert chord_1.note_heads[1] == chord_2.note_heads[1]
assert chord_1.note_heads[2] == chord_2.note_heads[2]
assert chord_1.note_heads[0] is not chord_2.note_heads[0]
assert chord_1.note_heads[1] is not chord_2.note_heads[1]
assert chord_1.note_heads[2] is not chord_2.note_heads[2]
def convert_abjad_pitches_and_mu_rhythms2abjad_notes(
self, harmonies: list, delays: list, grid) -> list:
leading_pulses = grid.leading_pulses
absolute_leading_pulses = tuple(
itertools.accumulate([0] + list(leading_pulses)))
converted_delays = grid.apply_delay(delays)
absolute_delays = tuple(
itertools.accumulate([0] + list(converted_delays)))
# 1. generate notes
notes = abjad.Measure(abjad.TimeSignature(grid.absolute_meter), [])
resulting_durations = []
for harmony, delay, start, end in zip(harmonies, converted_delays,
absolute_delays,
absolute_delays[1:]):
subnotes = abjad.Voice()
seperated_by_grid = Instrument.seperate_by_grid(
delay, start, end, absolute_leading_pulses, leading_pulses,
grid)
assert sum(seperated_by_grid) == delay
for d in seperated_by_grid:
seperated_by_assignable = Instrument.seperate_by_assignablity(
d, grid)
assert sum(seperated_by_assignable) == d
for assignable in seperated_by_assignable:
resulting_durations.append(assignable)
if harmony:
chord = abjad.Chord(harmony,
abjad.Duration(assignable))
else:
chord = abjad.Rest(abjad.Duration(assignable))
subnotes.append(chord)
if len(subnotes) > 1 and len(harmony) > 0:
abjad.attach(abjad.Tie(), subnotes[:])
notes.extend(subnotes)
assert sum(resulting_durations) == sum(converted_delays)
voice = Instrument.mk_voice(notes)
# 2. apply beams
voice = Instrument.apply_beams(voice, resulting_durations,
absolute_leading_pulses)
return voice
def test_Staff___getitem___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).wellformed()
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)
assert isinstance(staff[-5], abjad.Note)
assert isinstance(staff[-4], abjad.Rest)
assert isinstance(staff[-3], abjad.Chord)
assert isinstance(staff[-2], abjad.Skip)
assert isinstance(staff[-1], abjad.Tuplet)
def add_acciaccatura(
nth_event: int,
pitch: ji.JIPitch,
novent_line: lily.NOventLine,
add_glissando: bool = False,
use_artifical_harmonic: bool = False,
) -> None:
if use_artifical_harmonic:
abjad_note = abjad.Chord(
_get_artifical_harmonic_pitches(pitch),
abjad.Duration(1, 8),
)
abjad.tweak(abjad_note.note_heads[1]).style = "harmonic"
pitch = pitch + ji.r(4, 1)
else:
abjad_note = abjad.Note(
lily.convert2abjad_pitch(pitch, globals_.RATIO2PITCHCLASS),
abjad.Duration(1, 8),
)
novent_line[nth_event].acciaccatura = attachments.Acciaccatura(
[pitch], abjad_note, add_glissando)
def make_desordre_cell(pitches):
"""
Makes a Désordre cell.
"""
notes = [abjad.Note(pitch, (1, 8)) for pitch in pitches]
notes = abjad.Selection(notes)
abjad.beam(notes)
abjad.slur(notes)
abjad.attach(abjad.Dynamic("f"), notes[0])
abjad.attach(abjad.Dynamic("p"), notes[1])
# make the lower voice
lower_voice = abjad.Voice(notes)
lower_voice.name = "RH_Lower_Voice"
command = abjad.LilyPondLiteral(r"\voiceTwo")
abjad.attach(command, lower_voice)
n = int(math.ceil(len(pitches) / 2.0))
chord = abjad.Chord([pitches[0], pitches[0] + 12], (n, 8))
abjad.attach(abjad.Articulation(">"), chord)
# make the upper voice
upper_voice = abjad.Voice([chord])
upper_voice.name = "RH_Upper_Voice"
command = abjad.LilyPondLiteral(r"\voiceOne")
abjad.attach(command, upper_voice)
# combine them together
voices = [lower_voice, upper_voice]
container = abjad.Container(voices, simultaneous=True)
# make all 1/8 beats breakable
leaves = abjad.select(lower_voice).leaves()
for leaf in leaves[:-1]:
bar_line = abjad.BarLine("")
abjad.attach(bar_line, leaf)
return container
def test_remove_repeated_time_signatures_03():
staff = abjad.Staff([
abjad.Note("c'2"),
abjad.Chord("<d' f'>2"),
abjad.Tuplet((2, 3), "g2 a2 b2"),
])
abjad.attach(abjad.TimeSignature((2, 2)), staff[0])
abjad.attach(abjad.TimeSignature((2, 2)), staff[2][0])
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
\time 2/2
c'2
<d' f'>2
\times 2/3
{
\time 2/2
g2
a2
b2
}
}
""")
auxjad.mutate.remove_repeated_time_signatures(staff[:])
assert abjad.lilypond(staff) == abjad.String.normalize(r"""
\new Staff
{
\time 2/2
c'2
<d' f'>2
\times 2/3
{
g2
a2
b2
}
}
""")
def put_gong_to_separate_vox(nth_bar: int, nth_item: int,
staff: abjad.Staff) -> None:
event2separate = abjad.mutate(staff[nth_bar][nth_item]).copy()
staff[nth_bar][nth_item] = abjad.Container(
[
abjad.Voice([
abjad.Note(
event2separate.written_pitches[0],
event2separate.written_duration,
)
]),
abjad.Voice([
abjad.Chord(
event2separate.written_pitches[1:],
event2separate.written_duration,
)
]),
],
simultaneous=True,
)
for text in (
r'\set Staff.ottavation = #"8vb"',
r"\once \override Staff.OttavaBracket.direction = #DOWN",
r"\set Voice.middleCPosition = #(+ 6 7)",
):
abjad.attach(
abjad.LilyPondLiteral(text, format_slot="before"),
staff[nth_bar][nth_item][0][0],
)
for text in (
r"\unset Staff.ottavation",
r"\unset Voice.middleCPosition",
):
abjad.attach(
abjad.LilyPondLiteral(text, format_slot="after"),
staff[nth_bar][nth_item][0][0],
)
def test_respell_accidentals_02():
staff = abjad.Staff()
for pitch in range(12):
staff.append(abjad.Chord([pitch, pitch + 1], (1, 16)))
auxjad.mutate(staff[:]).respell_accidentals()
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
{
<c' df'>16
<cs' d'>16
<d' ef'>16
<ds' e'>16
<e' f'>16
<f' gf'>16
<fs' g'>16
<g' af'>16
<gs' a'>16
<a' bf'>16
<as' b'>16
<b' c''>16
}
""")
def test_Staff___getitem___08():
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).wellformed()
selection = staff[:]
assert len(selection) == 5
assert isinstance(selection, abjad.Selection)
assert isinstance(selection[0], abjad.Note)
assert isinstance(selection[1], abjad.Rest)
assert isinstance(selection[2], abjad.Chord)
assert isinstance(selection[3], abjad.Skip)
assert isinstance(selection[4], abjad.Tuplet)
for x in selection:
assert x._parent == staff
assert abjad.inspect(staff).wellformed()
def _tuple_to_component(self, argument):
pitch_string = argument[0]
duration = argument[1]
if isinstance(argument[0], abjad.Component):
component = argument[0]
elif " " in pitch_string:
component = abjad.Chord([], duration)
pitches = pitch_string.split()
for pitch in pitches:
component.note_heads.append(pitch)
else:
component = abjad.Note(pitch_string, duration)
for indicator in argument[2:]:
if indicator == "parenthesize":
if isinstance(component, abjad.Note):
component.note_head.is_parenthesized = True
elif isinstance(component, abjad.Chord):
for note_head in component.note_heads:
note_head.is_parenthesized = True
else:
copied_indicator = copy.deepcopy(indicator)
abjad.attach(copied_indicator, component)
return component
def test_scoretools_Chord___copy___05():
r'''Chord coipes articulations and markup.
'''
chord_1 = abjad.Chord("<ef' cs'' f''>4")
articulation_1 = abjad.Articulation('staccato')
abjad.attach(articulation_1, chord_1)
markup_1 = abjad.Markup('foo', abjad.Up)
abjad.attach(markup_1, chord_1)
chord_2 = copy.copy(chord_1)
assert format(chord_1) == format(chord_2)
assert chord_1 is not chord_2
articulation_2 = abjad.inspect(chord_2).get_indicators(
abjad.Articulation)[0]
assert articulation_1 == articulation_2
assert articulation_1 is not articulation_2
markup_2 = abjad.inspect(chord_2).get_markup()[0]
assert markup_1 == markup_2
assert markup_1 is not markup_2
def listnotes(x): # Input a chord list
notelist = []
for a in x:
if a[2] == ['r']:
d = convertduration(a[3])
if d[0] not in assignable:
splitd = splitduration(d[0])
duration1 = simplifyfraction(splitd[0], d[1])
duration2 = simplifyfraction(splitd[1], d[1])
notelist.append(ab.Rest(ab.Duration(*duration1)))
notelist.append(ab.Rest(ab.Duration(*duration2)))
else:
notelist.append(ab.Rest(ab.Duration(*d)))
elif len(a[2]) == 1:
notelist.append(
ab.Note(a[2][0] - 148, ab.Duration(*convertduration(a[3]))))
elif len(a[2]) > 1:
chordnotes = []
for b in a[2]:
chordnotes.append(b - 148)
notelist.append(
ab.Chord(chordnotes, ab.Duration(*convertduration(a[3]))))
return notelist
def test_Chord___copy___05():
"""
Chord coipes articulations and markup.
"""
chord_1 = abjad.Chord("<ef' cs'' f''>4")
articulation_1 = abjad.Articulation("staccato")
abjad.attach(articulation_1, chord_1)
markup_1 = abjad.Markup("foo", direction=abjad.Up)
abjad.attach(markup_1, chord_1)
chord_2 = copy.copy(chord_1)
assert format(chord_1) == format(chord_2)
assert chord_1 is not chord_2
articulation_2 = abjad.inspect(chord_2).indicators(abjad.Articulation)[0]
assert articulation_1 == articulation_2
assert articulation_1 is not articulation_2
markup_2 = abjad.inspect(chord_2).markup()[0]
assert markup_1 == markup_2
assert markup_1 is not markup_2
def _make_measures_seg_5(
self,
durations,
rhythm_maker,
pitches,
):
if rhythm_maker is not None:
measures = rhythm_maker(durations)
measures = abjad.Container(measures)
if pitches is not None:
logical_ties = abjad.select(measures).leaves().logical_ties()
for i, logical_tie in enumerate(logical_ties):
index = i % len(pitches)
pitch = pitches[index]
for note in logical_tie:
if isinstance(note, abjad.Rest):
pass
else:
note = abjad.Chord()
return measures
def test_LilyPondParser__misc__chord_repetition_02():
target = abjad.Staff(
[
abjad.Chord([0, 4, 7], (1, 8)),
abjad.Chord([0, 4, 7], (1, 8)),
abjad.Chord([0, 4, 7], (1, 4)),
abjad.Chord([0, 4, 7], (3, 16)),
abjad.Chord([0, 4, 7], (1, 16)),
abjad.Chord([0, 4, 7], (1, 4)),
]
)
dynamic = abjad.Dynamic("p")
abjad.attach(dynamic, target[0])
articulation = abjad.Articulation("staccatissimo")
abjad.attach(articulation, target[2])
markup = abjad.Markup("text", direction=abjad.Up)
abjad.attach(markup, target[3])
articulation = abjad.Articulation("staccatissimo")
abjad.attach(articulation, target[-1])
assert abjad.lilypond(target) == abjad.String.normalize(
r"""
\new Staff
{
<c' e' g'>8
\p
<c' e' g'>8
<c' e' g'>4
- \staccatissimo
<c' e' g'>8.
^ \markup { text }
<c' e' g'>16
<c' e' g'>4
- \staccatissimo
}
"""
)
string = r"""\new Staff { <c' e' g'>8\p q q4-! q8.^"text" q16 q4-! }"""
parser = abjad.parser.LilyPondParser()
result = parser(string)
assert abjad.lilypond(target) == abjad.lilypond(result) and target is not result
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_respell_augmented_unisons_02():
staff = abjad.Staff()
for pitch in range(12):
staff.append(abjad.Chord([pitch, pitch + 1], (1, 16)))
auxjad.mutate.respell_augmented_unisons(staff[:])
assert abjad.lilypond(staff) == abjad.String.normalize(
r"""
\new Staff
{
<c' df'>16
<cs' d'>16
<d' ef'>16
<ds' e'>16
<e' f'>16
<f' gf'>16
<fs' g'>16
<g' af'>16
<gs' a'>16
<a' bf'>16
<as' b'>16
<b' c''>16
}
"""
)
def __handle_insert_command(self, command: InsertCommand) -> List[Command]:
"""Attempt to parse whatever the InsertCommand contains. Return either [] if
successful or a command that sets the status line text to what happened."""
text = command.text
if len(text) == 0:
return
try:
# objects to add
objects = []
for item in text.split(";"):
item = item.strip()
if item[0] == "r":
obj = abjad.Rest(item)
elif item[0] == "<":
obj = abjad.Chord(item)
else:
obj = abjad.Note(item)
objects.append(obj)
for obj in objects:
self.score.insert(self.position, obj)
self.position += 1
self.changed_since_saving = True
self.previous_repeatable_command = command
except Exception as e:
return [
SetStatusLineTextCommand("The string could not be parsed.",
Position.CENTER)
]
def test_lilypondparsertools_LilyPondParser__misc__chord_repetition_02():
target = abjad.Staff([
abjad.Chord([0, 4, 7], (1, 8)),
abjad.Chord([0, 4, 7], (1, 8)),
abjad.Chord([0, 4, 7], (1, 4)),
abjad.Chord([0, 4, 7], (3, 16)),
abjad.Chord([0, 4, 7], (1, 16)),
abjad.Chord([0, 4, 7], (1, 4))
])
dynamic = abjad.Dynamic('p')
abjad.attach(dynamic, target[0])
articulation = abjad.Articulation('staccatissimo')
abjad.attach(articulation, target[2])
markup = abjad.Markup('text', abjad.Up)
abjad.attach(markup, target[3])
articulation = abjad.Articulation('staccatissimo')
abjad.attach(articulation, target[-1])
assert format(target) == abjad.String.normalize(r'''
\new Staff
{
<c' e' g'>8
\p
<c' e' g'>8
<c' e' g'>4
-\staccatissimo
<c' e' g'>8.
^ \markup { text }
<c' e' g'>16
<c' e' g'>4
-\staccatissimo
}
''')
string = r'''\new Staff { <c' e' g'>8\p q q4-| q8.^"text" q16 q4-| }'''
parser = abjad.lilypondparsertools.LilyPondParser()
result = parser(string)
assert format(target) == format(result) and target is not result
# -*- encoding: utf-8 -*-
import os
import abjad
from organi.tools import SegmentMaker
# TIME SIGNATURES
time_signatures = [(4, 4)]
# ORGAN NOTATION
rest_organ = abjad.Rest("r1")
abjad.attach(abjad.Fermata("verylongfermata"), rest_organ)
rest_organ_voice_four = abjad.Rest("r1")
# CHORD ZERO ELECTRONICS
chord_zero_electronics = abjad.Chord(
"<cqs' f' gs' c'' e'' ftqs'' gqs'' gs''" +
" b'' cs''' ctqs''' f''' fs''' ftqs''' gs'''>1")
# laisses vibrer
laissez_vibrer = abjad.LaissezVibrer()
abjad.attach(laissez_vibrer, chord_zero_electronics)
# tempo mark
mark = abjad.MetronomeMark(None, None, "Statico")
abjad.attach(mark, chord_zero_electronics)
# fermata
abjad.attach(abjad.Fermata("verylongfermata"), chord_zero_electronics)
# remove includes to collect segments
includes = ['../../stylesheets/stylesheet.ily']
import abjad chord = [-12, -5, 2, 9, 16] new_chord = abjad.Chord(chord, 1) new_chord.note_heads[4].is_parenthesized = True #staff = abjad.Staff(new_chord) abjad.show(new_chord)
with open(file_path, 'r') as file:
lower_staff_components = []
upper_staff_components = []
lines = file.readlines()
if len(lines) > 0:
for line in lines:
c = Chord.from_string(line)
lower_pitches = [p for p in c.pitches if p.midi_number < 60]
lower_abjad_chord = abjad.Chord([], abjad.Duration(1, 1))
if len(lower_pitches) > 0:
for i in range(0, len(lower_pitches)):
lower_abjad_chord.note_heads.extend(
[lower_pitches[i].midi_number - 60])
if lower_pitches[i].is_harmonic_tone == False:
abjad.tweak(lower_abjad_chord.note_heads[i]
).style = 'harmonic'
lower_staff_components.append(lower_abjad_chord)
else:
lower_staff_components.append(
abjad.Rest(abjad.Duration(1, 1)))
upper_pitches = [p for p in c.pitches if p.midi_number >= 60]
upper_abjad_chord = abjad.Chord([], abjad.Duration(1, 1))
if len(upper_pitches) > 0:
def test_scoretools_NoteHeadList___len___01():
assert len(abjad.Chord('<>4').note_heads) == 0
assert len(abjad.Chord("<ef'>4").note_heads) == 1
assert len(abjad.Chord("<ef' cs''>4").note_heads) == 2
assert len(abjad.Chord("<ef' cs'' f''>4").note_heads) == 3
