ly.music package
****************


Module contents
===============

An api to read music from the tokens of a ly.document.Document into a
tree structure.

This is meant to quickly read music from a document, to perform
modifications on the document, and to interpret music and markup and
to convert or export it to other formats.

All nodes are a subclass of items.Item, (which inherits from
node.WeakNode).

Tree structures are created from nested LilyPond structures, markup
and scheme code. Some Item types have special methods to query
information. The Music type, for example, has a length() method that
returns the duration of the music fragment.

Using the Music.events() method and the events module, it is possible
to iterate in musical time over the music tree, e.g. to convert music
to another format.

This package is not yet capable to construct documents entirely from
scratch. This needs to be developed. Until that time, the ly.dom
module can be used instead.

Some Item types can have a list of child items, but the tree structure
is as linear as possible.

A convenience function is available to create a
ly.music.items.Document instance for the specified
ly.document.Document.

Here is an example:

   >>> import ly.document
   >>> import ly.music
   >>> d=ly.document.Document(r'''
   \version "2.18.0"

   music = \relative {
     \time 4/4
     \key d \minor
     d4 e f g
     a g f e
     d2
   }

   \score {
     \new Staff <<
       \music
     >>
   }
   ''')
   >>> m=ly.music.document(d)
   >>> print(m.dump())
   <Document>
     <Version '\\version'>
       <String '"'>
     <Assignment 'music'>
       <Relative '\\relative'>
         <MusicList '{'>
           <TimeSignature '\\time'>
           <KeySignature '\\key'>
             <Note 'd'>
             <Command '\\minor'>
           <Note 'd'>
           <Note 'e'>
           <Note 'f'>
           <Note 'g'>
           <Note 'a'>
           <Note 'g'>
           <Note 'f'>
           <Note 'e'>
           <Note 'd'>
     <Score '\\score'>
       <Context '\\new'>
         <MusicList '<<'>
           <UserCommand '\\music'>
   >>> m[2][0][0]
   <MusicList '<<'>
   >>> m[2][0][0].length()
   Fraction(5, 2)
   >>>

ly.music.document(doc)

   Return a music.items.Document instance for the
   ly.document.Document.


Submodules
==========


ly.music.event module
=====================

Translates a music.items.Document tree into lists of events.

class ly.music.event.Events

   Bases: "object"

   Traverses a music tree and records music events from it.

   read(node, time=0, scaling=1)

      Read events from the node and all its child nodes; return time.

   traverse(node, time, scaling)

      Traverse node and call event handlers; record and return the
      time.

   unfold_repeats = False


ly.music.items module
=====================

The items a music expression is constructed with in a tree structure.

Whitespace and comments are left out.

All nodes (instances of Item) have a 'position' attribute that
indicates  where the item starts in the source text. Almost all items
have the token  that starts the expression in the 'token' attribute
and possibly other  tokens in the 'tokens' attribute, as a tuple.

The 'end_position()' method returns the position where the node
(including  its child nodes) ends.

You can get the whole tree structure of a LilyPond document by
instantiating a Document with the ly.document.Document instance. (It
will read all the tokens from the document using the Reader from the
read module.) As a convenience, the ly.music.document(doc) function
does this.

If you want to add new Item types, you should also add a method to
read.Reader to construct those items.

class ly.music.items.Absolute(parent=None)

   Bases: "Music"

   An absolute music expression. Has one child (normally Music).

class ly.music.items.AfterGrace(parent=None)

   Bases: "Music"

   The afterGrace function with its two arguments.

   Only the duration of the first is counted.

class ly.music.items.Alternative(parent=None)

   Bases: "Music"

   An alternative expression.

class ly.music.items.Articulation(parent=None)

   Bases: "Item"

   An articulation, fingering, string number, or other symbol.

class ly.music.items.Assignment(parent=None)

   Bases: "Item"

   A variable = value construct.

   name()

      The variable name.

   value()

      The assigned value.

class ly.music.items.Beam(parent=None)

   Bases: "Item"

   A [ or ].

   event = None

class ly.music.items.Book(parent=None)

   Bases: "Container"

   A book { ... } construct.

class ly.music.items.BookPart(parent=None)

   Bases: "Container"

   A bookpart { ... } construct.

class ly.music.items.Change(parent=None)

   Bases: "Translator"

   A change music expression.

class ly.music.items.Chord(parent=None)

   Bases: "Durable", "Container"

class ly.music.items.ChordItem(parent=None)

   Bases: "Item"

   An item inside a ChordSpecifier, e.g. a number or modifier.

class ly.music.items.ChordMode(parent=None)

   Bases: "InputMode"

   A chordmode or chords expression.

class ly.music.items.ChordSpecifier(parent=None)

   Bases: "Item"

   Chord specifications after a note in chord mode.

   Has children of Note or ChordItem class.

class ly.music.items.Clef(parent=None)

   Bases: "Item"

   A clef item.

   specifier()

class ly.music.items.Command(parent=None)

   Bases: "Item"

   A LilyPond command.

class ly.music.items.Container(parent=None)

   Bases: "Item"

   An item having a list of child items.

class ly.music.items.Context(parent=None)

   Bases: "Translator", "Music"

   A new or context music expression.

class ly.music.items.Document(doc)

   Bases: "Item"

   A toplevel item representing a ly.document.Document.

   get_included_document_node(node)

      Return a Document for the Include node. May return None.

   get_music(filename)

      Return the music Document for the specified filename.

      This implementation loads a ly.document.Document using utf-8
      encoding. Inherit from this class to implement other loading
      mechanisms or caching.

   iter_music(node=None)

      Iter over the music, following references to other assignments.

   music_events_til_position(position)

      Return a list of tuples.

      Every tuple is a (parent, nodes, scaling). If an empty list is
      returned, there is no music expression at this position.

   node(position, depth=-1)

      Return the node at or just before the specified position.

   resolve_filename(filename)

      Resolve filename against our document and include_path.

   substitute_for_node(node)

      Returns a node that replaces the specified node (e.g. in music).

      For example: a variable reference returns its value. Returns
      nothing if the node is not substitutable. Returns the node
      itself if it was substitutable, but the substitution failed.

   time_length(start, end)

      Return the length of the music between start and end positions.

      Returns None if start and end are not in the same expression.

   time_position(position)

      Return the time position in the music at the specified cursor
      position.

      The value is a fraction. If None is returned, we are not in a
      music  expression.

class ly.music.items.DrumMode(parent=None)

   Bases: "InputMode"

   A drummode or drums expression.

class ly.music.items.DrumNote(parent=None)

   Bases: "Durable"

class ly.music.items.Durable(parent=None)

   Bases: "Item"

   An Item that has a musical duration, in the duration attribute.

   duration = (0, 1)

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   length()

      Return the musical duration (our base * our scaling).

class ly.music.items.Duration(parent=None)

   Bases: "Item"

   A written duration

class ly.music.items.Dynamic(parent=None)

   Bases: "Item"

   Any dynamic symbol.

class ly.music.items.FigureMode(parent=None)

   Bases: "InputMode"

   A figuremode or figures expression.

class ly.music.items.Grace(parent=None)

   Bases: "Music"

   Music that has grace timing, i.e. 0 as far as computation is
   concerned.

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   preceding(node=None)

      Return a two-tuple (nodes, scaling).

      The nodes are the nodes in time before the node (which must be a
      child), and the scaling is 0 for (because we have grace notes).

      If node is None, all nodes that would precede a fictive node at
      the end are returned.

class ly.music.items.Header(parent=None)

   Bases: "Container"

   A header { ... } construct.

class ly.music.items.Include(parent=None)

   Bases: "Item"

   An include command (not changing the language).

   filename()

      Returns the filename.

class ly.music.items.InputMode(parent=None)

   Bases: "Music"

   Base class for inputmode-changing commands.

class ly.music.items.Item(parent=None)

   Bases: "WeakNode"

   Represents any item in the music of a document.

   This can be just a token, or an interpreted construct such as a
   note, rest or sequential or simultaneous construct , etc.

   Some Item instances just have one responsible token, but others
   have a list or tuple to tokens.

   An Item also has a pointer to the Document it originates from.

   document = None

   end_position()

      Return the end position of this node.

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   has_output(_seen_docs=None)

      Return True if this node has toplevel music, markup, book etc.

      I.e. returns True when LilyPond would likely generate output.
      Usually you'll call this method on a Document, Score, BookPart
      or Book node.

      You should not supply the _seen_docs argument; it is used
      internally  to avoid traversing recursively nested include
      files.

   iter_toplevel_items()

      Yield the toplevel items of our Document node in backward
      direction.

      Iteration starts with the node just before the node "self" is a
      descendant of.

   iter_toplevel_items_include()

      Same as iter_toplevel_items(), but follows include commands.

   length()

      Return the musical duration.

   music_children(depth=-1)

      Yield all the children that are new music expressions

      (i.e. that are inside other constructions).

   music_parent()

      Walk up the parent tree until Music is found; return the
      outermost Music node.

      Returns None is the node does not belong to any music expression
      (e.g. a toplevel Markup or Scheme object).

   plaintext()

      Return a plaintext value for this node.

      This only makes sense for items like Markup or String. For other
      types, an empty string is returned

   position = -1

   token = None

   tokens = ()

class ly.music.items.KeySignature(parent=None)

   Bases: "Item"

   A key pitch mode command.

   mode()

      The mode, e.g. "major", "minor", etc.

   pitch()

      The ly.pitch.Pitch that denotes the pitch.

class ly.music.items.Keyword(parent=None)

   Bases: "Item"

   A LilyPond keyword.

class ly.music.items.Language(parent=None)

   Bases: "Item"

   A command (language or certain include commands) that changes the
   pitch language.

   language = None

class ly.music.items.Layout(parent=None)

   Bases: "Container"

   A layout { ... } construct.

class ly.music.items.LayoutContext(parent=None)

   Bases: "Container"

   A context { ... } construct within Layout or Midi.

class ly.music.items.LyricItem(parent=None)

   Bases: "Item"

   Another lyric item (skip, extender, hyphen or tie).

class ly.music.items.LyricMode(parent=None)

   Bases: "InputMode"

   A lyricmode, lyrics or addlyrics expression.

class ly.music.items.LyricText(parent=None)

   Bases: "Durable"

   A lyric text (word, markup or string), with a Duration.

class ly.music.items.LyricsTo(parent=None)

   Bases: "InputMode"

   A lyricsto expression.

   context_id()

class ly.music.items.Markup(parent=None)

   Bases: "Item"

   A command starting markup (markup, -lines and -list).

   plaintext()

      Return the plain text value of this node.

class ly.music.items.MarkupCommand(parent=None)

   Bases: "Item"

   A markup command, such as italic etc.

   plaintext()

      Return the plain text value of this node.

class ly.music.items.MarkupList(parent=None)

   Bases: "Item"

   The group of markup items inside { and }. NOTE: *not* a markuplist.

   plaintext()

      Return the plain text value of this node.

class ly.music.items.MarkupScore(parent=None)

   Bases: "Item"

   A score inside Markup.

class ly.music.items.MarkupUserCommand(parent=None)

   Bases: "Item"

   A user-defined markup command

   name()

      Return the name of this user command (without the leading
      backslash).

   value()

      Find the value assigned to this variable.

class ly.music.items.MarkupWord(parent=None)

   Bases: "Item"

   A MarkupWord token.

   plaintext()

      Return a plaintext value for this node.

      This only makes sense for items like Markup or String. For other
      types, an empty string is returned

class ly.music.items.Midi(parent=None)

   Bases: "Container"

   A midi { ... } construct.

class ly.music.items.Music(parent=None)

   Bases: "Container"

   Any music expression, to be inherited of.

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   length()

      Return the musical duration.

   preceding(node=None)

      Return a two-tuple (nodes, scaling).

      The nodes are the nodes in time before the node (which must be a
      child), and the scaling is the scaling this node applies
      (normally 1).

      If node is None, all nodes that would precede a fictive node at
      the end are returned.

class ly.music.items.MusicList(parent=None)

   Bases: "Music"

   A music expression, either << >> or { }.

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   preceding(node=None)

      Return a two-tuple (nodes, scaling).

      The nodes are the nodes in time before the node (which must be a
      child), and the scaling is the scaling this node applies
      (normally 1).

      If node is None, all nodes that would precede a fictive node at
      the end are returned.

   simultaneous = False

class ly.music.items.Note(parent=None)

   Bases: "Durable"

   A Note that has a ly.pitch.Pitch

   accidental_token = None

   octave_token = None

   octavecheck_token = None

   pitch = None

class ly.music.items.NoteMode(parent=None)

   Bases: "InputMode"

   A notemode or notes expression.

class ly.music.items.Number(parent=None)

   Bases: "Item"

   A numerical value, directly entered.

   value()

class ly.music.items.Override(parent=None)

   Bases: "Item"

   An override command.

   context()

   grob()

class ly.music.items.Paper(parent=None)

   Bases: "Container"

   A paper { ... } construct.

class ly.music.items.PartCombine(parent=None)

   Bases: "Music"

   The partcombine command with 2 music arguments.

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   preceding(node=None)

      Return a two-tuple (nodes, scaling).

      The nodes are the nodes in time before the node (which must be a
      child), and the scaling is the scaling this node applies
      (normally 1).

      If node is None, all nodes that would precede a fictive node at
      the end are returned.

class ly.music.items.Partial(parent=None)

   Bases: "Item"

   A partial command.

   duration = (0, 1)

   partial_length()

      Return the duration given as argument as a Fraction.

class ly.music.items.PathItem(parent=None)

   Bases: "Item"

   An item in the path of an override or revert command.

class ly.music.items.PhrasingSlur(parent=None)

   Bases: "Item"

   A ( or ).

   event = None

class ly.music.items.PipeSymbol(parent=None)

   Bases: "Item"

   A pipe symbol: |

class ly.music.items.Postfix(parent=None)

   Bases: "Item"

   Any item that is prefixed with a _, - or ^ direction token.

class ly.music.items.Q(parent=None)

   Bases: "Durable"

class ly.music.items.Relative(parent=None)

   Bases: "Music"

   A relative music expression. Has one or two children (Note, Music).

class ly.music.items.Repeat(parent=None)

   Bases: "Music"

   A repeat expression.

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   repeat_count()

   specifier()

class ly.music.items.Rest(parent=None)

   Bases: "Durable"

class ly.music.items.Revert(parent=None)

   Bases: "Item"

   A revert command.

   context()

   grob()

class ly.music.items.Scaler(parent=None)

   Bases: "Music"

   A music construct that scales the duration of its contents.

   In the numerator and denominator attributes the values specified
   for LilyPond are stored, e.g. with times 3/2 { c d e }, the
   numerator is integer 3 and the denominator is integer 2. Note that
   for tuplet and times the meaning of these numbers is reversed.

   The algebraic scaling is stored in the scaling attribute.

   denominator = 0

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   numerator = 0

   preceding(node=None)

      Return a two-tuple (nodes, scaling).

      The nodes are the nodes in time before the node (which must be a
      child), and the scaling is the scaling this node applies.

      If node is None, all nodes that would precede a fictive node at
      the end are returned.

   scaling = 1

class ly.music.items.Scheme(parent=None)

   Bases: "Item"

   A Scheme expression inside LilyPond.

   get_fraction()

      A basic way to get one (may be fractional) numerical value.

   get_int()

      A basic way to get one integer value.

   get_list_ints()

      A basic way to get a list of integer values.

   get_ly_make_moment()

      A basic way to get a ly:make-moment fraction.

   get_pair_ints()

      Very basic way to get two integers specified as a pair.

   get_string()

      A basic way to get a quoted string value (without the quotes).

   plaintext()

      A crude way to get the plain text in this node.

class ly.music.items.SchemeItem(parent=None)

   Bases: "Item"

   Any scheme token.

class ly.music.items.SchemeLily(parent=None)

   Bases: "Container"

   A music expression inside #{ and #}.

class ly.music.items.SchemeList(parent=None)

   Bases: "Container"

   A ( ... ) expression.

class ly.music.items.SchemeQuote(parent=None)

   Bases: "Item"

   A ' in scheme.

class ly.music.items.Score(parent=None)

   Bases: "Container"

   A score { ... } construct.

class ly.music.items.Set(parent=None)

   Bases: "Item"

   A set command.

   context()

      The context, if specified.

   property()

      The property.

   value()

      The value, given as argument. This is simply the child element.

class ly.music.items.Skip(parent=None)

   Bases: "Durable"

class ly.music.items.Slur(parent=None)

   Bases: "Item"

   A ( or ).

   event = None

class ly.music.items.String(parent=None)

   Bases: "Item"

   A double-quoted string.

   plaintext()

      Return the plaintext value of this string, without escapes and
      quotes.

   value()

class ly.music.items.StringTuning(parent=None)

   Bases: "Item"

   A stringTuning command (with a chord as argument).

class ly.music.items.Tag(parent=None)

   Bases: "Music"

   A tag, keepWithTag or removeWithTag command.

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   preceding(node=None)

      Return a two-tuple (nodes, scaling).

      The nodes are the nodes in time before the node (which must be a
      child), and the scaling is the scaling this node applies
      (normally 1).

      If node is None, all nodes that would precede a fictive node at
      the end are returned.

class ly.music.items.Tempo(parent=None)

   Bases: "Item"

   duration = (0, 1)

   fraction()

      Return the note value as a fraction given before the equal sign.

   tempo()

      Return a list of integer values describing the tempo or range.

   text()

      Return the text, if set. Can be Markup, Scheme, or String.

class ly.music.items.Tie(parent=None)

   Bases: "Item"

   A tie.

class ly.music.items.TimeSignature(parent=None)

   Bases: "Item"

   A time command.

   beatstructure()

      The scheme expressions denoting the beat structure, if
      specified.

   fraction()

      The lower number as a Fraction (e.g. for 3/2 it returns 1/2).

   measure_length()

      The length of one measure in this time signature as a Fraction.

   numerator()

      The upper number (e.g. for 3/2 it returns 3).

class ly.music.items.Token(parent=None)

   Bases: "Item"

   Any token that is not otherwise recognized

class ly.music.items.Translator(parent=None)

   Bases: "Item"

   Base class for a change, new, or context music expression.

   context()

   context_id()

      The context id, if specified after an equal sign.

class ly.music.items.Transpose(parent=None)

   Bases: "Music"

   A transpose music expression. Has normally three children (Note,
   Note, Music).

class ly.music.items.Tremolo(parent=None)

   Bases: "Item"

   A tremolo item ":". The duration attribute is a tuple (base,
   scaling).

   duration = (0, 1)

class ly.music.items.Tweak(parent=None)

   Bases: "Item"

   A tweak command.

class ly.music.items.Unpitched(parent=None)

   Bases: "Durable"

   A "note" without pitch, just a standalone duration.

   pitch = None

class ly.music.items.Unset(parent=None)

   Bases: "Item"

   An unset command.

   context()

      The context, if specified.

   property()

      The property.

class ly.music.items.UserCommand(parent=None)

   Bases: "Music"

   A user command, most probably referring to music.

   events(e, time, scaling)

      Let the event.Events instance handle the events. Return the
      time.

   name()

      Return the name of this user command (without the leading
      backslash).

   value()

      Find the value assigned to this variable.

class ly.music.items.Version(parent=None)

   Bases: "Item"

   A version command.

   version()

      The version as a tuple of ints.

   version_string()

      The version as a string.

class ly.music.items.VoiceSeparator(parent=None)

   Bases: "Item"

   A voice separator: \

class ly.music.items.With(parent=None)

   Bases: "Container"

   A with ... construct.


ly.music.read module
====================

The Reader is used to construct a tree structure of (musical and
other) items in a LilyPond document. The item types that are used are
in the items module.

You instantiate a Reader with a ly.document.Source that reads tokens
from any (part of a) ly.document.Document.

Whitespace and comments are left out.

All nodes (instances of Item) have a 'position' attribute that
indicates  where the item starts in the source text. Almost all items
have the token  that starts the expression in the 'token' attribute
and possibly other  tokens in the 'tokens' attribute, as a tuple.

The 'end_position()' method returns the position where the node
(including  its child nodes) ends.

class ly.music.read.Reader(source)

   Bases: "object"

   Reads tokens from a Source and builds a meaningful tree structure.

   add_bracketed(item, source)

      Append the arguments between brackets to the item.

      Returns True if that succeeded, else False.

   add_duration(item, token=None, source=None)

      Add a duration attribute to the item.

      When there are tokens, a Duration item is also appended to the
      item.

   add_markup_arguments(item)

      Add markup arguments to the item.

   consume(last_token=None)

      Yield the tokens from our source until a parser is exit.

      If last_token is given, it is called with the last token that is
      read.

   factory(cls, token=None, consume=False, position=None)

      Create Item instance for token.

      If consume is True, consume()s the source into item.tokens. If
      you don't specify a token, you must specify the position (>= 0).

   handle_absolute(t, source)

      handle absolute

   handle_after_grace(t, source)

      handle afterGrace

   handle_alternative(t, source)

      handle alternative

   handle_articulation(t, source=None)

      handle Articulation

   handle_beam(t, source=None)

      handle Beam

   handle_bracketed(t, source)

      handle header, score, bookpart, book, paper, layout, midi, with,
      context

   handle_chord_start(t, source)

      handle ChordStart

   handle_clef(t, source)

      handle clef

   handle_direct_items(t, source)

      Tokens that directly translate to an Item.

      handle VoiceSeparator, PipeSymbol, Dynamic, Tie

   handle_direction(t, source)

      handle Direction

   handle_grace(t, source)

      handle grace, acciaccatura, appoggiatura, slashedGrace

   handle_include(t, source)

      handle include

   handle_inputmode(t, source)

      handle notemode, notes, chordmode, chords, figuremode, figures,
      drummode, drums

   handle_key(t, source)

      handle key

   handle_language(t, source)

      handle language

   handle_length(t, source)

      handle Length

   handle_lyricmode(t, source)

      handle lyricmode, lyrics, oldaddlyrics, addlyrics, lyricsto

   handle_markup(t, source=None)

      handle markup, markuplist, markuplines

   handle_markup_command(t)

      handle MarkupCommand

   handle_markup_open_bracket(t)

      handle OpenBracketMarkup

   handle_markup_score(t)

      handle MarkupScore

   handle_markup_user_command(t)

      handle MarkupUserCommand

   handle_markup_word(t)

      handle MarkupWord

   handle_music_item(t, source)

      handle MusicItem

   handle_music_list(t, source)

      handle OpenBracket, OpenSimultaneous,
      SimultaneousOrSequentialCommand

   handle_name(t, source)

      handle Name, ContextProperty

   handle_number_class(t, source=None)

      handle DecimalValue, IntegerValue, Fraction

   handle_override(t, source)

      handle override

   handle_partcombine(t, source=None)

      handle partcombine

   handle_partial(t, source)

      handle partial

   handle_relative(t, source)

      handle relative

   handle_repeat(t, source)

      handle repeat

   handle_revert(t, source)

      handle revert

   handle_scaler(t, source)

      handle times, tuplet, scaleDurations

   handle_scheme_lilypond_start(t)

      handle LilyPondStart

   handle_scheme_open_parenthesis(t)

      handle OpenParen

   handle_scheme_quote(t)

      handle Quote

   handle_scheme_start(t, source=None)

      handle SchemeStart

      handle SchemeStart

   handle_scheme_token(t)

      handle Dot, Bool, Char, Word, Number, Fraction, Float

   handle_set(t, source)

      handle set

   handle_slurs(t, source=None)

      handle Slur

   handle_string_start(t, source=None)

      handle StringStart

      handle StringStart

      handle StringStart

   handle_string_tuning(t, source)

      handle stringTuning

   handle_tag(t, source)

      handle tag, keepWithTag, removeWithTag, appendToTag, pushToTag

   handle_tempo(t, source)

      handle tempo

   handle_time(t, source)

      handle time

   handle_translator(t, source)

      handle new, context, change

   handle_transpose(t, source)

      handle transpose

   handle_tweak(t, source)

      handle tweak

   handle_unset(t, source)

      handle unset

   handle_variable_assignment(t, source)

      handle PaperVariable, LayoutVariable, HeaderVariable,
      UserVariable

   handle_version(t, source)

      handle version

   read(source=None)

      Yield Item instances reading from source.

   read_assignment(t)

      Read an assignment from the variable name. May return None.

   read_chord_specifier(t, source=None)

      Read stuff behind notes in chordmode.

      handle ChordSeparator

   read_command(t, source)

      Read the rest of a command given in t from the source.

      handle Command

   read_item(t, source=None)

      Return one Item that starts with token t. May return None.

   read_keyword(t, source)

      Read the rest of a keyword given in t from the source.

      handle Keyword

   read_lyric_item(t)

      Read one lyric item. Returns None for tokens it does not handle.

   read_markup(t)

      Read LilyPond markup (recursively).

   read_music_item(t, source)

      Read one music item (note, rest, s, skip, or q) from t and
      source.

   read_scheme(t)

      Return a Scheme item from the token t.

   read_scheme_item(t)

      Reads a Scheme expression (just after the # in LilyPond mode).

   read_tremolo(t, source=None)

      Read a tremolo.

      handle TremoloColon

   read_user_command(t, source)

      Read a user command, this can be a variable reference.

      handle UserCommand

   set_language(lang)

      Changes the pitch name language to use.

      Called internally when language or include tokens are
      encountered with a valid language name/file.

      Sets the language attribute to the language name.

   test_music_list(t)

      Test whether a music list ({ ... }, << ... >>, starts here.

      Also handles simultaneous { ... } and sequential { ... }
      correctly. These obscure commands are not even highlighted by
      lex, but they exist in LilyPond... simultaneous { ... } is like
      << ... >> but sequential << ... >> just behaves like << ... >>

      Returns a two-tuple(item; iterable), both may be None. If  item
      is not None, it can be either a UserCommand or a MusicList.  If
      iterable is None, the item is a UserCommand (namely simultaneous
      or sequential, but not followed by a { or <<); else the item is
      a MusicList, and the iterable should be read fully to get all
      the  tokens inside the MusicList. If item is None, there is no
      MusicList  and no token is read.

      This way you can handle the { ... } and << ... >> transparently
      in every input mode.

class ly.music.read.dispatcher

   Bases: "object"

   Decorator creator to dispatch commands, keywords, etc. to a method.

   method(token)

      The registered method to call for the token. May return None.

   read_arg(a)

class ly.music.read.dispatcher_class

   Bases: "dispatcher"

   Decorator creator to dispatch the class of a token to a method.

   method(token)

      The registered method to call for the token's class. May return
      None.

   read_arg(a)

ly.music.read.skip(source, what=(<class 'ly.lex._token.Space'>, <class 'ly.lex._token.Comment'>))

   Yield tokens from source, skipping items of classes specified in
   what.

   By default, comments and whitespace are skipped.
