def _make_music(self, divisions, seeds):
from abjad.tools import rhythmmakertools
selections = []
for division in divisions:
assert isinstance(division, durationtools.Division), division
for division in divisions:
container = self._make_container(division)
selection = selectiontools.Selection(container)
selections.append(selection)
beam_specifier = self.beam_specifier
if not beam_specifier:
beam_specifier = rhythmmakertools.BeamSpecifier()
if beam_specifier.beam_divisions_together:
durations = []
for selection in selections:
duration = selection.get_duration()
durations.append(duration)
beam = spannertools.DuratedComplexBeam(
durations=durations,
span_beam_count=1,
nibs_towards_nonbeamable_components=False,
)
components = []
for selection in selections:
components.extend(selection)
attach(beam, components)
elif beam_specifier.beam_each_division:
for selection in selections:
beam = spannertools.MultipartBeam()
attach(beam, selection)
return selections
def _apply_beam_specifier(self, selections):
from abjad.tools import rhythmmakertools
beam_specifier = self.beam_specifier
if beam_specifier is None:
beam_specifier = rhythmmakertools.BeamSpecifier()
if beam_specifier.beam_divisions_together:
durations = []
for x in selections:
if isinstance(x, selectiontools.Selection):
duration = x.get_duration()
else:
duration = x._get_duration()
durations.append(duration)
beam = spannertools.DuratedComplexBeam(
durations=durations,
span_beam_count=1,
)
components = []
for x in selections:
if isinstance(x, selectiontools.Selection):
components.extend(x)
elif isinstance(x, scoretools.Tuplet):
components.append(x)
else:
raise TypeError(x)
attach(beam, components)
elif beam_specifier.beam_each_division:
for cell in selections:
beam = spannertools.MultipartBeam()
attach(beam, cell)
def _beam_rhythm_containers(self, rhythm_containers):
beam_specifier = self.source_expression.beam_specifier
beam_specifier = beam_specifier or rhythmmakertools.BeamSpecifier()
beam_divisions_together = beam_specifier.beam_divisions_together
beam_each_division = beam_specifier.beam_each_division
if beam_divisions_together:
for container in iterate(rhythm_containers).by_class():
spanners = container._get_spanners(spannertools.Beam)
for spanner in spanners:
spanner._sever_all_components()
durations = [x._get_duration() for x in rhythm_containers]
beam = spannertools.DuratedComplexBeam(
durations=durations,
span_beam_count=1,
)
attach(beam, rhythm_containers)
elif beam_each_division:
for container in iterate(rhythm_containers).by_class():
spanners = container._get_spanners(spannertools.Beam)
for spanner in spanners:
spanner._sever_all_components()
for rhythm_container in rhythm_containers:
duration = rhythm_container._get_duration()
beam = spannertools.DuratedComplexBeam(
durations=[duration],
span_beam_count=1,
)
attach(beam, rhythm_container)
def test_systemtools_StorageFormatAgent_get_import_statements_04():
subject = rhythmmakertools.IncisedRhythmMaker(
incise_specifier=rhythmmakertools.InciseSpecifier(
prefix_talea=(1, ),
prefix_counts=(0, ),
suffix_talea=(1, ),
suffix_counts=(1, ),
talea_denominator=16,
body_ratio=mathtools.Ratio((1, )),
outer_divisions_only=True,
),
beam_specifier=rhythmmakertools.BeamSpecifier(
beam_each_division=False,
beam_divisions_together=False,
),
duration_spelling_specifier=rhythmmakertools.DurationSpellingSpecifier(
decrease_durations_monotonically=True,
forbidden_written_duration=durationtools.Duration(1, 2),
),
tuplet_spelling_specifier=rhythmmakertools.TupletSpellingSpecifier(
avoid_dots=True,
is_diminution=True,
simplify_redundant_tuplets=True,
),
)
agent = systemtools.StorageFormatAgent(subject)
assert agent.get_import_statements() == (
'from abjad.tools import durationtools',
'from abjad.tools import mathtools',
'from abjad.tools import rhythmmakertools',
)
def test_rhythmmakertools_DurationSpecifier_01():
r'''DurationSpecifier does not leave parent references.
'''
beam_specifier = rhythmmakertools.BeamSpecifier(
beam_each_division=True,
beam_divisions_together=False,
use_feather_beams=False,
)
duration_specifier = rhythmmakertools.DurationSpecifier(
decrease_monotonic=True,
forbid_meter_rewriting=False,
rewrite_meter=True,
spell_metrically='unassignable',
)
logical_tie_masks = [abjad.silence([0], 2)]
talea = rhythmmakertools.Talea(counts=[1, 2, 3, 4], denominator=16)
maker = rhythmmakertools.TaleaRhythmMaker(
beam_specifier=beam_specifier,
duration_specifier=duration_specifier,
logical_tie_masks=logical_tie_masks,
talea=talea,
)
divisions = [abjad.TimeSignature((3, 8)), abjad.TimeSignature((2, 4)), abjad.TimeSignature((5, 16))]
result = maker(divisions)
staff = abjad.Staff(result)
assert format(staff) == abjad.String.normalize(
r"""
\new Staff
{
r16
c'16
~
[
c'16
]
r8.
c'4
r16
c'16
~
[
c'16
]
r16
r8
c'8.
}
""")
def _get_beam_specifier(self):
from abjad.tools import rhythmmakertools
if self.beam_specifier is not None:
return self.beam_specifier
return rhythmmakertools.BeamSpecifier()
def _make_music(self, divisions, seeds):
from abjad.tools import rhythmmakertools
input_ = self._prepare_input(seeds)
prefix_talea = input_[0]
prefix_counts = input_[1]
suffix_talea = input_[2]
suffix_counts = input_[3]
extra_counts_per_division = input_[4]
split_divisions_by_counts = input_[5]
taleas = (
prefix_talea,
suffix_talea,
extra_counts_per_division,
split_divisions_by_counts,
)
if self.incise_specifier is not None:
talea_denominator = self.incise_specifier.talea_denominator
else:
talea_denominator = None
input_ = self._scale_taleas(
divisions,
talea_denominator,
taleas,
)
divisions = input_[0]
lcd = input_[1]
prefix_talea = input_[2]
suffix_talea = input_[3]
extra_counts_per_division = input_[4]
split_divisions_by_counts = input_[5]
secondary_divisions = self._make_secondary_divisions(
divisions, split_divisions_by_counts)
incise_specifier = self.incise_specifier
if incise_specifier is None:
incise_specifier = rhythmmakertools.InciseSpecifier()
if not incise_specifier.outer_divisions_only:
numeric_map = self._make_division_incised_numeric_map(
secondary_divisions,
prefix_talea,
prefix_counts,
suffix_talea,
suffix_counts,
extra_counts_per_division,
)
else:
assert incise_specifier.outer_divisions_only
numeric_map = self._make_output_incised_numeric_map(
secondary_divisions,
prefix_talea,
prefix_counts,
suffix_talea,
suffix_counts,
extra_counts_per_division,
)
result = []
selections = \
self._numeric_map_and_talea_denominator_to_leaf_selections(
numeric_map, lcd)
if not self.extra_counts_per_division:
result.extend(selections)
else:
tuplets = self._make_tuplets(
secondary_divisions,
selections,
)
result.extend(tuplets)
assert self._all_are_tuplets_or_all_are_leaf_selections(result)
beam_specifier = self.beam_specifier
if beam_specifier is None:
beam_specifier = rhythmmakertools.BeamSpecifier()
if beam_specifier.beam_divisions_together:
beam = spannertools.MultipartBeam()
attach(beam, result)
elif beam_specifier.beam_each_division:
for x in result:
beam = spannertools.MultipartBeam()
attach(beam, x)
selections = [selectiontools.Selection(x) for x in result]
selections = self._apply_output_masks(selections)
return selections
start_dynamic_tokens='f mf mp',
stop_dynamic_tokens='p',
),
percussion_staff=abbreviations.percussion_staff,
text_spanner=consort.AttachmentExpression(
attachments=abbreviations.make_text_spanner('shaker'),
selector=selectortools.Selector().by_leaf(),
),
),
color='blue',
labels=['shakers'],
pitch_handler=consort.AbsolutePitchHandler(
pitches_are_nonsemantic=True,
),
rhythm_maker=rhythmmakertools.AccelerandoRhythmMaker(
beam_specifier=rhythmmakertools.BeamSpecifier(
use_feather_beams=True,
),
duration_spelling_specifier=rhythmmakertools.DurationSpellingSpecifier(
forbid_meter_rewriting=True,
),
interpolation_specifiers=rhythmmakertools.InterpolationSpecifier(
start_duration=durationtools.Duration(1, 32),
stop_duration=durationtools.Duration(1, 8),
written_duration=durationtools.Duration(1, 32),
),
tuplet_spelling_specifier=rhythmmakertools.TupletSpellingSpecifier(
use_note_duration_bracket=True,
),
),
)
