def __call__(self, logical_ties, timespan=None, offset=0):
r'''Calls note and chord hairpin handler on `logical_ties`
with `offset`.
Returns none.
'''
groups = self._group_contiguous_logical_ties(logical_ties)
for group in groups:
notes = []
for logical_tie in group:
for note in logical_tie:
notes.append(note)
if len(notes) <= 1:
continue
total_notes = len(notes)
notes_to_span = []
for i, note in enumerate(notes):
if self._index_matches_patterns(i, total_notes):
notes_to_span.append(note)
if not notes_to_span:
continue
descriptor = ' '.join([_ for _ in self.hairpin_token if _])
hairpin = spannertools.Hairpin(
descriptor=descriptor,
include_rests=False,
)
attach(hairpin, notes_to_span)
def __call__(self, logical_ties, timespan=None, offset=0):
r'''Calls note and chord hairpin handler on `logical_ties`
with `offset`.
Returns none.
'''
if (self.span == 'contiguous notes and chords'
or isinstance(self.span, (tuple, list))):
groups = self._group_contiguous_logical_ties(logical_ties)
elif self.span == 'nontrivial ties':
groups = [[_] for _ in logical_ties]
else:
raise ValueError(self.span)
if isinstance(self.span, (tuple, list)):
new_groups = []
for group in groups:
leaves = iterate(group).by_class(scoretools.Leaf)
leaves = list(leaves)
shards = sequencetools.partition_sequence_by_counts(
leaves,
counts=self.span,
cyclic=True,
)
new_groups.extend(shards)
groups = new_groups
groups = [[_] for _ in groups]
for group_index, group in enumerate(groups):
notes = []
for logical_tie in group:
for note in logical_tie:
notes.append(note)
if len(notes) == 0:
continue
total_notes = len(notes)
notes_to_span = []
for note_index, note in enumerate(notes):
if self._index_matches_patterns(note_index, total_notes):
notes_to_span.append(note)
if not notes_to_span:
continue
if (len(notes_to_span) == 1
and not self.attach_start_dynamic_to_lone_notes):
continue
if (len(notes_to_span) == 1
and self.attach_start_dynamic_to_lone_notes):
hairpin_token = self.hairpin_token[group_index]
start_dynamic = hairpin_token[0]
dynamic = indicatortools.Dynamic(start_dynamic)
attach(dynamic, notes[0])
continue
hairpin_token = self.hairpin_token[group_index]
descriptor = ' '.join([_ for _ in hairpin_token if _])
hairpin = spannertools.Hairpin(
descriptor=descriptor,
include_rests=False,
)
attach(hairpin, notes_to_span)
def __call__(self, logical_ties, timespan=None, offset=0):
r'''Calls handler on `logical_ties` with `offset`.
Returns none.
'''
hairpin_tokens = datastructuretools.CyclicTuple(self.hairpin_tokens)
logical_tie_groups = self._group_contiguous_logical_ties(logical_ties)
for logical_tie_group in logical_tie_groups:
pairs = sequencetools.iterate_sequence_nwise(
logical_tie_group,
n=2,
)
for i, pair in enumerate(pairs):
hairpin_token = hairpin_tokens[i]
descriptor = ' '.join([_ for _ in hairpin_token if _])
hairpin = spannertools.Hairpin(
descriptor=descriptor,
include_rests=False,
)
first_logical_tie, second_logical_tie = pair
notes = []
notes.extend(first_logical_tie)
notes.append(second_logical_tie.head)
attach(hairpin, notes)
def __call__(self, logical_ties):
r'''Calls hairpin handler on `logical_ties`.
Passes silently when `logical_ties` is empty.
Returns none.
'''
if not logical_ties:
return
if not isinstance(logical_ties[0], selectiontools.LogicalTie):
assert isinstance(logical_ties[0], scoretools.Leaf)
logical_ties = [selectiontools.LogicalTie(_) for _ in logical_ties]
if (self.span == 'contiguous notes and chords'
or isinstance(self.span, (tuple, list))):
groups = self._group_contiguous_logical_ties(logical_ties)
elif self.span == 'nontrivial ties':
groups = [[_] for _ in logical_ties]
else:
raise ValueError(self.span)
if isinstance(self.span, (tuple, list)):
if not self.enchain_hairpins:
groups = self._partition_groups(groups)
else:
groups = self._partition_enchained_groups(groups)
hairpin_tokens = self.hairpin_tokens
for group_index, group in enumerate(groups):
notes = []
for logical_tie in group:
for note in logical_tie:
notes.append(note)
if len(notes) == 0:
continue
total_notes = len(notes)
notes_to_span = []
for note_index, note in enumerate(notes):
if self._index_matches_patterns(note_index, total_notes):
notes_to_span.append(note)
if not notes_to_span:
continue
if self.include_following_rests:
last_note = notes_to_span[-1]
next_leaf = inspect_(last_note).get_leaf(1)
prototype = (scoretools.Rest, scoretools.MultimeasureRest)
if isinstance(next_leaf, prototype):
notes_to_span.append(next_leaf)
if len(notes_to_span) == 1 and self.omit_lone_note_dynamic:
continue
if len(notes_to_span) == 1 and not self.omit_lone_note_dynamic:
hairpin_token = hairpin_tokens[group_index]
start_dynamic = hairpin_token[0]
if start_dynamic == 'niente':
message = 'can not attach niente dynamics to components.'
raise Exception(message)
dynamic = indicatortools.Dynamic(start_dynamic)
attach(dynamic, notes[0])
continue
hairpin_token = hairpin_tokens[group_index]
if hairpin_token is None:
continue
if isinstance(hairpin_token, tuple):
descriptor = ' '.join([_ for _ in hairpin_token if _])
include_rests = bool(self.include_following_rests)
hairpin = spannertools.Hairpin(
descriptor=descriptor,
include_rests=include_rests,
)
attach(hairpin, notes_to_span)
# hook to allow callable custom classes like SwellSpecifier
else:
hairpin_token(notes_to_span)
if self.flare:
first_note = notes_to_span[0]
prototype = scoretools.Note
assert isinstance(first_note, prototype), repr(first_note)
stencil = schemetools.Scheme('flared-hairpin')
override(first_note).hairpin.stencil = stencil
selector=selectortools.Selector().by_logical_tie(
pitched=True).by_duration('==', (1, 16), preprolated=True)[0],
),
shimmer=consort.AttachmentExpression(
attachments=[
[
indicatortools.Articulation('accent'),
indicatortools.Dynamic('fp'),
],
],
selector=selectortools.Selector().by_logical_tie(
pitched=True).by_duration(
'>', (1, 16),
preprolated=True).by_leaf().by_length('==', 1)[0]),
swell=consort.AttachmentExpression(
attachments=spannertools.Hairpin('niente < f'),
selector=selectortools.Selector().by_logical_tie(
pitched=True).by_duration(
'>', (1, 16),
preprolated=True).by_leaf().by_length('>', 1)),
text_spanner=consort.AttachmentExpression(
attachments=abbreviations.make_text_spanner('snare'),
selector=selectortools.select_pitched_runs(),
),
tremolo=consort.AttachmentExpression(
attachments=spannertools.StemTremoloSpanner(),
selector=selectortools.Selector().by_logical_tie(
pitched=True).by_duration('>', (1, 16), preprolated=True)),
),
color='yellow',
labels=[],