def make_mozart_measure(measure_dict):
r'''Makes Mozart measure.
'''
# parse the contents of a measure definition dictionary
# wrap the expression to be parsed inside a LilyPond { } block
treble = parse('{{ {} }}'.format(measure_dict['t']))
bass = parse('{{ {} }}'.format(measure_dict['b']))
return treble, bass
def __init__(self, *args):
from abjad.ly import drums
from abjad.tools import scoretools
from abjad.tools.topleveltools import parse
assert len(args) in (0, 1, 2)
if len(args) == 1 and isinstance(args[0], str):
string = '{{ {} }}'.format(args[0])
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
args = [parsed[0]]
is_cautionary = False
is_forced = False
is_parenthesized = False
if len(args) == 1 and isinstance(args[0], Leaf):
leaf = args[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(args) == 2:
written_pitch, written_duration = args
elif len(args) == 0:
written_pitch = 'C4'
written_duration = durationtools.Duration(1, 4)
else:
message = 'can not initialize note from {!r}.'
raise ValueError(message.format(args))
Leaf.__init__(self, written_duration)
if written_pitch is not None:
if written_pitch not in drums:
self.note_head = scoretools.NoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
self.note_head = scoretools.DrumNoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
self.note_head = None
if len(args) == 1 and isinstance(args[0], Leaf):
self._copy_override_and_set_from_leaf(args[0])
def register_material(self, material):
r'''Register `material`.
Change tuple or list to payload expression.
Change parseable string to start-positioned rhythm payload expression.
'''
from experimental.tools import musicexpressiontools
if isinstance(material, (tuple, list)):
return musicexpressiontools.IterablePayloadExpression(material)
elif isinstance(material, (str)):
component = topleveltools.parse(material)
return musicexpressiontools.StartPositionedRhythmPayloadExpression(
[component], start_offset=0)
else:
raise TypeError(material)
def __init__(self, written_duration=None):
from abjad.tools.topleveltools import parse
original_input = written_duration
if isinstance(written_duration, str):
string = '{{ {} }}'.format(written_duration)
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
written_duration = parsed[0]
if isinstance(written_duration, Leaf):
written_duration = written_duration.written_duration
elif written_duration is None:
written_duration = durationtools.Duration(1, 4)
else:
written_duration = durationtools.Duration(written_duration)
Leaf.__init__(self, written_duration)
if isinstance(original_input, Leaf):
self._copy_override_and_set_from_leaf(original_input)
def __init__(self, written_duration=None):
from abjad.tools.topleveltools import parse
original_input = written_duration
if isinstance(written_duration, str):
string = '{{ {} }}'.format(written_duration)
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
written_duration = parsed[0]
if isinstance(written_duration, Leaf):
written_duration = written_duration.written_duration
elif written_duration is None:
written_duration = durationtools.Duration(1, 4)
else:
written_duration = durationtools.Duration(written_duration)
Leaf.__init__(self, written_duration)
if isinstance(original_input, Leaf):
self._copy_override_and_set_from_leaf(original_input)
def _expr_to_expression(self, expr):
from abjad.tools import rhythmmakertools
from experimental.tools import musicexpressiontools
if isinstance(expr, musicexpressiontools.Expression):
return expr
elif self._all_are_expressions(expr):
return musicexpressiontools.ExpressionInventory(expr)
elif isinstance(expr, (tuple, list, datastructuretools.TypedList)):
return musicexpressiontools.IterablePayloadExpression(expr)
elif isinstance(expr, (str)):
component = topleveltools.parse(expr)
return musicexpressiontools.StartPositionedRhythmPayloadExpression(
[component], start_offset=0)
elif isinstance(expr, rhythmmakertools.RhythmMaker):
return musicexpressiontools.RhythmMakerExpression(expr)
else:
message = 'do not know how to change {!r} to expression.'
raise TypeError(message.format(expr))
def _expr_to_expression(self, expr):
from abjad.tools import rhythmmakertools
from experimental.tools import musicexpressiontools
if isinstance(expr, musicexpressiontools.Expression):
return expr
elif self._all_are_expressions(expr):
return musicexpressiontools.ExpressionInventory(expr)
elif isinstance(expr,
(tuple, list, datastructuretools.TypedList)):
return musicexpressiontools.IterablePayloadExpression(expr)
elif isinstance(expr, (str)):
component = topleveltools.parse(expr)
return musicexpressiontools.StartPositionedRhythmPayloadExpression(
[component], start_offset=0)
elif isinstance(expr, rhythmmakertools.RhythmMaker):
return musicexpressiontools.RhythmMakerExpression(expr)
else:
message = 'do not know how to change {!r} to expression.'
raise TypeError(message.format(expr))
def __init__(self, *args):
from abjad.tools.topleveltools import parse
input_leaf = None
written_duration = None
if len(args) == 1 and isinstance(args[0], str):
string = '{{ {} }}'.format(args[0])
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
input_leaf = parsed[0]
written_duration = input_leaf.written_duration
elif len(args) == 1 and isinstance(args[0], Leaf):
written_duration = args[0].written_duration
input_leaf = args[0]
elif len(args) == 1 and not isinstance(args[0], str):
written_duration = args[0]
elif len(args) == 0:
written_duration = durationtools.Duration(1, 4)
else:
message = 'can not initialize skip from {!r}.'
message = message.format(args)
raise ValueError(message)
Leaf.__init__(self, written_duration)
if input_leaf is not None:
self._copy_override_and_set_from_leaf(input_leaf)
def __init__(self, *arguments):
import abjad
from abjad.ly import drums
from abjad.tools.topleveltools import parse
assert len(arguments) in (0, 1, 2)
self._note_heads = abjad.NoteHeadList(client=self)
if len(arguments) == 1 and isinstance(arguments[0], str):
string = '{{ {} }}'.format(arguments[0])
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
arguments = [parsed[0]]
are_cautionary = []
are_forced = []
are_parenthesized = []
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
leaf = arguments[0]
written_pitches = []
written_duration = leaf.written_duration
if 'written_pitch' in dir(leaf):
written_pitches.append(leaf.note_head.written_pitch)
are_cautionary = [leaf.note_head.is_cautionary]
are_forced = [leaf.note_head.is_forced]
are_parenthesized = [leaf.note_head.is_parenthesized]
elif 'written_pitches' in dir(leaf):
written_pitches.extend(x.written_pitch
for x in leaf.note_heads)
are_cautionary = [x.is_cautionary for x in leaf.note_heads]
are_forced = [x.is_forced for x in leaf.note_heads]
are_parenthesized = [
x.is_parenthesized for x in leaf.note_heads
]
elif len(arguments) == 2:
written_pitches, written_duration = arguments
if isinstance(written_pitches, str):
written_pitches = [x for x in written_pitches.split() if x]
elif isinstance(written_pitches, type(self)):
written_pitches = written_pitches.written_pitches
elif len(arguments) == 0:
written_pitches = [0, 4, 7]
written_duration = abjad.Duration(1, 4)
else:
message = 'can not initialize chord from {!r}.'
message = message.format(arguments)
raise ValueError(message)
Leaf.__init__(self, written_duration)
if not are_cautionary:
are_cautionary = [None] * len(written_pitches)
if not are_forced:
are_forced = [None] * len(written_pitches)
if not are_parenthesized:
are_parenthesized = [None] * len(written_pitches)
for written_pitch, is_cautionary, is_forced, is_parenthesized in zip(
written_pitches, are_cautionary, are_forced,
are_parenthesized):
if not is_cautionary:
is_cautionary = None
if not is_forced:
is_forced = None
if not is_parenthesized:
is_parenthesized = None
if written_pitch not in drums:
note_head = abjad.NoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
note_head = abjad.DrumNoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
self._note_heads.append(note_head)
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
self._copy_override_and_set_from_leaf(arguments[0])
