def __iter__(self) -> typing.Generator:
r'''Iterates talea.
.. container:: example
>>> talea = abjad.rhythmmakertools.Talea(
... counts=[2, 1, 3, 2, 4, 1, 1],
... denominator=16,
... preamble=[1, 1, 1, 1],
... )
>>> for duration in talea:
... duration
...
Duration(1, 16)
Duration(1, 16)
Duration(1, 16)
Duration(1, 16)
Duration(1, 8)
Duration(1, 16)
Duration(3, 16)
Duration(1, 8)
Duration(1, 4)
Duration(1, 16)
Duration(1, 16)
'''
for count in self.preamble or []:
duration = Duration(count, self.denominator)
yield duration
for count in self.counts or []:
duration = Duration(count, self.denominator)
yield duration
def _get_timespan(self, in_seconds=False):
if len(self):
timespan_ = self[0]._get_timespan(in_seconds=in_seconds)
start_offset = timespan_.start_offset
timespan_ = self[-1]._get_timespan(in_seconds=in_seconds)
stop_offset = timespan_.stop_offset
else:
start_offset = Duration(0)
stop_offset = Duration(0)
return Timespan(
start_offset=start_offset,
stop_offset=stop_offset,
)
def _set_duration(self, new_duration, repeat_ties=False):
import abjad
new_duration = Duration(new_duration)
# change LilyPond multiplier if leaf already has LilyPond multiplier
if self._get_indicators(Multiplier):
detach(Multiplier, self)
multiplier = new_duration.__div__(self.written_duration)
attach(multiplier, self)
return select(self)
# change written duration if new duration is assignable
try:
self.written_duration = new_duration
return select(self)
except AssignabilityError:
pass
# make new notes or tuplets if new duration is nonassignable
maker = abjad.NoteMaker(repeat_ties=repeat_ties, )
components = maker(0, new_duration)
if isinstance(components[0], abjad.Leaf):
tied_leaf_count = len(components) - 1
tied_leaves = tied_leaf_count * self
all_leaves = [self] + tied_leaves
for leaf, component in zip(all_leaves, components):
leaf.written_duration = component.written_duration
self._splice(tied_leaves, grow_spanners=True)
parentage = abjad.inspect(self).get_parentage()
if not abjad.inspect(parentage).get_spanners(abjad.Tie):
tie = abjad.Tie()
if tie._attachment_test(self):
tie = abjad.Tie(repeat=repeat_ties)
attach(tie, all_leaves)
return select(all_leaves)
else:
assert isinstance(components[0], abjad.Tuplet)
tuplet = components[0]
components = tuplet[:]
tied_leaf_count = len(components) - 1
tied_leaves = tied_leaf_count * self
all_leaves = [self] + tied_leaves
for leaf, component in zip(all_leaves, components):
leaf.written_duration = component.written_duration
self._splice(tied_leaves, grow_spanners=True)
if not self._get_spanners(abjad.Tie):
tie = abjad.Tie()
if tie._attachment_test(self):
tie = abjad.Tie(repeat=repeat_ties)
attach(tie, all_leaves)
multiplier = tuplet.multiplier
tuplet = abjad.Tuplet(multiplier, [])
abjad.mutate(all_leaves).wrap(tuplet)
return select(tuplet)
def written_duration(self, argument):
rational = Duration(argument)
if not rational.is_assignable:
message = 'not assignable duration: {!r}.'
message = message.format(rational)
raise AssignabilityError(message)
self._written_duration = rational
def _get_duration_in_seconds(self):
mark = self._get_effective(MetronomeMark)
if mark is not None and not mark.is_imprecise:
result = (self._get_duration() / mark.reference_duration /
mark.units_per_minute * 60)
return Duration(result)
raise MissingMetronomeMarkError
def __init__(self, written_duration):
Component.__init__(self)
self._after_grace_container = None
self._grace_container = None
self._leaf_index = None
self._spanners = []
self.written_duration = Duration(written_duration)
def _get_multiplied_duration(self):
if self.written_duration:
multiplier_prototype = (Multiplier, NonreducedFraction)
if self._get_indicators(multiplier_prototype):
multipliers = self._get_indicators(multiplier_prototype)
if 1 == len(multipliers):
multiplier = multipliers[0]
multiplier = Duration(multiplier)
elif 1 < len(multipliers):
message = 'more than one duration multiplier.'
raise ValueError(message)
multiplied_duration = multiplier * self.written_duration
return multiplied_duration
else:
return Duration(self.written_duration)
else:
return None
def __init__(self, *arguments):
import abjad
from abjad.ly import drums
assert len(arguments) in (0, 1, 2)
if len(arguments) == 1 and isinstance(arguments[0], str):
string = '{{ {} }}'.format(arguments[0])
parsed = abjad.parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
arguments = [parsed[0]]
is_cautionary = False
is_forced = False
is_parenthesized = False
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
leaf = arguments[0]
written_pitch = None
written_duration = leaf.written_duration
if 'written_pitch' in dir(leaf):
written_pitch = leaf.note_head.written_pitch
is_cautionary = leaf.note_head.is_cautionary
is_forced = leaf.note_head.is_forced
is_parenthesized = leaf.note_head.is_parenthesized
elif 'written_pitches' in dir(leaf):
written_pitches = [x.written_pitch for x in leaf.note_heads]
if written_pitches:
written_pitch = written_pitches[0]
is_cautionary = leaf.note_heads[0].is_cautionary
is_forced = leaf.note_heads[0].is_forced
is_parenthesized = leaf.note_heads[0].is_parenthesized
elif len(arguments) == 2:
written_pitch, written_duration = arguments
elif len(arguments) == 0:
written_pitch = 'C4'
written_duration = Duration(1, 4)
else:
message = 'can not initialize note from {!r}.'
raise ValueError(message.format(arguments))
Leaf.__init__(self, written_duration)
if written_pitch is not None:
if written_pitch not in drums:
self.note_head = NoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
self.note_head = DrumNoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
self.note_head = None
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
self._copy_override_and_set_from_leaf(arguments[0])
def _to_tuplet_with_ratio(self, proportions, diminution=True):
import abjad
# check input
proportions = Ratio(proportions)
# find target duration of tuplet
target_duration = self.written_duration
# find basic duration of note in tuplet
basic_prolated_duration = target_duration / sum(proportions.numbers)
# find basic written duration of note in tuplet
basic_written_duration = \
basic_prolated_duration.equal_or_greater_assignable
# find written duration of each note in tuplet
written_durations = [
_ * basic_written_duration for _ in proportions.numbers
]
# make tuplet notes
maker = abjad.NoteMaker()
try:
notes = [abjad.Note(0, x) for x in written_durations]
except AssignabilityError:
denominator = target_duration.denominator
note_durations = [
Duration(_, denominator) for _ in proportions.numbers
]
notes = maker(0, note_durations)
# make tuplet
contents_duration = abjad.inspect(notes).get_duration()
multiplier = target_duration / contents_duration
tuplet = abjad.Tuplet(multiplier, notes)
# normalize tuplet multiplier if necessary
tuplet.normalize_multiplier()
# change prolation if necessary
if not tuplet.multiplier == 1:
if diminution:
if not tuplet.diminution():
tuplet.toggle_prolation()
else:
if tuplet.diminution():
tuplet.toggle_prolation()
# return tuplet
return tuplet
def __init__(
self,
avoid_dots: bool = None,
denominator: typing.Union[str, Duration, int] = None,
diminution: bool = True,
extract_trivial: bool = None,
force_fraction: bool = None,
rewrite_rest_filled: bool = None,
trivialize: bool = None,
use_note_duration_bracket: bool = None,
) -> None:
import abjad
if avoid_dots is not None:
avoid_dots = bool(avoid_dots)
self._avoid_dots = avoid_dots
if isinstance(denominator, tuple):
denominator = Duration(denominator)
self._denominator = denominator
# TODO: Consider renaming diminution=True to augmentation=None.
# That would allow for all keywords to default to None,
# and therefore a single-line storage format.
if diminution is not None:
diminution = bool(diminution)
self._diminution = diminution
if extract_trivial is not None:
extract_trivial = bool(extract_trivial)
self._extract_trivial = extract_trivial
if force_fraction is not None:
force_fraction = bool(force_fraction)
self._force_fraction = force_fraction
if rewrite_rest_filled is not None:
rewrite_rest_fille = bool(rewrite_rest_filled)
self._rewrite_rest_filled = rewrite_rest_filled
if trivialize is not None:
trivialize = bool(trivialize)
self._trivialize = trivialize
if use_note_duration_bracket is not None:
use_note_duration_bracket = bool(use_note_duration_bracket)
self._use_note_duration_bracket = use_note_duration_bracket
def _get_right_markup(self):
if self.right_markup is not None:
return self.right_markup
markup = Duration._to_score_markup(self.right_rhythm)
return markup
def _split_by_durations(
self,
durations,
cyclic=False,
fracture_spanners=False,
tie_split_notes=True,
repeat_ties=False,
):
import abjad
durations = [Duration(_) for _ in durations]
durations = abjad.sequence(durations)
leaf_duration = abjad.inspect(self).get_duration()
if cyclic:
durations = durations.repeat_to_weight(leaf_duration)
if sum(durations) < leaf_duration:
last_duration = leaf_duration - sum(durations)
durations = list(durations)
durations.append(last_duration)
durations = abjad.sequence(durations)
durations = durations.truncate(weight=leaf_duration)
result_selections = []
# detach grace containers
grace_container = self._detach_grace_container()
after_grace_container = self._detach_after_grace_container()
leaf_prolation = abjad.inspect(self).get_parentage().prolation
for duration in durations:
new_leaf = copy.copy(self)
preprolated_duration = duration / leaf_prolation
selection = new_leaf._set_duration(
preprolated_duration,
repeat_ties=repeat_ties,
)
result_selections.append(selection)
result_components = abjad.sequence(result_selections).flatten(depth=-1)
result_components = select(result_components)
result_leaves = select(result_components).leaves()
assert all(isinstance(_, abjad.Selection) for _ in result_selections)
assert all(isinstance(_, Component) for _ in result_components)
assert result_leaves.are_leaves()
if abjad.inspect(self).has_spanner(abjad.Tie):
for leaf in result_leaves:
detach(abjad.Tie, leaf)
# strip result leaves of indicators (other than multipliers)
for leaf in result_leaves:
multiplier = abjad.inspect(leaf).get_indicator(Multiplier)
detach(object, leaf)
if multiplier is not None:
attach(multiplier, leaf)
# replace leaf with flattened result
selection = select(self)
parent, start, stop = selection._get_parent_and_start_stop_indices()
if parent:
parent.__setitem__(slice(start, stop + 1), result_components)
else:
selection._give_dominant_spanners(result_components)
selection._withdraw_from_crossing_spanners()
# fracture spanners
if fracture_spanners:
first_selection = result_selections[0]
for spanner in abjad.inspect(first_selection[-1]).get_spanners():
index = spanner._index(first_selection[-1])
spanner._fracture(index, direction=abjad.Right)
last_selection = result_selections[-1]
for spanner in abjad.inspect(last_selection[0]).get_spanners():
index = spanner._index(last_selection[0])
spanner._fracture(index, direction=abjad.Left)
for middle_selection in result_selections[1:-1]:
spanners = abjad.inspect(middle_selection[0]).get_spanners()
for spanner in spanners:
index = spanner._index(middle_selection[0])
spanner._fracture(index, direction=abjad.Left)
spanners = abjad.inspect(middle_selection[-1]).get_spanners()
for spanner in spanners:
index = spanner._index(middle_selection[-1])
spanner._fracture(index, direction=abjad.Right)
# move indicators
first_result_leaf = result_leaves[0]
last_result_leaf = result_leaves[-1]
for indicator in abjad.inspect(self).get_indicators():
if isinstance(indicator, Multiplier):
continue
detach(indicator, self)
direction = getattr(indicator, '_time_orientation', abjad.Left)
if direction == abjad.Left:
attach(indicator, first_result_leaf)
elif direction == abjad.Right:
attach(indicator, last_result_leaf)
else:
raise ValueError(direction)
# move grace containers
if grace_container is not None:
container = grace_container[0]
assert isinstance(container, abjad.GraceContainer), repr(container)
attach(container, first_result_leaf)
if after_grace_container is not None:
container = after_grace_container[0]
prototype = abjad.AfterGraceContainer
assert isinstance(container, prototype), repr(container)
attach(container, last_result_leaf)
if isinstance(result_components[0], abjad.Tuplet):
abjad.mutate(result_components).fuse()
# tie split notes
if isinstance(self, (abjad.Note, abjad.Chord)) and tie_split_notes:
result_leaves._attach_tie_spanner_to_leaves(
repeat_ties=repeat_ties, )
assert isinstance(result_selections, list), repr(result_selections)
assert all(isinstance(_, abjad.Selection) for _ in result_selections)
return result_selections
def _get_duration_in_seconds(self):
duration = Duration(0)
for leaf in self.leaves:
duration += leaf._get_duration(in_seconds=True)
return duration