def _parse_string(self, string):
from abjad.parser.ReducedLyParser import ReducedLyParser
from abjad.lilypondfile.LilyPondFile import LilyPondFile
user_input = string.strip()
if user_input.startswith("abj:"):
parser = ReducedLyParser()
parsed = parser(user_input[4:])
if parser._toplevel_component_count == 1:
parent = inspect(parsed).parentage().parent
if parent is None:
parsed = Container([parsed])
else:
parsed = parent
elif user_input.startswith("rtm:"):
parsed = rhythmtrees.parse_rtm_syntax(user_input[4:])
else:
if not user_input.startswith("<<") or not user_input.endswith(
">>"
):
user_input = f"{{ {user_input} }}"
parsed = parse(user_input)
if isinstance(parsed, LilyPondFile):
parsed = Container(parsed.items[:])
assert isinstance(parsed, Container)
return parsed
def _parse_string(self, string):
from abjad.parser.ReducedLyParser import ReducedLyParser
from abjad.lilypondfile.LilyPondFile import LilyPondFile
user_input = string.strip()
if user_input.startswith('abj:'):
parser = ReducedLyParser()
parsed = parser(user_input[4:])
if parser._toplevel_component_count == 1:
parent = inspect(parsed).parentage().parent
if parent is None:
parsed = Container([parsed])
else:
parsed = parent
elif user_input.startswith('rtm:'):
parsed = rhythmtrees.parse_rtm_syntax(user_input[4:])
else:
if (
not user_input.startswith('<<') or
not user_input.endswith('>>')
):
user_input = f'{{ {user_input} }}'
parsed = parse(user_input)
if isinstance(parsed, LilyPondFile):
parsed = Container(parsed.items[:])
assert isinstance(parsed, Container)
return parsed
def __init__(
self,
*arguments,
multiplier: typings.DurationTyping = None,
tag: Tag = None,
) -> None:
input_leaf = None
written_duration = None
if len(arguments) == 1 and isinstance(arguments[0], str):
string = f"{{ {arguments[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(arguments) == 1 and isinstance(arguments[0], Leaf):
written_duration = arguments[0].written_duration
input_leaf = arguments[0]
elif len(arguments) == 1 and not isinstance(arguments[0], str):
written_duration = arguments[0]
elif len(arguments) == 0:
written_duration = Duration(1, 4)
else:
message = f"can not initialize skip from {arguments!r}."
raise ValueError(message)
Leaf.__init__(self, written_duration, multiplier=multiplier, tag=tag)
if input_leaf is not None:
self._copy_override_and_set_from_leaf(input_leaf)
def __init__(
self,
*arguments,
multiplier: typings.DurationTyping = None,
tag: str = None,
) -> None:
input_leaf = None
written_duration = None
if len(arguments) == 1 and isinstance(arguments[0], str):
string = f"{{ {arguments[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(arguments) == 1 and isinstance(arguments[0], Leaf):
written_duration = arguments[0].written_duration
input_leaf = arguments[0]
elif len(arguments) == 1 and not isinstance(arguments[0], str):
written_duration = arguments[0]
elif len(arguments) == 0:
written_duration = Duration(1, 4)
else:
message = f"can not initialize skip from {arguments!r}."
raise ValueError(message)
Leaf.__init__(self, written_duration, multiplier=multiplier, tag=tag)
if input_leaf is not None:
self._copy_override_and_set_from_leaf(input_leaf)
def __init__(
self,
written_duration=None,
*,
multiplier: typings.DurationTyping = None,
tag: str = None,
) -> None:
original_input = written_duration
if isinstance(written_duration, Leaf):
multiplier = written_duration.multiplier
if isinstance(written_duration, str):
string = f'{{ {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 = Duration(1, 4)
else:
written_duration = Duration(written_duration)
Leaf.__init__(
self,
written_duration,
multiplier=multiplier,
tag=tag,
)
if isinstance(original_input, Leaf):
self._copy_override_and_set_from_leaf(original_input)
def __init__(
self,
written_duration=None,
*,
multiplier: typings.DurationTyping = None,
tag: str = None,
) -> None:
original_input = written_duration
if isinstance(written_duration, Leaf):
multiplier = written_duration.multiplier
if isinstance(written_duration, str):
string = f"{{ {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 = Duration(1, 4)
else:
written_duration = Duration(written_duration)
Leaf.__init__(self, written_duration, multiplier=multiplier, tag=tag)
if isinstance(original_input, Leaf):
self._copy_override_and_set_from_leaf(original_input)
def __init__(
self,
*arguments,
multiplier: typings.DurationTyping = None,
tag: str = None,
) -> None:
from abjad.ly import drums
from .Chord import Chord
assert len(arguments) in (0, 1, 2)
if len(arguments) == 1 and isinstance(arguments[0], str):
string = f"{{ {arguments[0]} }}"
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
arguments = tuple([parsed[0]])
written_pitch = None
is_cautionary = False
is_forced = False
is_parenthesized = False
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
leaf = arguments[0]
written_pitch = None
written_duration = leaf.written_duration
if multiplier is None:
multiplier = leaf.multiplier
if isinstance(leaf, Note) and leaf.note_head is not None:
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
# TODO: move into separate from_chord() constructor:
elif isinstance(leaf, Chord):
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(arguments) == 2:
written_pitch, written_duration = arguments
elif len(arguments) == 0:
written_pitch = NamedPitch("C4")
written_duration = Duration(1, 4)
else:
raise ValueError("can not initialize note from {arguments!r}.")
Leaf.__init__(self, written_duration, multiplier=multiplier, tag=tag)
if written_pitch is not None:
if written_pitch not in drums:
self.note_head = NoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
assert isinstance(written_pitch, str), repr(written_pitch)
self.note_head = DrumNoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
self._note_head = None
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
self._copy_override_and_set_from_leaf(arguments[0])
def __init__(
self, *arguments, multiplier: typings.DurationTyping = None, tag: Tag = None,
) -> None:
from abjad.ly import drums
from .Note import Note
assert len(arguments) in (0, 1, 2)
self._note_heads = NoteHeadList(client=self)
if len(arguments) == 1 and isinstance(arguments[0], str):
string = f"{{ {arguments[0]} }}"
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
arguments = tuple([parsed[0]])
are_cautionary: typing.List[typing.Optional[bool]] = []
are_forced: typing.List[typing.Optional[bool]] = []
are_parenthesized: typing.List[typing.Optional[bool]] = []
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
leaf = arguments[0]
written_pitches = []
written_duration = leaf.written_duration
if multiplier is None:
multiplier = leaf.multiplier
# TODO: move to dedicated from_note() constructor:
if isinstance(leaf, Note) and leaf.note_head is not None:
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 isinstance(leaf, Chord):
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]
# TODO: move to dedicated constructor:
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 = [abjad_pitch.NamedPitch(_) for _ in [0, 4, 7]]
written_duration = Duration(1, 4)
else:
raise ValueError(f"can not initialize chord from {arguments!r}.")
Leaf.__init__(self, written_duration, multiplier=multiplier, tag=tag)
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 = NoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
assert isinstance(written_pitch, str), repr(written_pitch)
note_head = 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])
def __init__(
self,
*arguments,
multiplier: typings.DurationTyping = None,
tag: str = None,
) -> None:
from abjad.ly import drums
assert len(arguments) in (0, 1, 2)
if len(arguments) == 1 and isinstance(arguments[0], str):
string = f"{{ {arguments[0]} }}"
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
arguments = tuple([parsed[0]])
is_cautionary = False
is_forced = False
is_parenthesized = False
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
leaf = arguments[0]
written_pitch = None
written_duration = leaf.written_duration
if multiplier is None:
multiplier = leaf.multiplier
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(arguments) == 2:
written_pitch, written_duration = arguments
elif len(arguments) == 0:
written_pitch = "C4"
written_duration = Duration(1, 4)
else:
raise ValueError("can not initialize note from {arguments!r}.")
Leaf.__init__(self, written_duration, multiplier=multiplier, tag=tag)
if written_pitch is not None:
if written_pitch not in drums:
self.note_head = NoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
self.note_head = DrumNoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
self._note_head = None
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
self._copy_override_and_set_from_leaf(arguments[0])
def __init__(
self,
*arguments,
multiplier: typings.DurationTyping = None,
tag: str = None,
) -> None:
from abjad.ly import drums
assert len(arguments) in (0, 1, 2)
if len(arguments) == 1 and isinstance(arguments[0], str):
string = f'{{ {arguments[0]} }}'
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
arguments = tuple([parsed[0]])
is_cautionary = False
is_forced = False
is_parenthesized = False
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
leaf = arguments[0]
written_pitch = None
written_duration = leaf.written_duration
if multiplier is None:
multiplier = leaf.multiplier
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(arguments) == 2:
written_pitch, written_duration = arguments
elif len(arguments) == 0:
written_pitch = 'C4'
written_duration = Duration(1, 4)
else:
raise ValueError('can not initialize note from {arguments!r}.')
Leaf.__init__(
self,
written_duration,
multiplier=multiplier,
tag=tag,
)
if written_pitch is not None:
if written_pitch not in drums:
self.note_head = NoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
self.note_head = DrumNoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
self._note_head = None
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
self._copy_override_and_set_from_leaf(arguments[0])
def __init__(
self,
*arguments,
multiplier: typings.DurationTyping = None,
tag: str = None,
) -> None:
from abjad.ly import drums
assert len(arguments) in (0, 1, 2)
self._note_heads = NoteHeadList(client=self)
if len(arguments) == 1 and isinstance(arguments[0], str):
string = f'{{ {arguments[0]} }}'
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
arguments = tuple([parsed[0]])
are_cautionary: typing.List[typing.Optional[bool]] = []
are_forced: typing.List[typing.Optional[bool]] = []
are_parenthesized: typing.List[typing.Optional[bool]] = []
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
leaf = arguments[0]
written_pitches = []
written_duration = leaf.written_duration
if multiplier is None:
multiplier = leaf.multiplier
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 = Duration(1, 4)
else:
raise ValueError(f'can not initialize chord from {arguments!r}.')
Leaf.__init__(
self,
written_duration,
multiplier=multiplier,
tag=tag,
)
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 = NoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
note_head = 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])
def __init__(
self,
*arguments,
multiplier: typings.DurationTyping = None,
tag: str = None,
) -> None:
from abjad.ly import drums
assert len(arguments) in (0, 1, 2)
self._note_heads = NoteHeadList(client=self)
if len(arguments) == 1 and isinstance(arguments[0], str):
string = f"{{ {arguments[0]} }}"
parsed = parse(string)
assert len(parsed) == 1 and isinstance(parsed[0], Leaf)
arguments = tuple([parsed[0]])
are_cautionary: typing.List[typing.Optional[bool]] = []
are_forced: typing.List[typing.Optional[bool]] = []
are_parenthesized: typing.List[typing.Optional[bool]] = []
if len(arguments) == 1 and isinstance(arguments[0], Leaf):
leaf = arguments[0]
written_pitches = []
written_duration = leaf.written_duration
if multiplier is None:
multiplier = leaf.multiplier
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 = Duration(1, 4)
else:
raise ValueError(f"can not initialize chord from {arguments!r}.")
Leaf.__init__(self, written_duration, multiplier=multiplier, tag=tag)
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 = NoteHead(
written_pitch=written_pitch,
is_cautionary=is_cautionary,
is_forced=is_forced,
is_parenthesized=is_parenthesized,
)
else:
note_head = 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])