def __init__(
self,
cascade_pattern=(1, ),
division_masks=None,
fuse_groups=None,
padding=None,
playing_talea=rmakers.Talea(
counts=[4],
denominator=16,
),
playing_groupings=(1, ),
seed=None,
repeat=True,
silence_talea=rmakers.Talea(
counts=[4],
denominator=16,
),
timespan_specifier=None,
):
tsmakers.TimespanMaker.__init__(
self,
division_masks=division_masks,
padding=padding,
seed=seed,
timespan_specifier=timespan_specifier,
)
self._initialize_cascade_pattern(cascade_pattern)
self._initialize_fuse_groups(fuse_groups)
self._initialize_playing_talea(playing_talea)
self._initialize_playing_groupings(playing_groupings)
self._initialize_repeat(repeat)
self._initialize_silence_talea(silence_talea)
def _make_timespans(
self,
layer=None,
music_specifiers=None,
target_timespan=None,
timespan_list=None,
):
initial_silence_talea = self.initial_silence_talea
if not initial_silence_talea:
initial_silence_talea = rmakers.Talea(counts=(0,), denominator=1)
initial_silence_talea = Cursor(initial_silence_talea)
playing_talea = Cursor(self.playing_talea)
playing_groupings = Cursor(self.playing_groupings)
silence_talea = self.silence_talea
if silence_talea is None:
silence_talea = rmakers.Talea(counts=(0,), denominator=1)
silence_talea = Cursor(silence_talea)
if self.seed is not None and 0 < self.seed:
for _ in range(self.seed):
next(initial_silence_talea)
next(playing_talea)
next(playing_groupings)
next(silence_talea)
if self.synchronize_step:
procedure = self._make_with_synchronized_step
else:
procedure = self._make_without_synchronized_step
new_timespan_list, final_offset = procedure(
initial_silence_talea=initial_silence_talea,
layer=layer,
playing_talea=playing_talea,
playing_groupings=playing_groupings,
music_specifiers=music_specifiers,
silence_talea=silence_talea,
target_timespan=target_timespan,
)
assert all(0 < _.duration for _ in new_timespan_list), (
format(self),
target_timespan,
)
if self.reflect:
new_timespan_list = new_timespan_list.reflect(
axis=target_timespan.axis,
)
return new_timespan_list
def make_basic_rhythm(self, durations):
talea = rmakers.Talea(
counts = self.counts,
denominator=self.denominator,
)
beam_specifier = rmakers.BeamSpecifier(
beam_divisions_together=self.beams,
beam_each_division=self.beams,
beam_rests=self.beams,
)
# burnish_specifier=abjadext.rmakers.BurnishSpecifier(
# left_classes=[abjad.Rest],
# left_counts=[1, 0, 1],
# )
if self.mask_indices or self.mask_period == None:
division_masks = None
else:
division_masks = rmakers.SilenceMask(
pattern = abjad.Pattern(
indices=self.mask_indices,
period=self.mask_period,
)
)
tuplet_specifier = rmakers.TupletSpecifier(
trivialize=True,
extract_trivial=True,
rewrite_rest_filled=True,
)
talea_rhythm_maker = rmakers.TaleaRhythmMaker(
talea=talea,
beam_specifier=beam_specifier,
extra_counts_per_division=self.extra_counts_per_division,
division_masks=division_masks,
tuplet_specifier=tuplet_specifier,
burnish_specifier=self.burnish_specifier
#tag=self.tag,
)
selections = talea_rhythm_maker(durations)
music = self._apply_pitches(selections)
return music
from hamon_shu.materials.score_structure.instruments import instruments
padovan_1 = evans.e_dovan_cycle(n=3, iters=30, first=3, second=5, modulus=6)
padovan_2 = evans.e_dovan_cycle(n=2, iters=30, first=2, second=3, modulus=5)
padovan_3 = evans.e_dovan_cycle(n=2, iters=30, first=1, second=1, modulus=3)
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 15)
rhythm_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([0, 0, 0, 0]), denominator=4),
synchronize_step=True,
# synchronize_groupings=True,
playing_talea=rmakers.Talea(counts=(padovan_1), denominator=2),
playing_groupings=(padovan_3),
silence_talea=rmakers.Talea(counts=(padovan_2), denominator=2),
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan)
# ######
# pitch#
# ######
pitch_target_timespan = abjad.Timespan(0, 15)
def _make_timespans(
self,
layer=None,
music_specifiers=None,
target_timespan=None,
timespan_list=None,
):
new_timespans = abjad.TimespanList()
if not self.voice_names and not self.labels:
return new_timespans
start_talea = self.start_talea
if start_talea is None:
start_talea = rmakers.Talea((0, ), 1)
start_talea = tsmakers.Cursor(start_talea)
start_groupings = self.start_groupings
if start_groupings is None:
start_groupings = (1, )
start_groupings = tsmakers.Cursor(start_groupings)
stop_talea = self.stop_talea
if stop_talea is None:
stop_talea = rmakers.Talea((0, ), 1)
stop_talea = tsmakers.Cursor(stop_talea)
stop_groupings = self.stop_groupings
if stop_groupings is None:
stop_groupings = (1, )
stop_groupings = tsmakers.Cursor(stop_groupings)
if self.seed:
if self.seed < 0:
for _ in range(abs(self.seed)):
start_talea.backtrack()
start_groupings.backtrack()
stop_talea.backtrack()
stop_groupings.backtrack()
else:
next(start_talea)
next(start_groupings)
next(stop_talea)
next(stop_groupings)
context_counter = collections.Counter()
preexisting_timespans = self._collect_preexisting_timespans(
target_timespan=target_timespan,
timespan_list=timespan_list,
)
new_timespan_mapping = {}
for group_index, group in enumerate(
preexisting_timespans.partition(True)):
for context_name, music_specifier in music_specifiers.items():
if context_name not in new_timespan_mapping:
continue
new_timespan_mapping[context_name] - group.timespan
for context_name, music_specifier in music_specifiers.items():
if context_name not in new_timespan_mapping:
new_timespan_mapping[context_name] = \
abjad.TimespanList()
context_seed = context_counter[context_name]
start_durations = []
for _ in range(next(start_groupings)):
start_durations.append(next(start_talea))
stop_durations = []
for _ in range(next(stop_groupings)):
stop_durations.append(next(stop_talea))
start_timespans, stop_timespans = (), ()
if start_durations:
group_start = group.start_offset
if self.start_anchor is abjad.Right:
#print('!!!', float(group_start), float(group_start -
# sum(start_durations)))
group_start -= sum(start_durations)
start_timespans = music_specifier(
durations=start_durations,
layer=layer,
division_masks=self.division_masks,
padding=self.padding,
seed=context_seed,
start_offset=group_start,
timespan_specifier=self.timespan_specifier,
voice_name=context_name,
)
context_counter[context_name] += 1
if stop_durations:
group_stop = group.stop_offset
if self.stop_anchor is abjad.Right:
group_stop -= sum(stop_durations)
stop_timespans = music_specifier(
durations=stop_durations,
layer=layer,
division_masks=self.division_masks,
padding=self.padding,
seed=context_seed,
start_offset=group_stop,
timespan_specifier=self.timespan_specifier,
voice_name=context_name,
)
context_counter[context_name] += 1
#if start_timespans and stop_timespans:
# start_timespans & group.timespan
new_timespan_mapping[context_name].extend(start_timespans)
new_timespan_mapping[context_name].extend(stop_timespans)
for context_name, timespans in new_timespan_mapping.items():
timespans.compute_logical_or()
new_timespans.extend(timespans)
return new_timespans
# temp_list = abjad.TimespanList([
# abjad.AnnotatedTimespan(_.start_offset, _.stop_offset, annotation=_.voice_name) for _ in rhythm_timespan_list
# ])
#
# abjad.show(temp_list, scale=0.7, key="annotation")
#
# raise Exception("Stop")
# ######
# pitch#
# ######
pitch_target_timespan = abjad.Timespan(0, 6)
pitch_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(
counts=([15, 0, 24, 24]),
denominator=4,
),
playing_talea=rmakers.Talea(counts=([9, 8, 7]), denominator=4),
silence_talea=rmakers.Talea(counts=([5, 1, 5, 1]), denominator=4),
)
pitch_timespan_list = pitch_timespan_maker(
music_specifiers=music_specifiers, target_timespan=pitch_target_timespan)
# ######
# dynamic#
# ######
dynamic_target_timespan = abjad.Timespan(0, 6)
dynamic_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(
import abjad
from abjadext import rmakers as rmakers
from tsmakers.TaleaTimespanMaker import TaleaTimespanMaker
from sim.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 14)
# 4, 0, 1, 3
rhythm_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([0]), denominator=2),
playing_talea=rmakers.Talea(
counts=([8, 10, 8, 6, 8, 8, 6, 8, 8, 10, 8, 8, 8, 8]), denominator=8),
silence_talea=rmakers.Talea(counts=([0]), denominator=8),
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan)
# ######
# pitch#
# ######
pitch_target_timespan = abjad.Timespan(0, 14)
pitch_timespan_maker = TaleaTimespanMaker(
playing_talea=rmakers.Talea(counts=([14]), denominator=1),
from abjadext import rmakers as rmakers
from tsmakers.TaleaTimespanMaker import TaleaTimespanMaker
from adumbration.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict(
[(f"Voice {i+1}", None) for i, name in enumerate(instruments)]
)
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, (25, 4))
rhythm_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([0]), denominator=8),
playing_talea=rmakers.Talea(counts=([5, 1, 2, 5, 3, 4, 5]), denominator=4),
# playing_groupings=([1, 2, 3, 2,]),
silence_talea=rmakers.Talea(
counts=(
[
0,
]
),
denominator=8,
),
# synchronize_step=True,
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan
music_specifiers = OrderedDict(
[(f"Voice {i+1}", None) for i, name in enumerate(instruments)]
)
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 6)
rhythm_timespan_maker = tsmakers.TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(
counts=(
[
0,
0,
0,
0,
]
),
denominator=4,
),
playing_talea=rmakers.Talea(
counts=(
[
4,
5,
6,
7,
8,
7,
6,
import abjad
from abjadext import rmakers as rmakers
from tsmakers.TaleaTimespanMaker import TaleaTimespanMaker
from adumbration.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, (30, 8))
rhythm_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([0]), denominator=8),
playing_talea=rmakers.Talea(counts=([3, 4, 2, 1, 1]), denominator=4),
# playing_groupings=([1, 2, 3, 2,]),
silence_talea=rmakers.Talea(
counts=([
1,
2,
4,
1,
]),
denominator=8,
),
# synchronize_step=True,
)
rhythm_timespan_list = rhythm_timespan_maker(
from adumbration.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 24)
rhythm_timespan_maker = tsmakers.TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(
counts=([
7,
4,
0,
7,
]),
denominator=4,
),
playing_talea=rmakers.Talea(
counts=([
2,
3,
8,
8,
2,
5,
8,
6,
2,
from adumbration.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 14)
rhythm_timespan_maker = tsmakers.TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(
counts=([
9,
0,
0,
0,
]),
denominator=4,
),
playing_talea=rmakers.Talea(
counts=([
27,
16,
4,
4,
4,
4,
4,
4,
4,
import evans
import pathlib
tsmakers.BoundaryTimespanMaker()
# work with timespans to generate durations that will be filled by rhythm makers
# voices names
music_specifiers = abjad.OrderedDict([(f"Voice {i+1}", None) for i in range(9)])
# segment size
target_timespan = abjad.Timespan(0, 16)
# taleas
timespan_maker = tsmakers.TaleaTimespanMaker(
# initial_silence_talea=rmakers.Talea(counts=([13, 5, 1]), denominator=4),
playing_talea=rmakers.Talea(counts=([4]), denominator=8),
playing_groupings=([1, 2, 1, 2, 3]),
silence_talea=rmakers.Talea(counts=([13, 5, 1]), denominator=4),
)
# temporary list
temp_list = timespan_maker(
music_specifiers=music_specifiers, target_timespan=target_timespan
)
# the same algorythm generates durations for different voices using the annotation
# the list bellow contains all the timespans
the_list = muda.timespan.TimespanList()
# translate evans classes to abjad AnnotatedTimespan
for span in temp_list:
music_specifiers = abjad.OrderedDict(
[(f"Voice {i+1}", None) for i, name in enumerate(instruments)]
)
voice_names = [specifier for specifier in music_specifiers]
# #######
# rhythm#
# #######
# # 01
target_timespan_01 = abjad.Timespan(0, (86, 4))
timespan_maker_01 = tsmakers.TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([0]), denominator=4),
playing_talea=rmakers.Talea(
counts=(
[
11, # vnI-1
15,
15,
3,
5,
12,
25,
26, # vnI-2
15,
3,
5,
12,
("Voice 1", "music specifier"),
("Voice 2", None),
("Voice 3", None),
("Voice 4", None),
("Voice 5", None),
("Voice 6", None),
("Voice 7", None),
("Voice 8", None),
("Voice 9", None),
("Voice 9+1", None),
])
target_timespan = abjad.Timespan(0, 8)
timespan_maker = tsmakers.TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=(0, 5, 3, 6, 2), denominator=8),
# synchronize_step=True, #goes down voices instead of across? maybe not consistent...
# synchronize_groupings=True, #goes down voices instead of across? maybe not consistent...
playing_talea=rmakers.Talea(counts=(5, 3, 1, 2, 6), denominator=4),
playing_groupings=(
1,
2,
3,
2,
), # smashes timespans together without intermittent silence
silence_talea=rmakers.Talea(counts=(2, 1, 1), denominator=4),
# fuse_groups=False, #turns groups from multiple timespans into one large timespan
)
timespan_list = timespan_maker(music_specifiers=music_specifiers,
target_timespan=target_timespan)
from adumbration.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 21)
rhythm_timespan_maker = tsmakers.TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(
counts=([
0,
0,
0,
0,
]),
denominator=4,
),
playing_talea=rmakers.Talea(
counts=([
3,
5,
2,
5,
3,
2,
4,
6,
7,
import abjad
import tsmakers
from abjadext import rmakers
timespan_maker = tsmakers.TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=(1, 4, 1), denominator=16),
silence_talea=rmakers.Talea(counts=(0, 5), denominator=(32)))
abjad.f(timespan_maker)
music_specifiers = abjad.OrderedDict([
('Violin', None),
('Viola', None),
])
target_timespan = abjad.Timespan(0, 10)
timespan_list = timespan_maker(
music_specifiers=music_specifiers,
target_timespan=target_timespan,
)
abjad.f(timespan_list)
abjad.show(timespan_list)
import abjad
from abjadext import rmakers as rmakers
from tsmakers.TaleaTimespanMaker import TaleaTimespanMaker
from sim.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, (96, 4))
rhythm_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([18, 0, 4, 9]),
denominator=16),
playing_talea=rmakers.Talea(counts=([3, 1, 2, 2]), denominator=4),
silence_talea=rmakers.Talea(
counts=([3, 1, 2, 2, 4, 2, 4, 6, 5, 2, 3, 1, 6, 3, 1, 2]),
denominator=8),
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan)
# ######
# pitch#
# ######
pitch_target_timespan = abjad.Timespan(0, (96, 4))
pitch_timespan_maker = TaleaTimespanMaker(
import abjad
from abjadext import rmakers as rmakers
from tsmakers.TaleaTimespanMaker import TaleaTimespanMaker
from adumbration.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 12)
rhythm_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([0]), denominator=8),
playing_talea=rmakers.Talea(counts=([5, 2, 3, 1, 1]), denominator=4),
playing_groupings=([2, 3, 2, 1]),
silence_talea=rmakers.Talea(counts=([1, 2, 1, 3]), denominator=4),
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan)
# temp_list = abjad.TimespanList([
# abjad.AnnotatedTimespan(_.start_offset, _.stop_offset, annotation=_.voice_name) for _ in rhythm_timespan_list
# ])
#
# abjad.show(temp_list, scale=0.7, key="annotation")
# ######
def __init__(
self,
fuse_groups=None,
initial_silence_talea=None,
division_masks=None,
padding=None,
playing_talea=rmakers.Talea(
counts=[4],
denominator=16,
),
playing_groupings=(1,),
reflect=None,
repeat=True,
seed=None,
silence_talea=rmakers.Talea(
counts=[4],
denominator=16,
),
step_anchor=abjad.Right,
synchronize_groupings=False,
synchronize_step=False,
timespan_specifier=None,
):
TimespanMaker.__init__(
self,
division_masks=division_masks,
padding=padding,
seed=seed,
timespan_specifier=timespan_specifier,
)
if fuse_groups is not None:
fuse_groups = bool(fuse_groups)
self._fuse_groups = fuse_groups
if initial_silence_talea is not None:
assert isinstance(initial_silence_talea, rmakers.Talea)
assert initial_silence_talea.counts
assert all(0 <= x for x in initial_silence_talea.counts)
self._initial_silence_talea = initial_silence_talea
assert isinstance(playing_talea, rmakers.Talea)
assert playing_talea.counts
assert all(0 < x for x in playing_talea.counts)
self._playing_talea = playing_talea
if not isinstance(playing_groupings, collections.abc.Sequence):
playing_groupings = (playing_groupings,)
playing_groupings = tuple(int(x) for x in playing_groupings)
assert len(playing_groupings)
assert all(0 < x for x in playing_groupings)
self._playing_groupings = playing_groupings
if reflect is not None:
reflect = bool(reflect)
self._reflect = reflect
self._repeat = bool(repeat)
if silence_talea is not None:
assert isinstance(silence_talea, rmakers.Talea)
assert silence_talea.counts
assert all(0 <= x for x in silence_talea.counts)
self._silence_talea = silence_talea
assert step_anchor in (abjad.Left, abjad.Right)
self._step_anchor = step_anchor
self._synchronize_groupings = bool(synchronize_groupings)
self._synchronize_step = bool(synchronize_step)
import tsmakers
from abjadext import rmakers
from adumbration.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 30)
rhythm_timespan_maker = tsmakers.TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(
counts=([
0,
]),
denominator=4,
),
playing_talea=rmakers.Talea(
counts=([
2,
2,
2,
1,
1,
1,
1,
1,
1,
2,
2,
music_specifiers = OrderedDict(
[(f"Voice {i+1}", None) for i, name in enumerate(instruments)]
)
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 7)
rhythm_timespan_maker = tsmakers.TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(
counts=(
[
5,
2,
4,
0,
]
),
denominator=4,
),
playing_talea=rmakers.Talea(
counts=(
[
5,
4,
3,
4,
5,
6,
5,
padovan_3 = evans.Sequence.e_dovan_cycle(n=2,
iters=30,
first=1,
second=1,
modulus=5)
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 81)
rhythm_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([0, 0, 0, 0]), denominator=8),
# synchronize_step=True,
# synchronize_groupings=True,
playing_talea=rmakers.Talea(counts=(padovan_1), denominator=2),
playing_groupings=(padovan_3),
silence_talea=rmakers.Talea(counts=(padovan_2), denominator=4),
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan)
# ######
# pitch#
# ######
pitch_target_timespan = abjad.Timespan(0, 81)
from hamon_shu.materials.score_structure.instruments import instruments
padovan_1 = evans.e_dovan_cycle(n=3, iters=30, first=3, second=5, modulus=7)
padovan_2 = evans.e_dovan_cycle(n=2, iters=30, first=2, second=3, modulus=3)
padovan_3 = evans.e_dovan_cycle(n=2, iters=30, first=1, second=1, modulus=5)
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# ####### #was 225
rhythm_target_timespan = abjad.Timespan(0, (136, 4))
rhythm_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([7, 7, 2, 0]), denominator=4),
# synchronize_step=True,
# synchronize_groupings=True,
playing_talea=rmakers.Talea(counts=(padovan_1), denominator=2),
playing_groupings=(padovan_3),
silence_talea=rmakers.Talea(counts=(padovan_2), denominator=2),
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan)
# ######
# pitch#
# ######
pitch_target_timespan = abjad.Timespan(0, (170, 4))
pitch_padovan_1 = evans.Sequence.e_dovan_cycle(n=3,
iters=5,
first=3,
second=5,
modulus=5)
music_specifiers = OrderedDict([(f"Voice {i+1}", None)
for i, name in enumerate(instruments)])
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 22)
# 1, 3, 2
rhythm_timespan_maker = TaleaTimespanMaker(
initial_silence_talea=rmakers.Talea(counts=([0, 3, 2, 0]), denominator=8),
# synchronize_step=True, #goes down voices instead of across? maybe not consistent...
# synchronize_groupings=True, #goes down voices instead of across? maybe not consistent...
playing_talea=rmakers.Talea(counts=(padovan_1), denominator=4),
playing_groupings=(
padovan_3), # smashes timespans together without intermittent silence
silence_talea=rmakers.Talea(counts=(padovan_2), denominator=4),
# fuse_groups=False, #turns groups from multiple timespans into one large timespan
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan)
# ######
# pitch#
# ######
from abjadext import rmakers
import magnolia
music_specifiers = OrderedDict(
[(f"Voice {i+1}", None) for i, name in enumerate(magnolia.instruments)]
)
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 54)
rhythm_timespan_maker = tsmakers.TaleaTimespanMaker(
playing_talea=rmakers.Talea(
counts=([6, 2, 4, 4, 5, 2, 3, 3, 4, 5]),
denominator=4,
),
silence_talea=rmakers.Talea(counts=([0]), denominator=4),
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan
)
# ######
# pitch#
# ######
pitch_target_timespan = abjad.Timespan(0, 54)
pitch_timespan_maker = tsmakers.TaleaTimespanMaker(
playing_talea=rmakers.Talea(counts=([5, 4, 3, 2, 1, 2, 3, 4]), denominator=4),
def __init__(
self,
start_talea=None,
stop_talea=None,
start_groupings=None,
stop_groupings=None,
start_anchor=abjad.Left,
stop_anchor=abjad.Left,
labels=None,
division_masks=None,
padding=None,
seed=None,
timespan_specifier=None,
voice_names=None,
):
tsmakers.TimespanMaker.__init__(
self,
division_masks=division_masks,
padding=padding,
seed=seed,
timespan_specifier=timespan_specifier,
)
if start_talea is not None:
if not isinstance(start_talea, rmakers.Talea):
start_duration = abjad.Duration(start_talea)
counts = [start_duration.numerator]
denominator = start_duration.denominator
start_talea = rmakers.Talea(
counts=counts,
denominator=denominator,
)
assert isinstance(start_talea, rmakers.Talea)
assert start_talea.counts
assert all(0 < x for x in start_talea.counts)
self._start_talea = start_talea
if start_groupings is not None:
if not isinstance(start_groupings, collections.Sequence):
start_groupings = (start_groupings, )
start_groupings = tuple(int(x) for x in start_groupings)
assert len(start_groupings)
assert all(0 < x for x in start_groupings)
self._start_groupings = start_groupings
if stop_talea is not None:
if not isinstance(stop_talea, rmakers.Talea):
stop_duration = abjad.Duration(stop_talea)
counts = [stop_duration.numerator]
denominator = stop_duration.denominator
stop_talea = rmakers.Talea(
counts=counts,
denominator=denominator,
)
assert isinstance(stop_talea, rmakers.Talea)
assert stop_talea.counts
assert all(0 < x for x in stop_talea.counts)
self._stop_talea = stop_talea
if stop_groupings is not None:
if not isinstance(stop_groupings, collections.Sequence):
stop_groupings = (stop_groupings, )
stop_groupings = tuple(int(x) for x in stop_groupings)
assert len(stop_groupings)
assert all(0 < x for x in stop_groupings)
self._stop_groupings = stop_groupings
if labels is not None:
if isinstance(labels, str):
labels = (labels, )
labels = tuple(str(_) for _ in labels)
self._labels = labels
if voice_names is not None:
voice_names = tuple(voice_names)
self._voice_names = voice_names
assert start_anchor in (abjad.Left, abjad.Right)
self._start_anchor = start_anchor
assert stop_anchor in (abjad.Left, abjad.Right)
self._stop_anchor = stop_anchor
import abjad
import tsmakers
from abjadext import rmakers
timespan_maker = tsmakers.BoundaryTimespanMaker(
start_talea=rmakers.Talea(
counts=[1],
denominator=2,
),
stop_talea=rmakers.Talea(
counts=[1],
denominator=4,
),
voice_names=('Violin 1 Voice', 'Violin 2 Voice'),
)
abjad.f(timespan_maker)
initial_list = abjad.TimespanList([
tsmakers.PerformedTimespan(
start_offset=0,
stop_offset=1,
voice_name='Violin 1 Voice',
),
tsmakers.PerformedTimespan(
start_offset=(1, 2),
stop_offset=(3, 2),
voice_name='Violin 2 Voice',
),
from tsmakers.TaleaTimespanMaker import TaleaTimespanMaker
from chalk_line.materials.score_structure.instruments import instruments
music_specifiers = OrderedDict(
[(f"Voice {i+1}", None) for i, name in enumerate(instruments)]
)
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, (80, 4))
rhythm_timespan_maker = TaleaTimespanMaker(
playing_talea=rmakers.Talea(
counts=([1, 9, 2, 8, 3, 7, 4, 6, 5, 5, 4, 6, 3, 7, 2, 8]), denominator=8
),
silence_talea=rmakers.Talea(counts=([0]), denominator=4),
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan
)
print("Making timespans ...")
# ######
# pitch#
# ######
pitch_target_timespan = abjad.Timespan(0, 32)
pitch_timespan_maker = TaleaTimespanMaker(
# #######
# rhythm#
# #######
rhythm_target_timespan = abjad.Timespan(0, 38)
rhythm_timespan_maker = CascadingTimespanMaker(
cascade_pattern=(-1),
# division_masks=None,
# fuse_groups=None,
# padding=None,
playing_talea=rmakers.Talea(
[
2,
2,
2,
4,
2,
3,
],
8,
),
playing_groupings=([3, 4, 2, 3, 4, 3, 2]),
repeat=True,
# silence_talea=rmakers.Talea([1, 1, 2, 3, 5], 4),
timespan_specifier=None,
)
rhythm_timespan_list = rhythm_timespan_maker(
music_specifiers=music_specifiers, target_timespan=rhythm_target_timespan)
# temp_list = abjad.TimespanList([
