def music(
location,
rmaker,
*args,
forget=False,
preprocessor=None,
rewrite_meter=None,
):
commands = []
arguments = []
for arg in args:
if issubclass(arg.__class__, rmakers.Command):
commands.append(arg)
else:
arguments.append(arg)
if rewrite_meter is not None:
stack = rmakers.stack(
rmaker,
*commands,
rmakers.trivialize(lambda _: abjad.Selection(_).tuplets()),
rmakers.rewrite_rest_filled(
lambda _: abjad.Selection(_).tuplets()),
rmakers.rewrite_sustained(lambda _: abjad.Selection(_).tuplets()),
rmakers.extract_trivial(),
rmakers.RewriteMeterCommand(
boundary_depth=rewrite_meter,
reference_meters=[
abjad.Meter((4, 4))
], # reference meters is for constructing special offset inventories (i.e. akasha 6/8)
),
preprocessor=preprocessor,
)
handler = RhythmHandler(
stack,
forget=forget,
)
else:
stack = rmakers.stack(
rmaker,
*commands,
rmakers.trivialize(lambda _: abjad.Selection(_).tuplets()),
rmakers.rewrite_rest_filled(
lambda _: abjad.Selection(_).tuplets()),
rmakers.rewrite_sustained(lambda _: abjad.Selection(_).tuplets()),
rmakers.extract_trivial(),
preprocessor=preprocessor,
)
handler = RhythmHandler(
stack,
forget=forget,
)
out = MusicCommand(
location,
handler,
*arguments,
)
return out
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 make_fused_tuplet_monads(
*,
measures: typings.SliceTyping = None,
tuplet_ratio: typing.Tuple[int] = None,
) -> RhythmCommand:
"""
Makes fused tuplet monads.
"""
tuplet_ratios = []
if tuplet_ratio is None:
tuplet_ratios.append((1, ))
else:
tuplet_ratios.append(tuplet_ratio)
return RhythmCommand(
rmakers.stack(
rmakers.tuplet(tuplet_ratios),
rmakers.beam(),
rmakers.rewrite_rest_filled(),
rmakers.trivialize(),
rmakers.extract_trivial(),
rmakers.force_repeat_tie(),
preprocessor=lambda _: classes.Sequence(
[classes.Sequence(_).sum()]),
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def intercalate_silences(rhythm_command_list, voice_names=None):
global_timespan = abjad.Timespan(
start_offset=0,
stop_offset=max(_.timespan.stop_offset for _ in rhythm_command_list),
)
silence_maker = handlers.RhythmHandler(
rmakers.stack(
rmakers.NoteRhythmMaker(),
rmakers.force_rest(
lambda _: abjad.Selection(_).leaves(pitched=True)),
),
name="silence_maker",
)
if voice_names is None:
voice_names = sorted(set(_.voice_name for _ in rhythm_command_list))
for voice_name in voice_names:
timespan_list = abjad.TimespanList([
_.timespan for _ in rhythm_command_list
if _.voice_name == voice_name
])
silences = abjad.TimespanList([global_timespan])
for timespan in timespan_list:
silences -= timespan
for timespan in silences:
new_command = RhythmCommand(
voice_name,
timespan,
silence_maker,
)
rhythm_command_list.append(new_command)
def make_music(self, durations, denominator, divisions, pitches):
# make rhythm with one tuplet per division
stack = rmakers.stack(
rmakers.talea(
durations,
denominator,
extra_counts=(0, 0, 0),
),
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 pitch material
cyclic_tuple = abjad.CyclicTuple(pitches)
iterator = abjad.iterate(selection).logical_ties(pitched=True) # make iterator out of selection using logical ties as virtual measures
iterator = enumerate(iterator) # makes enum out of iterator
for index, logical_tie in iterator:
print("entered the loop make_music")
pitch = cyclic_tuple[index]
print(pitch)
for old_leaf in logical_tie:
print("here is the old leaf: ", old_leaf)
if isinstance(pitch, int):
print("in if pitch is still", pitch)
old_leaf.written_pitch = pitch
print(old_leaf)
elif isinstance(pitch, list):
print("entered elif")
print("pitch is still", pitch)
new_leaf = abjad.Chord(pitch, old_leaf.written_duration)
print("this is the new leaf: ", new_leaf)
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)
elif isinstance(pitch, abjad.Chord):
print("entered elif")
print("pitch is still", pitch)
new_leaf = abjad.Chord(pitch, old_leaf.written_duration)
print("this is the new leaf: ", new_leaf)
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 make_phrase(self, durations, denominator, divisions, pitches):
# make rhythm with one tuplet per division
stack = rmakers.stack(
rmakers.talea(
durations,
denominator,
extra_counts=(0, 0, 0),
),
rmakers.beam()
)
selection = stack(divisions)
# attach time signature to first leaf in each tuplet
assert len(divisions) == len(selection)
previous_time_signature = None
for division, tuplet in zip(divisions, selection):
time_signature = abjad.TimeSignature(division)
leaf = abjad.select(tuplet).leaf(0)
if time_signature != previous_time_signature:
abjad.attach(time_signature, leaf)
previous_time_signature = time_signature
# apply pitch material
cyclic_tuple = abjad.CyclicTuple(pitches)
iterator = abjad.iterate(selection).logical_ties(pitched=True) # make iterator out of selection using logical ties as virtual measures
iterator = enumerate(iterator) # makes enum out of 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, str):
# warning: was formerly checking for list import rill.tools.FuzzyHarmony as FuzzyHarmony
#import rill.tools.PhraseMaker as PhraseMaker
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)
elif isinstance(pitch, abjad.Chord):
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.container.extend(selection)
command = rmakers.extract_trivial()
command(selection)
def silence_and_rhythm_maker(maker, annotated_divisions, *commands):
rest_maker = rmakers.stack(rmakers.note(), rmakers.force_rest(abjad.select()))
my_stack_voice = abjad.Container()
for dur in annotated_divisions:
if dur.annotation.startswith("Rests ") is True:
rests = rest_maker([dur])
my_stack_voice.extend(rests)
else:
selection = maker([dur], *commands)
my_stack_voice.extend(selection)
return my_stack_voice
def material_test():
print(
"Running material test using ``muda.Material()`` class and its methods."
)
timespans = muda.alternating_timespans([[1, 1], [1, 1], [1, 1]], 2,
["matA", "matB"])
durations = timespans.annotated_durations(subdivision=(2, 4))
makers = {
"matA":
rmakers.stack(rmakers.talea([-1, 2, -1], 16),
rmakers.extract_trivial()),
"matB":
rmakers.stack(rmakers.talea([1, 1, 1, 1], 16),
rmakers.extract_trivial()),
}
mat = muda.Material("A")
mat.alternating_materials(durations, makers)
pitches = {
"matA": abjad.PitchSegment("fs'"),
"matB": abjad.PitchSegment("ds'"),
}
mat.write_pitches_by_name(pitches)
mat.material_name_markups(["matA", "matB"])
def guitar_bitones_test():
print(
"Running guitar bitones test using ``muda.Material.guitar_bitones()`` method."
)
timespans = muda.alternating_timespans([[1, 1], [1, 1], [1, 1]], 4,
["matA", "matB"])
durations = timespans.annotated_durations(subdivision=(2, 4))
makers = {
"matA": rmakers.stack(rmakers.note()),
"matB": rmakers.stack(rmakers.note())
}
mat = muda.Material("A")
mat.alternating_materials(durations, makers)
pitches = {
"matA": abjad.PitchSegment("fs'"),
"matB": abjad.PitchSegment("ds'"),
}
pitched_leaves = lambda _: abjad.select.leaves(_)
mat.write_pitches_by_name(pitches)
mat.attach(abjad.StringNumber([2]), pitched_leaves, "matA")
mat.attach(abjad.StringNumber([3]), pitched_leaves, "matB")
mat.guitar_bitones(pitched_leaves, "matA", hammering=True)
mat.print()
def make_rests(*, measures: typings.SliceTyping = None) -> RhythmCommand:
"""
Makes rests.
"""
return RhythmCommand(
rmakers.stack(
rmakers.note(),
rmakers.force_rest(classes.select().lts()),
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def make_even_divisions(*,
measures: typings.SliceTyping = None) -> RhythmCommand:
"""
Makes even divisions.
"""
return RhythmCommand(
rmakers.stack(
rmakers.even_division([8]),
rmakers.beam(),
rmakers.extract_trivial(),
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def make_tied_notes(*, measures: typings.SliceTyping = None) -> RhythmCommand:
"""
Makes tied notes; rewrites meter.
"""
return RhythmCommand(
rmakers.stack(
rmakers.note(),
rmakers.beam(classes.select().plts()),
rmakers.tie(classes.select().ptails()[:-1]),
rmakers.rewrite_meter(),
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def _make_selection(
self,
time_signatures: typing.Sequence[abjad.IntegerPair],
runtime: abjad.OrderedDict = None,
) -> abjad.Selection:
"""
Calls ``RhythmCommand`` on ``time_signatures``.
"""
rhythm_maker = self.rhythm_maker
selection: abjad.Selection
if isinstance(rhythm_maker, abjad.Selection):
selection = rhythm_maker
total_duration = sum([_.duration for _ in time_signatures])
selection_duration = abjad.get.duration(selection)
if (not self.do_not_check_total_duration
and selection_duration != total_duration):
message = f"selection duration ({selection_duration}) does not"
message += f" equal total duration ({total_duration})."
raise Exception(message)
else:
rcommand: rmakers.Stack
if isinstance(self.rhythm_maker, rmakers.Stack):
rcommand = self.rhythm_maker
else:
rcommand = rmakers.stack(self.rhythm_maker)
previous_segment_stop_state = self._previous_segment_stop_state(
runtime)
if isinstance(rcommand, rmakers.Stack):
selection = rcommand(
time_signatures,
previous_state=previous_segment_stop_state)
self._state = rcommand.maker.state
else:
selection = rcommand(
time_signatures,
previous_segment_stop_state=previous_segment_stop_state,
)
self._state = rcommand.state
assert isinstance(selection, abjad.Selection), repr(selection)
if self.attach_not_yet_pitched or not isinstance(
self.rhythm_maker, abjad.Selection):
container = abjad.Container(selection, name="Dummy")
self._attach_not_yet_pitched_(container)
container[:] = []
self._attach_rhythm_annotation_spanner(selection)
return selection
def rhythm(
*arguments,
frame=None,
preprocessor: abjad.Expression = None,
measures: typings.SliceTyping = None,
persist: str = None,
tag: abjad.Tag = None,
) -> RhythmCommand:
"""
Makes rhythm command from ``argument``.
"""
if tag is not None:
assert isinstance(tag, abjad.Tag), repr(tag)
argument = rmakers.stack(*arguments, preprocessor=preprocessor, tag=tag)
return RhythmCommand(
argument,
attach_not_yet_pitched=True,
frame=frame,
measures=measures,
persist=persist,
)
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 make_tied_repeated_durations(
durations: typing.Sequence[abjad.DurationTyping],
*,
measures: typings.SliceTyping = None,
) -> RhythmCommand:
"""
Makes tied repeated durations; does not rewrite meter.
"""
specifiers: typing.List[rmakers.Command] = []
if isinstance(durations, abjad.Duration):
durations = [durations]
elif isinstance(durations, tuple):
assert len(durations) == 2
durations = [abjad.Duration(durations)]
tie_specifier: rmakers.Command
tie_specifier = rmakers.repeat_tie(classes.select().pheads()[1:])
specifiers.append(tie_specifier)
tie_specifier = rmakers.force_repeat_tie()
specifiers.append(tie_specifier)
def preprocessor(divisions):
divisions = classes.Sequence(divisions)
divisions = divisions.fuse()
divisions = divisions.split_divisions(durations, cyclic=True)
return divisions
return RhythmCommand(
rmakers.stack(
rmakers.note(),
*specifiers,
preprocessor=preprocessor,
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def make_repeated_duration_notes(
durations: typing.Sequence[abjad.DurationTyping],
*specifiers: rmakers.Command,
do_not_rewrite_meter: bool = None,
measures: typings.SliceTyping = None,
) -> RhythmCommand:
"""
Makes repeated-duration notes; rewrites meter.
"""
if isinstance(durations, abjad.Duration):
durations = [durations]
elif isinstance(durations, tuple):
assert len(durations) == 2
durations = [abjad.Duration(durations)]
def preprocessor(divisions):
divisions = classes.Sequence(divisions)
divisions = divisions.fuse()
divisions = divisions.split_divisions(durations, cyclic=True)
return divisions
rewrite_specifiers: typing.List[rmakers.Command] = []
if not do_not_rewrite_meter:
rewrite_specifiers.append(rmakers.rewrite_meter())
return RhythmCommand(
rmakers.stack(
rmakers.note(),
*specifiers,
*rewrite_specifiers,
rmakers.force_repeat_tie(),
preprocessor=preprocessor,
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
def make_notes(
*specifiers,
measures: typings.SliceTyping = None,
repeat_ties: bool = False,
) -> RhythmCommand:
"""
Makes notes; rewrites meter.
"""
if repeat_ties:
repeat_tie_specifier = [rmakers.force_repeat_tie()]
else:
repeat_tie_specifier = []
return RhythmCommand(
rmakers.stack(
rmakers.note(),
*specifiers,
rmakers.rewrite_meter(),
*repeat_tie_specifier,
tag=_site(inspect.currentframe()),
),
annotation_spanner_color="#darkcyan",
frame=inspect.currentframe(),
measures=measures,
)
import evans
from abjadext import rmakers
rmaker_one = evans.RTMMaker(rtm=[
"(1 ((3 (1 1 1)) 1 2 2))",
"(1 (1 2 2 3))",
"(1 ((2 (1 1)) 2 3 1))",
"(1 ((2 (1 1)) 3 1 2))",
])
rmaker_two = rmakers.stack(
rmakers.talea(
[3, -1, 2, -2, 3, 1, 2, 2, -3, 1, -2, 2],
4,
extra_counts=[0, 3, -1, 2, -2, 0, 3, 1, 2, 2, 0, -3, 1, -2, 2],
),
rmakers.trivialize(abjad.select().tuplets()),
rmakers.extract_trivial(abjad.select().tuplets()),
rmakers.rewrite_rest_filled(abjad.select().tuplets()),
rmakers.rewrite_sustained(abjad.select().tuplets()),
)
rmaker_three = evans.RTMMaker(rtm=[
"(1 (2 2 1 3))",
"(1 (2 2 1 4))",
"(1 (3 3 3 5))",
"(1 (4 4 4 5))",
"(1 (4 4 3 4))",
# "(1 (5 4 4 5))",
"(1 (2 1 1 2))",
# "(1 (5 5 5 5))",
# 4 _ _ _ 1 4 _ _ _ 1 4 _ _ _ 1 4 _ _ _ 1
# 3 _ _ 2 _ 3 _ _ 2 _
# 2 _ 2 _ 2 _ 2 _ 2
# 4 _ _ _ 4 _ \ _ _ 1 3 _ _ \ 1 3 _ _ 1 2 _ 1 2 _ 1 1
# 1 2 _ 1 2 _ \ 1 3 _ _ 1 3 \ _ _ 1 2 _ 1 2 _ 1 1
# 2 _ 3 _ _ 4 \ _ _ _ 1 3 _ \ _ 1 2 _ 1 2 _ 1 1
# TALEA RHYTHM MAKER
selector = abjad.select().tuplets()[:-1]
selector = selector.map(abjad.select().note(-1))
rhythm_maker_voice_two = rmakers.stack(
rmakers.talea(
[4, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 1], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
rmakers.tie(selector),
)
rhythm_maker_voice_three = rmakers.stack(
rmakers.talea(
[1, 2, 1, 2, 1, 3, 1, 3, 1, 2, 1, 2, 1, 1], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
rmakers.tie(selector),
)
import abjad
import abjadext.rmakers as rmakers
import evans
import random
# THOSE CHORDS IN VOICE FIVE (once was one)
rhythm_maker_voice_five = rmakers.stack(
rmakers.talea(
[2, 1, 3], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.extract_trivial(),
# rmakers.tie(selector),
)
# MATERIAL FROM SEGMENT 2 AND 3
# REST LIST
rest_list = evans.e_dovan_cycle(n=2, iters=16, first=1, second=1, modulus=5)
rest_list.sort(reverse=True)
# NOTE LIST VOICE TWO
note_list_voice_two = [4, 1]
non_cyc_generator = evans.CyclicList(lst=note_list_voice_two,
continuous=False,
count=1)
new_note_list_voice_two = non_cyc_generator(r=40)
# NOTE + REST = TALEA VOICE TWO
note_and_rest_voice_two = []
note_sublist_voice_two = []
import abjad
import abjadext.rmakers as rmakers
import random
import organi
voz = abjad.Voice()
selector = abjad.select().tuplets()[:-1]
selector = selector.map(abjad.select().note(-1))
rhythm = rmakers.stack(
rmakers.talea(
[7, 7, 7, 7], # counts
8, # denominator
),
# rmakers.beam(),
rmakers.denominator((1, 8)),
rmakers.extract_trivial(),
# rmakers.tie(selector),
)
divisions = [(4, 8)] * 7
measures = rhythm(divisions)
voz = abjad.Voice(
measures) # NEED TO PUT IN A CONTAINER TO SEPARATE WELL THE LOGICAL TIES
logical_ties = abjad.select(voz).leaves().logical_ties(pitched=True)
logical_ties
voz_time = abjad.Voice("s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s2 s4 s1")
abjad.Staff(voz, voz_time)
time_signatures = []
for item in divisions:
time_signatures.append(abjad.TimeSignature(item))
abjad.detach(signature, skips[i])
abjad.attach(new_signature, skips[i])
ts_staff = abjad.Staff(skips,
lilypond_type="TimeSignatureContext",
name="globalcontext")
selector = abjad.select().notes().exclude([0, 1, 3, 4, -1])
selector = abjad.select().tuplets().map(selector)
stack = rmakers.stack(
rmakers.tuplet([(1, 2, 4, 1, 1, 1)]),
rmakers.force_rest(selector),
rmakers.before_grace_container(
[1, 2, 1],
abjad.select().tuplets().map(
abjad.select().logical_ties(pitched=True).exclude([0, 3, 4, 5])),
),
rmakers.rewrite_dots(abjad.select().tuplets().get([1])),
rmakers.trivialize(abjad.select().tuplets()),
rmakers.extract_trivial(abjad.select().tuplets()),
rmakers.rewrite_rest_filled(abjad.select().tuplets()),
rmakers.rewrite_sustained(abjad.select().tuplets()),
)
stack2 = rmakers.stack(
rmakers.talea([3, 1, 4, -1, 5, 9], 8, extra_counts=[1, 3, 5]),
rmakers.trivialize(abjad.select().tuplets()),
rmakers.extract_trivial(abjad.select().tuplets()),
rmakers.rewrite_rest_filled(abjad.select().tuplets()),
rmakers.rewrite_sustained(abjad.select().tuplets()),
)
selection1 = stack([time_signatures[0]])
import abjad
import evans
from abjadext import rmakers
silence_maker = rmakers.stack(
rmakers.NoteRhythmMaker(),
rmakers.force_rest(abjad.select().leaves(pitched=True)),
)
silence_handler = evans.RhythmHandler(
rmaker=silence_maker,
forget=True,
name="silence_handler",
)
##
##
note_maker = rmakers.stack(rmakers.NoteRhythmMaker(), )
note_handler = evans.RhythmHandler(
rmaker=note_maker,
forget=True,
name="note_handler",
)
##
##
anuran_maker = rmakers.stack(
evans.RTMMaker([
time_signatures = []
for item in durations:
if isinstance(item, list):
for i in item:
time_signatures.append(abjad.TimeSignature(i))
else:
time_signatures.append(abjad.TimeSignature(item))
# time_signatures = timespans.time_signatures()
# It is a list of durations where each one is annotated with
# the material name.
# Rhythms of each material
makers = {
"matL": rmakers.stack(rmakers.talea([2, 1, -1], 16), rmakers.extract_trivial()),
"matK": rmakers.stack(
rmakers.talea([1, 1, 1, 1, 1], 32, extra_counts=[1]),
rmakers.extract_trivial(),
),
"matJ": rmakers.stack(
rmakers.talea([-1, 1, -1], 8, extra_counts=[1]), rmakers.extract_trivial()
),
"matI": rmakers.stack(
rmakers.talea([1, 1, 1], 4, extra_counts=[1]), rmakers.extract_trivial()
),
"matH": rmakers.stack(
rmakers.talea([-3, -2, 1, -3, -3], 16, extra_counts=[4]),
rmakers.extract_trivial(),
),
"matG": rmakers.stack(
divisions = evans.BacaSequence(divisions).flatten(depth=-1)
return divisions
commands = [
rmakers.trivialize(lambda _: abjad.Selection(_).tuplets()),
rmakers.rewrite_rest_filled(lambda _: abjad.Selection(_).tuplets()),
rmakers.rewrite_sustained(lambda _: abjad.Selection(_).tuplets()),
rmakers.extract_trivial(),
rmakers.RewriteMeterCommand(
boundary_depth=-1,
reference_meters=[
abjad.Meter((6, 8)),
abjad.Meter((9, 8)),
],
),
]
stack = rmakers.stack(
rmaker,
*commands,
preprocessor=quarters,
)
divisions = [(6, 8), (9, 8)]
selections = stack(divisions)
lilypond_file = rmakers.helpers.example(selections, divisions)
abjad.show(lilypond_file)
import abjad
import math
from abjadext import rmakers
selector = abjad.select().notes().exclude([0, 1, 3, 4, -1])
selector = abjad.select().tuplets().map(selector)
stack = rmakers.stack(
rmakers.tuplet([(1, 2, 4, 1, 1, 1)]),
rmakers.force_rest(selector),
rmakers.before_grace_container([0, 2, 3],
abjad.select().logical_ties(pitched=True)),
)
time_signatures = [
abjad.TimeSignature((3, 4)),
abjad.TimeSignature((7, 8)),
abjad.TimeSignature((3, 8)),
abjad.TimeSignature((4, 4)),
]
selection = stack(time_signatures)
skips = [abjad.Skip((1, 1)) for signature in time_signatures]
for skip, signature in zip(skips, time_signatures):
skip.multiplier = abjad.Multiplier(signature.pair)
abjad.attach(signature, skip)
ts_staff = abjad.Staff(skips,
lilypond_type="TimeSignatureContext",
name="globalcontext")
staff = abjad.Staff(selection, name="staffname")
import abjad
import abjadext.rmakers as rmakers
import muda
durations_general = [(4, 4)] * 32
rmaker_afluteA = rmakers.stack(
rmakers.talea([4, -2, 1], 8),
rmakers.extract_trivial(), # counts # denominator
tag=abjad.Tag("Mat_A"),
)
rmaker_afluteB = rmakers.stack(
rmakers.talea([1], 8, extra_counts=[1]),
rmakers.beam(),
rmakers.extract_trivial(), # counts # denominator
# rmakers.rewrite_meter(),
tag=abjad.Tag("Mat_B"),
)
rest_maker = rmakers.stack(rmakers.note(),
rmakers.force_rest(abjad.select()),
tag=abjad.Tag("Rests"))
rmaker_bclarinetA = rmakers.stack(
rmakers.talea([-4, 2], 8), # counts # denominator
rmakers.beam(),
rmakers.extract_trivial(),
tag=abjad.Tag("Mat_A"),
)
rmaker_bclarinetB = rmakers.stack(
[
abjad.Voice(
"c'8 c'8 c'8 c'8 c'8 c'8 c'8 c'8",
name="Voice 2",
)
],
name="Staff 2",
),
],
name="group",
)
],
name="Score",
)
h = evans.IntermittentVoiceHandler(
evans.RhythmHandler(
rmakers.stack(evans.RTMMaker([
"(1 (1 1 1))",
]), ),
forget=False,
),
direction=abjad.Up,
)
selector = abjad.select().leaf(1)
target = selector(score["Voice 1"])
h(target)
abjad.show(score)
(5, 4),
(6, 4),
(5, 4),
(4, 4),
(3, 4),
(2, 4),
]
nonlast_tuplets = abjad.select().tuplets()[:-1]
last_leaf = abjad.select().leaf(-1)
s = rmakers.stack(
evans.RTMMaker(final_rtm_list),
rmakers.force_rest(abjad.select().leaves().get([0, -2, -1])),
rmakers.tie(nonlast_tuplets.map(last_leaf)),
rmakers.trivialize(abjad.select().tuplets()),
rmakers.extract_trivial(abjad.select().tuplets()),
rmakers.rewrite_rest_filled(abjad.select().tuplets()),
rmakers.rewrite_sustained(abjad.select().tuplets()),
rmakers.beam(),
)
h = evans.RhythmHandler(s, forget=False)
voice_1_selections = h(durs)
staff_1 = abjad.Staff(name="Voice 1", lilypond_type="RhythmicStaff")
staff_1.extend(voice_1_selections)
quantizer = evans.RhythmTreeQuantizer()
final_rtm_list = [quantizer(_) for _ in final_rtm_list]
print("")
for _ in final_rtm_list:
