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])