def _apply_output_masks(self, selections):
from abjad.tools import rhythmmakertools
if not self.output_masks:
return selections
new_selections = []
if self.duration_spelling_specifier is None:
duration_spelling_specifier = \
rhythmmakertools.DurationSpellingSpecifier()
decrease_durations_monotonically = \
duration_spelling_specifier.decrease_durations_monotonically
forbidden_written_duration = \
duration_spelling_specifier.forbidden_written_duration
length = len(selections)
output_masks = self.output_masks
for i, selection in enumerate(selections):
if not any(_._matches_index(i, length) for _ in output_masks):
new_selections.append(selection)
continue
duration = selection.get_duration()
new_selection = scoretools.make_leaves(
[None],
[duration],
decrease_durations_monotonically=\
decrease_durations_monotonically,
forbidden_written_duration=forbidden_written_duration,
)
for component in iterate(selection).by_class():
detach(spannertools.Tie, component)
new_selections.append(new_selection)
return new_selections
def _make_container(self, division):
from abjad.tools import rhythmmakertools
duration_spelling_specifier = self.duration_spelling_specifier
if duration_spelling_specifier is None:
duration_spelling_specifier = \
rhythmmakertools.DurationSpellingSpecifier()
forbidden_written_duration = \
duration_spelling_specifier.forbidden_written_duration
time_signature = indicatortools.TimeSignature(division)
implied_prolation = time_signature.implied_prolation
numerator, denominator = division.pair
denominator = mathtools.greatest_power_of_two_less_equal(denominator)
assert mathtools.is_positive_integer_power_of_two(denominator)
exponent = self.exponent or 0
denominator_multiplier = 2**exponent
denominator *= denominator_multiplier
unit_duration = durationtools.Duration(1, denominator)
if forbidden_written_duration is not None:
multiplier = 1
while forbidden_written_duration <= unit_duration:
unit_duration /= 2
multiplier *= 2
numerator *= multiplier
numerator *= denominator_multiplier
notes = scoretools.make_notes(numerator * [0], [unit_duration])
if implied_prolation == 1:
result = scoretools.Container(notes)
else:
multiplier = implied_prolation
result = scoretools.Tuplet(multiplier, notes)
return result
def _make_music(self, divisions, seeds):
from abjad.tools import rhythmmakertools
selections = []
duration_specifier = self.duration_spelling_specifier
if duration_specifier is None:
duration_specifier = rhythmmakertools.DurationSpellingSpecifier()
tuplet_specifier = self.tuplet_spelling_specifier
if tuplet_specifier is None:
tuplet_specifier = rhythmmakertools.TupletSpellingSpecifier()
for division in divisions:
if (duration_specifier.spell_metrically == True or
(duration_specifier.spell_metrically == 'unassignable' and
not mathtools.is_assignable_integer(division.numerator))):
meter = metertools.Meter(division)
rhythm_tree_container = meter.root_node
durations = [_.duration for _ in rhythm_tree_container]
else:
durations = [division]
selection = scoretools.make_leaves(
pitches=0,
durations=durations,
decrease_durations_monotonically=\
duration_specifier.decrease_durations_monotonically,
forbidden_written_duration=\
duration_specifier.forbidden_written_duration,
is_diminution=tuplet_specifier.is_diminution,
)
selections.append(selection)
selections = self._apply_burnish_specifier(selections)
self._apply_beam_specifier(selections)
selections = self._apply_output_masks(selections)
return selections
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 reverse(self):
r'''Reverses rhythm-maker.
Concrete rhythm-makers should override this method.
Returns new rhythm-maker.
'''
from abjad.tools import rhythmmakertools
specifier = self.duration_spelling_specifier
if specifier is None:
specifier = rhythmmakertools.DurationSpellingSpecifier()
specifier = specifier.reverse()
maker = new(
self,
duration_spelling_specifier=specifier,
)
return maker
def _numeric_map_and_talea_denominator_to_leaf_selections(
self, numeric_map, lcd):
from abjad.tools import rhythmmakertools
selections = []
specifier = self.duration_spelling_specifier
if specifier is None:
specifier = rhythmmakertools.DurationSpellingSpecifier()
for numeric_map_part in numeric_map:
numeric_map_part = [
_ for _ in numeric_map_part if _ != durationtools.Duration(0)
]
selection = scoretools.make_leaves_from_talea(
numeric_map_part,
lcd,
forbidden_written_duration=\
specifier.forbidden_written_duration,
decrease_durations_monotonically=\
specifier.decrease_durations_monotonically,
)
selections.append(selection)
return selections
def _get_duration_spelling_specifier(self):
from abjad.tools import rhythmmakertools
if self.duration_spelling_specifier is not None:
return self.duration_spelling_specifier
return rhythmmakertools.DurationSpellingSpecifier()
def reverse(self):
r'''Reverses even-run rhythm-maker.
.. container:: example
::
>>> maker = rhythmmakertools.EvenRunRhythmMaker()
>>> reversed_maker = maker.reverse()
::
>>> print(format(reversed_maker))
rhythmmakertools.EvenRunRhythmMaker(
duration_spelling_specifier=rhythmmakertools.DurationSpellingSpecifier(
decrease_durations_monotonically=False,
),
)
::
>>> divisions = [(4, 8), (3, 4), (2, 4)]
>>> music = maker(divisions)
>>> lilypond_file = rhythmmakertools.make_lilypond_file(
... music,
... divisions,
... )
>>> show(lilypond_file) # doctest: +SKIP
.. doctest::
>>> staff = maker._get_rhythmic_staff(lilypond_file)
>>> f(staff)
\new RhythmicStaff {
{
\time 4/8
{
c'8 [
c'8
c'8
c'8 ]
}
}
{
\time 3/4
{
c'4
c'4
c'4
}
}
{
\time 2/4
{
c'4
c'4
}
}
}
Returns new even-run rhythm-maker.
'''
from abjad.tools import rhythmmakertools
duration_spelling_specifier = self.duration_spelling_specifier
if duration_spelling_specifier is None:
default = rhythmmakertools.DurationSpellingSpecifier()
duration_spelling_specifier = default
duration_spelling_specifier = duration_spelling_specifier.reverse()
maker = new(
self,
duration_spelling_specifier=duration_spelling_specifier,
)
return maker
# -*- encoding: utf-8 -*-
import consort
from abjad.tools import durationtools
from abjad.tools import rhythmmakertools
from abjad.tools import selectortools
left_hand_stasis_music_specifier = consort.MusicSpecifier(
attachment_handler=consort.AttachmentHandler(
trill_spanner=consort.AttachmentExpression(
attachments=(
consort.ConsortTrillSpanner(interval='+m3'),
consort.ConsortTrillSpanner(interval='+P4'),
consort.ConsortTrillSpanner(interval='+m3'),
),
selector=selectortools.Selector().by_leaf(),
), ),
minimum_phrase_duration=durationtools.Duration(1, 4),
pitch_handler=consort.AbsolutePitchHandler(
deviations=(0, 0, 0.5),
pitch_specifier="gs'",
),
rhythm_maker=rhythmmakertools.NoteRhythmMaker(
duration_spelling_specifier=rhythmmakertools.DurationSpellingSpecifier(
forbid_meter_rewriting=True, ), ),
)
def reverse(self):
r'''Reverses note rhythm-maker.
.. container:: example
::
>>> maker = rhythmmakertools.NoteRhythmMaker()
>>> reversed_maker = maker.reverse()
::
>>> print(format(reversed_maker))
rhythmmakertools.NoteRhythmMaker(
duration_spelling_specifier=rhythmmakertools.DurationSpellingSpecifier(
decrease_durations_monotonically=False,
),
)
::
>>> divisions = [(5, 8), (3, 8)]
>>> music = maker(divisions)
>>> lilypond_file = rhythmmakertools.make_lilypond_file(
... music,
... divisions,
... )
>>> show(lilypond_file) # doctest: +SKIP
.. doctest::
>>> staff = maker._get_rhythmic_staff(lilypond_file)
>>> f(staff)
\new RhythmicStaff {
{
\time 5/8
c'2 ~
c'8
}
{
\time 3/8
c'4.
}
}
Defined equal to copy of note rhythm-maker with
`duration_spelling_specifier` reversed.
Returns new note rhythm-maker.
'''
from abjad.tools import rhythmmakertools
duration_spelling_specifier = self.duration_spelling_specifier
if duration_spelling_specifier is None:
default = rhythmmakertools.DurationSpellingSpecifier()
duration_spelling_specifier = default
duration_spelling_specifier = duration_spelling_specifier.reverse()
arguments = {
'duration_spelling_specifier': duration_spelling_specifier,
}
result = new(self, **arguments)
return result
period=4,
), )[0]),
tremolo_trill=consort.AttachmentExpression(
attachments=(
spannertools.ComplexTrillSpanner(interval='+m3'),
spannertools.StemTremoloSpanner(),
spannertools.ComplexTrillSpanner(interval='+m3'),
spannertools.ComplexTrillSpanner(interval='+M2'),
spannertools.StemTremoloSpanner(),
),
selector=selectortools.Selector().by_leaf().by_logical_tie(
pitched=True).by_pattern(
patterntools.Pattern(
indices=[0, 1, 2],
period=4,
), ),
),
),
color='green',
labels=[],
pitch_handler=consort.AbsolutePitchHandler(
pitch_specifier="d' f' d' fqs' ef' d' ef' f' fqs' d' g' d' d' as'",
pitch_application_rate='division',
),
rhythm_maker=rhythmmakertools.EvenDivisionRhythmMaker(
denominators=[8, 4, 8, 1],
duration_spelling_specifier=rhythmmakertools.DurationSpellingSpecifier(
forbidden_written_duration=durationtools.Duration(1, 2), ),
extra_counts_per_division=[0, 1, 0, 2, 1],
))
labels=['pedaled'],
pitch_handler=consort.AbsolutePitchHandler(
forbid_repetitions=True,
pitch_specifier="f c' g' c' f g' c' f c' g' f",
),
rhythm_maker=consort.CompositeRhythmMaker(
last=rhythmmakertools.IncisedRhythmMaker(
incise_specifier=rhythmmakertools.InciseSpecifier(
prefix_counts=[0],
suffix_talea=[1],
suffix_counts=[1],
talea_denominator=16,
),
duration_spelling_specifier=rhythmmakertools.DurationSpellingSpecifier(
forbidden_written_duration=(1, 4),
forbid_meter_rewriting=True,
spell_metrically='unassignable',
),
tie_specifier=rhythmmakertools.TieSpecifier(
strip_ties=True,
),
),
default=rhythmmakertools.EvenDivisionRhythmMaker(
denominators=(4,),
duration_spelling_specifier=rhythmmakertools.DurationSpellingSpecifier(
forbidden_written_duration=(1, 4),
forbid_meter_rewriting=True,
spell_metrically='unassignable',
),
),
),