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