# ly.lex package

## Module contents

This module is built on top of slexer and can parse LilyPond input and other formats.

The base functionality is delegated to modules with an underscore in this package. The modules describing parsing modes (filetypes) are the files without underscore.

Currently available are modes for lilypond, latex, html, texinfo, scheme, and docbook.

The ‘underscored’ modules should not be imported in application code. What is needed from them is available here, in the ly.lex namespace.

If you add new files for parsing other file types, you should add them in _mode.py. The _token.py module contains base Token types and Token mixin classes.

The State, Parser, FallthroughParser and Fridge classes from slexer are all slightly extended here,

Usage:

    >>> import ly.lex
    >>> txt = r"\relative c' { c d e f-^ g }"
    >>> s = ly.lex.state("lilypond")
    >>> for t in s.tokens(txt):
    ...     print(t, t.__class__.__name__)
    \relative Command
      Space
    c Name
    ' Unparsed
      Space
    { SequentialStart
      Space
    c Note
      Space
    d Note
      Space
    e Note
      Space
    f Note
    - Direction
    ^ ScriptAbbreviation
      Space
    g Note
      Space
    } SequentialEnd

A State() is used to parse text. The text is given to the tokens() method, that returns an iterator iterating over Token instances as they are found. Each token has a ‘pos’ and an ‘end’ attribute describing its position in the original string.

While iterating over the tokens(), the State maintains information about what kind of text is parsed. (So don’t iterate over more than one call to tokens() of the same State object at the same time.)

Use ly.lex.state(“name”) to get a state for a specific mode to start parsing with. If you don’t know the type of text, you can use ly.lex.guessState(text), where text is the text you want to parse. A quick heuristic is then used to determine the type of the text.

See for more information the documentation of the slexer module.

class `ly.lex.``State`(initialParserClass)

  Bases: `ly.slexer.State`

  `endArgument`()

    Decrease argcount and leave the parser if it would reach 0.

  `mode`()

    Returns the mode attribute of the first parser (from current parser) that has it.

class `ly.lex.``Parser`(argcount=None)

  Bases: `ly.slexer.Parser`

  `argcount` = 0
  `default`

    alias of `Unparsed`

  `freeze`()
  `mode` = None
  `re_flags` = 40

class `ly.lex.``FallthroughParser`(argcount=None)

  Bases: `ly.lex.Parser`, `ly.slexer.FallthroughParser`

class `ly.lex.``Fridge`(stateClass=<class 'ly.lex.State'>)

  Bases: `ly.slexer.Fridge`

`ly.lex.``guessMode`(text)

  Tries to guess the type of the input text, using a quite fast heuristic.

  Returns one of the strings also present as key in the modes dictionary.

`ly.lex.``state`(mode)

  Returns a State instance for the given mode.

`ly.lex.``guessState`(text)

  Returns a State instance, guessing the type of text.

class `ly.lex.``Token`

  Bases: `ly.slexer.Token`

class `ly.lex.``Unparsed`

  Bases: `ly.lex._token.Token`

  Represents an unparsed piece of input text.

class `ly.lex.``Space`

  Bases: `ly.lex._token.Token`

  A token containing whitespace.

  `rx` = u'\\s+'

class `ly.lex.``Newline`

  Bases: `ly.lex._token.Space`

  A token that is a single newline.

  `rx` = u'\\n'

class `ly.lex.``Comment`

  Bases: `ly.lex._token.Token`

  Base class for tokens that belong to a comment.

class `ly.lex.``LineComment`

  Bases: `ly.lex._token.Comment`

  Base class for items that are a whole line comment.

class `ly.lex.``BlockComment`

  Bases: `ly.lex._token.Comment`

  Base class for tokens that belong to a block/multiline comment.

class `ly.lex.``BlockCommentStart`

  Bases: `ly.lex._token.BlockComment`

  Base class for tokens that start a block/multiline comment.

class `ly.lex.``BlockCommentEnd`

  Bases: `ly.lex._token.BlockComment`

  Base class for tokens that end a block/multiline comment.

class `ly.lex.``String`

  Bases: `ly.lex._token.Token`

  Base class for tokens that belong to a quote-delimited string.

class `ly.lex.``StringStart`

  Bases: `ly.lex._token.String`

  Base class for tokens that start a quote-delimited string.

class `ly.lex.``StringEnd`

  Bases: `ly.lex._token.String`

  Base class for tokens that end a quote-delimited string.

class `ly.lex.``Character`

  Bases: `ly.lex._token.Token`

  Base class for tokens that are an (escaped) character.

class `ly.lex.``Numeric`

  Bases: `ly.lex._token.Token`

  Base class for tokens that are a numerical value.

class `ly.lex.``Error`

  Bases: `ly.lex._token.Token`

  Base class for tokens that represent erroneous input.

class `ly.lex.``MatchStart`

  Bases: `object`

  Mixin class for tokens that have a matching token forward in the text.

  The matchname attribute should give a unique name.

  `matchname` = u''

class `ly.lex.``MatchEnd`

  Bases: `object`

  Mixin class for tokens that have a matching token backward in the text.

  The matchname attribute should give a unique name.

  `matchname` = u''

class `ly.lex.``Indent`

  Bases: `object`

  Mixin class for tokens that have the text on the next line indent more.

class `ly.lex.``Dedent`

  Bases: `object`

  Mixin class for tokens that have the text on the next line indent less.

## Submodules

## ly.lex.docbook module

Parses and tokenizes DocBook input, recognizing LilyPond in DocBook.

class `ly.lex.docbook.``ParseDocBook`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex._token.Space'>,)
  `mode` = u'docbook'
  `pattern` = <_sre.SRE_Pattern object>

## ly.lex.html module

Parses and tokenizes HTML input, recognizing LilyPond in HTML.

class `ly.lex.html.``AttrName`

  Bases: `ly.lex._token.Token`

  `rx` = u'\\w+([-_:]\\w+)?'

class `ly.lex.html.``Comment`

  Bases: `ly.lex._token.Comment`

class `ly.lex.html.``CommentEnd`

  Bases: `ly.lex.html.Comment`, `ly.lex._token.Leaver`, `ly.lex._token.BlockCommentEnd`

  `rx` = u'-->'

class `ly.lex.html.``CommentStart`

  Bases: `ly.lex.html.Comment`, `ly.lex._token.BlockCommentStart`

  `rx` = u'<!--'
  `update_state`(state)

class `ly.lex.html.``EntityRef`

  Bases: `ly.lex._token.Character`

  `rx` = u'\\&(#\\d+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);'

class `ly.lex.html.``EqualSign`

  Bases: `ly.lex._token.Token`

  `rx` = u'='
  `update_state`(state)

class `ly.lex.html.``LilyPondCloseTag`

  Bases: `ly.lex.html.LilyPondTag`, `ly.lex._token.Leaver`

  `rx` = u'</lilypond>'

class `ly.lex.html.``LilyPondFileTag`

  Bases: `ly.lex.html.LilyPondTag`

  `rx` = u'</?lilypondfile\\b'
  `update_state`(state)

class `ly.lex.html.``LilyPondFileTagEnd`

  Bases: `ly.lex.html.LilyPondTag`, `ly.lex._token.Leaver`

  `rx` = u'/?>'

class `ly.lex.html.``LilyPondInlineTag`

  Bases: `ly.lex.html.LilyPondTag`

  `rx` = u'<lilypond\\b'
  `update_state`(state)

class `ly.lex.html.``LilyPondInlineTagEnd`

  Bases: `ly.lex.html.LilyPondTag`, `ly.lex._token.Leaver`

  `rx` = u'/?>'

class `ly.lex.html.``LilyPondTag`

  Bases: `ly.lex.html.Tag`

class `ly.lex.html.``LilyPondTagEnd`

  Bases: `ly.lex.html.LilyPondTag`

  `rx` = u'>'
  `update_state`(state)

class `ly.lex.html.``LilyPondVersionTag`

  Bases: `ly.lex.html.LilyPondTag`

  `rx` = u'<lilypondversion/?>'

class `ly.lex.html.``ParseAttr`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.TagEnd'>, <class 'ly.lex.html.AttrName'>, <class 'ly.lex.html.EqualSign'>, <class 'ly.lex.html.StringDQStart'>, <class 'ly.lex.html.StringSQStart'>)
  `pattern` = <_sre.SRE_Pattern object at 0x22c4440>

class `ly.lex.html.``ParseComment`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `Comment`

  `items` = (<class 'ly.lex.html.CommentEnd'>,)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.html.``ParseHTML`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.LilyPondVersionTag'>, <class 'ly.lex.html.LilyPondFileTag'>, <class 'ly.lex.html.LilyPondInlineTag'>, <class 'ly.lex.html.CommentStart'>, <class 'ly.lex.html.TagStart'>, <class 'ly.lex.html.EntityRef'>)
  `mode` = u'html'
  `pattern` = <_sre.SRE_Pattern object at 0x32c2e20>

class `ly.lex.html.``ParseLilyPond`(argcount=None)

  Bases: `ly.lex.lilypond.ParseGlobal`

  `items` = (<class 'ly.lex.html.LilyPondCloseTag'>, <class 'ly.lex.lilypond.Book'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)
  `pattern` = <_sre.SRE_Pattern object at 0x32cc850>

class `ly.lex.html.``ParseLilyPondAttr`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.AttrName'>, <class 'ly.lex.html.EqualSign'>, <class 'ly.lex.html.StringDQStart'>, <class 'ly.lex.html.StringSQStart'>, <class 'ly.lex.html.LilyPondTagEnd'>, <class 'ly.lex.html.SemiColon'>)
  `pattern` = <_sre.SRE_Pattern object at 0x31d8600>

class `ly.lex.html.``ParseLilyPondFileOptions`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.AttrName'>, <class 'ly.lex.html.EqualSign'>, <class 'ly.lex.html.StringDQStart'>, <class 'ly.lex.html.StringSQStart'>, <class 'ly.lex.html.LilyPondFileTagEnd'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2a2e190>

class `ly.lex.html.``ParseLilyPondInline`(argcount=None)

  Bases: `ly.lex.lilypond.ParseMusic`

  `items` = (<class 'ly.lex.html.LilyPondInlineTagEnd'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.TremoloColon'>)
  `pattern` = <_sre.SRE_Pattern object at 0x30aa1f0>

class `ly.lex.html.``ParseStringDQ`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `String`

  `items` = (<class 'ly.lex.html.StringDQEnd'>, <class 'ly.lex.html.EntityRef'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2e0fc70>

class `ly.lex.html.``ParseStringSQ`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `String`

  `items` = (<class 'ly.lex.html.StringSQEnd'>, <class 'ly.lex.html.EntityRef'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2349670>

class `ly.lex.html.``ParseValue`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  Finds a value or drops back.

  `fallthrough`(state)
  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.Value'>)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.html.``SemiColon`

  Bases: `ly.lex._token.Token`

  `rx` = u':'
  `update_state`(state)

class `ly.lex.html.``String`

  Bases: `ly.lex._token.String`

class `ly.lex.html.``StringDQEnd`

  Bases: `ly.lex.html.String`, `ly.lex._token.StringEnd`, `ly.lex._token.Leaver`

  `rx` = u'"'

class `ly.lex.html.``StringDQStart`

  Bases: `ly.lex.html.String`, `ly.lex._token.StringStart`

  `rx` = u'"'
  `update_state`(state)

class `ly.lex.html.``StringSQEnd`

  Bases: `ly.lex.html.String`, `ly.lex._token.StringEnd`, `ly.lex._token.Leaver`

  `rx` = u"'"

class `ly.lex.html.``StringSQStart`

  Bases: `ly.lex.html.String`, `ly.lex._token.StringStart`

  `rx` = u"'"
  `update_state`(state)

class `ly.lex.html.``Tag`

  Bases: `ly.lex._token.Token`

class `ly.lex.html.``TagEnd`

  Bases: `ly.lex.html.Tag`, `ly.lex._token.Leaver`

  `rx` = u'/?>'

class `ly.lex.html.``TagStart`

  Bases: `ly.lex.html.Tag`

  `rx` = u'</?\\w[-_:\\w]*\\b'
  `update_state`(state)

class `ly.lex.html.``Value`

  Bases: `ly.lex._token.Leaver`

  `rx` = u'\\w+'

## ly.lex.latex module

Parses and tokenizes LaTeX input, recognizing LilyPond in LaTeX.

class `ly.lex.latex.``ParseLaTeX`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex._token.Space'>,)
  `mode` = u'latex'
  `pattern` = <_sre.SRE_Pattern object>

## ly.lex.lilypond module

Parses and tokenizes LilyPond input.

class `ly.lex.lilypond.``Accidental`

  Bases: `ly.lex._token.Token`

class `ly.lex.lilypond.``AccidentalCautionary`

  Bases: `ly.lex.lilypond.Accidental`

  `rx` = u'\\?'

class `ly.lex.lilypond.``AccidentalReminder`

  Bases: `ly.lex.lilypond.Accidental`

  `rx` = u'!'

class `ly.lex.lilypond.``AccidentalStyle`

  Bases: `ly.lex.lilypond.Command`

  `rx` = u'\\\\accidentalStyle\\b'
  `update_state`(state)

class `ly.lex.lilypond.``AccidentalStyleSpecifier`

  Bases: `ly.lex.lilypond.Specifier`

  `rx` = u'\\b(default|voice|modern|modern-cautionary|modern-voice|modern-voice-cautionary|piano|piano-cautionary|neo-modern|neo-modern-cautionary|neo-modern-voice|neo-modern-voice-cautionary|dodecaphonic|teaching|no-reset|forget)(?!-?\\w)'

class `ly.lex.lilypond.``AlterBroken`

  Bases: `ly.lex.lilypond.Command`

  `rx` = u'\\\\alterBroken\\b'
  `update_state`(state)

class `ly.lex.lilypond.``Articulation`

  Bases: `ly.lex._token.Token`

  Base class for articulation things.

class `ly.lex.lilypond.``ArticulationCommand`

  Bases: `ly.lex.lilypond.Articulation`, `ly.lex.lilypond.IdentifierRef`

  classmethod `test_match`(match)

class `ly.lex.lilypond.``BackSlashedContextName`

  Bases: `ly.lex.lilypond.ContextName`

  `rx` = u'\\\\(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanStaff|KievanVoice|Lyrics|MensuralStaff|MensuralVoice|NoteNames|NullVoice|PetrucciStaff|PetrucciVoice|PianoStaff|RhythmicStaff|Score|Staff|StaffGroup|TabStaff|TabVoice|Timing|VaticanaStaff|VaticanaVoice|Voice)\\b'

class `ly.lex.lilypond.``Beam`

  Bases: `ly.lex._token.Token`

class `ly.lex.lilypond.``BeamEnd`

  Bases: `ly.lex.lilypond.Beam`, `ly.lex._token.MatchEnd`

  `matchname` = u'beam'
  `rx` = u'\\]'

class `ly.lex.lilypond.``BeamStart`

  Bases: `ly.lex.lilypond.Beam`, `ly.lex._token.MatchStart`

  `matchname` = u'beam'
  `rx` = u'\\['

class `ly.lex.lilypond.``BlockComment`

  Bases: `ly.lex.lilypond.Comment`, `ly.lex._token.BlockComment`

class `ly.lex.lilypond.``BlockCommentEnd`

  Bases: `ly.lex.lilypond.Comment`, `ly.lex._token.BlockCommentEnd`, `ly.lex._token.Leaver`

  `rx` = u'%}'

class `ly.lex.lilypond.``BlockCommentStart`

  Bases: `ly.lex.lilypond.Comment`, `ly.lex._token.BlockCommentStart`

  `rx` = u'%{'
  `update_state`(state)

class `ly.lex.lilypond.``Book`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\book\\b'
  `update_state`(state)

class `ly.lex.lilypond.``BookPart`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\bookpart\\b'
  `update_state`(state)

class `ly.lex.lilypond.``Change`

  Bases: `ly.lex.lilypond.Translator`

  `rx` = u'\\\\change\\b'

class `ly.lex.lilypond.``Chord`

  Bases: `ly.lex._token.Token`

  Base class for Chord delimiters.

class `ly.lex.lilypond.``ChordEnd`

  Bases: `ly.lex.lilypond.Chord`, `ly.lex._token.Leaver`

  `rx` = u'>'

class `ly.lex.lilypond.``ChordItem`

  Bases: `ly.lex._token.Token`

  Base class for chordmode items.

class `ly.lex.lilypond.``ChordMode`

  Bases: `ly.lex.lilypond.InputMode`

  `rx` = u'\\\\(chords|chordmode)\\b'
  `update_state`(state)

class `ly.lex.lilypond.``ChordModifier`

  Bases: `ly.lex.lilypond.ChordItem`

  `rx` = u'((?<![a-z])|^)(aug|dim|sus|min|maj|m)(?![a-z])'

class `ly.lex.lilypond.``ChordSeparator`

  Bases: `ly.lex.lilypond.ChordItem`

  `rx` = u':|\\^|/\\+?'

class `ly.lex.lilypond.``ChordStart`

  Bases: `ly.lex.lilypond.Chord`

  `rx` = u'<'
  `update_state`(state)

class `ly.lex.lilypond.``ChordStepNumber`

  Bases: `ly.lex.lilypond.ChordItem`

  `rx` = u'\\d+[-+]?'

class `ly.lex.lilypond.``Clef`

  Bases: `ly.lex.lilypond.Command`

  `rx` = u'\\\\clef\\b'
  `update_state`(state)

class `ly.lex.lilypond.``ClefSpecifier`

  Bases: `ly.lex.lilypond.Specifier`

  `rx` = u'\\b(alto|baritone|bass|C|F|french|G|GG|mezzosoprano|percussion|soprano|subbass|tab|tenor|tenorG|treble|varbaritone|varC|varpercussion|violin)\\b'
  `update_state`(state)

class `ly.lex.lilypond.``CloseBracket`

  Bases: `ly.lex.lilypond.Delimiter`, `ly.lex._token.MatchEnd`, `ly.lex._token.Dedent`

  `matchname` = u'bracket'
  `rx` = u'\\}'
  `update_state`(state)

class `ly.lex.lilypond.``CloseBracketMarkup`

  Bases: `ly.lex.lilypond.CloseBracket`

  `update_state`(state)

class `ly.lex.lilypond.``CloseSimultaneous`

  Bases: `ly.lex.lilypond.Delimiter`, `ly.lex._token.MatchEnd`, `ly.lex._token.Dedent`

  `matchname` = u'simultaneous'
  `rx` = u'>>'
  `update_state`(state)

class `ly.lex.lilypond.``Command`

  Bases: `ly.lex._token.Item`, `ly.lex.lilypond.IdentifierRef`

  classmethod `test_match`(match)

class `ly.lex.lilypond.``Comment`

  Bases: `ly.lex._token.Comment`

class `ly.lex.lilypond.``Context`

  Bases: `ly.lex.lilypond.Translator`

  `rx` = u'\\\\context\\b'

class `ly.lex.lilypond.``ContextName`

  Bases: `ly.lex._token.Token`

  `rx` = u'\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanStaff|KievanVoice|Lyrics|MensuralStaff|MensuralVoice|NoteNames|NullVoice|PetrucciStaff|PetrucciVoice|PianoStaff|RhythmicStaff|Score|Staff|StaffGroup|TabStaff|TabVoice|Timing|VaticanaStaff|VaticanaVoice|Voice)\\b'

class `ly.lex.lilypond.``ContextProperty`

  Bases: `ly.lex.lilypond.Variable`

  `rx` = u'\\b(aDueText|accidentalGrouping|additionalPitchPrefix|alignAboveContext|alignBassFigureAccidentals|alignBelowContext|alternativeNumberingStyle|associatedVoice|autoAccidentals|autoBeamCheck|autoBeaming|autoCautionaries|automaticBars|barAlways|barCheckSynchronize|barNumberFormatter|barNumberVisibility|baseMoment|bassFigureFormatFunction|bassStaffProperties|beamExceptions|beamHalfMeasure|beatStructure|chordChanges|chordNameExceptions|chordNameExceptionsFull|chordNameExceptionsPartial|chordNameFunction|chordNameLowercaseMinor|chordNameSeparator|chordNoteNamer|chordPrefixSpacer|chordRootNamer|clefGlyph|clefPosition|clefTransposition|clefTranspositionFormatter|clefTranspositionStyle|completionBusy|completionUnit|connectArpeggios|countPercentRepeats|createKeyOnClefChange|createSpacing|crescendoSpanner|crescendoText|cueClefGlyph|cueClefPosition|cueClefTransposition|cueClefTranspositionFormatter|cueClefTranspositionStyle|currentBarNumber|decrescendoSpanner|decrescendoText|defaultBarType|defaultStrings|doubleRepeatSegnoType|doubleRepeatType|doubleSlurs|drumPitchTable|drumStyleTable|endRepeatSegnoType|endRepeatType|explicitClefVisibility|explicitCueClefVisibility|explicitKeySignatureVisibility|extendersOverRests|extraNatural|figuredBassAlterationDirection|figuredBassCenterContinuations|figuredBassFormatter|figuredBassPlusDirection|fingeringOrientations|firstClef|followVoice|fontSize|forbidBreak|forceClef|fretLabels|glissandoMap|gridInterval|handleNegativeFrets|harmonicAccidentals|harmonicDots|highStringOne|ignoreBarChecks|ignoreFiguredBassRest|ignoreMelismata|implicitBassFigures|implicitTimeSignatureVisibility|includeGraceNotes|instrumentCueName|instrumentEqualizer|instrumentName|instrumentTransposition|internalBarNumber|keepAliveInterfaces|keyAlterationOrder|keySignature|lyricMelismaAlignment|majorSevenSymbol|markFormatter|maximumFretStretch|measureLength|measurePosition|melismaBusyProperties|metronomeMarkFormatter|middleCClefPosition|middleCCuePosition|middleCOffset|middleCPosition|midiBalance|midiChannelMapping|midiChorusLevel|midiInstrument|midiMaximumVolume|midiMergeUnisons|midiMinimumVolume|midiPanPosition|midiReverbLevel|minimumFret|minimumPageTurnLength|minimumRepeatLengthForPageTurn|minorChordModifier|noChordSymbol|noteToFretFunction|ottavation|output|partCombineTextsOnNote|pedalSostenutoStrings|pedalSostenutoStyle|pedalSustainStrings|pedalSustainStyle|pedalUnaCordaStrings|pedalUnaCordaStyle|predefinedDiagramTable|printKeyCancellation|printOctaveNames|printPartCombineTexts|proportionalNotationDuration|rehearsalMark|repeatCommands|repeatCountVisibility|restCompletionBusy|restNumberThreshold|restrainOpenStrings|searchForVoice|segnoType|shapeNoteStyles|shortInstrumentName|shortVocalName|skipBars|skipTypesetting|slashChordSeparator|soloIIText|soloText|squashedPosition|staffLineLayoutFunction|stanza|startRepeatSegnoType|startRepeatType|stemLeftBeamCount|stemRightBeamCount|strictBeatBeaming|stringNumberOrientations|stringOneTopmost|stringTunings|strokeFingerOrientations|subdivideBeams|suggestAccidentals|systemStartDelimiter|systemStartDelimiterHierarchy|tabStaffLineLayoutFunction|tablatureFormat|tempoHideNote|tempoWholesPerMinute|tieWaitForNote|timeSignatureFraction|timeSignatureSettings|timing|tonic|topLevelAlignment|trebleStaffProperties|tremoloFlags|tupletFullLength|tupletFullLengthNote|tupletSpannerDuration|useBassFigureExtenders|vocalName|voltaSpannerDuration|whichBar)\\b'

class `ly.lex.lilypond.``DecimalValue`

  Bases: `ly.lex.lilypond.Value`

  `rx` = u'-?\\d+(\\.\\d+)?'

class `ly.lex.lilypond.``Delimiter`

  Bases: `ly.lex._token.Token`

class `ly.lex.lilypond.``Direction`

  Bases: `ly.lex._token.Token`

  `rx` = u'[-_^]'
  `update_state`(state)

class `ly.lex.lilypond.``Dot`

  Bases: `ly.lex.lilypond.Duration`

  `rx` = u'\\.'

class `ly.lex.lilypond.``DotChord`

  Bases: `ly.lex.lilypond.ChordItem`

  `rx` = u'\\.'

class `ly.lex.lilypond.``DotPath`

  Bases: `ly.lex.lilypond.Delimiter`

  A dot in dotted path notation.

  `rx` = u'\\.'

class `ly.lex.lilypond.``DrumChordEnd`

  Bases: `ly.lex.lilypond.ChordEnd`

class `ly.lex.lilypond.``DrumChordStart`

  Bases: `ly.lex.lilypond.ChordStart`

  `update_state`(state)

class `ly.lex.lilypond.``DrumMode`

  Bases: `ly.lex.lilypond.InputMode`

  `rx` = u'\\\\(drums|drummode)\\b'
  `update_state`(state)

class `ly.lex.lilypond.``DrumNote`

  Bases: `ly.lex.lilypond.MusicItem`

  `rx` = u'[a-z]+(?![A-Za-z])'

class `ly.lex.lilypond.``Duration`

  Bases: `ly.lex._token.Token`

class `ly.lex.lilypond.``Dynamic`

  Bases: `ly.lex._token.Token`

  `rx` = u'\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z])'

class `ly.lex.lilypond.``EqualSign`

  Bases: `ly.lex._token.Token`

  `rx` = u'='

class `ly.lex.lilypond.``Error`

  Bases: `ly.lex._token.Error`

class `ly.lex.lilypond.``ErrorInChord`

  Bases: `ly.lex.lilypond.Error`

  `rx` = u'[-_^][_.>|!+^-]|<<|>>|\\\\[\\\\\\]\\[\\(\\)()]|(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))|\\*[\\t ]*\\d+(/\\d+)?'

class `ly.lex.lilypond.``ExpectBook`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `replace`

    alias of `ParseBook`

class `ly.lex.lilypond.``ExpectBookPart`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `replace`

    alias of `ParseBookPart`

class `ly.lex.lilypond.``ExpectChordMode`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectMusicList`

  `replace`

    alias of `ParseChordMode`

class `ly.lex.lilypond.``ExpectContext`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `replace`

    alias of `ParseContext`

class `ly.lex.lilypond.``ExpectDrumMode`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectMusicList`

  `replace`

    alias of `ParseDrumMode`

class `ly.lex.lilypond.``ExpectFigureMode`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectMusicList`

  `replace`

    alias of `ParseFigureMode`

class `ly.lex.lilypond.``ExpectGrobProperty`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.GrobProperty'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2b9b6a0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ExpectHeader`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `replace`

    alias of `ParseHeader`

class `ly.lex.lilypond.``ExpectLayout`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `replace`

    alias of `ParseLayout`

class `ly.lex.lilypond.``ExpectLyricMode`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectMusicList`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x334b360>
  `replace`

    alias of `ParseLyricMode`

class `ly.lex.lilypond.``ExpectMidi`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `replace`

    alias of `ParseMidi`

class `ly.lex.lilypond.``ExpectMusicList`(argcount=None)

  Bases: `ly.lex.FallthroughParser`, `ly.lex.lilypond.ParseLilyPond`

  Waits for an OpenBracket or << and then replaces the parser with the class set in the replace attribute.

  Subclass this to set the destination for the OpenBracket.

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x31b7de0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ExpectNoteMode`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectMusicList`

  `replace`

    alias of `ParseNoteMode`

class `ly.lex.lilypond.``ExpectOpenBracket`(argcount=None)

  Bases: `ly.lex.FallthroughParser`, `ly.lex.lilypond.ParseLilyPond`

  Waits for an OpenBracket and then replaces the parser with the class set in the replace attribute.

  Subclass this to set the destination for the OpenBracket.

  `default`

    alias of `Error`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.OpenBracket'>)
  `pattern` = <_sre.SRE_Pattern object>
  `update_state`(state, token)

class `ly.lex.lilypond.``ExpectPaper`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `replace`

    alias of `ParsePaper`

class `ly.lex.lilypond.``ExpectScore`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `replace`

    alias of `ParseScore`

class `ly.lex.lilypond.``ExpectTranslatorId`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.EqualSign'>)
  `pattern` = <_sre.SRE_Pattern object>
  `update_state`(state, token)

class `ly.lex.lilypond.``ExpectWith`(argcount=None)

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `replace`

    alias of `ParseWith`

class `ly.lex.lilypond.``Figure`

  Bases: `ly.lex._token.Token`

  Base class for Figure items.

class `ly.lex.lilypond.``FigureAccidental`

  Bases: `ly.lex.lilypond.Figure`

  A figure accidental.

  `rx` = u'[-+!]+'

class `ly.lex.lilypond.``FigureBracket`

  Bases: `ly.lex.lilypond.Figure`

  `rx` = u'[][]'

class `ly.lex.lilypond.``FigureEnd`

  Bases: `ly.lex.lilypond.Figure`, `ly.lex._token.Leaver`

  `rx` = u'>'

class `ly.lex.lilypond.``FigureMode`

  Bases: `ly.lex.lilypond.InputMode`

  `rx` = u'\\\\(figures|figuremode)\\b'
  `update_state`(state)

class `ly.lex.lilypond.``FigureModifier`

  Bases: `ly.lex.lilypond.Figure`

  A figure modifier.

  `rx` = u'\\\\[\\\\!+]|/'

class `ly.lex.lilypond.``FigureStart`

  Bases: `ly.lex.lilypond.Figure`

  `rx` = u'<'
  `update_state`(state)

class `ly.lex.lilypond.``FigureStep`

  Bases: `ly.lex.lilypond.Figure`

  A step figure number or the underscore.

  `rx` = u'_|\\d+'

class `ly.lex.lilypond.``Fingering`

  Bases: `ly.lex.lilypond.Articulation`, `ly.lex._token.Leaver`

  `rx` = u'\\d'

class `ly.lex.lilypond.``Fraction`

  Bases: `ly.lex.lilypond.Value`

  `rx` = u'\\d+/\\d+'

class `ly.lex.lilypond.``GrobName`

  Bases: `ly.lex._token.Token`

  `rx` = u'\\b(Accidental|AccidentalCautionary|AccidentalPlacement|AccidentalSuggestion|Ambitus|AmbitusAccidental|AmbitusLine|AmbitusNoteHead|Arpeggio|BalloonTextItem|BarLine|BarNumber|BassFigure|BassFigureAlignment|BassFigureAlignmentPositioning|BassFigureBracket|BassFigureContinuation|BassFigureLine|Beam|BendAfter|BreakAlignGroup|BreakAlignment|BreathingSign|ChordName|Clef|ClefModifier|ClusterSpanner|ClusterSpannerBeacon|CombineTextScript|CueClef|CueEndClef|Custos|DotColumn|Dots|DoublePercentRepeat|DoublePercentRepeatCounter|DoubleRepeatSlash|DynamicLineSpanner|DynamicText|DynamicTextSpanner|Episema|Fingering|FingeringColumn|Flag|FootnoteItem|FootnoteSpanner|FretBoard|Glissando|GraceSpacing|GridLine|GridPoint|Hairpin|HorizontalBracket|InstrumentName|InstrumentSwitch|KeyCancellation|KeySignature|KievanLigature|LaissezVibrerTie|LaissezVibrerTieColumn|LedgerLineSpanner|LeftEdge|LigatureBracket|LyricExtender|LyricHyphen|LyricSpace|LyricText|MeasureCounter|MeasureGrouping|MelodyItem|MensuralLigature|MetronomeMark|MultiMeasureRest|MultiMeasureRestNumber|MultiMeasureRestText|NonMusicalPaperColumn|NoteCollision|NoteColumn|NoteHead|NoteName|NoteSpacing|OttavaBracket|PaperColumn|ParenthesesItem|PercentRepeat|PercentRepeatCounter|PhrasingSlur|PianoPedalBracket|RehearsalMark|RepeatSlash|RepeatTie|RepeatTieColumn|Rest|RestCollision|Script|ScriptColumn|ScriptRow|Slur|SostenutoPedal|SostenutoPedalLineSpanner|SpacingSpanner|SpanBar|SpanBarStub|StaffGrouper|StaffSpacing|StaffSymbol|StanzaNumber|Stem|StemStub|StemTremolo|StringNumber|StrokeFinger|SustainPedal|SustainPedalLineSpanner|System|SystemStartBar|SystemStartBrace|SystemStartBracket|SystemStartSquare|TabNoteHead|TextScript|TextSpanner|Tie|TieColumn|TimeSignature|TrillPitchAccidental|TrillPitchGroup|TrillPitchHead|TrillSpanner|TupletBracket|TupletNumber|UnaCordaPedal|UnaCordaPedalLineSpanner|VaticanaLigature|VerticalAlignment|VerticalAxisGroup|VoiceFollower|VoltaBracket|VoltaBracketSpanner)\\b'

class `ly.lex.lilypond.``GrobProperty`

  Bases: `ly.lex.lilypond.Variable`

  `rx` = u'\\b([a-z]+|[XY])(-([a-z]+|[XY]))*(?![\\w])'

class `ly.lex.lilypond.``Header`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\header\\b'
  `update_state`(state)

class `ly.lex.lilypond.``HeaderVariable`

  Bases: `ly.lex.lilypond.Variable`

  A variable inside Header. Always follow this one by UserVariable.

  classmethod `test_match`(match)

class `ly.lex.lilypond.``Hide`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\hide\\b'
  `update_state`(state)

class `ly.lex.lilypond.``Identifier`

  Bases: `ly.lex._token.Token`

  A variable name, like `some-variable`.

  `rx` = u'(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d])'

class `ly.lex.lilypond.``IdentifierRef`

  Bases: `ly.lex._token.Token`

  A reference to an identifier, e.g. `\some-variable`.

  `rx` = u'\\\\[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d])'

class `ly.lex.lilypond.``InputMode`

  Bases: `ly.lex.lilypond.Command`

class `ly.lex.lilypond.``IntegerValue`

  Bases: `ly.lex.lilypond.DecimalValue`

  `rx` = u'\\d+'

class `ly.lex.lilypond.``KeySignatureMode`

  Bases: `ly.lex.lilypond.Command`

  `rx` = u'\\\\(major|minor|ionian|dorian|phrygian|lydian|mixolydian|aeolian|locrian)(?![A-Za-z])'

class `ly.lex.lilypond.``Keyword`

  Bases: `ly.lex._token.Item`, `ly.lex.lilypond.IdentifierRef`

  classmethod `test_match`(match)

class `ly.lex.lilypond.``Layout`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\layout\\b'
  `update_state`(state)

class `ly.lex.lilypond.``LayoutContext`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\context\\b'
  `update_state`(state)

class `ly.lex.lilypond.``LayoutVariable`

  Bases: `ly.lex.lilypond.Variable`

  A variable inside Header. Always follow this one by UserVariable.

  classmethod `test_match`(match)

class `ly.lex.lilypond.``Length`

  Bases: `ly.lex.lilypond.Duration`

  `rx` = u'(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))'
  `update_state`(state)

class `ly.lex.lilypond.``Ligature`

  Bases: `ly.lex._token.Token`

class `ly.lex.lilypond.``LigatureEnd`

  Bases: `ly.lex.lilypond.Ligature`, `ly.lex._token.MatchEnd`

  `matchname` = u'ligature'
  `rx` = u'\\\\\\]'

class `ly.lex.lilypond.``LigatureStart`

  Bases: `ly.lex.lilypond.Ligature`, `ly.lex._token.MatchStart`

  `matchname` = u'ligature'
  `rx` = u'\\\\\\['

class `ly.lex.lilypond.``LineComment`

  Bases: `ly.lex.lilypond.Comment`, `ly.lex._token.LineComment`

  `rx` = u'%.*$'

class `ly.lex.lilypond.``Lyric`

  Bases: `ly.lex._token.Item`

  Base class for Lyric items.

class `ly.lex.lilypond.``LyricExtender`

  Bases: `ly.lex.lilypond.Lyric`

  `rx` = u'__(?=($|[\\s\\\\]))'

class `ly.lex.lilypond.``LyricHyphen`

  Bases: `ly.lex.lilypond.Lyric`

  `rx` = u'--(?=($|[\\s\\\\]))'

class `ly.lex.lilypond.``LyricMode`

  Bases: `ly.lex.lilypond.InputMode`

  `rx` = u'\\\\(lyricmode|((old)?add)?lyrics|lyricsto)\\b'
  `update_state`(state)

class `ly.lex.lilypond.``LyricSkip`

  Bases: `ly.lex.lilypond.Lyric`

  `rx` = u'_(?=($|[\\s\\\\]))'

class `ly.lex.lilypond.``LyricText`

  Bases: `ly.lex.lilypond.Lyric`

  `rx` = u'[^\\\\\\s\\d\\"]+'

class `ly.lex.lilypond.``Markup`

  Bases: `ly.lex._token.Item`

  Base class for all markup commands.

class `ly.lex.lilypond.``MarkupCommand`

  Bases: `ly.lex.lilypond.Markup`, `ly.lex.lilypond.IdentifierRef`

  A markup command.

  classmethod `test_match`(match)
  `update_state`(state)

class `ly.lex.lilypond.``MarkupLines`

  Bases: `ly.lex.lilypond.Markup`

  `rx` = u'\\\\markuplines(?![_-]?[^\\W\\d])'
  `update_state`(state)

class `ly.lex.lilypond.``MarkupList`

  Bases: `ly.lex.lilypond.Markup`

  `rx` = u'\\\\markuplist(?![_-]?[^\\W\\d])'
  `update_state`(state)

class `ly.lex.lilypond.``MarkupScore`

  Bases: `ly.lex.lilypond.Markup`

  `rx` = u'\\\\score\\b'
  `update_state`(state)

class `ly.lex.lilypond.``MarkupStart`

  Bases: `ly.lex.lilypond.Markup`, `ly.lex.lilypond.Command`

  `rx` = u'\\\\markup(?![_-]?[^\\W\\d])'
  `update_state`(state)

class `ly.lex.lilypond.``MarkupUserCommand`

  Bases: `ly.lex.lilypond.Markup`, `ly.lex.lilypond.IdentifierRef`

  A user-defined markup (i.e. not in the words markupcommands list).

  `update_state`(state)

class `ly.lex.lilypond.``MarkupWord`

  Bases: `ly.lex._token.Item`

  `rx` = u'[^{}"\\\\\\s#%]+'

class `ly.lex.lilypond.``Midi`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\midi\\b'
  `update_state`(state)

class `ly.lex.lilypond.``MusicItem`

  Bases: `ly.lex._token.Token`

  A note, rest, spacer, `\skip` or `q`.

class `ly.lex.lilypond.``Name`

  Bases: `ly.lex.lilypond.UserVariable`

  A variable name without prefix.

class `ly.lex.lilypond.``New`

  Bases: `ly.lex.lilypond.Translator`

  `rx` = u'\\\\new\\b'

class `ly.lex.lilypond.``Note`

  Bases: `ly.lex.lilypond.MusicItem`

  `rx` = u'[a-x]+(?![A-Za-z])'

class `ly.lex.lilypond.``NoteMode`

  Bases: `ly.lex.lilypond.InputMode`

  `rx` = u'\\\\(notes|notemode)\\b'
  `update_state`(state)

class `ly.lex.lilypond.``Octave`

  Bases: `ly.lex._token.Token`

  `rx` = u",+|'+"

class `ly.lex.lilypond.``OctaveCheck`

  Bases: `ly.lex._token.Token`

  `rx` = u"=(,+|'+)?"

class `ly.lex.lilypond.``Omit`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\omit\\b'
  `update_state`(state)

class `ly.lex.lilypond.``OpenBracket`

  Bases: `ly.lex.lilypond.Delimiter`, `ly.lex._token.MatchStart`, `ly.lex._token.Indent`

  An open bracket, does not enter different parser, subclass or reimplement Parser.update_state().

  `matchname` = u'bracket'
  `rx` = u'\\{'

class `ly.lex.lilypond.``OpenBracketMarkup`

  Bases: `ly.lex.lilypond.OpenBracket`

  `update_state`(state)

class `ly.lex.lilypond.``OpenSimultaneous`

  Bases: `ly.lex.lilypond.Delimiter`, `ly.lex._token.MatchStart`, `ly.lex._token.Indent`

  An open double French quote, does not enter different parser, subclass or reimplement Parser.update_state().

  `matchname` = u'simultaneous'
  `rx` = u'<<'

class `ly.lex.lilypond.``Override`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\override\\b'
  `update_state`(state)

class `ly.lex.lilypond.``Paper`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\paper\\b'
  `update_state`(state)

class `ly.lex.lilypond.``PaperVariable`

  Bases: `ly.lex.lilypond.Variable`

  A variable inside Paper. Always follow this one by UserVariable.

  classmethod `test_match`(match)

class `ly.lex.lilypond.``ParseAccidentalStyle`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.AccidentalStyleSpecifier'>)
  `pattern` = <_sre.SRE_Pattern object at 0x335d5f0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseAlterBroken`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.GrobProperty'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2b9b6a0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseBlockComment`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `BlockComment`

  `items` = (<class 'ly.lex.lilypond.BlockCommentEnd'>,)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.lilypond.``ParseBook`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses the expression after `\book {`, leaving at `}`

  `items` = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x3368620>

class `ly.lex.lilypond.``ParseBookPart`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses the expression after `\bookpart {`, leaving at `}`

  `items` = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x33557c0>

class `ly.lex.lilypond.``ParseChord`(argcount=None)

  Bases: `ly.lex.lilypond.ParseMusic`

  LilyPond inside chords `< >`

  `items` = (<class 'ly.lex.lilypond.ErrorInChord'>, <class 'ly.lex.lilypond.ChordEnd'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x3384f40>

class `ly.lex.lilypond.``ParseChordItems`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex.lilypond.ChordSeparator'>, <class 'ly.lex.lilypond.ChordModifier'>, <class 'ly.lex.lilypond.ChordStepNumber'>, <class 'ly.lex.lilypond.DotChord'>, <class 'ly.lex.lilypond.Note'>)
  `pattern` = <_sre.SRE_Pattern object at 0x3349f40>

class `ly.lex.lilypond.``ParseChordMode`(argcount=None)

  Bases: `ly.lex.lilypond.ParseInputMode`, `ly.lex.lilypond.ParseMusic`

  Parser for `\chords` and `\chordmode`.

  `items` = (<class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.ChordSeparator'>)
  `pattern` = <_sre.SRE_Pattern object at 0x339b1b0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseClef`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `argcount` = 1
  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ClefSpecifier'>, <class 'ly.lex.lilypond.StringQuotedStart'>)
  `pattern` = <_sre.SRE_Pattern object at 0x3383bd0>

class `ly.lex.lilypond.``ParseContext`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses the expression after (`\layout {`) `\context {`, leaving at `}`

  `items` = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.BackSlashedContextName'>, <class 'ly.lex.lilypond.ContextProperty'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x3390e00>

class `ly.lex.lilypond.``ParseDecimalValue`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  Parses a decimal value without a # before it (if present).

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)
  `pattern` = <_sre.SRE_Pattern object at 0x27b3a20>

class `ly.lex.lilypond.``ParseDrumChord`(argcount=None)

  Bases: `ly.lex.lilypond.ParseMusic`

  LilyPond inside chords in drummode `< >`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.ErrorInChord'>, <class 'ly.lex.lilypond.DrumChordEnd'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.DrumNote'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x33b53d0>

class `ly.lex.lilypond.``ParseDrumMode`(argcount=None)

  Bases: `ly.lex.lilypond.ParseInputMode`, `ly.lex.lilypond.ParseMusic`

  Parser for `\drums` and `\drummode`.

  `items` = (<class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.DrumNote'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.DrumChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2c6a6d0>

class `ly.lex.lilypond.``ParseDuration`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `fallthrough`(state)
  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Dot'>)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.lilypond.``ParseDurationScaling`(argcount=None)

  Bases: `ly.lex.lilypond.ParseDuration`

  `fallthrough`(state)
  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Scaling'>)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.lilypond.``ParseFigure`(argcount=None)

  Bases: `ly.lex.Parser`

  Parse inside `< >` in figure mode.

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.FigureEnd'>, <class 'ly.lex.lilypond.FigureBracket'>, <class 'ly.lex.lilypond.FigureStep'>, <class 'ly.lex.lilypond.FigureAccidental'>, <class 'ly.lex.lilypond.FigureModifier'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2ac9e00>

class `ly.lex.lilypond.``ParseFigureMode`(argcount=None)

  Bases: `ly.lex.lilypond.ParseInputMode`, `ly.lex.lilypond.ParseMusic`

  Parser for `\figures` and `\figuremode`.

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.CloseSimultaneous'>, <class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.FigureStart'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2fbfe20>

class `ly.lex.lilypond.``ParseGlobal`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses LilyPond from the toplevel of a file.

  `items` = (<class 'ly.lex.lilypond.Book'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)
  `pattern` = <_sre.SRE_Pattern object at 0x336ba50>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseGlobalAssignment`(argcount=None)

  Bases: `ly.lex.FallthroughParser`, `ly.lex.lilypond.ParseLilyPond`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.Dynamic'>)
  `pattern` = <_sre.SRE_Pattern object at 0x30625b0>

class `ly.lex.lilypond.``ParseGrobPropertyPath`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.DotPath'>)
  `pattern` = <_sre.SRE_Pattern object>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseHeader`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses the expression after `\header {`, leaving at `}`

  `items` = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.HeaderVariable'>, <class 'ly.lex.lilypond.UserVariable'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x23b0860>

class `ly.lex.lilypond.``ParseHideOmit`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.GrobName'>)
  `pattern` = <_sre.SRE_Pattern object at 0x30ca880>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseInputMode`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Base class for parser for mode-changing music commands.

  classmethod `update_state`(state, token)

class `ly.lex.lilypond.``ParseLayout`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses the expression after `\layout {`, leaving at `}`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.LayoutContext'>, <class 'ly.lex.lilypond.LayoutVariable'>, <class 'ly.lex.lilypond.UserVariable'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.DecimalValue'>, <class 'ly.lex.lilypond.Unit'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x33aeed0>

class `ly.lex.lilypond.``ParseLilyPond`(argcount=None)

  Bases: `ly.lex.Parser`

  `mode` = u'lilypond'

class `ly.lex.lilypond.``ParseLyricMode`(argcount=None)

  Bases: `ly.lex.lilypond.ParseInputMode`

  Parser for `\lyrics`, `\lyricmode`, `\addlyrics`, etc.

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.CloseSimultaneous'>, <class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.LyricHyphen'>, <class 'ly.lex.lilypond.LyricExtender'>, <class 'ly.lex.lilypond.LyricSkip'>, <class 'ly.lex.lilypond.LyricText'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x3067090>

class `ly.lex.lilypond.``ParseMarkup`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex.lilypond.MarkupScore'>, <class 'ly.lex.lilypond.MarkupCommand'>, <class 'ly.lex.lilypond.MarkupUserCommand'>, <class 'ly.lex.lilypond.OpenBracketMarkup'>, <class 'ly.lex.lilypond.CloseBracketMarkup'>, <class 'ly.lex.lilypond.MarkupWord'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>)
  `pattern` = <_sre.SRE_Pattern object at 0x32c4cb0>

class `ly.lex.lilypond.``ParseMidi`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses the expression after `\midi {`, leaving at `}`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.LayoutContext'>, <class 'ly.lex.lilypond.LayoutVariable'>, <class 'ly.lex.lilypond.UserVariable'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.DecimalValue'>, <class 'ly.lex.lilypond.Unit'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x33aeed0>

class `ly.lex.lilypond.``ParseMusic`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses LilyPond music expressions.

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.TremoloColon'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2d5af10>

class `ly.lex.lilypond.``ParseNoteMode`(argcount=None)

  Bases: `ly.lex.lilypond.ParseMusic`

  Parser for `\notes` and `\notemode`. Same as Music itself.

class `ly.lex.lilypond.``ParseOverride`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  `argcount` = 0
  `items` = (<class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.GrobProperty'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>)
  `pattern` = <_sre.SRE_Pattern object at 0x24237f0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParsePaper`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses the expression after `\paper {`, leaving at `}`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.PaperVariable'>, <class 'ly.lex.lilypond.UserVariable'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.DecimalValue'>, <class 'ly.lex.lilypond.Unit'>)
  `pattern` = <_sre.SRE_Pattern object at 0x3131ce0>

class `ly.lex.lilypond.``ParsePitchCommand`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `argcount` = 1
  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Octave'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2aabe70>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseRepeat`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.RepeatSpecifier'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.RepeatCount'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2a239d0>

class `ly.lex.lilypond.``ParseRevert`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  parse the arguments of `\revert`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.GrobProperty'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2d3e7e0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseScore`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses the expression after `\score {`, leaving at `}`

  `items` = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex.lilypond.Midi'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2b68420>

class `ly.lex.lilypond.``ParseScriptAbbreviationOrFingering`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `argcount` = 1
  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ScriptAbbreviation'>, <class 'ly.lex.lilypond.Fingering'>)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.lilypond.``ParseSet`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  `argcount` = 0
  `items` = (<class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.ContextProperty'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>)
  `pattern` = <_sre.SRE_Pattern object at 0x23899e0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseString`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `String`

  `items` = (<class 'ly.lex.lilypond.StringQuotedEnd'>, <class 'ly.lex.lilypond.StringQuoteEscape'>)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.lilypond.``ParseTempo`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.EqualSign'>)
  `pattern` = <_sre.SRE_Pattern object at 0x30095c0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseTempoAfterEqualSign`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.TempoSeparator'>)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.lilypond.``ParseTranslator`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.Name'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2abe150>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseTranslatorId`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `argcount` = 1
  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.StringQuotedStart'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2f0bfc0>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseTremolo`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex.lilypond.TremoloDuration'>,)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.lilypond.``ParseTweak`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.GrobProperty'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2e53d30>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseTweakGrobProperty`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.DecimalValue'>)
  `pattern` = <_sre.SRE_Pattern object at 0x26a6d00>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseUnset`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.ContextProperty'>, <class 'ly.lex.lilypond.Name'>)
  `pattern` = <_sre.SRE_Pattern object at 0x26bac20>
  `update_state`(state, token)

class `ly.lex.lilypond.``ParseWith`(argcount=None)

  Bases: `ly.lex.lilypond.ParseLilyPond`

  Parses the expression after `\with {`, leaving at `}`

  `items` = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.ContextProperty'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2bf98a0>

class `ly.lex.lilypond.``PhrasingSlurEnd`

  Bases: `ly.lex.lilypond.SlurEnd`

  `matchname` = u'phrasingslur'
  `rx` = u'\\\\\\)'

class `ly.lex.lilypond.``PhrasingSlurStart`

  Bases: `ly.lex.lilypond.SlurStart`

  `matchname` = u'phrasingslur'
  `rx` = u'\\\\\\('

class `ly.lex.lilypond.``PipeSymbol`

  Bases: `ly.lex.lilypond.Delimiter`

  `rx` = u'\\|'

class `ly.lex.lilypond.``PitchCommand`

  Bases: `ly.lex.lilypond.Command`

  `rx` = u'\\\\(relative|transpose|transposition|key|octaveCheck)\\b'
  `update_state`(state)

class `ly.lex.lilypond.``Q`

  Bases: `ly.lex.lilypond.MusicItem`

  `rx` = u'q(?![A-Za-z])'

class `ly.lex.lilypond.``Repeat`

  Bases: `ly.lex.lilypond.Command`

  `rx` = u'\\\\repeat(?![A-Za-z])'
  `update_state`(state)

class `ly.lex.lilypond.``RepeatCount`

  Bases: `ly.lex.lilypond.IntegerValue`, `ly.lex._token.Leaver`

class `ly.lex.lilypond.``RepeatSpecifier`

  Bases: `ly.lex.lilypond.Specifier`

  `rx` = u'\\b(unfold|percent|volta|tremolo)(?![A-Za-z])'

class `ly.lex.lilypond.``Rest`

  Bases: `ly.lex.lilypond.MusicItem`

  `rx` = u'[Rr](?![A-Za-z])'

class `ly.lex.lilypond.``Revert`

  Bases: `ly.lex.lilypond.Override`

  `rx` = u'\\\\revert\\b'
  `update_state`(state)

class `ly.lex.lilypond.``Scaling`

  Bases: `ly.lex.lilypond.Duration`

  `rx` = u'\\*[\\t ]*\\d+(/\\d+)?'

class `ly.lex.lilypond.``SchemeStart`

  Bases: `ly.lex._token.Item`

  `rx` = u'[#$](?![{}])'
  `update_state`(state)

class `ly.lex.lilypond.``Score`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\score\\b'
  `update_state`(state)

class `ly.lex.lilypond.``ScriptAbbreviation`

  Bases: `ly.lex.lilypond.Articulation`, `ly.lex._token.Leaver`

  `rx` = u'[+|!>._^-]'

class `ly.lex.lilypond.``SequentialEnd`

  Bases: `ly.lex.lilypond.CloseBracket`

class `ly.lex.lilypond.``SequentialStart`

  Bases: `ly.lex.lilypond.OpenBracket`

  `update_state`(state)

class `ly.lex.lilypond.``Set`

  Bases: `ly.lex.lilypond.Override`

  `rx` = u'\\\\set\\b'
  `update_state`(state)

class `ly.lex.lilypond.``SimultaneousEnd`

  Bases: `ly.lex.lilypond.CloseSimultaneous`

class `ly.lex.lilypond.``SimultaneousOrSequentialCommand`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\(simultaneous|sequential)\\b'

class `ly.lex.lilypond.``SimultaneousStart`

  Bases: `ly.lex.lilypond.OpenSimultaneous`

  `update_state`(state)

class `ly.lex.lilypond.``Skip`

  Bases: `ly.lex.lilypond.MusicItem`

  `rx` = u'\\\\skip(?![_-]?[^\\W\\d])'

class `ly.lex.lilypond.``Slur`

  Bases: `ly.lex._token.Token`

class `ly.lex.lilypond.``SlurEnd`

  Bases: `ly.lex.lilypond.Slur`, `ly.lex._token.MatchEnd`

  `matchname` = u'slur'
  `rx` = u'\\)'

class `ly.lex.lilypond.``SlurStart`

  Bases: `ly.lex.lilypond.Slur`, `ly.lex._token.MatchStart`

  `matchname` = u'slur'
  `rx` = u'\\('

class `ly.lex.lilypond.``Spacer`

  Bases: `ly.lex.lilypond.MusicItem`

  `rx` = u's(?![A-Za-z])'

class `ly.lex.lilypond.``Specifier`

  Bases: `ly.lex._token.Token`

class `ly.lex.lilypond.``String`

  Bases: `ly.lex._token.String`

class `ly.lex.lilypond.``StringNumber`

  Bases: `ly.lex.lilypond.Articulation`

  `rx` = u'\\\\\\d+'

class `ly.lex.lilypond.``StringQuoteEscape`

  Bases: `ly.lex._token.Character`

  `rx` = u'\\\\[\\\\"]'

class `ly.lex.lilypond.``StringQuotedEnd`

  Bases: `ly.lex.lilypond.String`, `ly.lex._token.StringEnd`

  `rx` = u'"'
  `update_state`(state)

class `ly.lex.lilypond.``StringQuotedStart`

  Bases: `ly.lex.lilypond.String`, `ly.lex._token.StringStart`

  `rx` = u'"'
  `update_state`(state)

class `ly.lex.lilypond.``Tempo`

  Bases: `ly.lex.lilypond.Command`

  `rx` = u'\\\\tempo\\b'
  `update_state`(state)

class `ly.lex.lilypond.``TempoSeparator`

  Bases: `ly.lex.lilypond.Delimiter`

  `rx` = u'[-~](?=\\s*\\d)'

class `ly.lex.lilypond.``Tie`

  Bases: `ly.lex.lilypond.Slur`

  `rx` = u'~'

class `ly.lex.lilypond.``Translator`

  Bases: `ly.lex.lilypond.Command`

  `update_state`(state)

class `ly.lex.lilypond.``Tremolo`

  Bases: `ly.lex._token.Token`

class `ly.lex.lilypond.``TremoloColon`

  Bases: `ly.lex.lilypond.Tremolo`

  `rx` = u':'
  `update_state`(state)

class `ly.lex.lilypond.``TremoloDuration`

  Bases: `ly.lex.lilypond.Tremolo`, `ly.lex._token.Leaver`

  `rx` = u'\\b(8|16|32|64|128|256|512|1024|2048)(?!\\d)'

class `ly.lex.lilypond.``Tweak`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\tweak\\b'
  `update_state`(state)

class `ly.lex.lilypond.``Unit`

  Bases: `ly.lex.lilypond.Command`

  `rx` = u'\\\\(mm|cm|in|pt)\\b'

class `ly.lex.lilypond.``Unset`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\unset\\b'
  `update_state`(state)

class `ly.lex.lilypond.``UserCommand`

  Bases: `ly.lex.lilypond.IdentifierRef`

class `ly.lex.lilypond.``UserVariable`

  Bases: `ly.lex.lilypond.Identifier`

class `ly.lex.lilypond.``Value`

  Bases: `ly.lex._token.Item`, `ly.lex._token.Numeric`

class `ly.lex.lilypond.``Variable`

  Bases: `ly.lex.lilypond.Identifier`

class `ly.lex.lilypond.``VoiceSeparator`

  Bases: `ly.lex.lilypond.Delimiter`

  `rx` = u'\\\\\\\\'

class `ly.lex.lilypond.``With`

  Bases: `ly.lex.lilypond.Keyword`

  `rx` = u'\\\\with\\b'
  `update_state`(state)

## ly.lex.scheme module

Parses and tokenizes Scheme input.

class `ly.lex.scheme.``BlockComment`

  Bases: `ly.lex.scheme.Comment`, `ly.lex._token.BlockComment`

class `ly.lex.scheme.``BlockCommentEnd`

  Bases: `ly.lex.scheme.Comment`, `ly.lex._token.BlockCommentEnd`, `ly.lex._token.Leaver`

  `rx` = u'!#'

class `ly.lex.scheme.``BlockCommentStart`

  Bases: `ly.lex.scheme.Comment`, `ly.lex._token.BlockCommentStart`

  `rx` = u'#!'
  `update_state`(state)

class `ly.lex.scheme.``Bool`

  Bases: `ly.lex.scheme.Scheme`, `ly.lex._token.Item`

  `rx` = u'#[tf]\\b'

class `ly.lex.scheme.``Char`

  Bases: `ly.lex.scheme.Scheme`, `ly.lex._token.Item`

  `rx` = u'#\\\\([a-z]+|.)'

class `ly.lex.scheme.``CloseParen`

  Bases: `ly.lex.scheme.Scheme`, `ly.lex._token.MatchEnd`, `ly.lex._token.Dedent`

  `matchname` = u'schemeparen'
  `rx` = u'\\)'
  `update_state`(state)

class `ly.lex.scheme.``Comment`

  Bases: `ly.lex._token.Comment`

class `ly.lex.scheme.``Constant`

  Bases: `ly.lex.scheme.Word`

  classmethod `test_match`(match)

class `ly.lex.scheme.``Dot`

  Bases: `ly.lex.scheme.Scheme`

  `rx` = u'\\.(?!\\S)'

class `ly.lex.scheme.``Float`

  Bases: `ly.lex.scheme.Number`

  `rx` = u'-?((\\d+(\\.\\d*)|\\.\\d+)(E\\d+)?)(?=$|[)\\s])'

class `ly.lex.scheme.``Fraction`

  Bases: `ly.lex.scheme.Number`

  `rx` = u'-?\\d+/\\d+(?=$|[)\\s])'

class `ly.lex.scheme.``Function`

  Bases: `ly.lex.scheme.Word`

  classmethod `test_match`(match)

class `ly.lex.scheme.``Keyword`

  Bases: `ly.lex.scheme.Word`

  classmethod `test_match`(match)

class `ly.lex.scheme.``LilyPond`

  Bases: `ly.lex._token.Token`

class `ly.lex.scheme.``LilyPondEnd`

  Bases: `ly.lex.scheme.LilyPond`, `ly.lex._token.Leaver`, `ly.lex._token.MatchEnd`, `ly.lex._token.Dedent`

  `matchname` = u'schemelily'
  `rx` = u'#}'

class `ly.lex.scheme.``LilyPondStart`

  Bases: `ly.lex.scheme.LilyPond`, `ly.lex._token.MatchStart`, `ly.lex._token.Indent`

  `matchname` = u'schemelily'
  `rx` = u'#{'
  `update_state`(state)

class `ly.lex.scheme.``LineComment`

  Bases: `ly.lex.scheme.Comment`, `ly.lex._token.LineComment`

  `rx` = u';.*$'

class `ly.lex.scheme.``Number`

  Bases: `ly.lex._token.Item`, `ly.lex._token.Numeric`

  `rx` = u'(-?\\d+|#(b[0-1]+|o[0-7]+|x[0-9a-fA-F]+)|[-+]inf.0|[-+]?nan.0)(?=$|[)\\s])'

class `ly.lex.scheme.``OpenParen`

  Bases: `ly.lex.scheme.Scheme`, `ly.lex._token.MatchStart`, `ly.lex._token.Indent`

  `matchname` = u'schemeparen'
  `rx` = u'\\('
  `update_state`(state)

class `ly.lex.scheme.``ParseBlockComment`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `BlockComment`

  `items` = (<class 'ly.lex.scheme.BlockCommentEnd'>,)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.scheme.``ParseLilyPond`(argcount=None)

  Bases: `ly.lex.lilypond.ParseMusic`

  `items` = (<class 'ly.lex.scheme.LilyPondEnd'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.TremoloColon'>)
  `pattern` = <_sre.SRE_Pattern object at 0x3519df0>

class `ly.lex.scheme.``ParseScheme`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.scheme.OpenParen'>, <class 'ly.lex.scheme.CloseParen'>, <class 'ly.lex.scheme.LineComment'>, <class 'ly.lex.scheme.BlockCommentStart'>, <class 'ly.lex.scheme.LilyPondStart'>, <class 'ly.lex.scheme.VectorStart'>, <class 'ly.lex.scheme.Dot'>, <class 'ly.lex.scheme.Bool'>, <class 'ly.lex.scheme.Char'>, <class 'ly.lex.scheme.Quote'>, <class 'ly.lex.scheme.Fraction'>, <class 'ly.lex.scheme.Float'>, <class 'ly.lex.scheme.Number'>, <class 'ly.lex.scheme.Constant'>, <class 'ly.lex.scheme.Keyword'>, <class 'ly.lex.scheme.Function'>, <class 'ly.lex.scheme.Variable'>, <class 'ly.lex.scheme.Word'>, <class 'ly.lex.scheme.StringQuotedStart'>)
  `mode` = u'scheme'
  `pattern` = <_sre.SRE_Pattern object at 0x3443070>

class `ly.lex.scheme.``ParseString`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `String`

  `items` = (<class 'ly.lex.scheme.StringQuotedEnd'>, <class 'ly.lex.scheme.StringQuoteEscape'>)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.scheme.``Quote`

  Bases: `ly.lex.scheme.Scheme`

  `rx` = u"['`,]"

class `ly.lex.scheme.``Scheme`

  Bases: `ly.lex._token.Token`

  Baseclass for Scheme tokens.

class `ly.lex.scheme.``String`

  Bases: `ly.lex._token.String`

class `ly.lex.scheme.``StringQuoteEscape`

  Bases: `ly.lex._token.Character`

  `rx` = u'\\\\[\\\\"]'

class `ly.lex.scheme.``StringQuotedEnd`

  Bases: `ly.lex.scheme.String`, `ly.lex._token.StringEnd`

  `rx` = u'"'
  `update_state`(state)

class `ly.lex.scheme.``StringQuotedStart`

  Bases: `ly.lex.scheme.String`, `ly.lex._token.StringStart`

  `rx` = u'"'
  `update_state`(state)

class `ly.lex.scheme.``Variable`

  Bases: `ly.lex.scheme.Word`

  classmethod `test_match`(match)

class `ly.lex.scheme.``VectorStart`

  Bases: `ly.lex.scheme.OpenParen`

  `rx` = u'#\\('

class `ly.lex.scheme.``Word`

  Bases: `ly.lex.scheme.Scheme`, `ly.lex._token.Item`

  `rx` = u'[^()"{}\\s]+'

## ly.lex.texinfo module

Parses and tokenizes Texinfo input, recognizing LilyPond in Texinfo.

class `ly.lex.texinfo.``Accent`

  Bases: `ly.lex.texinfo.EscapeChar`

  `rx` = u'@[\'"\',=^`~](\\{[a-zA-Z]\\}|[a-zA-Z]\\b)'

class `ly.lex.texinfo.``Attribute`

  Bases: `ly.lex._token.Token`

class `ly.lex.texinfo.``Block`

  Bases: `ly.lex._token.Token`

class `ly.lex.texinfo.``BlockCommentEnd`

  Bases: `ly.lex.texinfo.Comment`, `ly.lex._token.Leaver`, `ly.lex._token.BlockCommentEnd`

  `rx` = u'@end\\s+ignore\\b'

class `ly.lex.texinfo.``BlockCommentStart`

  Bases: `ly.lex.texinfo.Comment`, `ly.lex._token.BlockCommentStart`

  `rx` = u'@ignore\\b'
  `update_state`(state)

class `ly.lex.texinfo.``BlockEnd`

  Bases: `ly.lex.texinfo.Block`, `ly.lex._token.Leaver`

  `rx` = u'\\}'

class `ly.lex.texinfo.``BlockStart`

  Bases: `ly.lex.texinfo.Block`

  `rx` = u'@[a-zA-Z]+\\{'
  `update_state`(state)

class `ly.lex.texinfo.``Comment`

  Bases: `ly.lex._token.Comment`

class `ly.lex.texinfo.``EscapeChar`

  Bases: `ly.lex._token.Character`

  `rx` = u'@[@{}]'

class `ly.lex.texinfo.``Keyword`

  Bases: `ly.lex._token.Token`

  `rx` = u'@[a-zA-Z]+'

class `ly.lex.texinfo.``LilyPondAttrEnd`

  Bases: `ly.lex.texinfo.Attribute`, `ly.lex._token.Leaver`

  `rx` = u'\\]'

class `ly.lex.texinfo.``LilyPondAttrStart`

  Bases: `ly.lex.texinfo.Attribute`

  `rx` = u'\\['
  `update_state`(state)

class `ly.lex.texinfo.``LilyPondBlockEnd`

  Bases: `ly.lex.texinfo.Block`, `ly.lex._token.Leaver`

  `rx` = u'\\}'

class `ly.lex.texinfo.``LilyPondBlockStart`

  Bases: `ly.lex.texinfo.Block`

  `rx` = u'@lilypond(?=(\\[[a-zA-Z,=0-9\\\\\\s]+\\])?\\{)'
  `update_state`(state)

class `ly.lex.texinfo.``LilyPondBlockStartBrace`

  Bases: `ly.lex.texinfo.Block`

  `rx` = u'\\{'
  `update_state`(state)

class `ly.lex.texinfo.``LilyPondEnvEnd`

  Bases: `ly.lex.texinfo.Keyword`, `ly.lex._token.Leaver`

  `rx` = u'@end\\s+lilypond\\b'

class `ly.lex.texinfo.``LilyPondEnvStart`

  Bases: `ly.lex.texinfo.Keyword`

  `rx` = u'@lilypond\\b'
  `update_state`(state)

class `ly.lex.texinfo.``LilyPondFileStart`

  Bases: `ly.lex.texinfo.Block`

  `rx` = u'@lilypondfile\\b'
  `update_state`(state)

class `ly.lex.texinfo.``LilyPondFileStartBrace`

  Bases: `ly.lex.texinfo.Block`

  `rx` = u'\\{'
  `update_state`(state)

class `ly.lex.texinfo.``LineComment`

  Bases: `ly.lex.texinfo.Comment`, `ly.lex._token.LineComment`

  `rx` = u'@c\\b.*$'

class `ly.lex.texinfo.``ParseBlock`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex.texinfo.BlockEnd'>, <class 'ly.lex.texinfo.Accent'>, <class 'ly.lex.texinfo.EscapeChar'>, <class 'ly.lex.texinfo.BlockStart'>, <class 'ly.lex.texinfo.Keyword'>)
  `pattern` = <_sre.SRE_Pattern object at 0x2700cc0>

class `ly.lex.texinfo.``ParseComment`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `Comment`

  `items` = (<class 'ly.lex.texinfo.BlockCommentEnd'>,)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.texinfo.``ParseLilyPondAttr`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `Attribute`

  `items` = (<class 'ly.lex.texinfo.LilyPondAttrEnd'>,)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.texinfo.``ParseLilyPondBlock`(argcount=None)

  Bases: `ly.lex.lilypond.ParseGlobal`

  `items` = (<class 'ly.lex.texinfo.LilyPondBlockEnd'>, <class 'ly.lex.lilypond.Book'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)
  `pattern` = <_sre.SRE_Pattern object at 0x35ed840>

class `ly.lex.texinfo.``ParseLilyPondBlockAttr`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex.texinfo.LilyPondAttrStart'>, <class 'ly.lex.texinfo.LilyPondBlockStartBrace'>)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.texinfo.``ParseLilyPondEnv`(argcount=None)

  Bases: `ly.lex.lilypond.ParseGlobal`

  `items` = (<class 'ly.lex.texinfo.LilyPondEnvEnd'>, <class 'ly.lex.lilypond.Book'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)
  `pattern` = <_sre.SRE_Pattern object at 0x35eb310>

class `ly.lex.texinfo.``ParseLilyPondEnvAttr`(argcount=None)

  Bases: `ly.lex.FallthroughParser`

  `fallthrough`(state)
  `items` = (<class 'ly.lex.texinfo.LilyPondAttrStart'>,)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.texinfo.``ParseLilyPondFile`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex.texinfo.LilyPondAttrStart'>, <class 'ly.lex.texinfo.LilyPondFileStartBrace'>)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.texinfo.``ParseTexinfo`(argcount=None)

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex.texinfo.LineComment'>, <class 'ly.lex.texinfo.BlockCommentStart'>, <class 'ly.lex.texinfo.Accent'>, <class 'ly.lex.texinfo.EscapeChar'>, <class 'ly.lex.texinfo.LilyPondBlockStart'>, <class 'ly.lex.texinfo.LilyPondEnvStart'>, <class 'ly.lex.texinfo.LilyPondFileStart'>, <class 'ly.lex.texinfo.BlockStart'>, <class 'ly.lex.texinfo.VerbatimStart'>, <class 'ly.lex.texinfo.Keyword'>)
  `mode` = u'texinfo'
  `pattern` = <_sre.SRE_Pattern object at 0x35e5fe0>

class `ly.lex.texinfo.``ParseVerbatim`(argcount=None)

  Bases: `ly.lex.Parser`

  `default`

    alias of `Verbatim`

  `items` = (<class 'ly.lex.texinfo.VerbatimEnd'>,)
  `pattern` = <_sre.SRE_Pattern object>

class `ly.lex.texinfo.``Verbatim`

  Bases: `ly.lex._token.Token`

class `ly.lex.texinfo.``VerbatimEnd`

  Bases: `ly.lex.texinfo.Keyword`, `ly.lex._token.Leaver`

  `rx` = u'@end\\s+verbatim\\b'

class `ly.lex.texinfo.``VerbatimStart`

  Bases: `ly.lex.texinfo.Keyword`

  `rx` = u'@verbatim\\b'
  `update_state`(state)