rhSrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK J r SSK J r SSK J r SSK J r SSK Jr SS K Jr SS K Jr SS K Jr SS K Jr \R&(aSS KJr \ R,"S5r"SS\ R05r"SS5r"SS\5r"SS\5r"SS\5r"SS\5r"SS5r"SS\5r "SS \5r!"S!S"5r""S#S$\"5r#"S%S&\"5r$"S'S(\$5r%"S)S*\$5r&S5S+jr'SS,S-.r("S.S/5r)"S0S1\RT5r+"S2S3\RT5r,\)\"\\/r-\.S4:XaSSK r \ R^"\+5 gg)6a" tinyNotation is a simple way of specifying single line melodies that uses a notation somewhat similar to Lilypond but with WAY fewer options. It was originally developed to notate trecento (medieval Italian) music, but it is pretty useful for a lot of short examples, so we have made it a generally supported music21 format. N.B.: TinyNotation is not meant to expand to cover every single case. Instead, it is meant to be subclassable to extend to the cases *your* project needs. Here are the most important rules by default: 1. Note names are: a,b,c,d,e,f,g and r for rest 2. Flats, sharps, and naturals are notated as #,- (not b), and (if needed) n. If the accidental is above the staff (i.e., editorial), enclose it in parentheses: (#), etc. Make sure that flats in the key signatures are explicitly specified. 3. Note octaves are specified as follows:: CC to BB = from C below bass clef to second-line B in bass clef C to B = from bass clef C to B below middle C. c to b = from middle C to the middle of treble clef c' to b' = from C in treble clef to B above treble clef Octaves below and above these are specified by further doublings of letter (CCC) or apostrophes (c'') -- this is one of the note name standards found in many music theory books. 4. After the note name, a number may be placed indicating the note length: 1 = whole note, 2 = half, 4 = quarter, 8 = eighth, 16 = sixteenth. etc. If the number is omitted then it is assumed to be the same as the previous note. I.e., c8 B c d is a string of eighth notes. 5. After the number, a ~ can be placed to show a tie to the next note. A "." indicates a dotted note. (If you are entering data via Excel or other spreadsheet, be sure that "capitalize the first letter of sentences" is turned off under "Tools->AutoCorrect," otherwise the next letter will be capitalized, and the octave will be screwed up.) 6. For triplets use this notation: `trip{c4 d8}` indicating that these two notes both have "3s" over them. For 4 in the place of 3, use `quad{c16 d e8}`. No other tuplets are supported. Here is an example of TinyNotation in action. >>> stream1 = converter.parse("tinyNotation: 3/4 E4 r f# g=lastG trip{b-8 a g} c4~ c") >>> stream1.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} {0.0} {1.0} {1.3333} {1.6667} {2.0} {6.0} {0.0} {1.0} >>> stream1.recurse().getElementById('lastG').step 'G' >>> stream1.flatten().notesAndRests[1].isRest True >>> stream1.flatten().notesAndRests[0].octave 3 >>> stream1.flatten().notes[-2].tie.type 'start' >>> stream1.flatten().notes[-1].tie.type 'stop' Changing time signatures are supported: >>> s1 = converter.parse('tinynotation: 3/4 C4 D E 2/4 F G A B 1/4 c') >>> s1.show('t') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} {0.0} {0.0} {1.0} {5.0} {0.0} {1.0} {7.0} {0.0} {0.0} {1.0} Here is an equivalent way of doing the example above, but using the lower level :class:`music21.tinyNotation.Converter` object: >>> tnc = tinyNotation.Converter('3/4 E4 r f# g=lastG trip{b-8 a g} c4~ c') >>> stream2 = tnc.parse().stream >>> len(stream1.recurse()) == len(stream2.recurse()) True This lower level is needed in case you want to add additional features. For instance, here we will set the "modifierStar" to change the color of notes: >>> class ColorModifier(tinyNotation.Modifier): ... def postParse(self, m21Obj): ... m21Obj.style.color = self.modifierData ... return m21Obj >>> tnc = tinyNotation.Converter('3/4 C4*pink* D4*green* E4*blue*') >>> tnc.modifierStar = ColorModifier >>> s = tnc.parse().stream >>> for n in s.recurse().getElementsByClass(note.Note): ... print(n.step, n.style.color) C pink D green E blue Or more usefully, and often desired: >>> class HarmonyModifier(tinyNotation.Modifier): ... def postParse(self, n): ... cs = harmony.ChordSymbol(n.pitch.name + self.modifierData) ... cs.duration = n.duration ... return cs >>> tnc = tinyNotation.Converter('4/4 C2_maj7 D4_m E-_sus4') >>> tnc.modifierUnderscore = HarmonyModifier >>> s = tnc.parse().stream >>> s.show('text') {0.0} {0.0} {0.0} {0.0} {2.0} {3.0} {4.0} >>> for cs in s.recurse().getElementsByClass(harmony.ChordSymbol): ... print([p.name for p in cs.pitches]) ['C', 'E', 'G', 'B'] ['D', 'F', 'A'] ['E-', 'A-', 'B-'] The supported modifiers are: * `=data` (`modifierEquals`, default action is to set `.id`) * `_data` (`modifierUnderscore`, default action is to set `.lyric`) * `[data]` (`modifierSquare`, no default action) * `` (`modifierAngle`, no default action) * `(data)` (`modifierParens`, no default action) * `*data*` (`modifierStar`, no default action) Another example: TinyNotation does not support key signatures -- well, no problem! Let's create a new Token type and add it to the tokenMap >>> class KeyToken(tinyNotation.Token): ... def parse(self, parent): ... keyName = self.token ... return key.Key(keyName) >>> keyMapping = (r'k(.*)', KeyToken) >>> tnc = tinyNotation.Converter('4/4 kE- G1 kf# A1') >>> tnc.tokenMap.append(keyMapping) >>> s = tnc.parse().stream >>> s.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {4.0} {0.0} {0.0} {4.0} TokenMap should be passed a string, representing a regular expression with exactly one group (which can be the entire expression), and a subclass of :class:`~music21.tinyNotation.Token` which will handle the parsing of the string. Tokens can take advantage of the `parent` variable, which is a reference to the `Converter` object, to use the `.stateDict` dictionary to store information about state. For instance, the `NoteOrRestToken` uses `parent.stateDict['lastDuration']` to get access to the last duration. There is also the concept of "State" which affects multiple tokens. The best way to create a new State is to define a subclass of the :class:`~music21.tinyNotation.State` and add it to `bracketStateMapping` of the converter. Here's one that a lot of people have asked for over the years: >>> class ChordState(tinyNotation.State): ... def affectTokenAfterParse(self, n): ... super().affectTokenAfterParse(n) ... return None # do not append Note object ... def end(self): ... ch = chord.Chord(self.affectedTokens) ... ch.duration = self.affectedTokens[0].duration ... return ch >>> tnc = tinyNotation.Converter("2/4 C4 chord{C4 e g'} F.4 chord{D8 F# A}") >>> tnc.bracketStateMapping['chord'] = ChordState >>> s = tnc.parse().stream >>> s.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {0.0} {1.5} {2.0} If you want to create a very different dialect, you can subclass tinyNotation.Converter and set it up once to use the mappings above. See :class:`~music21.alpha.trecento.notation.TrecentoTinyConverter` (especially the code) for details on how to do that. ) annotationsN)note)duration) environment) exceptions21)stream)tie) expressions)meter)pitch) Music21Object tinyNotationc\rSrSrSrg)TinyNotationExceptionN)__name__ __module__ __qualname____firstlineno____static_attributes__rN/home/james-whalen/.local/lib/python3.13/site-packages/music21/tinyNotation.pyrrsrrct\rSrSr%SrSrS\S'SSSjjrSrSS jr SS jr SS jr SS jr S r g)Stateiam State tokens apply something to every note found within it. State objects can have "autoExpires" set, which is False if it does not expire or an integer if it expires after a certain number of tokens have been processed. >>> tnc = tinyNotation.Converter() >>> ts = tinyNotation.TieState(tnc, '~') >>> isinstance(ts, tinyNotation.State) True >>> ts.autoExpires 2 Fztyping.Literal[False] | int autoExpiresNc*/UlXlX lgNaffectedTokensparent stateInfo)selfr!r"s r__init__State.__init__s35&, #,rcg)z$ called when the state is initiated Nrr#s rstart State.starts rcg)z" called just after removing state Nrr's rend State.end"srcU$)z) called to modify the string of a token. r)r#tokenStrs raffectTokenBeforeParseState.affectTokenBeforeParse(s rcU$)zS called after the object has been acquired but before modifiers have been applied. rr#m21Objs r$affectTokenAfterParseBeforeModifiers*State.affectTokenAfterParseBeforeModifiers.  rcURRU5 URSLa[UR5UR:Xa~UR 5 UR nUcU$[ [UR55H;nSUS--nURUULdMURRU5 U$ U$)zd called to modify the tokenObj after parsing tokenObj may be None if another state has deleted it. F) r appendrlenr+r!range activeStatespop)r#r3pi backCounts raffectTokenAfterParseState.affectTokenAfterParse7s ""6*   5 (4&&'4+;+;; KK9!M s1>>23A "a!e I~~i0D8**95 4  rr)NN)r!Converter | Noner"z str | None)returnzMusic21Object | None)r.strrErF)r3r rEr )rrrr__doc__r__annotations__r$r(r+r/r4rBrrrrrrsV .3K*2-      rrc"\rSrSrSrSrSrSrg)TieStateiVzm A TieState is an auto-expiring state that applies a tie start to this note and a tie stop to the next note. cJURSRc)[R"S5URSlOSURSRl[ UR5S:a)[R"S5URSlgg)zA end the tie state by applying tie ties to the appropriate notes rNr(continuer9stop)r r Tietyper;r's rr+ TieState.end]s   q ! % % -),)9D   " &.8D   " & & + t"" #a '),D   " & (rrN)rrrrrGrr+rrrrrJrJVsK 9rrJc:^\rSrSrSrSrSrSrU4SjrSr U=r $) TupletStateiiz a tuplet state applies tuplets to notes while parsing and sets 'start' and 'stop' on the first and last note when end is called. rKcUR(dgSURSRRSlSURSRRSlg)zG end a tuplet by putting start on the first note and stop on the last. Nr(rrNr8)r rtupletsrPr's rr+TupletState.endqs["":AA''//27;AB((0038rc>[TU]U5 [R"5n[R"URR S5Ul[R"URR S5UlURUl URUl URRU5 U$)z puts a tuplet on the note r) superrBrTupletdurationTupleFromTypeDotsrPdurationActualdurationNormalactualnumberNotesActualnormalnumberNotesNormal appendTuplet)r#nnewTup __class__s rrB!TupletState.affectTokenAfterParse{s %a(" ( B B1::??TU V ( B B1::??TU V#';; #';;  'rr) rrrrrGr^r`r+rBr __classcell__res@rrSrSis#F F  rrSc \rSrSrSrSrSrSrg) TripletStateiz a 3:2 tuplet rTrKrNrrrrrGr^r`rrrrrjrjF Frrjc \rSrSrSrSrSrSrg)QuadrupletStateiz a 4:3 tuplet rTrNrkrrrrnrnrlrrnc*\rSrSrSrSrSrSrSrg)ModifierizZ a modifier is something that changes the current token, like setting the `.id` or Lyric. c(XlX lX0lgr modifierDatamodifierStringr!)r#rtrur!s rr$Modifier.__init__s(, rcg)z> called before the tokenString has been turned into an object Nr)r# tokenStrings rpreParseModifier.preParses rcU$)z called after the tokenString has been turned into an m21Obj. m21Obj may be None Important: must return the m21Obj, or a different object! rr2s r postParseModifier.postParser6rrsN) rrrrrGr$ryr|rrrrrqrqs   rrqc\rSrSrSrSrSrg) IdModifieriz6 sets the .id of the m21Obj, called with = by default cJ[US5(aURUlU$)Nid)hasattrrtrr2s rr|IdModifier.postParses! 64 ))FI rrNrrrrrGr|rrrrrr rrc\rSrSrSrSrSrg) LyricModifieriz9 sets the .lyric of the m21Obj, called with _ by default cJ[US5(aURUlU$)Nlyric)rrtrr2s rr|LyricModifier.postParses! 67 # #,,FL rrNrrrrrrrrrc(\rSrSrSrSSjrSrSrg)TokenizL A single token made from the parser. Call .parse(parent) to make it work. cXlgrtoken)r#rs rr$Token.__init__s rcg)z* do NOT store parent -- probably too slow Nr)r#r!s rparse Token.parses rrN)rrrrrGr$rrrrrrrs rrc\rSrSrSrSrSrg)TimeSignatureTokeniz. Represents a single time signature, like 1/4 cb[R"UR5nX!RS'U$)NcurrentTimeSignature)r TimeSignaturer stateDict)r#r!tsObjs rrTimeSignatureToken.parses*##DJJ/38/0 rrNrrrrrGrrrrrrrs rrcB^\rSrSrSrSU4SjjrSrSrSrSr U=r $) NoteOrRestTokenizD represents a Note or Rest. Chords are represented by Note objects cD>[TU]U5 SS/UlSUlg)N)z(\d+) durationType)z(\.+)dotsF)rYr$ durationMap durationFoundr#rres rr$NoteOrRestToken.__init__s*  &  #rc|URH9upE[R"XB5nU(dM$[X5nU"XXBU5nM; URSLa/[ US5(aUR SURl[ US5(a#URRUR S'U$)za takes the information in the string `t` and creates a Duration object for the note or rest `n`. Fr lastDuration) rresearchgetattrrrrr quarterLength)r#rctr!pmmethod searchSuccesscallFuncs r applyDurationNoteOrRestToken.applyDurations **JBIIb,M}"40Qrf= +    &76;+G+G'-'7'7'GAJJ $ 6; ' '/0zz/G/GF  ^ ,rcSUl[URS55nUS:XaqURSb`[R "URSR 5UlURR[R"55 O#[RUURl [R "USU5nU$![an[SU35UeSnAff=f)z\ The result of a successful search for a duration type: puts a Duration in the right place. Tr9rrNz!Cannot parse token with duration r)rintgrouprcopydeepcopy barDurationrr r:FermatatypeFromNumDictrPKeyErrorrrsub)r#elementrrrr!typeNumkes rrNoteOrRestToken.durationTypes"fll1o& a< 67C#'==$$%;<HH$ ##**;+>+>+@A (0(@(@(I  % FF2r1   +7yA s"C C4 C//C4c[URS55URl[R "USU5nU$)z adds the appropriate number of dots to the right place. Subclassed in TrecentoNotation where two dots has a different meaning. r9r)r;rrrrr)r#rrrrr!s rrNoteOrRestToken.dotss6 !$FLLO 4 FF2r1 r)rrr) rrrrrGr$rrrrrgrhs@rrrs!#(,rrc&\rSrSrSrSSSjjrSrg) RestTokeni(z1 A token starting with 'r', representing a rest. Nch[R"5nURX RU5 U$r)rRestrr)r#r!rs rrRestToken.parse,s& IIK 1jj&1rrrr!rDrrrrrr(srrc^\rSrSrSr\R "/SQ5rSU4SjjrSSSjjr Sr Sr Sr S r S rS rS rS rSrU=r$) NoteTokeni2a A NoteToken represents a single Note with pitch >>> c3 = tinyNotation.NoteToken('C') >>> c3 >>> n = c3.parse() >>> n >>> n.nameWithOctave 'C3' >>> bFlat6 = tinyNotation.NoteToken("b''-") >>> bFlat6 >>> n = bFlat6.parse() >>> n >>> n.nameWithOctave 'B-6' )) lowOctavez([A-G]+)) highOctavez ([a-g])(\'*))editorialAccidentalz\(([\#\-n]+)\)(.*))sharpsz(\#+))flatsz(\-+))naturalz(n)c2>[TU]U5 SUlg)NF)rYr$ isEditorialrs rr$NoteToken.__init__Qs  rcURn[R"5nURX25nU(aUR X2U5 U$)z< Extract the pitch from the note and then returns the Note. )rrNoteprocessPitchMapr)r#r!rrcs rrNoteToken.parseUs@ JJ IIK   &    qV ,rcURR5H8up4[R"XB5nU(dM$[ X5nU"XXB5nM: U$)z' processes the pitchMap on the object. )pitchMapitemsrrr)r#rcrrrrrs rrNoteToken.processPitchMapasM----/JFIIb,M}"40Qr5 0 rcZSUlURS5URS5-nU$)zV indicates that the accidental is in parentheses, so set it up to be stored in ficta. Tr9rK)rrr#rcrrrs rrNoteToken.editorialAccidentalls+  LLOfll1o -rc[R"U5nUR(aXQRlOXQRl[ R"USU5nU$)a helper function for all accidental types. >>> nToken = tinyNotation.NoteToken('BB--') >>> n = note.Note('B') >>> n.octave = 2 >>> tPost = nToken._addAccidental(n, -2, r'(\-+)', 'BB--') >>> tPost 'BB' >>> n.pitch.accidental >>> nToken = tinyNotation.NoteToken('BB(--)') >>> nToken.isEditorial = True >>> n = note.Note('B') >>> n.octave = 2 >>> tPost = nToken._addAccidental(n, -2, r'(\-+)', 'BB--') >>> tPost 'BB' >>> n.editorial.ficta r)r Accidentalr editorialficta accidentalrr)r#rcalterrraccs r_addAccidentalNoteToken._addAccidentaltsH0u%    #KK !$GG  FF2r1 rcZ[URS55nURXX45$)a called when one or more sharps have been found and adds the appropriate accidental to it. >>> import re >>> tStr = 'C##' >>> nToken = tinyNotation.NoteToken(tStr) >>> n = note.Note('C') >>> n.octave = 3 >>> searchResult = re.search(nToken.pitchMap['sharps'], tStr) >>> tPost = nToken.sharps(n, searchResult, nToken.pitchMap['sharps'], tStr) >>> tPost 'C' >>> n.pitch.accidental r9r;rrr#rcrrrrs rrNoteToken.sharpss)"FLLO$""1R33rc`S[URS55-nURXX45$)a called when one or more flats have been found and calls adds the appropriate accidental to it. >>> import re >>> tStr = 'BB--' >>> nToken = tinyNotation.NoteToken(tStr) >>> n = note.Note('B') >>> n.octave = 2 >>> searchResult = re.search(nToken.pitchMap['flats'], tStr) >>> tPost = nToken.flats(n, searchResult, nToken.pitchMap['flats'], tStr) >>> tPost 'BB' >>> n.pitch.accidental r8r9rrs rrNoteToken.flatss.$Sa))""1R33rc(URUSX45$)a called when an explicit natural has been found. All pitches are natural without being specified, so not needed. Adds a natural accidental to it. >>> import re >>> tStr = 'En' >>> nToken = tinyNotation.NoteToken(tStr) >>> n = note.Note('E') >>> n.octave = 3 >>> searchResult = re.search(nToken.pitchMap['natural'], tStr) >>> tPost = nToken.natural(n, searchResult, nToken.pitchMap['natural'], tStr) >>> tPost 'E' >>> n.pitch.accidental r)rrs rrNoteToken.naturals$""1a//rcURS5SR5nS[URS55- nXQlXal[ R "USU5nU$)aI Called when a note of octave 3 or below is encountered. >>> import re >>> tStr = 'BBB' >>> nToken = tinyNotation.NoteToken(tStr) >>> n = note.Note('B') >>> searchResult = re.search(nToken.pitchMap['lowOctave'], tStr) >>> tPost = nToken.lowOctave(n, searchResult, nToken.pitchMap['lowOctave'], tStr) >>> tPost '' >>> n.octave 1 r9rrorrupperr;stepoctaverrr#rcrrrstepName octaveNums rrNoteToken.lowOctaveW <<?1%++-FLLO,,  FF2r1 rcURS5SR5nS[URS55-nXQlXal[ R "USU5nU$)aM Called when a note of octave 4 or higher is encountered. >>> import re >>> tStr = "e''" >>> nToken = tinyNotation.NoteToken(tStr) >>> n = note.Note('E') >>> searchResult = re.search(nToken.pitchMap['highOctave'], tStr) >>> tPost = nToken.highOctave(n, searchResult, nToken.pitchMap['highOctave'], tStr) >>> tPost '' >>> n.octave 6 r9rrorKrrrs rrNoteToken.highOctaverr)rrrr)rrrrrG collections OrderedDictrr$rrrrrrrrrrrgrhs@rrr2sW*&&(H!  @4(4*0(.rrcSnSUS3nUSUS3nSUS3nSS US US 3-nUS U3nS nSnSnSn Sn Sn Sn Sn US U S U S 3U S U S U 3-nS[4SUSUS3[4SUSUS3SUSUS3-[4/$)a Returns the default tokenMap for TinyNotation. Based on the following grammar (in Extended Backus-Naur form) (https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form) (* Items in parentheses are grouped *) (* Items in curly braces appear zero or more times *) (* Items in square brackets may appear exactly zero or one time *) (* Items in double quotes are literal strings *) (* Items between question marks should be interpreted as English *) (* Each rule is ended by a semicolon *) TINY-NOTATION = TOKEN, { WHITESPACE, TOKEN } ; WHITESPACE = ( " " | ? Carriage return ? ) , { " " | ? Carriage return ? } ; TOKEN = ( TIME-SIGNATURE | TUPLET | REST | NOTE ); TIME-SIGNATURE = INTEGER, "/", INTEGER ; INTEGER = DIGIT, { DIGIT } ; DIGIT = ( "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ) ; TUPLET = ( "trip" | "quad" | ALPHANUMERIC ), "{", [ WHITESPACE ], ( REST | NOTE ), { WHITESPACE, ( REST | NOTE ) }, [ WHITESPACE ], "}" ; REST = "r", [ DURATION ], [ MODIFIER ] ; DURATION = ( EVEN-NUMBER, { "." } | { "." }, EVEN-NUMBER | ".", { "." } ) ; EVEN-NUMBER = { INTEGER }, ( "0" | "2" | "4" | "6" | "8" ) ; NOTE = PITCH, [ DURATION ], [ TIE ], { MODIFIER } ; PITCH = ( ( LOW-A | LOW-B | LOW-C | LOW-D | LOW-E | LOW-F | LOW-G ), [ ACCIDENTAL ] | ( "a" | "b" | "c" | "d" | "e" | "f" | "g" ), [ ACCIDENTAL ], { "'" } | ( "a" | "b" | "c" | "d" | "e" | "f" | "g" ), { "'" }, [ ACCIDENTAL ] ) ; LOW-A = "A", { "A" } ; LOW-B = "B", { "B" } ; LOW-C = "C", { "C" } ; LOW-D = "D", { "D" } ; LOW-E = "E", { "E" } ; LOW-F = "F", { "F" } ; LOW-G = "G", { "G" } ; ACCIDENTAL = ( EDITORIAL | SHARPS | FLATS | NATURAL ) ; EDITORIAL = "(", ( SHARPS | FLATS | NATURAL ), ")" ; SHARPS = "#", { "#" } ; FLATS = "-", { "-" } ; NATURAL = "n" ; TIE = "~" ; MODIFIER = ( EQUALS-MODIFIER | UNDERSCORE-MODIFIER | SQUARE-MODIFIER | ANGLE-MODIFIER | PARENS-MODIFIER | STAR-MODIFIER ) ; EQUALS-MODIFIER = "=", EQUALS-DATA ; UNDERSCORE-MODIFIER = "_", UNDERSCORE-DATA ; SQUARE-MODIFIER = "[", ALPHANUMERIC, "]" ; ANGLE-MODIFIER = "<", ALPHANUMERIC, ">" ; PARENS-MODIFIER = "(", ALPHANUMERIC, ")" ; STAR-MODIFIER = "*", ALPHANUMERIC, "*" ; (* The following is just shorthand. *) ALPHANUMERIC = ? At least one alphanumeric character. So "a-z", "A-Z", or "0-9" ? ; EQUALS-DATA = ? At least one non-whitespace, non-"_" character. ? ; UNDERSCORE-DATA = ? At least one non-whitespace, non-"=" character. ? ; z#+|-+|nz\((?:z)\)z|(?:)z(?:A+|B+|C+|D+|E+|F+|G+)(?:z)?z(?:a|b|c|d|e|f|g)z(?:(?:z )?'*|'*(?:z)?)|z\d+\.*|\.*\d+|\.+~z=[^\s_]*z\*.*?\*z<.*?>z\(.*?\)z\[.*?]z_[^\s=]z ^(\d+\/\d+)$z^r((?:z)?(?:z)*)$z^((?:z)(?:z(?:)rrr)sharpsFlatsOrNaturalRegexeditorialRegexaccidentalRegex lowNoteRegex highNoteRegex noteNameRegex durationRegex tieStateRegex equalsRegex starRegex angleRegex parensRegex squareRegexunderscoreRegex modifierRegexs r_getDefaultTokenMaprs5F!+78>> part = converter.parse('4/4 C4 D4 E2 F1', format='tinyNotation') >>> part.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {4.0} {0.0} {4.0} But for advanced work, create a tinyNotation.Converter object as shown: >>> tnc = tinyNotation.Converter('4/4 C##4 D e-8 f~ f f# g4 trip{f8 e d} C2=hello') Run the parsing routine with `.parse()` >>> tnc.parse() And now the `.stream` attribute of the converter object has the Stream (generally Part) ready to send out: >>> tnc.stream And all normal Stream methods are available on it: >>> tnc.stream.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {2.5} {3.0} {3.5} {4.0} {0.0} {1.0} {1.3333} {1.6667} {2.0} {4.0} Or, breaking down what Parse does bit by bit: >>> tnc = tinyNotation.Converter('4/4 C##4 D e-8 f~ f f# g4 trip{f8 e d} C2=hello') >>> tnc.stream >>> tnc.makeNotation True >>> tnc.stringRep '4/4 C##4 D e-8 f~ f f# g4 trip{f8 e d} C2=hello' >>> tnc.activeStates [] >>> tnc.preTokens [] >>> tnc.splitPreTokens() >>> tnc.preTokens ['4/4', 'C##4', 'D', 'e-8', 'f~', 'f', 'f#', 'g4', 'trip{f8', 'e', 'd}', 'C2=hello'] >>> tnc.setupRegularExpressions() Then we parse the time signature. >>> tnc.parseOne(0, tnc.preTokens[0]) >>> tnc.stream.coreElementsChanged() >>> tnc.stream.show('text') {0.0} (Note that because we are calling `show()` after each note in these docs, but TinyNotation uses high efficiency `stream.core` routines, we need to set the stream to a stable-state by calling `coreElementsChanged` after each call. You would not need to do this in your own subclasses, since that would lose the `O(n)` efficiency when parsing) Then parse the first actual note: >>> tnc.parseOne(1, tnc.preTokens[1]) >>> tnc.stream.coreElementsChanged() >>> tnc.stream.show('text') {0.0} {0.0} The next notes to 'g4' are pretty similar: >>> for i in range(2, 8): ... tnc.parseOne(i, tnc.preTokens[i]) >>> tnc.stream.coreElementsChanged() >>> tnc.stream.show('text') {0.0} {0.0} {1.0} {2.0} {2.5} {3.0} {3.5} {4.0} The next note starts a "State" since it has a triplet: >>> tnc.preTokens[8] 'trip{f8' >>> tnc.parseOne(8, tnc.preTokens[8]) >>> tnc.activeStates [] >>> tnc.activeStates[0].affectedTokens [] The state is still active for the next token: >>> tnc.preTokens[9] 'e' >>> tnc.parseOne(9, tnc.preTokens[9]) >>> tnc.activeStates [] >>> tnc.activeStates[0].affectedTokens [, ] The :class:`~music21.tinyNotation.TripletState` state adds tuplets along the way, but does not set their type. >>> f_starts_tuplet = tnc.activeStates[0].affectedTokens[0] >>> f_starts_tuplet.duration.tuplets (,) >>> f_starts_tuplet.duration.tuplets[0].type is None True But the next token closes the state: >>> tnc.preTokens[10] 'd}' >>> tnc.parseOne(10, tnc.preTokens[10]) >>> tnc.activeStates [] And this sets the tupet types for the F and D properly: >>> f_starts_tuplet.duration.tuplets[0].type 'start' >>> tnc.stream.coreElementsChanged() >>> tnc.stream.show('text') {0.0} ... {4.0} {5.0} {5.3333} {5.6667} The last token has a modifier, which is an IdModifier: >>> tnc.preTokens[11] 'C2=hello' >>> tnc.parseOne(11, tnc.preTokens[11]) >>> tnc.stream.coreElementsChanged() >>> tnc.stream.show('text') {0.0} ... {5.6667} {6.0} >>> tnc.stream[-1].id 'hello' At this point the flattened stream is ready, if Converter.makeNotation is False, then not much more needs to happen, but it is True by default. So, then calling tnc.postParse() runs the makeNotation: >>> tnc.postParse() >>> tnc.stream.show('text') {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {2.5} {3.0} {3.5} {4.0} {0.0} {1.0} {1.3333} {1.6667} {2.0} {4.0} Let's look at edge cases. Normally, invalid notes or other bad tokens pass freely by dropping the unparseable token. Here `3` is not a valid duration, so `d3` will be dropped. >>> x = converter.parse('tinyNotation: 4/4 c2 d3 e2') >>> x.show('text') {0.0} {0.0} {0.0} {0.0} {2.0} {4.0} But with the keyword 'raiseExceptions=True' a `TinyNotationException` is raised if any token cannot be parsed. >>> x = converter.parse('tinyNotation: 4/4 c2 d3 e2', raiseExceptions=True) Traceback (most recent call last): music21.tinyNotation.TinyNotationException: Could not parse token: 'd3' )tripquadz=([A-Za-z0-9]*)z \*(.*?)\*z<(.*?)>z \((.*?)\)z\[(.*?)]z_(.*)TF) makeNotationraiseExceptionsc [R"5Ul[R"[5UlXl/Ul/Ul[R"S5Ul [R"S5Ul [5Ul [UlSUlSUlSUlSUl[(UlX lX0l/Ulg)Nz(\w+){r)rPartr_stateDictDefaultr stringRepr= preTokensrcompilegeneralBracketStateRe tieStateRertokenMaprmodifierEquals modifierStar modifierAnglemodifierParensmodifierSquarermodifierUnderscorerr _tokenMapRe)r#rrr _keywordss rr$Converter.__init__^skkm #45")+$&%'ZZ %:"**T*+- ( !"""/(.>@rc[R"5Ul[R"[5Ul/Ul/UlXlg)a} Loads a stringRepresentation into `.stringRep` and resets the parsing state. >>> tnc = tinyNotation.Converter() >>> tnc.load('4/4 c2 d e f') >>> s = tnc.parse().stream >>> tnc.load('4/4 f e d c') >>> s2 = tnc.parse().stream >>> ns2 = s2.flatten().notes Check that the duration of 2.0 from the first load did not carry over. >>> ns2[0].duration.quarterLength 1.0 >>> len(ns2) 4 N)rrrrrr=r r)r#rs rloadConverter.load|s6*kkm #45"rcBURR5Ulg)z splits the string into textual preTokens. Right now just splits on spaces, but might be smarter to ignore spaces in quotes, etc. later. N)rsplitr r's rsplitPreTokensConverter.splitPreTokenss--/rc/UlURH7upURR[R"U5U45 M9 g![R an[ SUSU35UeSnAff=f)a Regular expressions get compiled for faster usage. This is called automatically by .parse(), but can be called separately for testing. It is also important that it is not called in __init__ since subclasses should override the tokenMap, etc. for a class. zError in compiling token, z: N)r+r$r:rr!errorr)r#rePre classCalles rsetupRegularExpressions!Converter.setupRegularExpressionssz $ E   ''E):I(FG!.88 +0r!= s1AA;$A66A;c(UR(d URS:waUR5 UR(dUR 5 [ UR5HupUR X5 M UR5 U$)z_ splitPreTokens, setupRegularExpressions, then runs through each preToken, and runs postParse. r)r rr3r+r: enumerateparseOner|)r#r@rs rrConverter.parsesg ~~$..B"6    !  ( ( *dnn-DA MM! .  rcUnURU5nURU5up$URU5up%URSSHnUR U5nM SnSnSn UR HMupU R U5n U cMSn U RS5n U "U 5nURU5nUb OMO U (d UR(a[SU<35eUb'URSSHnURU5nM UbUHnURU5nM Ub'URSSHnURU5nM UbURRU5 U[!UR5:a6UR(a[SU<S35e[!UR5n[#U5HMnURR%5nUR'5nUcM2URRU5 MO g![a-nUR(a[SU<35UeSnAGMSnAff=f)z parse a single token at position i, with text t, possibly adding it to the stream. Checks for state changes, modifiers, tokens, and end-state brackets. NFTr9zCould not parse token: zToken z" closes more states than are open.)parseStartStatesparseEndStatesparseModifiersr=r/r+matchrrrrr4r|rBr coreAppendr;r<r>r+)r#r@rt_orignumberOfStatesToEndactiveModifiersstateObjr3tokenObjhasMatchtokenRe tokenClass matchSuccess tokenDataexcepmodObj stateToRemove possibleObjs rr>Converter.parseOnes\  ! !! $!%!4!4Q!7!003))!,H//2A-#'#3#3 G"==+L#H$**1-I!),H a!-%&$4 D00'*A&(LM M   --a0!FFvN1  )))&1*   --a0!77?1   KK " "6 * T%6%6!7 7##+fVJ>`,abb"%d&7&7"8 *+A --113M'++-K& &&{3 ,7) a''/2I&0TU[``( as*H&& I0!IIc&URRU5nU(aURS5nURS5nURRSUSS9nURRU5nX@R;a9SU<3nUR (a [ U5e[RU5 MURU"X5nUR5 URRU5 U(aMURRU5nU(acURS5nURRSU5n[X5nUR5 URRU5 U$)av Changes the states in self.activeStates, and starts the state given the current data. Returns a newly processed token. A contrived example: >>> tnc = tinyNotation.Converter() >>> tnc.setupRegularExpressions() >>> len(tnc.activeStates) 0 >>> tIn = 'trip{quad{f8~' >>> tOut = tnc.parseStartStates(tIn) >>> tOut 'f8' >>> len(tnc.activeStates) 3 >>> tripState = tnc.activeStates[0] >>> tripState >>> quadState = tnc.activeStates[1] >>> quadState >>> tieState = tnc.activeStates[2] >>> tieState >>> tieState.parent is tnc True >>> tieState.stateInfo '~' >>> quadState.stateInfo 'quad{' Note that the affected tokens haven't yet been added: >>> tripState.affectedTokens [] Unknown state gives a warning or if `.raisesException=True` raises a TinyNotationException >>> tnc.raiseExceptions = True >>> tIn = 'blah{f8~' >>> tOut = tnc.parseStartStates(tIn) Traceback (most recent call last): music21.tinyNotation.TinyNotationException: Incorrect bracket state: 'blah' rr9r)countzIncorrect bracket state: )r"rrrbracketStateMappingrr environLocalwarnr(r=r:r#rJ) r#rbracketMatchSuccess stateData bracketTypemsgrItieMatchSuccesstieStates rrAConverter.parseStartStatessYh#88??B!+11!4I-33A6K**..r1A.>A"&"<"<"C"CA"F ":"::1+A''/44!!#&// >> tnc = tinyNotation.Converter() >>> tnc.parseEndStates('C4') ('C4', 0) >>> tnc.parseEndStates('C4}}') ('C4', 2) }r)rVreplace)r#r endBracketss rrBConverter.parseEndStatesXs)ggcl IIc2 ~rcH/nSH~n[USU-S5nUcM[USU-S-S5nURU5nUcMAURS5nURSU5nU"XqU5nUR U5 M UHn U R U5 M X4$)a Parses `modifierEquals`, `modifierUnderscore`, `modifierStar`, etc. for a given token and returns the modified token and a (possibly empty) list of activeModifiers. Modifiers affect only the current token. To affect multiple tokens, use a :class:`~music21.tinyNotation.State` object. )EqualsStarAngleParensSquare UnderscoremodifierN _modifierRer9r)rrrrr:ry) r#rrH modifierName modifierClass modifierRefoundItrtmodifierObjectrQs rrCConverter.parseModifiersisYL#D*|*CTJM$ {\'AD'H$OJ ''*G"&}}Q/ NN2q)!.|!E&&~6Z&F OOA &!!rcVURSLaURRSS9 gg)z Called after all the tokens have been run. It currently runs `.makeMeasures()` on `.stream` unless `.makeNotation` is `False`. FT)inPlaceN)rr makeMeasuresr's rr|Converter.postParses,   E ) KK $ $T $ 2 *r)r+r=r"rr'r%r(r)r&r*r rrrrr#r$Nr)rrFrboolrrz)rrFrENone)r@rrrF)rrFrErF)rrFrEztuple[str, int])rrrrrGrjrnrWrr!_modifierEqualsRe_modifierStarRe_modifierAngleRe_modifierParensRe_modifierSquareRe_modifierUnderscoreRer$r/r3r:rr>rArBrCr|rrrrrrrs^@ #56jj.Ozz*- <0 ;/JJx0A" % AA A  A<#60$  A4HPd""83rrc<\rSrSrSrS SjrS SjrS SjrSrSr g) TestizL1/4 trip{C8~ C~_hello C=mine} F~ F~ 2/8 F F# quad{g--16 a## FF(n) g#} g16 F0c[UR5nUR5 URnUR 5R [ R5nUSRnUSRnUSRn[R(aUceUceUceURU[R5 URU[R5 URU[R5 URURS5 URURS5 URURS5 URUSRS5 URUSR S5 URUSR"S 5 URUSR$S 5 US R&R(nUS R&R(n[R(a UceUceURUR*S5 URUR*S 5 URUSR,R.R*S5 URUSR0R2S5 URUSR4SR6[4R8"5R65 g)Nrr9rKr(rMrNCrThellomine r)r parseTestrrflattengetElementsByClassrrr typing TYPE_CHECKINGassertIsInstancerO assertEqualrPrrrrr rrrrrrr classesr) r#cssfnt0t1t2acc6acc7s rtestOne Test.testOnesK dnn %  HHiik,,TYY7 VZZ VZZ VZZ   > !>> !>> !> b#''* b#''* b#''* '* *- &) Qc* Q* Qw/ QF+1v||&&1v||&&   # ### ## Q' R( Q))//55q9 R))77= R,,Q/779L9L9N9V9VWrc SSS.SSS.SSS.SSS.SS S.S S S./nUHMnUR[S S USSUSS3-S9 [USSS9nUR5 SSS5 MO g!,(df  Ma=f)Nhzh is not a valid note)stringreasonza;z0a semicolon is not a valid character or modifierzr;z4/4;ABCzJonly the same upper-cased letter may be repeated to indicate lower octavesaaazdthe same lower-cased letter may not be repeated to indicate higher octaves. Instead use apostrophes.z5Should have raised a TinyNotationException for input 'rz ' because r.)r]T)r) assertRaisesrrr)r# error_states error_state converters rtestRaiseExceptionsTest.testRaiseExceptionss1  L  L  !L   /  J 1 B(K""#8K+h/0 ;x;P:QQRST#&k(&;TR ! (s A// A> c[5nUR[U5SS5 [S[S[ S0nUHtup4UR UUSURRS3-5 X$==S- ss'UR[U5SSURRS3-5 Mv UHnURX$SS5 M g) NrTzUThere should be three valid token types by default: Time signatures, Notes, and Restsrz1Found unexpected token type in default token map:rr9ziShould provide a non-empty string for the regular expression in the default token map for tokens of type zNShould have found each valid token type exactly once in the default token map.) rrr;rrrassertInrer assertGreater)r#defaultTokenMapvalidTokenTypeCountsregex tokenTypes rtestGetDefaultTokenMapTest.testGetDefaultTokenMaps-/   1   q q   !0 E MM$G",,556a89   ! +q 0 +   E P",,556a89  !0,.I   $//  .rc[SSS9nUR5 URnURURSR R [R"SS55 URURR5R R S5 [SSS9nSUl UR[S 5 UR5 SSS5 g!,(df  g=f) Nz2/4 trip{c8 d e}} f4F)rrr9rTrTz,Token 'e}}' closes more states than are open) rrrrnotesrr fractionsFractionlastrassertRaisesRegexr)r#rrs rtest_too_many_statesTest.test_too_many_statess ,5 A  HH --;;Y=O=OPQST=UV 00>>D ,5 A   # # ! :  GGI    s C.. C<rN)rEr{) rrrrrrrrrrrrrrrs^I!XF("T0d rrc\rSrSrSrSrSrg) TestExternali!Tc[[R5nUR5 UR(aUR R S5 gg)Nz musicxml.png)rrrrshowr)r#rs rrTestExternal.testOne$s5 dnn %  99 HHMM. ) rrN)rrrrrrrrrrrr!s D*rr__main__)rEzlist[tuple[str, type[Token]]])0rG __future__rrrrrrunittestmusic21rrrrrr r r r r music21.baser EnvironmentrXMusic21ExceptionrrrJrSrjrnrqrrrrrrrrrrTestCaserr _DOC_ORDERrmainTestrrrrsYt#    *&&~6  L99 OOd9u9&%@;k8H$>e>BKK\j\! Z3Z3zO8  Od*8$$*x 0  z Tr