TaleaRhythmMaker

digraph InheritanceGraph { graph [bgcolor=transparent, color=lightsteelblue2, fontname=Arial, fontsize=10, outputorder=edgesfirst, overlap=prism, penwidth=2, rankdir=LR, splines=spline, style="dashed, rounded", truecolor=true]; node [colorscheme=pastel19, fontname=Arial, fontsize=10, height=0, penwidth=2, shape=box, style="filled, rounded", width=0]; edge [color=lightslategrey, penwidth=1]; subgraph "cluster_abjad.system" { graph [label="abjad.system"]; node [color=1]; "abjad.system.AbjadObject.AbjadObject" [URL="../api/abjadext/rmakers/../../abjad/system/AbjadObject.html#abjad.system.AbjadObject.AbjadObject", label="Abjad\nObject", target=_top]; "abjad.system.AbjadValueObject.AbjadValueObject" [URL="../api/abjadext/rmakers/../../abjad/system/AbjadValueObject.html#abjad.system.AbjadValueObject.AbjadValueObject", label="Abjad\nValue\nObject", target=_top]; "abjad.system.AbjadObject.AbjadObject" -> "abjad.system.AbjadValueObject.AbjadValueObject"; } subgraph "cluster_abjadext.rmakers" { graph [label="abjadext.rmakers"]; node [color=2]; "abjadext.rmakers.RhythmMaker.RhythmMaker" [URL="../api/abjadext/rmakers/RhythmMaker.html#abjadext.rmakers.RhythmMaker.RhythmMaker", label="Rhythm\nMaker", target=_top]; "abjadext.rmakers.TaleaRhythmMaker.TaleaRhythmMaker" [URL="../api/abjadext/rmakers/TaleaRhythmMaker.html#abjadext.rmakers.TaleaRhythmMaker.TaleaRhythmMaker", color=black, fontcolor=white, label="Talea\nRhythm\nMaker", target=_top]; "abjadext.rmakers.RhythmMaker.RhythmMaker" -> "abjadext.rmakers.TaleaRhythmMaker.TaleaRhythmMaker"; } subgraph cluster_builtins { graph [label=builtins]; node [color=3]; "builtins.object" [URL="https://docs.python.org/3.6/library/functions.html#object", label=object, target=_top]; } "abjad.system.AbjadValueObject.AbjadValueObject" -> "abjadext.rmakers.RhythmMaker.RhythmMaker"; "builtins.object" -> "abjad.system.AbjadObject.AbjadObject"; }

class abjadext.rmakers.TaleaRhythmMaker.TaleaRhythmMaker(*, talea=None, beam_specifier=None, burnish_specifier=None, division_masks=None, duration_specifier=None, extra_counts_per_division=None, logical_tie_masks=None, read_talea_once_only=None, rest_tied_notes=None, split_divisions_by_counts=None, tie_specifier=None, tie_split_notes=True, tuplet_specifier=None)

Talea rhythm-maker.

Repeats talea of 1/16, 2/16, 3/16, 4/16:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Follows the configure-once / call-repeatedly pattern shown here.

Object model of a partially evaluated function. Function accepts a list of divisions as input. Function returns a list of selections as output. Length of input equals length of output.


Attributes Summary

__call__ Calls talea rhythm-maker on divisions.
__format__ Formats talea rhythm-maker.
__illustrate__ Illustrates talea rhythm-maker.
__repr__ Gets interpreter representation.
beam_specifier Gets beam specifier.
burnish_specifier Gets burnish specifier.
division_masks Gets division masks.
duration_specifier Gets duration specifier.
extra_counts_per_division Gets extra counts per division.
logical_tie_masks Gets logical tie masks.
read_talea_once_only Is true when rhythm-maker should read talea once only.
rest_tied_notes Is true when rhythm-maker should leave the head of each logical tie but change tied notes to rests and remove ties.
split_divisions_by_counts Gets secondary divisions.
state Gets state dictionary.
talea Gets talea.
tie_specifier Gets tie specifier.
tie_split_notes Is true when talea rhythm-maker should tie split notes.
tuplet_specifier Gets tuplet specifier.

Special methods

__call__(divisions, previous_state=None)

Calls talea rhythm-maker on divisions.

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> for selection in selections:
...     selection
... 
Selection([Note("c'16"), Note("c'8"), Note("c'8.")])
Selection([Note("c'4"), Note("c'16"), Note("c'8"), Note("c'16")])
Selection([Note("c'8"), Note("c'4")])
Selection([Note("c'16"), Note("c'8"), Note("c'8."), Note("c'8")])
Return type:List[Selection]
(AbjadValueObject).__copy__(*arguments)

Copies Abjad value object.

Returns new Abjad value object.

(AbjadValueObject).__eq__(argument)

Is true when all initialization values of Abjad value object equal the initialization values of argument.

Returns true or false.

__format__(format_specification='')

Formats talea rhythm-maker.

Formats talea rhythm-maker:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> abjad.f(rhythm_maker)
abjadext.rmakers.TaleaRhythmMaker(
    talea=abjadext.rmakers.Talea(
        counts=[1, 2, 3, 4],
        denominator=16,
        ),
    )

Storage formats talea rhythm-maker:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> abjad.f(rhythm_maker)
abjadext.rmakers.TaleaRhythmMaker(
    talea=abjadext.rmakers.Talea(
        counts=[1, 2, 3, 4],
        denominator=16,
        ),
    )
Return type:str
(AbjadValueObject).__hash__()

Hashes Abjad value object.

Returns integer.

__illustrate__(divisions=[(3, 8), (4, 8), (3, 16), (4, 16)])

Illustrates talea rhythm-maker.

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> abjad.show(rhythm_maker) 

Defaults divisions to 3/8, 4/8, 3/16, 4/16.

Returns LilyPond file.

Return type:LilyPondFile
__repr__()

Gets interpreter representation.

>>> abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
TaleaRhythmMaker(talea=Talea(counts=[1, 2, 3, 4], denominator=16))

Returns string.

Return type:str

Read-only properties

beam_specifier

Gets beam specifier.

Beams each division:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1],
...         denominator=16,
...         ),
...     beam_specifier=abjadext.rmakers.BeamSpecifier(
...         beam_each_division=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Beams divisions together:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1],
...         denominator=16,
...         ),
...     beam_specifier=abjadext.rmakers.BeamSpecifier(
...         beam_divisions_together=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Beams nothing:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1],
...         denominator=16,
...         ),
...     beam_specifier=abjadext.rmakers.BeamSpecifier(
...         beam_each_division=False,
...         beam_divisions_together=False,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Does not beam rests:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 1, 1, -1],
...         denominator=16,
...         ),
...     beam_specifier=abjadext.rmakers.BeamSpecifier(
...         beam_each_division=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Does beam rests:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 1, 1, -1],
...         denominator=16,
...         ),
...     beam_specifier=abjadext.rmakers.BeamSpecifier(
...         beam_each_division=True,
...         beam_rests=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Beams rests with stemlets:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 1, 1, -1],
...         denominator=16,
...         ),
...     beam_specifier=abjadext.rmakers.BeamSpecifier(
...         beam_each_division=True,
...         beam_rests=True,
...         stemlet_length=0.75,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
Return type:Optional[BeamSpecifier]
burnish_specifier

Gets burnish specifier.

Forces the first leaf and the last two leaves to be rests:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     burnish_specifier=abjadext.rmakers.BurnishSpecifier(
...         left_classes=[abjad.Rest],
...         left_counts=[1],
...         right_classes=[abjad.Rest],
...         right_counts=[2],
...         outer_divisions_only=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Forces the first leaf of every division to be a rest:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     burnish_specifier=abjadext.rmakers.BurnishSpecifier(
...         left_classes=[abjad.Rest],
...         left_counts=[1],
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
Return type:Optional[BurnishSpecifier]
division_masks

Gets division masks.

No division masks:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Silences every other output division:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     division_masks=[
...         abjadext.rmakers.SilenceMask(
...             pattern=abjad.index([1], 2),
...             ),
...         ],
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Sustains every other output division:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     division_masks=[
...         abjadext.rmakers.sustain([1], 2),
...         ],
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Silences every other secondary output division:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1],
...         denominator=16,
...         ),
...     split_divisions_by_counts=[9],
...     division_masks=[
...         abjadext.rmakers.SilenceMask(
...             pattern=abjad.index([1], 2),
...             ),
...         ],
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Sustains every other secondary output division:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1],
...         denominator=16,
...         ),
...     split_divisions_by_counts=[9],
...     division_masks=[
...         abjadext.rmakers.sustain([1], 2),
...         ],
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

REGRESSION. Nonperiodic division masks respect state.

Only divisions 0 and 2 are masked here:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, 1, 2],
...     division_masks=[abjadext.rmakers.silence([0, 2, 7])],
...     talea=abjadext.rmakers.Talea(
...         counts=[4],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         extract_trivial=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 4),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 8),
        ('talea_weight_consumed', 31),
        ]
    )

Only division 7 is masked here:

>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions, previous_state=state)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 8),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 15),
        ('talea_weight_consumed', 63),
        ]
    )

REGRESSION. Periodic division masks also respect state.

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, 1, 2],
...     division_masks=[abjadext.rmakers.silence([2], period=3)],
...     talea=abjadext.rmakers.Talea(
...         counts=[4],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         extract_trivial=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 4),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 8),
        ('talea_weight_consumed', 31),
        ]
    )

Incomplete first note is masked here:

>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions, previous_state=state)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 8),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 15),
        ('talea_weight_consumed', 63),
        ]
    )
Return type:Optional[PatternTuple]
duration_specifier

Gets duration specifier.

Several duration specifier configurations are available.

Spells nonassignable durations with monontonically decreasing durations:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5],
...         denominator=16,
...         ),
...     duration_specifier=abjadext.rmakers.DurationSpecifier(
...         decrease_monotonic=True,
...         ),
...     )
>>> divisions = [(5, 8), (5, 8), (5, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Spells nonassignable durations with monontonically increasing durations:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5],
...         denominator=16,
...         ),
...     duration_specifier=abjadext.rmakers.DurationSpecifier(
...         decrease_monotonic=False,
...         ),
...     )
>>> divisions = [(5, 8), (5, 8), (5, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Forbids no durations:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 1, 1, 1, 4, 4],
...         denominator=16,
...         ),
...     duration_specifier=abjadext.rmakers.DurationSpecifier(
...         forbidden_duration=None,
...         ),
...     )
>>> divisions = [(3, 4), (3, 4)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Forbids durations equal to 1/4 or greater:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 1, 1, 1, 4, 4],
...         denominator=16,
...         ),
...     duration_specifier=abjadext.rmakers.DurationSpecifier(
...         forbidden_duration=(1, 4),
...         ),
...     )
>>> divisions = [(3, 4), (3, 4)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Rewrites forbidden durations with smaller durations tied together.

Spells all durations metrically:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5, 4],
...         denominator=16,
...         ),
...     duration_specifier=abjadext.rmakers.DurationSpecifier(
...         spell_metrically=True,
...         ),
...     )
>>> divisions = [(3, 4), (3, 4), (3, 4)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Spells unassignable durations metrically:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5, 4],
...         denominator=16,
...         ),
...     duration_specifier=abjadext.rmakers.DurationSpecifier(
...         spell_metrically='unassignable',
...         ),
...     )
>>> divisions = [(3, 4), (3, 4), (3, 4)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Rewrites meter:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5, 4],
...         denominator=16,
...         ),
...     duration_specifier=abjadext.rmakers.DurationSpecifier(
...         rewrite_meter=True,
...         ),
...     )
>>> divisions = [(3, 4), (3, 4), (3, 4)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
Return type:Optional[DurationSpecifier]
extra_counts_per_division

Gets extra counts per division.

No extra counts per division:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Adds one extra count to every other division:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     extra_counts_per_division=[0, 1],
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Adds two extra counts to every other division:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     extra_counts_per_division=[0, 2],
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

The duration of each added count equals the duration of each count in the rhythm-maker’s input talea.

Removes one count from every other division:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     extra_counts_per_division=[0, -1],
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
Return type:Optional[List[int]]
logical_tie_masks

Gets logical tie masks.

Silences every third logical tie:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     logical_tie_masks=[
...         abjadext.rmakers.silence([2], 3),
...         ],
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Silences the first and last logical ties:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     logical_tie_masks=[
...         abjadext.rmakers.silence([0]),
...         abjadext.rmakers.silence([-1]),
...         ],
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

REGRESSION. Nonperiodic logical tie masks respect state.

Only logical ties 0 and 2 are masked here:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, 1, 2],
...     logical_tie_masks=[abjadext.rmakers.silence([0, 2, 12])],
...     talea=abjadext.rmakers.Talea(
...         counts=[4],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         extract_trivial=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 4),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 8),
        ('talea_weight_consumed', 31),
        ]
    )

Only logical tie 12 is masked here:

>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions, previous_state=state)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 8),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 16),
        ('talea_weight_consumed', 63),
        ]
    )

REGRESSION. Periodic logical tie masks also respect state.

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, 1, 2],
...     logical_tie_masks=[
...         abjadext.rmakers.silence([3], period=4),
...     ],
...     talea=abjadext.rmakers.Talea(
...         counts=[4],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         extract_trivial=True,
...         ),
...     )

Incomplete last note is masked here:

>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 4),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 8),
        ('talea_weight_consumed', 31),
        ]
    )

Incomplete first note is masked here:

>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions, previous_state=state)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 8),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 16),
        ('talea_weight_consumed', 63),
        ]
    )
Return type:Optional[PatternTuple]
(RhythmMaker).previous_state

Gets previous state dictionary.

Return type:OrderedDict
read_talea_once_only

Is true when rhythm-maker should read talea once only.

Reads talea cyclically:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Reads talea once only:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     read_talea_once_only=True,
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )

Calling rhythm_maker on these divisions raises an exception because talea is too short to read once only:

>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> rhythm_maker(divisions)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Users/josiah/Source/github.com/Abjad/abjad-ext-rmakers/abjadext/rmakers/TaleaRhythmMaker.py", line 182, in __call__
    previous_state=previous_state,
  File "/Users/josiah/Source/github.com/Abjad/abjad-ext-rmakers/abjadext/rmakers/RhythmMaker.py", line 82, in __call__
    selections = self._make_music(divisions)
  File "/Users/josiah/Source/github.com/Abjad/abjad-ext-rmakers/abjadext/rmakers/TaleaRhythmMaker.py", line 539, in _make_music
    counts['extra_counts_per_division'],
  File "/Users/josiah/Source/github.com/Abjad/abjad-ext-rmakers/abjadext/rmakers/TaleaRhythmMaker.py", line 612, in _make_numeric_map
    prolated_numerators,
  File "/Users/josiah/Source/github.com/Abjad/abjad-ext-rmakers/abjadext/rmakers/TaleaRhythmMaker.py", line 695, in _split_talea_extended_to_weights
    raise Exception(message)
Exception: () + (1, 2, 3, 4) is too short to read [6, 6, 6, 6] once.

Set to true to ensure talea is long enough to cover all divisions without repeating.

Provides way of using talea noncyclically when, for example, interpolating from short durations to long durations.

Return type:Optional[bool]
rest_tied_notes

Is true when rhythm-maker should leave the head of each logical tie but change tied notes to rests and remove ties.

Does not rest tied notes:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Rests tied notes:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     rest_tied_notes=True,
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
Return type:Optional[bool]
split_divisions_by_counts

Gets secondary divisions.

Note

Deprecated. Preprocess divisions by hand instead.

Secondary divisions impose a cyclic split operation on divisions.

Here’s a talea equal to two thirty-second notes repeating indefinitely. Output equals four divisions of 12 thirty-second notes each:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[2],
...         denominator=32,
...         ),
...     )
>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Here’s the same talea with secondary divisions set to split the divisions every 17 thirty-second notes. The rhythm_maker makes six divisions with durations equal, respectively, to 12, 5, 7, 10, 2 and 12 thirty-second notes.

Note that 12 + 5 = 17 and 7 + 10 = 17:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[2],
...         denominator=32,
...         ),
...     split_divisions_by_counts=[17],
...     )
>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Additional divisions created when using split_divisions_by_counts are subject to extra_counts_per_division just like other divisions.

This example adds one extra thirty-second note to every other division. The durations of the divisions remain the same as in the previous example. But now every other division is tupletted:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[2],
...         denominator=32,
...         ),
...     split_divisions_by_counts=[17],
...     extra_counts_per_division=[0, 1],
...     )
>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
Return type:Optional[Tuple[int, …]]
state

Gets state dictionary.

Consumes 4 divisions and 31 counts:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, 1, 2],
...     talea=abjadext.rmakers.Talea(
...         counts=[4],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         extract_trivial=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 4),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 8),
        ('talea_weight_consumed', 31),
        ]
    )

Advances 4 divisions and 31 counts; then consumes another 4 divisions and 31 counts:

>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions, previous_state=state)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 8),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 16),
        ('talea_weight_consumed', 63),
        ]
    )

Advances 8 divisions and 62 counts; then consumes 4 divisions and 31 counts:

>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions, previous_state=state)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
>>> state = rhythm_maker.state
>>> abjad.f(state)
abjad.OrderedDict(
    [
        ('divisions_consumed', 12),
        ('incomplete_last_note', True),
        ('logical_ties_produced', 24),
        ('talea_weight_consumed', 96),
        ]
    )
Return type:OrderedDict
talea

Gets talea.

No talea:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker()
>>> divisions = [(3, 8), (3, 8), (3, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Working with preamble.

Preamble less than total duration:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[8, -4, 8],
...         denominator=32,
...         preamble=[1, 1, 1, 1],
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Preamble more than total duration; ignores counts:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[8, -4, 8],
...         denominator=32,
...         preamble=[32, 32, 32, 32],
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
Return type:Optional[Talea]
tie_specifier

Gets tie specifier.

Does not tie across divisions:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5, 3, 3, 3],
...         denominator=16,
...         ),
...     )
>>> divisions = [(4, 8), (3, 8), (4, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Ties across divisions:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5, 3, 3, 3],
...         denominator=16,
...         ),
...     tie_specifier=abjadext.rmakers.TieSpecifier(
...         tie_across_divisions=True,
...         ),
...     )
>>> divisions = [(4, 8), (3, 8), (4, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Patterns ties across divisions:

>>> pattern = abjad.Pattern(
...     indices=[0],
...     period=2,
...     )
>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5, 3, 3, 3],
...         denominator=16,
...         ),
...     tie_specifier=abjadext.rmakers.TieSpecifier(
...         tie_across_divisions=pattern,
...         ),
...     )
>>> divisions = [(4, 8), (3, 8), (4, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Uses repeat ties:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5, 3, 3, 3],
...         denominator=16,
...         ),
...     tie_specifier=abjadext.rmakers.TieSpecifier(
...         tie_across_divisions=True,
...         repeat_ties=True,
...         ),
...     )
>>> divisions = [(4, 8), (3, 8), (4, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Ties consecutive notes:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     talea=abjadext.rmakers.Talea(
...         counts=[5, -3, 3, 3],
...         denominator=16,
...         ),
...     tie_specifier=abjadext.rmakers.TieSpecifier(
...         tie_consecutive_notes=True,
...         ),
...     )
>>> divisions = [(4, 8), (3, 8), (4, 8), (3, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
Return type:Optional[TieSpecifier]
tie_split_notes

Is true when talea rhythm-maker should tie split notes.

Todo

Add examples.

Return type:Optional[bool]
tuplet_specifier

Gets tuplet specifier.

Working with denominator.

Reduces terms in tuplet ratio to relative primes when no tuplet specifier is given:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[1, 1, 2, 2],
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

REGRESSION. Spells tuplet denominator in terms of duration when denominator is given as a duration:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[1, 1, 2, 2],
...     talea=abjadext.rmakers.Talea(
...         counts=[1, 2, 3, 4],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         denominator=(1, 16),
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Working with diminution.

Makes diminished tuplets when diminution is true (or when no tuplet specifier is given):

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, -1],
...     talea=abjadext.rmakers.Talea(
...         counts=[1],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         extract_trivial=True,
...         ),
...     )
>>> divisions = [(1, 4), (1, 4), (1, 4), (1, 4), (1, 4), (1, 4)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Makes augmented tuplets when diminution is set to false:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, -1],
...     talea=abjadext.rmakers.Talea(
...         counts=[1],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         diminution=False,
...         extract_trivial=True,
...         ),
...     )
>>> divisions = [(1, 4), (1, 4), (1, 4), (1, 4), (1, 4), (1, 4)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Working with trivialize.

Leaves trivializable tuplets as-is when no tuplet specifier is given. The tuplets in measures 2 and 4 can be written as trivial tuplets, but they are not:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, 4],
...     talea=abjadext.rmakers.Talea(
...         counts=[3, 3, 6, 6],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Rewrites trivializable tuplets as trivial (1:1) tuplets when trivialize is true:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, 4],
...     talea=abjadext.rmakers.Talea(
...         counts=[3, 3, 6, 6],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         trivialize=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

REGRESSION #907a. Rewrites trivializable tuplets even when tuplets contain multiple ties:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, 4],
...     talea=abjadext.rmakers.Talea(
...         counts=[3, 3, 6, 6],
...         denominator=16,
...         ),
...     tie_specifier=abjadext.rmakers.TieSpecifier(
...         tie_across_divisions=True,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         trivialize=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

REGRESSION #907b. Rewrites trivializable tuplets even when tuplets contain very long ties:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[0, 4],
...     talea=abjadext.rmakers.Talea(
...         counts=[3, 3, 6, 6],
...         denominator=16,
...         ),
...     tie_specifier=abjadext.rmakers.TieSpecifier(
...         tie_across_divisions=True,
...         tie_consecutive_notes=True,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         trivialize=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Working with rewrite_rest_filled.

Makes rest-filled tuplets when rewrite_rest_filled is false (or when no tuplet specifier is given):

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[1, 0],
...     talea=abjadext.rmakers.Talea(
...         counts=[3, 3, -6, -6],
...         denominator=16,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 

Rewrites rest-filled tuplets when rewrite_rest_filled is true:

>>> rhythm_maker = abjadext.rmakers.TaleaRhythmMaker(
...     extra_counts_per_division=[1, 0],
...     talea=abjadext.rmakers.Talea(
...         counts=[3, 3, -6, -6],
...         denominator=16,
...         ),
...     tuplet_specifier=abjadext.rmakers.TupletSpecifier(
...         rewrite_rest_filled=True,
...         ),
...     )
>>> divisions = [(3, 8), (4, 8), (3, 8), (4, 8)]
>>> selections = rhythm_maker(divisions)
>>> lilypond_file = abjad.LilyPondFile.rhythm(
...     selections,
...     divisions,
...     )
>>> abjad.show(lilypond_file) 
Return type:Optional[TupletSpecifier]