# 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 `ly.lex._token.Unparsed`

  `freeze`()

    Return our instance values as a hashable tuple.

  `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` = '\\s+'

class `ly.lex.``Newline`

  Bases: `ly.lex._token.Space`

  A token that is a single newline.

  `rx` = '\\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` = ''

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` = ''

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` = 'docbook'
  `pattern` = re.compile('(?P<g_0>\\s+)', re.MULTILINE)

## ly.lex.html module

Parses and tokenizes HTML input, recognizing LilyPond in HTML.

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

  Bases: `ly.lex._token.Token`

  `rx` = '\\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` = '-->'

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex._token.Character`

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

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

  Bases: `ly.lex._token.Token`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

  `rx` = '</lilypond>'

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

  Bases: `ly.lex.html.LilyPondTag`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

  `rx` = '/?>'

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

  Bases: `ly.lex.html.LilyPondTag`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

  `rx` = '/?>'

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

  Bases: `ly.lex.html.Tag`

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

  Bases: `ly.lex.html.LilyPondTag`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.html.LilyPondTag`

  `rx` = '<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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>/?>)|(?P<g_2>\\w+([-_:]\\w+)?)|(?P<g_3>=)|(?P<g_4>")|(?P<g_5>\')', re.MULTILINE)

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

  Bases: `ly.lex.Parser`

  `default`

    alias of `Comment`

  `items` = (<class 'ly.lex.html.CommentEnd'>,)
  `pattern` = re.compile('(?P<g_0>-->)', re.MULTILINE)

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` = 'html'
  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1><lilypondversion/?>)|(?P<g_2></?lilypondfile\\b)|(?P<g_3><lilypond\\b)|(?P<g_4><!--)|(?P<g_5></?\\w[-_:\\w]*\\b)|(?P<g_6>\\&(#\\d+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);)', re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0></lilypond>)|(?P<g_1>\\\\book\\b)|(?P<g_2>\\\\bookpart\\b)|(?P<g_3>\\\\score\\b)|(?P<g_4>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_5>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_6>\\\\markuplist(?![_-], re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>\\w+([-_:]\\w+)?)|(?P<g_2>=)|(?P<g_3>")|(?P<g_4>\')|(?P<g_5>>)|(?P<g_6>:)', re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>\\w+([-_:]\\w+)?)|(?P<g_2>=)|(?P<g_3>")|(?P<g_4>\')|(?P<g_5>/?>)', re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>/?>)|(?P<g_1>\\s+)|(?P<g_2>%{)|(?P<g_3>%.*$)|(?P<g_4>[#$](?![{}]))|(?P<g_5>")|(?P<g_6>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z]))|(?P<g_7>\, re.MULTILINE)

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` = re.compile('(?P<g_0>")|(?P<g_1>\\&(#\\d+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);)', re.MULTILINE)

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` = re.compile("(?P<g_0>')|(?P<g_1>\\&(#\\d+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);)", re.MULTILINE)

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

  Bases: `ly.lex.FallthroughParser`

  Finds a value or drops back.

  `fallthrough`(state)

    Called when no match is returned by parse().

    This implementation leaves the current parser and returns None (causing the State to continue parsing).

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.Value'>)
  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>\\w+)', re.MULTILINE)

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

  Bases: `ly.lex._token.Token`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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` = '"'

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

  `rx` = "'"

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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` = '/?>'

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

  Bases: `ly.lex.html.Tag`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex._token.Leaver`

  `rx` = '\\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` = 'latex'
  `pattern` = re.compile('(?P<g_0>\\s+)', re.MULTILINE)

## 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` = '\\?'

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

  Bases: `ly.lex.lilypond.Accidental`

  `rx` = '!'

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

  Bases: `ly.lex.lilypond.Command`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Specifier`

  `rx` = '\\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` = '\\\\alterBroken\\b'
  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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

  Bases: `ly.lex.lilypond.ContextName`

  `rx` = '\\\\(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` = 'beam'
  `rx` = '\\]'

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

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

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

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` = '%}'

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Translator`

  `rx` = '\\\\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` = '>'

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` = '\\\\(chords|chordmode)\\b'
  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.ChordItem`

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

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

  Bases: `ly.lex.lilypond.ChordItem`

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

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

  Bases: `ly.lex.lilypond.Chord`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.ChordItem`

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

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

  Bases: `ly.lex.lilypond.Command`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Specifier`

  `rx` = '\\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)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.CloseBracket`

  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

  classmethod `test_match`(match)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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

  Bases: `ly.lex._token.Comment`

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

  Bases: `ly.lex.lilypond.Translator`

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

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

  Bases: `ly.lex._token.Token`

  `rx` = '\\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` = '\\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|supportNonIntegerFret|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` = '-?\\d+(\\.\\d+)?'

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

  Bases: `ly.lex._token.Token`

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

  Bases: `ly.lex._token.Token`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Duration`

  `rx` = '\\.'

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

  Bases: `ly.lex.lilypond.ChordItem`

  `rx` = '\\.'

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

  Bases: `ly.lex.lilypond.Delimiter`

  A dot in dotted path notation.

  `rx` = '\\.'

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

  Bases: `ly.lex.lilypond.ChordEnd`

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

  Bases: `ly.lex.lilypond.ChordStart`

  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.InputMode`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.MusicItem`

  `rx` = '[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` = '\\\\[<!>]|\\\\(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` = '='

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

  Bases: `ly.lex._token.Error`

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

  Bases: `ly.lex.lilypond.Error`

  `rx` = '[-_^][_.>|!+^-]|<<|>>|\\\\[\\\\\\]\\[\\(\\)()]|(\\\\(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`

  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)
  `replace`

    alias of `ParseBook`

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

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)
  `replace`

    alias of `ParseBookPart`

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

  Bases: `ly.lex.lilypond.ExpectMusicList`

  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>\\\\(simultaneous|sequential)\\b)', re.MULTILINE)
  `replace`

    alias of `ParseChordMode`

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

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)
  `replace`

    alias of `ParseContext`

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

  Bases: `ly.lex.lilypond.ExpectMusicList`

  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>\\\\(simultaneous|sequential)\\b)', re.MULTILINE)
  `replace`

    alias of `ParseDrumMode`

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

  Bases: `ly.lex.lilypond.ExpectMusicList`

  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>\\\\(simultaneous|sequential)\\b)', re.MULTILINE)
  `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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b([a-z]+|[XY])(-([a-z]+|[XY]))*(?![\\w]))', re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)
  `replace`

    alias of `ParseHeader`

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

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)
  `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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>[#$](?![{}]))|(?P<g_6>")|(?P<g_7>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_8>\\\\(simultaneous|sequ, re.MULTILINE)
  `replace`

    alias of `ParseLyricMode`

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

  Bases: `ly.lex.lilypond.ExpectOpenBracket`

  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)
  `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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>\\\\(simultaneous|sequential)\\b)', re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>=)', re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = '[-+!]+'

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

  Bases: `ly.lex.lilypond.Figure`

  `rx` = '[][]'

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

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

  `rx` = '>'

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

  Bases: `ly.lex.lilypond.InputMode`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Figure`

  A figure modifier.

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

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

  Bases: `ly.lex.lilypond.Figure`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Figure`

  A step figure number or the underscore.

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

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

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

  `rx` = '\\d+'

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

  Bases: `ly.lex.lilypond.Value`

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

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

  Bases: `ly.lex._token.Token`

  `rx` = '\\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` = '\\b([a-z]+|[XY])(-([a-z]+|[XY]))*(?![\\w])'

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Variable`

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

  classmethod `test_match`(match)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex._token.Token`

  A variable name, like `some-variable`.

  `rx` = '(?<![^\\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` = '\\\\[^\\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` = '\\d+'

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

  Bases: `ly.lex.lilypond.Command`

  `rx` = '\\\\(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)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Variable`

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

  classmethod `test_match`(match)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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

  Bases: `ly.lex.lilypond.Duration`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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` = 'ligature'
  `rx` = '\\\\\\]'

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

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

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

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

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

  `rx` = '%.*$'

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` = '__(?=($|[\\s\\\\]))'

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

  Bases: `ly.lex.lilypond.Lyric`

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

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

  Bases: `ly.lex.lilypond.InputMode`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Lyric`

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

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

  Bases: `ly.lex.lilypond.Lyric`

  `rx` = '[^\\\\\\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)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Markup`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Markup`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Markup`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex._token.Item`

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

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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` = '\\\\new\\b'

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

  Bases: `ly.lex.lilypond.MusicItem`

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

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

  Bases: `ly.lex.lilypond.InputMode`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex._token.Token`

  `rx` = ",+|'+"

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

  Bases: `ly.lex._token.Token`

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

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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` = 'bracket'
  `rx` = '\\{'

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

  Bases: `ly.lex.lilypond.OpenBracket`

  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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` = 'simultaneous'
  `rx` = '<<'

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Variable`

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

  classmethod `test_match`(match)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b([a-z]+|[XY])(-([a-z]+|[XY]))*(?![\\w]))', re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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

  Bases: `ly.lex.Parser`

  `default`

    alias of `BlockComment`

  `items` = (<class 'ly.lex.lilypond.BlockCommentEnd'>,)
  `pattern` = re.compile('(?P<g_0>%})', re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_2>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_3>\\\\markuplist(?![_-]?[^\\W\\d]))|(?P<g_4>\\\\bookpart\\b)|(?P<g_5>\\\\score\\b)|(?P<g_6>\\\\pape, re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_2>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_3>\\\\markuplist(?![_-]?[^\\W\\d]))|(?P<g_4>\\\\score\\b)|(?P<g_5>\\\\paper\\b)|(?P<g_6>\\\\header\, re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>[-_^][_.>|!+^-]|<<|>>|\\\\[\\\\\\]\\[\\(\\)()]|(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))|\\*[\\t ]*\\d+(/\\d+)?)|(?P<g_1>>)|(?P<g_2>\\s+)|(?P<g_3>%{)|(?P<g, re.MULTILINE)

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` = re.compile('(?P<g_0>:|\\^|/\\+?)|(?P<g_1>((?<![a-z])|^)(aug|dim|sus|min|maj|m)(?![a-z]))|(?P<g_2>\\d+[-+]?)|(?P<g_3>\\.)|(?P<g_4>[a-x]+(?![A-Za-z]))', re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\{)|(?P<g_1><<)|(?P<g_2>\\s+)|(?P<g_3>%{)|(?P<g_4>%.*$)|(?P<g_5>[#$](?![{}]))|(?P<g_6>")|(?P<g_7>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z], re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(alto|baritone|bass|C|F|french|G|GG|mezzosoprano|percussion|soprano|subbass|tab|tenor|tenorG|treble|varbaritone|varC|varpercussion|violin)\\b)|(?P<g, re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanSt, re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\d+/\\d+)|(?P<g_4>-?\\d+(\\.\\d+)?)', re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>[-_^][_.>|!+^-]|<<|>>|\\\\[\\\\\\]\\[\\(\\)()]|(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?, re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\{)|(?P<g_1><<)|(?P<g_2>\\s+)|(?P<g_3>%{)|(?P<g_4>%.*$)|(?P<g_5>[#$](?![{}]))|(?P<g_6>")|(?P<g_7>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z], re.MULTILINE)

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

  Bases: `ly.lex.FallthroughParser`

  `fallthrough`(state)

    Called when no match is returned by parse().

    This implementation leaves the current parser and returns None (causing the State to continue parsing).

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Dot'>)
  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\.)', re.MULTILINE)

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

  Bases: `ly.lex.lilypond.ParseDuration`

  `fallthrough`(state)

    Called when no match is returned by parse().

    This implementation leaves the current parser and returns None (causing the State to continue parsing).

  `items` = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Scaling'>)
  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\*[\\t ]*\\d+(/\\d+)?)', re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>>)|(?P<g_6>[][])|(?P<g_7>_|\\d+)|(?P<g_8>[-+!]+)|(?P<g_9>\\\\[\\\\!+]|/)|(?P<g_10>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_, re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>>>)|(?P<g_7>\\{)|(?P<g_8><<)|(?P<g_9>\\|)|(?P<g_10><)|(?P<g_11>\\\\skip(?![_-]?[^\\W\\d]))|(?P<g_12>s(?![, re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\\\book\\b)|(?P<g_1>\\\\bookpart\\b)|(?P<g_2>\\\\score\\b)|(?P<g_3>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_4>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_5>\\\\markuplist(?![_-]?[^\\W\\d]))|(?P<g_6>, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\\\skip(?![_-]?[^\\W\\d]))|(?P<g_4>s(?![A-Za-z]))|(?P<g_5>q(?![A-Za-z]))|(?P<g_6>[Rr](?![A-Za-z]))|(?P<g_7>[a-x]+(?![A-Za-z]))|(?P<g_8>(\\\\(maxima|lo, re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\.)', re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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.Partial'>, <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` = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_2>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_3>\\\\markuplist(?![_-]?[^\\W\\d]))|(?P<g_4>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\, re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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.Partial'>, <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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>\\\\context\\b)|(?P<g_7>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_8>=)|(?P<g_9, re.MULTILINE)

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

  Bases: `ly.lex.Parser`

  `mode` = '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.Partial'>, <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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>>>)|(?P<g_7>\\{)|(?P<g_8><<)|(?P<g_9>\\|)|(?P<g_10>--(?=($|[\\s\\\\])))|(?P<g_11>__(?=($|[\\s\\\\])))|(?P, re.MULTILINE)

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` = re.compile('(?P<g_0>\\\\score\\b)|(?P<g_1>\\\\[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_2>\\{)|(?P<g_3>\\})|(?P<g_4>[^{}"\\\\\\s#%]+)|(?P<g_5>\\s+)|(?P<g_6>%{)|(?P<g_7>%.*$)|(?P<g_8>[#$](?![{}]))|(?, re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>\\\\context\\b)|(?P<g_7>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_8>=)|(?P<g_9, re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z]))|(?P<g_6>\\\\skip(?![_-, re.MULTILINE)

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` = re.compile('(?P<g_0>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanStaff|KievanVoic, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_7>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_8>\\\\markuplist(?![_-]?[^, re.MULTILINE)

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` = re.compile("(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[a-x]+(?![A-Za-z]))|(?P<g_4>,+|'+)", re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(unfold|percent|volta|tremolo)(?![A-Za-z]))|(?P<g_4>")|(?P<g_5>\\d+)', re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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.Partial'>, <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` = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\header\\b)|(?P<g_2>\\\\layout\\b)|(?P<g_3>\\\\midi\\b)|(?P<g_4>\\\\with\\b)|(?P<g_5>\\s+)|(?P<g_6>%{)|(?P<g_7>%.*$)|(?P<g_8>[#$](?![{}]))|(?P<g_9>")|(?P<g_10>\\{)|(?P<g_11><<, re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[+|!>._^-])|(?P<g_4>\\d+)', re.MULTILINE)

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` = re.compile('(?P<g_0>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanStaff|KievanVoic, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>")|(?P<g_1>\\\\[\\\\"])', re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_4>")|(?P<g_5>[#$](?![{}]))|(?P<g_6>(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d)))|(, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\d+)|(?P<g_4>[-~](?=\\s*\\d))', re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_4>")', re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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

  Bases: `ly.lex.FallthroughParser`

  `items` = (<class 'ly.lex.lilypond.TremoloDuration'>,)
  `pattern` = re.compile('(?P<g_0>\\b(8|16|32|64|128|256|512|1024|2048)(?!\\d))', re.MULTILINE)

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(Accidental|AccidentalCautionary|AccidentalPlacement|AccidentalSuggestion|Ambitus|AmbitusAccidental|AmbitusLine|AmbitusNoteHead|Arpeggio|BalloonText, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\.)|(?P<g_4>-?\\d+(\\.\\d+)?)', re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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` = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)
  `update_state`(state, token)

    Called by the default implementation of Token.update_state().

    Does nothing by default.

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.Partial'>, <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` = re.compile('(?P<g_0>\\})|(?P<g_1>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanSta, re.MULTILINE)

class `ly.lex.lilypond.``Partial`

  Bases: `ly.lex.lilypond.Command`

  `rx` = '\\\\partial\\b'

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

  Bases: `ly.lex.lilypond.SlurEnd`

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

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

  Bases: `ly.lex.lilypond.SlurStart`

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

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

  Bases: `ly.lex.lilypond.Delimiter`

  `rx` = '\\|'

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

  Bases: `ly.lex.lilypond.Command`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.MusicItem`

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

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

  Bases: `ly.lex.lilypond.Command`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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` = '\\b(unfold|percent|volta|tremolo)(?![A-Za-z])'

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

  Bases: `ly.lex.lilypond.MusicItem`

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

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

  Bases: `ly.lex.lilypond.Override`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Duration`

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

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

  Bases: `ly.lex._token.Item`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

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

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

  Bases: `ly.lex.lilypond.CloseBracket`

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

  Bases: `ly.lex.lilypond.OpenBracket`

  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Override`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.CloseSimultaneous`

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

  Bases: `ly.lex.lilypond.Keyword`

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

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

  Bases: `ly.lex.lilypond.OpenSimultaneous`

  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.MusicItem`

  `rx` = '\\\\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` = 'slur'
  `rx` = '\\)'

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

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

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

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

  Bases: `ly.lex.lilypond.MusicItem`

  `rx` = '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` = '\\\\\\d+'

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

  Bases: `ly.lex._token.Character`

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

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Command`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Delimiter`

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

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

  Bases: `ly.lex.lilypond.Slur`

  `rx` = '~'

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

  Bases: `ly.lex.lilypond.Command`

  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex._token.Token`

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

  Bases: `ly.lex.lilypond.Tremolo`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

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

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.lilypond.Command`

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

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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` = '\\\\\\\\'

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

  Bases: `ly.lex.lilypond.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

## 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` = '!#'

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

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

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

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

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

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex._token.Comment`

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

  Bases: `ly.lex.scheme.Word`

  classmethod `test_match`(match)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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

  Bases: `ly.lex.scheme.Scheme`

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

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

  Bases: `ly.lex.scheme.Number`

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

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

  Bases: `ly.lex.scheme.Number`

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

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

  Bases: `ly.lex.scheme.Word`

  classmethod `test_match`(match)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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

  Bases: `ly.lex.scheme.Word`

  classmethod `test_match`(match)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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` = 'schemelily'
  `rx` = '#}'

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

  `rx` = ';.*$'

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

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

  `rx` = '(-?\\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` = 'schemeparen'
  `rx` = '\\('
  `update_state`(state)

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.Parser`

  `default`

    alias of `BlockComment`

  `items` = (<class 'ly.lex.scheme.BlockCommentEnd'>,)
  `pattern` = re.compile('(?P<g_0>!#)', re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>#})|(?P<g_1>\\s+)|(?P<g_2>%{)|(?P<g_3>%.*$)|(?P<g_4>[#$](?![{}]))|(?P<g_5>")|(?P<g_6>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z]))|(?P<g_7>\\, re.MULTILINE)

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` = 'scheme'
  `pattern` = re.compile('(?P<g_0>\\s+)|(?P<g_1>\\()|(?P<g_2>\\))|(?P<g_3>;.*$)|(?P<g_4>#!)|(?P<g_5>#{)|(?P<g_6>#\\()|(?P<g_7>\\.(?!\\S))|(?P<g_8>#[tf]\\b)|(?P<g_9>#\\\\([a-z]+|.))|(?P<g_10>[\'`,])|(?P<g_11>-?\\d+/\\d+(?=$|[), re.MULTILINE)

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` = re.compile('(?P<g_0>")|(?P<g_1>\\\\[\\\\"])', re.MULTILINE)

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

  Bases: `ly.lex.scheme.Scheme`

  `rx` = "['`,]"

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` = '\\\\[\\\\"]'

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.scheme.Word`

  classmethod `test_match`(match)

    Should return True if the match should indeed instantiate this class.

    This class method is only called if multiple Token classes in the Parser’s items list have the same rx attribute. This method is then called for every matching Token subclass until one returns True. That token is then instantiated. (The method is not called for the last class in the list that have the same rx attribute, and also not if there is only one class with that rx attribute.)

    The default implementation always returns True.

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

  Bases: `ly.lex.scheme.OpenParen`

  `rx` = '#\\('

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

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

  `rx` = '[^()"{}\\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` = '@[\'"\',=^`~](\\{[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` = '@end\\s+ignore\\b'

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

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

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

  `rx` = '\\}'

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

  Bases: `ly.lex.texinfo.Block`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex._token.Comment`

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

  Bases: `ly.lex._token.Character`

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

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

  Bases: `ly.lex._token.Token`

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

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

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

  `rx` = '\\]'

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

  Bases: `ly.lex.texinfo.Attribute`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

  `rx` = '\\}'

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

  Bases: `ly.lex.texinfo.Block`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.texinfo.Block`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

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

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

  Bases: `ly.lex.texinfo.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.texinfo.Block`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

  Bases: `ly.lex.texinfo.Block`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.

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

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

  `rx` = '@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` = re.compile('(?P<g_0>\\})|(?P<g_1>@[\'"\',=^`~](\\{[a-zA-Z]\\}|[a-zA-Z]\\b))|(?P<g_2>@[@{}])|(?P<g_3>@[a-zA-Z]+\\{)|(?P<g_4>@[a-zA-Z]+)', re.MULTILINE)

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

  Bases: `ly.lex.Parser`

  `default`

    alias of `Comment`

  `items` = (<class 'ly.lex.texinfo.BlockCommentEnd'>,)
  `pattern` = re.compile('(?P<g_0>@end\\s+ignore\\b)', re.MULTILINE)

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

  Bases: `ly.lex.Parser`

  `default`

    alias of `Attribute`

  `items` = (<class 'ly.lex.texinfo.LilyPondAttrEnd'>,)
  `pattern` = re.compile('(?P<g_0>\\])', re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\book\\b)|(?P<g_2>\\\\bookpart\\b)|(?P<g_3>\\\\score\\b)|(?P<g_4>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_5>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_6>\\\\markuplist(?![_-]?[^\\W\\, re.MULTILINE)

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

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex.texinfo.LilyPondAttrStart'>, <class 'ly.lex.texinfo.LilyPondBlockStartBrace'>)
  `pattern` = re.compile('(?P<g_0>\\[)|(?P<g_1>\\{)', re.MULTILINE)

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.Partial'>, <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` = re.compile('(?P<g_0>@end\\s+lilypond\\b)|(?P<g_1>\\\\book\\b)|(?P<g_2>\\\\bookpart\\b)|(?P<g_3>\\\\score\\b)|(?P<g_4>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_5>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_6>\\\\markuplis, re.MULTILINE)

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

  Bases: `ly.lex.FallthroughParser`

  `fallthrough`(state)

    Called when no match is returned by parse().

    This implementation leaves the current parser and returns None (causing the State to continue parsing).

  `items` = (<class 'ly.lex.texinfo.LilyPondAttrStart'>,)
  `pattern` = re.compile('(?P<g_0>\\[)', re.MULTILINE)

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

  Bases: `ly.lex.Parser`

  `items` = (<class 'ly.lex.texinfo.LilyPondAttrStart'>, <class 'ly.lex.texinfo.LilyPondFileStartBrace'>)
  `pattern` = re.compile('(?P<g_0>\\[)|(?P<g_1>\\{)', re.MULTILINE)

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` = 'texinfo'
  `pattern` = re.compile('(?P<g_0>@c\\b.*$)|(?P<g_1>@ignore\\b)|(?P<g_2>@[\'"\',=^`~](\\{[a-zA-Z]\\}|[a-zA-Z]\\b))|(?P<g_3>@[@{}])|(?P<g_4>@lilypond(?=(\\[[a-zA-Z,=0-9\\\\\\s]+\\])?\\{))|(?P<g_5>@lilypond\\b)|(?P<g_6>@lilypon, re.MULTILINE)

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

  Bases: `ly.lex.Parser`

  `default`

    alias of `Verbatim`

  `items` = (<class 'ly.lex.texinfo.VerbatimEnd'>,)
  `pattern` = re.compile('(?P<g_0>@end\\s+verbatim\\b)', re.MULTILINE)

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` = '@end\\s+verbatim\\b'

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

  Bases: `ly.lex.texinfo.Keyword`

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

    Lets the token update the state, e.g. enter a different parser.

    This method is called by the State upon instantiation of the tokens.

    Don’t use it later on to have a State follow already instantiated Tokens because the FallthroughParser type can also change the state without generating a Token. Use State.follow() to have a State follow instantiated Tokens.

    The default implementation lets the Parser decide on state change.