def __init__(
self,
cascade_pattern=(1,),
division_masks=None,
fuse_groups=None,
padding=None,
playing_talea=rhythmmakertools.Talea(
counts=[4],
denominator=16,
),
playing_groupings=(1,),
seed=None,
repeat=True,
silence_talea=rhythmmakertools.Talea(
counts=[4],
denominator=16,
),
timespan_specifier=None,
):
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 __init__(
self,
division_masks=None,
padding=None,
seed=None,
timespan_specifier=None,
):
TimespanMaker.__init__(
self,
division_masks=division_masks,
padding=padding,
seed=seed,
timespan_specifier=timespan_specifier,
)
def __init__(
self,
hysteresis=None,
include_inner_starts=None,
include_inner_stops=None,
inspect_music=None,
labels=None,
division_masks=None,
padding=None,
rotation_indices=None,
seed=None,
timespan_specifier=None,
voice_names=None,
):
TimespanMaker.__init__(
self,
division_masks=division_masks,
padding=padding,
seed=seed,
timespan_specifier=timespan_specifier,
)
if hysteresis is not None:
hysteresis = abjad.Duration(hysteresis)
assert 0 < hysteresis
self._hysteresis = hysteresis
if include_inner_starts is not None:
include_inner_starts = bool(include_inner_starts)
self._include_inner_starts = include_inner_starts
if include_inner_stops is not None:
include_inner_stops = bool(include_inner_stops)
self._include_inner_stops = include_inner_stops
if inspect_music is not None:
inspect_music = bool(inspect_music)
self._inspect_music = inspect_music
if rotation_indices is not None:
if not isinstance(rotation_indices, collections.Sequence):
rotation_indices = int(rotation_indices)
rotation_indices = (rotation_indices,)
rotation_indices = tuple(rotation_indices)
self._rotation_indices = rotation_indices
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
def __init__(
self,
start_talea=None,
stop_talea=None,
start_groupings=None,
stop_groupings=None,
start_anchor=Left,
stop_anchor=Left,
labels=None,
division_masks=None,
padding=None,
seed=None,
timespan_specifier=None,
voice_names=None,
):
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, rhythmmakertools.Talea):
start_duration = abjad.Duration(start_talea)
counts = [start_duration.numerator]
denominator = start_duration.denominator
start_talea = rhythmmakertools.Talea(
counts=counts,
denominator=denominator,
)
assert isinstance(start_talea, rhythmmakertools.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, rhythmmakertools.Talea):
stop_duration = abjad.Duration(stop_talea)
counts = [stop_duration.numerator]
denominator = stop_duration.denominator
stop_talea = rhythmmakertools.Talea(
counts=counts,
denominator=denominator,
)
assert isinstance(stop_talea, rhythmmakertools.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 (Left, Right)
self._start_anchor = start_anchor
assert stop_anchor in (Left, Right)
self._stop_anchor = stop_anchor
def __init__(
self,
fuse_groups=None,
initial_silence_talea=None,
division_masks=None,
padding=None,
playing_talea=rhythmmakertools.Talea(
counts=[4],
denominator=16,
),
playing_groupings=(1,),
reflect=None,
repeat=True,
seed=None,
silence_talea=rhythmmakertools.Talea(
counts=[4],
denominator=16,
),
step_anchor=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, rhythmmakertools.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, rhythmmakertools.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.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, rhythmmakertools.Talea)
assert silence_talea.counts
assert all(0 <= x for x in silence_talea.counts)
self._silence_talea = silence_talea
assert step_anchor in (Left, Right)
self._step_anchor = step_anchor
self._synchronize_groupings = bool(synchronize_groupings)
self._synchronize_step = bool(synchronize_step)
