3jxdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddl$m%Z%ddl&m'Z'ddl&m(Z(ejRrddl*Z*ejVdZ,dd iZ-gd!Z.Gd"d#ej^Z0Gd$d%e jbZ2Gd&d'e2Z3Gd(d)e jbZ4Gd*d+e4Z5Gd,d-e4Z6Gd.d/e4Z7Gd0d1e4Z8Gd2d3e jbZ9Gd4d5e jbZ:Gd6d7e:Z;Gd8d9e:Z<Gd:d;e:Z=Gd<d=e jbZ>Gd>d?e jbZ?Gd@dAe jbZ@dPdBZA dQ dRdCZBdSdDZCGdEdFejZEGdGdHejZFGdIdJejZGGdKdLejZHGdMdNejZJeKdOk(rddlZejeJyy)Ta music21.humdrum.spineParser is a collection of utilities for changing native humdrum code into music21 streams. Most music21 users will simply want to call: >>> #_DOCS_SHOW myFile = converter.parse('myFile.krn') >>> #_DOCS_SHOW myFile.show() The methods in here are documented for developers wishing to expand music21's ability to parse humdrum. SpineParsing consists of several steps. * The data file is read in and all events are sliced horizontally (EventCollections) and vertically (Protospines) * Protospines are parsed into HumdrumSpines by following Spine Path Indicators (:samp:`*^` and :samp:`*v` especially) Protospines that separate become new Protospines with their parentSpine indicated. Protospines that merge again then followed by the same Protospine as before. This will cause problems if a voice re-merges with another staff, but in practice I have not seen a .krn file that does this and should be avoided in any case. * HumdrumSpines are reclassed according to their exclusive definition. :samp:`**kern` becomes KernSpines, etc. * All reclassed HumdrumSpines are filled with music21 objects in their .stream property. Measures are put into the spine but are empty containers. The resulting HumdrumSpine.stream objects look like `Stream.flatten(retainContainers=True)` versions in many ways. * For HumdrumSpines with parent spines their .stream contents are then inserted into their parent spines with voice tagged as a music21 Group property. * Lyrics and Dynamics are placed into their corresponding HumdrumSpine.stream objects. * Stream elements are moved into their measures within a Stream. * Measures are searched for elements with voice groups and Voice objects are created. * Changed in v10: flag attributes `isSpineLine, isComment, isGlobal, isReference` have been removed from HumdrumLine and all subclasses. `isinstance(...)` is a bit slower than checking these, but adds correct typing. Nothing is stored with weakrefs. `.iterIndex` and hand roled iterator/generators are gone now (could've gone when Python 2.4 became the minimum version). `HumdrumDataCollection.parsePositionInStream` is gone (was duplicating `numLines`); `HumdrumDataCollection.fileLength` is now the read-only property `numLines` (= `len(self.dataStream)`); `HumdrumLine.position` and `SpineEvent.position` were both renamed to `lineNumber` and now hold the 1-based source line number (was eventList index for SpineEvent), advancing on blank lines too. Blank lines now produce `BlankLine` HumdrumLine entries rather than being skipped, so `eventList[lineNumber - 1]` always resolves to the line at that source position. ) annotationsN)opFrac)OffsetQL) articulations)bar)base)chord)clef)common)dynamics)duration) environment) exceptions21) expressions) instrument)key)note)meter)metadata)roman)prebase)stream)tempo)tie) GraceDuration) harmParser) instrumentszhumdrum.spineParserJRPF)z*+*-*^*v*x*ceZdZdZy)HumdrumExceptionzB General Exception class for problems relating to Humdrum N)__name__ __module__ __qualname____doc__H/DATA/.local/lib/python3.12/site-packages/music21/humdrum/spineParser.pyr%r%js  r+r%ceZdZdZddZeddZddZddZ d ddZ ddZ d dd Z dd Z d dd Z dd Zddd Zy)HumdrumDataCollectiona .. note:: Most users should not need to be here. Just run `converter.parse('file.krn')` and it will give you a stream.Score instead. Intermediate users who want to get into the guts of Humdrum are still probably better off running humdrum.parseFile("filename") which returns a humdrum.SpineCollection directly. A HumdrumDataCollection takes in a mandatory list where each element is a line of humdrum data. Together this list represents a collection of spines. Essentially it's the contents of a humdrum file. Usually you will probably want to use HumdrumFile which can read in a file directly. This class exists in case you have your Humdrum data in another format (database, from the web, etc.) and already have it as a string. LIMITATIONS: (1) Spines cannot change definition (\*\*exclusive interpretations) mid-spine. So if you start off with \*\*kern, the rest of the spine needs to be \*\*kern (actually, the first exclusive interpretation for a spine is used throughout). Note that, even though changing exclusive interpretations mid-spine seems to be legal by the humdrum definition, it looks like none of the conventional humdrum parsing tools allow for changing definitions mid-spine, so I don't think this limitation is a problem. (Craig Stuart Sapp confirmed this to me.) The Aarden/Miller Palestrina dataset uses `\*-` followed by `\*\*kern` at the changes of sections thus some parsing of multiple exclusive interpretations in a protospine may be necessary. But none change definition. (2) Split spines are assumed to be voices in a single spine staff. cg|_d|_g|_g|_d|_t |t r|j}||_tj|_ yNr) eventList maxSpines protoSpineseventCollectionsspineCollection isinstancestr splitlines dataStreamrScore)selfr9s r,__init__zHumdrumDataCollection.__init__sV,.-/7959 j# &#..0J%/17  r+c,t|jS)zR The number of lines in `self.dataStream`, including blank lines. )lenr9r;s r,numLineszHumdrumDataCollection.numLiness 4??##r+c|js td|j|j\}}|r||j|S|j |jS)a Parse `self.dataStream` into music21 objects, returning the resulting :class:`~music21.stream.Score` (or :class:`~music21.stream.Opus` for multipart files like the Palestrina dataset). The parsed stream is also stored on `self.stream`. +Need a list of lines (dataStream) to parse!)r9r%determineIfDataStreamIsOpusparseOpusDataCollections parseNonOpus)r;hasOpusdataCollectionss r,parsezHumdrumDataCollection.parses^"#PQ Q#'#C#CDOO#T  200A A$$T__5 5r+c,tj}||_d|_|j||j |j |_|j j|j|j D])}dt|jz|j_ +|j D]:}|j|jdk(s |j|j<|j|S)z The main parse function for non-opus data collections. Populates `self.stream` (a :class:`~music21.stream.Score`) and returns it. rspine_kern)rr:r2parseEventListFromDataStream#parseProtoSpinesAndEventCollectionscreateHumdrumSpinesr5createMusic21StreamsinsertGlobalEventsr7id parentSpine spineTypeinsert parseMetadata)r;r9score thisSpines r,rEz"HumdrumDataCollection.parseNonOpuss   ))*5 002#779 113 !--I"*S->">I   .--I$$,1D1D1N Y--..  r+Nc| |j}| tdg}g}t|D]e\}}|j}t j d|r|j |>t j d|sU|j |gt|dkry|d|dkDrn|j t|g}tt|D]|}|dk(r||}|j |d|d z%|t|d z k(r ||d z d z}|j ||dV||d z d z}||d z} |j ||| ~t|d kDrd |fStd ) a Some Humdrum files contain multiple pieces in one file which are better represented as :class:`~music21.stream.Opus` file containing multiple scores. This method examines that dataStream (or `self.dataStream`) and if it only has a single piece then it returns (False, None). If it has multiple pieces, it returns True and a list of dataStreams. >>> from pprint import pprint as pp >>> mps = humdrum.testFiles.multipartSanctus >>> hdc = humdrum.spineParser.HumdrumDataCollection(mps) >>> (hasOpus, dataCollections) = hdc.determineIfDataStreamIsOpus() >>> hasOpus True >>> pp(dataCollections) [['!!!COM: Palestrina, Giovanni Perluigi da', '**kern\t**kern\t**kern\t**kern', '*Ibass\t*Itenor\t*Icalto\t*Icant', '!Bassus\t!Tenor\t!Altus\t!Cantus', '*clefF4\t*clefGv2\t*clefG2\t*clefG2', '*M4/2\t*M4/2\t*M4/2\t*M4/2', '=1\t=1\t=1\t=1', '0r\t0r\t1g\t1r', '.\t.\t1a\t1cc', '=2\t=2\t=2\t=2', '0r\t0r\t1g\t1dd', '.\t.\t1r\t1cc', '*-\t*-\t*-\t*-'], ['!! Pleni', '**kern\t**kern\t**kern', '*Ibass\t*Itenor\t*Icalto', '*clefF4\t*clefGv2\t*clefG2', '*M4/2\t*M4/2\t*M4/2', '=3\t=3\t=3', '1G\t1r\t0r', '1A\t1c\t.', '=4\t=4\t=4', '1B\t1d\t1r', '1c\t1e\t1g', '*-\t*-\t*-'], ['!! Hosanna', '**kern\t**kern\t**kern\t**kern', '*Ibass\t*Itenor\t*Icalto\t*Icant', '*clefF4\t*clefGv2\t*clefG2\t*clefG2', '*M3/2\t*M3/2\t*M3/2\t*M3/2', '=5\t=5\t=5\t=5', '1r\t1r\t1g\t1r', '2r\t2r\t[2a\t[2cc', '=5\t=5\t=5\t=5', '1r\t1r\t2a]\t2cc]', '.\t.\t2f\t1dd', '2r\t2r\t2g\t.', '*-\t*-\t*-\t*-']] NzdataStream cannot be Nonez ^(\*-\t)*\*-$z^(\*\*\w+\t)*\*\*\w+$)FNrTzMalformed humdrum data: possibly multiple **tags without closing information. Or a *tandem tag accidentally encoded as a **spine tag.) r9 TypeError enumeraterstripresearchappendr>ranger%) r;r9 startIndices endIndicesilinerGendPos startIndexendIndexs r,rCz1HumdrumDataCollection.determineIfDataStreamIsOpuss|  J  78 8   ,GAt;;=Dyy)40!!!$3T:##A& - | q  b>L, ,    c*o .s:'AAv#A&&z+6A:'>?c*o))'A.2 &&z*+'>?(A.2 %a=1,&&z*X'FG(  ! #/* *";< >> mps = humdrum.testFiles.multipartSanctus >>> hdc = humdrum.spineParser.HumdrumDataCollection(mps) >>> (hasOpus, dataCollections) = hdc.determineIfDataStreamIsOpus() >>> if hasOpus is True: ... op = hdc.parseOpusDataCollections(dataCollections) ... print(len(op.scores)) ... for sc in op.scores: ... print(sc) 3 section_r[r) rOpusr]r.rHr7rQrnumberracopydeepcopyscores)r;rGopusredchdcscs r,rDz.HumdrumDataCollection.parseOpusDataCollectionsFs&{{}/EAr'+CBQU+BE!"QBKK  KKO 0  MM$++a.*A*ABDM#$DMM   r+cz||j}| tdg|_d}|D]}|dz }|j}|dk(r%|jj t |Ct jd|r&|jj t||t jd|r&|jj t||t||}t|j|j|_ |jj | |jS)a Sets `self.eventList` from a dataStream (that is, a list of lines). It sets `self.maxSpines` to the largest number of spine events found on any line in the file. The difference between the dataStream and `self.eventList` are the following: * Blank lines are skipped. * !!! lines become :class:`~music21.humdrum.spineParser.GlobalReferenceLine` objects * !! lines become :class:`~music21.humdrum.spineParser.GlobalCommentLine` objects * all other lines become :class:`~music21.humdrum.spineParser.SpineLine` objects Returns eventList in addition to setting it as `self.eventList`. >>> eventString = ('!!! COM: Beethoven, Ludwig van\n' ... '!! Not really a piece by Beethoven\n' ... '**kern\t**dynam\n' ... 'C4\tpp\n' ... 'D8\t.\n') >>> hdc = humdrum.spineParser.HumdrumDataCollection(eventString) >>> hdc.maxSpines = 2 >>> eList = hdc.parseEventListFromDataStream() >>> eList is hdc.eventList True >>> for e in eList: ... print(e) >>> print(eList[0].value) Beethoven, Ludwig van Print line number 4 (which is eList[3] in zero indexed) >>> print(eList[3].spineData) ['C4', 'pp'] rBrr[z!!!!!)r9r%r1r^ra BlankLiner_matchGlobalReferenceLineGlobalCommentLine SpineLinemaxr2 numSpines)r;r9 lineNumberrfthisLines r,rLz2HumdrumDataCollection.parseEventListFromDataStreamhsZ  J!&'TUU D !OJ;;=Drz%%i &;<&$'%%&9*d&KL%&%%&7 D&IJ$Z6!$T^^X5G5G!H%%h/~~r+c jsjg}gdfd }tj}tjD]}g}t|D]\}|dk(r=j t jj|j|j |||^|j t||_ _ |fS)aj Run after :meth:`~music21.humdrum.spineParser.HumdrumDataCollection.parseEventListFromDataStream()` to take `self.eventList` and slice it horizontally to get `self.eventCollections`, which is a list of EventCollection objects, or things that happen simultaneously. And, more importantly, this method slices `self.eventList` vertically to get `self.protoSpines` which is a list of ProtoSpines, that is a vertical slice of everything that happens in a column, regardless of spine-path indicators. EventCollection objects store global events. ProtoSpines do not. So `self.eventCollections` and `self.protoSpines` can each be thought of as a two-dimensional sheet of cells, but where the first index of the former is the vertical index in the dataStream and the first index of the latter is the horizontal index in the dataStream. The contents of each cell is a SpineEvent object or None (if there's no data at that point). Even '.' (continuation events) get translated into SpineEvent objects. Calls :meth:`~music21.humdrum.spineParser.parseEventListFromDataStream` if it hasn't already been called. Returns a tuple of protoSpines and eventCollections in addition to setting it in the calling object. >>> eventString = ('!!!COM: Beethoven, Ludwig van\n' ... '!! Not really a piece by Beethoven\n' ... '**kern\t**dynam\n' ... 'C4\tpp\n' ... 'D8\t.\n') >>> hdc = humdrum.spineParser.HumdrumDataCollection(eventString) >>> hdc.maxSpines = 2 >>> protoSpines, eventCollections = hdc.parseProtoSpinesAndEventCollections() >>> protoSpines is hdc.protoSpines True >>> eventCollections is hdc.eventCollections True Looking at individual slices is unlikely to tell you much: >>> for thisSlice in eventCollections: ... print(thisSlice) >>> for thisSlice in protoSpines: ... print(thisSlice) But looking at the individual slices is revealing: >>> eventCollections[4].getAllOccurring() [, ] >>> for protoEvent in protoSpines[0]: ... print(repr(protoEvent)) None None c|} j|}t|trt|j|kDrt |j||j }||_|jtvrd|_ |j|||jdk(rG|dkDrB|dz j|}|+|dz j|}||j|||St|ts|dk(r|j|t d|j }||_|j||y)z Process the (i, j) cell. Mutates `returnEventCollections[i]` and returns the SpineEvent to record in the protoSpine, or None if there's no event at this cell. T.rr[Nrv)r1r6r|r> spineData SpineEventr protoSpineIdcontentsspinePathIndicators spinePathData addSpineEventeventsgetSpineOccurringaddLastSpineEventaddGlobalEvent) rejthisEventCollection currentLine thisEvent lastEventoccurringEvent placeholderreturnEventCollectionsr;s r,processEventForOneCellzYHumdrumDataCollection.parseProtoSpinesAndEventCollections..processEventForOneCells@ #9"; ..+K+y1c+:O:O6PST6T&{'<'rbr2raEventCollectionr ProtoSpiner3r4)r;returnProtoSpinesr numEventsrprotoSpineEventListrers` @r,rMz9HumdrumDataCollection.parseProtoSpinesAndEventCollectionssR~~  - - //18:! F' t~~&A9; 9%6*11'37>>!3D3O3OQR$**+A!Q+GH &  $ $Z0C%D E'- 6!#9::r+c|||j}|j}t|}tjd}t }t t|D]}||}|j}t |D]\} || j|} | || } | |j} || _ | || <| j| | j| _ ^|jstjd} d} d}t |D]:} || j|} || } | | | j| 1| 4| jdk(r|| _K| jdk(r|jt"j$}|dz|_ | |_d|_|jt"j$}|dz|_ | |_|| _| j*j|| j*j|||f| j,|<| j|| j|5| jd k(r| dur$| j& | j&} nd} || _l|| _| j&| j| j&nN| dur| j| n8|jt"j.}||_ | j|d} | jd k(r.|dur| }| j| | j|d}*| j| =|durt1d |d |j2d | }|S)a Takes the data from the object's protoSpines and eventCollections and returns a :class:`~music21.humdrum.spineParser.SpineCollection` object that contains HumdrumSpine() objects. A HumdrumSpine object differs from a ProtoSpine in that it follows spinePathData -- a ProtoSpine records all data in a given tab position, and thus might consist of data from several spines that move around. HumdrumSpines are smart enough not to have this limitation. When we check for spinePathData we look for the following spine path indicators (from HumdrumDoc):: *+ add a new spine (to the right of the current spine) *- terminate a current spine *^ split a spine (into two) *v join (two or more) spines into one *x exchange the position of two spines * do nothing cyNr*r*r+r,z;HumdrumDataCollection.createHumdrumSpines..Tdr+cyrr*r*r+r,rz;HumdrumDataCollection.createHumdrumSpines..vrr+Frr ) streamClassr[Tr!r"zr defaultlistSpineCollectionrbrr1addSpine insertPointrarQrrr endingPointrVoicerR isFirstVoice childSpineschildSpineInsertPointsPartr%r)r;r3r4r2currentSpineListr5rerrrr currentSpine newSpineList mergerActiveexchangeActive newSpine1 newSpine2ss r,rNz)HumdrumDataCollection.createHumdrumSpines3s4  "2":**K#44  $ "--l;)+s+,-A"21"5 ,77J9%'N44Q7 $/2 '$3#;#;#=L/9L,*6$Q'##I.)5 &!&&'44"--l;L!L"N9%'N44Q7 /2 $)A '' 5&%%-/9L,''4/ / 8 8V\\ 8 RI,6NI),8I)-1I* / 8 8V\\ 8 RI,6NI),8I)/9L, ,,33I> ,,33I>GPR[F\L77 C '' 2 '' 2''4/$u,'33?+7+C+CL+/L3= 04> 0'33?(// 0H0HI)5(// =!0 8 8V[[ 8 QA,6AM(//2', ''4/%.)5%++L9$++N;). '' 5K&NU*&(22<R@S@Z@Z?[[\(^__+ ].`r+cb|j}| td|j}|j}t |}d}g}g}t |D]\}} t | ttfr|dz }d} d} t|dz|D]+} | |vs|| d} || ddjdz |z} nt | tr!t| j| j} nt| j} | | _ | |j| | | f}|j|d}|D]!\}} |j j#|| #|r|j j%|D]} |j j'| |r|j j%yy)aK Insert the Global Events (GlobalReferenceLines and GlobalCommentLines) into an appropriate place in the outer Stream. Run after `self.spineCollection.createMusic21Streams()`. Is run automatically by `self.parse()`. uses `self.spineCollection.getOffsetsAndPrioritiesByLineNumber()` Nzrcannot insert global events: no spineCollection. Call parse() (or createHumdrumSpines() and parseMusic21()) first.rr[()r5r%#getOffsetsAndPrioritiesByLineNumberr1r>r]r6rzr{rbpriorityGlobalReferencecodevalue GlobalCommentrar coreInsertcoreElementsChanged coreAppend)r;r5lineNumberDictr1 maxEventListnumberOfGlobalEventsInARow insertList appendListreevent insertOffsetinsertPriorityrel insertTupleoffsets r,rPz(HumdrumDataCollection.insertGlobalEventss..  ""TU U)LLNNN 9~ %&"KM :< !),HAu%"57H!IJ*a/*.2 !"q1ul3AN*'5a'8'; *8*;A*>q*A*J*J,.+/,F+G4e%89)U[[AB&u{{3B, '%%b)#/"4K%%k2./*9-<%JFB KK " "62 .%  KK + + -B KK " "2 &  KK + + - r+c| |j}tj}||_g}|tD]$}|j ||j |&|r|j |dyy)z8 Create a metadata object for the file. NT)recurse)rrMetadatarupdateMetadatararemove)r;rmd grToRemovegrs r,rUz#HumdrumDataCollection.parseMetadata#sq 9 A     ,. O$B   b !   b !%  HHZH . r+)r9zstr | list[str]rNone)rr)rstream.Score | stream.Opus)r9z list[str]rz stream.Scorer)r9list[str] | Nonerz#tuple[bool, list[list[str]] | None])rGzlist[list[str]]rz stream.Opus)r9rrzlist[HumdrumLine])rz.tuple[list[ProtoSpine], list[EventCollection]])NN)r3zlist[ProtoSpine] | Noner4zlist[EventCollection] | Nonerrrr)rzstream.Stream | Nonerr)r&r'r(r)r<propertyr@rHrErCrDrLrMrNrPrUr*r+r,r.r.qs"H? $$ 6$:&*j<"j< +j>> hsl = humdrum.spineParser.SpineLine( ... lineNumber=7, contents='C4\t!local comment\t*M[4/4]\t.\n') >>> hsl >>> hsl.lineNumber 7 >>> hsl.numSpines 4 >>> hsl.spineData ['C4', '!local comment', '*M[4/4]', '.'] c||_|j}tjd|}t ||_||_||_y)Nz +)rr^r_splitr>r~rr)r;rr returnLists r,r<zSpineLine.__init__zs>$??$XXeX. Z  $.r+c<d|jd|jdS)Nline z (z spines))rr~r?s r, _reprInternalzSpineLine._reprInternals!t'r$..)9BBr+Nrrvrrrr7rrrr7r&r'r(r)r<rr*r+r,r|r|gs$/Cr+r|c"eZdZdZdddZddZy)rza A GlobalReferenceLine is a type of HumdrumLine that contains information/metadata about the humdrum document. In humdrum it is represented by three exclamation points followed by non-whitespace followed by a colon. Examples:: !!!COM: Stravinsky, Igor Fyodorovich !!!CDT: 1882/6/17/-1971/4/6 !!!ODT: 1911//-1913//; 1947// !!!OPT@@RUS: Vesna svyashchennaya !!!OPT@FRE: Le sacre du printemps The GlobalReferenceLine object takes two inputs:: lineNumber 1-based line number in the humdrum file contents string of contents And stores them as three attributes:: lineNumber: as above code: non-whitespace code (usually three letters) value: its value >>> gr = humdrum.spineParser.GlobalReferenceLine( ... lineNumber=20, contents='!!!COM: Stravinsky, Igor Fyodorovich\n') >>> gr >>> gr.lineNumber 20 >>> gr.code 'COM' >>> gr.value 'Stravinsky, Igor Fyodorovich' TODO: add parsing of three-digit Kern comment codes into fuller metadata TODO: parse ``@``/``@@`` language tags here (e.g. ``!!!OPT@@RUS:``, ``!!!OPT@FRE:``) and propagate language/isPrimary so that GlobalReference.updateMetadata can attach ``metadata.Text(value, language=...)`` instead of bare strings. c||_tjdd|} |jdd\}}|j }|t d|d ||_||_||_ y#t $rt d|dwxYw)N^!!!+rv:r[zSGlobalReferenceLine (!!!) found without a code listed; this is probably a problem!  ) rr_subrstripr% IndexErrorrrr)r;rr noExclaimrrs r,r<zGlobalReferenceLine.__init__s$FF8R2  O%OOC3MT5KKME|&(NNVZWX(Z[[!    O"$BBJ1$NO O Os 6A--Bc8|jd|jS)N: rrr?s r,rz!GlobalReferenceLine._reprInternals))Btzzn--r+N)rz !!! NUL: Nonerrrr*r+r,rzrzs'P ".r+rzc2eZdZUdZdZded<dd dZd dZy) r{av A GlobalCommentLine is a humdrum comment that pertains to all spines In humdrum it is represented by two exclamation points (and usually one space) The GlobalComment object takes two inputs and stores them as attributes:: lineNumber (1-based line number in the humdrum file) contents (string of contents) value (contents minus !!) The constructor can be passed (lineNumber, contents); if contents begins with bangs, they are removed along with up to one space directly afterwards. >>> com1 = humdrum.spineParser.GlobalCommentLine( ... lineNumber=4, contents='!! this comment is global') >>> com1 >>> com1.lineNumber 4 >>> com1.contents '!! this comment is global' >>> com1.value 'this comment is global' rvr7rc\||_tjdd|}||_||_y)N^!!+\s?rv)rr_rrr)r;rrrs r,r<zGlobalCommentLine.__init__s)$z2x0   r+c,t|jSr)reprrr?s r,rzGlobalCommentLine._reprInternalsDJJr+Nrrr)r&r'r(r)rrr<rr*r+r,r{r{s0E3O  r+r{c"eZdZdZdddZddZy)rxa* A blank line in a humdrum source. Humdrum forbids blank lines, but they appear in the wild. Storing them as BlankLine objects keeps `eventList` aligned with the source: `eventList[lineNumber - 1]` is always the HumdrumLine at that 1-based source line. Treated as a global event by `parseProtoSpinesAndEventCollections` (no SpineEvent is created at this line for any spine). >>> b = humdrum.spineParser.BlankLine(lineNumber=12) >>> b >>> b.lineNumber 12 c ||_d|_yNrv)rr)r;rs r,r<zBlankLine.__init__s$ r+c d|jS)Nrrr?s r,rzBlankLine._reprInternalst'((r+N)r)rrrrrrr*r+r,rxrxs)r+rxc*eZdZdZdddZddZd dZy) raS A ProtoSpine is a collection of events arranged vertically. It differs from a HumdrumSpine in that spine paths are not followed. So ProtoSpine(1) would be everything in the 2nd column of a Humdrum file regardless of whether the 2nd column was at some point an independent Spine or if it later became a split from the first spine. See :meth:`~music21.humdrum.spineParser.parseProtoSpinesAndEventCollections` for more details on how ProtoSpine objects are created. * Changed in v10: ProtoSpines now iterate over their eventLists and are ProtoM21Objects. Nc|g}||_yr)r1)r;r1s r,r<zProtoSpine.__init__s  I09r+c,t|jSriterr1r?s r,__iter__zProtoSpine.__iter__DNN##r+c2t|jdS)Nz events)r>r1r?s r,rzProtoSpine._reprInternalsdnn%&g..r+r)r1zlist[SpineEvent | None] | Nonerr)rzt.Iterator[SpineEvent | None]r)r&r'r(r)r<rrr*r+r,rrs : $/r+rceZdZdZej ddejdf ddZddZ ddZ ddZ ddZ dd Z dd Zddd ZeeeZdd Zdd Zy) HumdrumSpineaL A HumdrumSpine is a representation of a generic HumdrumSpine regardless of \*\*definition after spine path indicators have been simplified. A subclass of HumdrumSpine should be defined for each \*\*type. Those subclasses cannot redefine `__init__()` A HumdrumSpine is a collection of events arranged vertically that have a connection to each other. Each HumdrumSpine MUST have an id (numeric or string) attached to it. >>> SE = humdrum.spineParser.SpineEvent >>> spineEvents = [SE('**kern'), SE('c,4'), SE('d#8')] >>> spine1Id = 5 >>> spine1 = humdrum.spineParser.HumdrumSpine(spine1Id, spineEvents) >>> spine1.insertPoint = 5 >>> spine1.endingPoint = 6 >>> spine1.parentSpine = 3 # spine 3 is the previous spine leading to this one >>> spine1.childSpines = [7, 8] # the spine ends by being split into spines 7 and 8 A spine knows the SpineCollection it belongs to: >>> spineCollection1 = humdrum.spineParser.SpineCollection() >>> spine1.parentSpineCollection = spineCollection1 The spineType property searches the EventList or parentSpine to figure out the spineType. >>> spine1.spineType 'kern' Spines can be iterated through: >>> for e in spine1: ... print(e) **kern c,4 d#8 If you'd eventually like this spine to be converted to a class other than :class:`~music21.stream.Stream`, pass its classname in as the streamClass argument: >>> spine2 = humdrum.spineParser.HumdrumSpine(streamClass=stream.Part) >>> spine2.stream rNc*||_|g}|D] }||_ ||_||_d|_d|_d|_d|_d|_g|_ i|_ d|_ d|_ d|_ | t}||_d|_d|_y)NrFrv)rQspineIdr1rrrrRnewSpine isLastSpinerrparsed measuresMovedinsertionsDonerparentSpineCollection _spineTyper)r;rr1rr#rs r,r<zHumdrumSpine.__init__Ps  IE#EM,5%0] ! !.2+/ !&/1KM#! #($) (%4$5 !6K"!"'r+c"dt|jz}|jr(|dt|jjzdzz }|jr6|dz }|jD]}|t|jdzz }|dz }|S)Nrz [child of: rz [parent of: rz ])r7rQrRr)r;representationrs r,rzHumdrumSpine._reprInternalusDGG ,    ns43C3C3F3F/GG#M MN    o -N%%#add)c/1& d "Nr+c:|jj|y)z+ add an item to this Spine N)r1ra)r;rs r,razHumdrumSpine.appends e$r+c,t|jSrrr?s r,rzHumdrumSpine.__iter__rr+c|jr |jS|jD]H}tjd|j}|s&|j d|_|jcSy)Nz\*\*(.*)r[rv)r$r1r_ryrgroup)r;rm1s r,_getLocalSpineTypezHumdrumSpine._getLocalSpineTypesX ???? "I+y'9'9:B"$((1+& ( r+c8|j}|y|jSr)rRrS)r;rRs r,_getParentSpineTypez HumdrumSpine._getParentSpineTypes"&&  $$$r+c|jr |jS|j}|r ||_|S|j}|r ||_|Stdt |j z)zH searches the current and parent spineType for a search z0Could not determine spineType for spine with id )r$r,r.r%r7rQ)r;sts r, _getSpineTypezHumdrumSpine._getSpineTypest ???? "  $ $ &  DOI  % % '  DOI 68;DGG  EF Fr+c||_yr)r$)r; newSpineTypes r, _setSpineTypezHumdrumSpine._setSpineTypes &r+cX|j}tj}d|_d}d}d}|D]}t |tjrK|dk7s|r!|j |j ||}|j}|j}|dk(sed}h|dk7s|jjdk7r |j|j|z ||j ||j |j |r|j||jtj}|r|d} |sd| _|jd} | D]O}t |tjrd|jvr-| j!d||j#|Q| j$} | h| jj| j&jkr;t)| j&j| jjz | _|S)a Takes a parsed stream and moves the elements inside the measures. Works with pickup measures, etc. Does not automatically create ties, etc. Why not just use Stream.makeMeasures()? because humdrum measures contain extra information about barlines etc. and pickups are explicitly defined. >>> s1 = stream.Stream() >>> s1.append(meter.TimeSignature('2/4')) >>> m1 = stream.Measure() >>> m1.number = 1 >>> s1.append(m1) >>> s1.append(note.Note('C4', type='quarter')) >>> m2 = stream.Measure() >>> m2.number = 2 >>> s1.append(m2) >>> s1.append(note.Note('D4', type='half')) >>> s1.show('text') {0.0} {0.0} {0.0} {1.0} {1.0} >>> hds = humdrum.spineParser.HumdrumSpine() >>> s2 = hds.moveElementsIntoMeasures(s1) >>> s2.show('text') {0.0} {0.0} {0.0} {1.0} {0.0} The first measure is correctly identified as a pickup! >>> s2.measure(1).paddingLeft 1.0 rFr[T MiscTandem)rrMeasurermr6rrrr quarterLengthrragetElementsByClassgetElementsByOffsetStreamclassesrTr timeSignature barDurationr paddingLeft) r;streamIn streamOutcurrentMeasurecurrentMeasureNumbercurrentMeasureOffset hasMeasureOnermeasureElementsr+beginningStuffm1TimeSignatures r,moveElementsIntoMeasuresz%HumdrumSpine.moveElementsIntoMeasuressX&&( ) ! ), B"fnn-'1,"668((8!#')yy$')yy$'1,$(M'1, 0I0IQ0N"--bii:N.NPRS((,#& **,%%'    ^ ,$66v~~F  #B  &::1=N$b&--0!RZZ/IIa$$$R(%!..O*;;,,/J/J/X/XX%+O,G,G,U,U.0kk.G.G-H&IBNr+c|jj}td}|jD]}t |j }d}|dk(rnw|j dr|tvr^t|}nR|j drt||}|}n2|j dr t|}ntj|}||j||<|jj||jjy)z Dummy method that pushes all these objects to HumdrumSpine.stream as ElementWrappers. Should be overridden in specific Spine subclasses. =0Nrr#=!)r#humdrumLineNumbershdStringToMeasurer1r7r startswithrr7 SpineCommentrElementWrapperrrrr)r;rO lastContainerreventC thisObjects r,rHzHumdrumSpine.parses "77JJ)$/ ^^E(F26J}""3'!44!+F!3J""3' 1&- H * ""3')&1 !007 %161A1A":. &&z2'$( '')r+) rrr1zlist[SpineEvent] | Nonertype[stream.Stream]r#zSpineCollection | Nonerrr)rrrr)rzt.Iterator[SpineEvent]rv)r3r7rr)rA stream.StreamrrYr)r&r'r(r)tfinalrr<r<rrarr,r.r1r4rrSrJrHr*r+r,rrs/`WW+/+1==6: "("()"() "( 4 "(  "( "(H % $% F"' 6I_B*r+rcveZdZUdZded<ded<ded<ded <d ed <d ed <dd ZddZddZddZddZ y) KernSpinea A KernSpine is a type of humdrum spine with the \*\*kern attribute set and thus events are processed as if they are kern notes. Instances are not constructed directly; `reclassSpines` reassigns `__class__` from `HumdrumSpine` to `KernSpine` once the spine's exclusive interpretation is known. All KernSpine-specific state is initialized at the top of `parse()`. * Changed in v10: `currentTupletDuration` / `desiredTupletDuration` renamed to `currentTupletQL` / `desiredTupletQL`. stream.Measure | NonerTboolinTupletznote.GeneralNote | NonelastNotercurrentBeamNumbersrcurrentTupletQLdesiredTupletQLc |jj}td|_d|_d|_d|_d|_d|_|jD]} |j}d}|dk(rn|jdrt|}||}n|jdr(t||j|_|j}nU|jdrt|}|jd k7r*|}n'd |vr|j|}n|j!|}|;|j"||<|j"|_|j&j)||j&j9y#t*$rv}ddl}t.j1d |jd |j"d |j2d||j5} t.j7d| Yd}~d}~wwxYw)NrLFrr6rr#rMrNrvrzError in parsing event (z ) at line z for spine rzTraceback for the exception: )r#rOrPrTr`rarbrcrdr1rrQkernTandemToObjectrRcommentprocessChordEventprocessNoteEventrrrr Exception traceback environLocalwarnr format_exc printDebugr) r;rOrrUrV tempObjectspineCommentObjerktbs r,rHzKernSpine.parseFs!77JJ.t4  "#""^^E% P6: S=&&s+!3F!;J!-%/ &&s+):64CUCU)VD&!%!3!3J&&s+&26&:O&.."4%4 F]!%!7!7!?J!%!6!6v!>J)5:5E5E&z2+0*:*:J'KK**:6=$T '') P !!.u~~.@A$//01!!&r!6 ))+''*I"(NOO PsDE99 G8A+G33G8cnt|}|j||j|||_|S)z similar to hdStringToNote, this method processes a string representing a single note, but stores information about current beam and tuplet state. )hdStringToNotesetBeamsForNotesetTupletTypeForNotera)r;rU eventNotes r,rizKernSpine.processNoteEvent|s7 #6*  Y' !!),! r+ch|j}g}|D]9}t|}t|tjs)|j |;t j||dj}|dj|_ |j||j|||_ |S)z Process a single chord event Like processNoteEvent, stores information about current beam and tuplet state. rZ)beamsr) rrur6rNoterar Chordrzr rvrwra)r;rUnotesToProcess chordNotes noteToProcessthisNote eventChords r,rhzKernSpine.processChordEvents &( +M%m4H(DII.!!(+,[[:b>3G3GH (m44  Z( !!*-" r+ct|dsy|jdk7rL|jjs6t |jD]}|jj dy|jjro|jjdj dk(rd|_y|jjD]'}|j dk7s|xjdz c_)yy)z sets the beams for a Note (or Chord) given self.currentBeamNumbers and updates self.currentBeamNumbers based on stop beams. Safe enough to use on elements such as rests that don't have beam info. rzNrcontinuestopr[)hasattrrbrz beamsListrbratype)r;nunused_counterthisBeams r,rvzKernSpine.setBeamsForNotesq'"  " "a '0A0A"'(?(?"@z*#A WW  ww  #((F2*+' ! 1 1H}}.//14/!2 r+c|j}|jj}|jsQ|rOd|_|dj|_|j |_d|jjd_y|jrM|sKd|_d|_d|_|j)d|jjjd_yy|jr~t|j |j z|_|j |jk\r=|j |jzdk(r d|d_d|_d|_d|_yyyy)NTrstartFr6r) r tupletsr`totalTupletLengthrdr9rcrrar)r;rnDurnTupletss r,rwzKernSpine.setTupletTypeForNotes7zz::%%}} DM#+A;#@#@#BD #'#5#5D )0AJJ  q ! & ]]8!DM#&D #&D }}(9? &&..q16) ]]#)$*>*>ASAS*S#TD $$(<(<<,,t/C/CCqH#)  % '*$'*$ I= r+Nr)rUr7rnote.GeneralNote)rUr7rz chord.Chord)rrrr) r&r'r(r)rrHrirhrvrwr*r+r,r]r]0sF '&N##3*l ,5*+r+r]ceZdZdZddZy) DynamSpinez A DynamSpine is a type of humdrum spine with the \*\*dynam attribute set and thus events are processed as if they are dynamics. c|jj}d}|jD]X}|j}d}|dk(rn|j dr|t vrt |}n|j dr9|+|j|jj|t|}n|j drt|}|jdk7rd|}na|j drtj}n;|j drtj}ntj |}||j"||<||jj|H|j|[|+|j|jj||jjy)Nrr#rMrNrv<>)r#rOr1rrQrr7rrrrPrRrgr Diminuendo CrescendoDynamicr)r;rO thisContainerrrUrVrqs r,rHzDynamSpine.parses!77JJ-1 ^^E^^F26J}""3'!44!+F!3J""3' ,!557KK**=9 1& 9 ""3'".v"6"**b0!0J""3'%002 ""3'%//1 %--f5 %161A1A":. (KK**:6!,,Z8?$D  $  - - / KK " "= 1 '')r+Nrr&r'r(r)rHr*r+r,rrs  (*r+rceZdZdZddZy) HarmSpinea A HarmSpine is a type of humdrum spine with the \*\*harm attribute set and thus events are processed as if they are harmonic analysis annotations in the "harm" syntax. The harm roman numeral annotations are parsed using a superset of the original \*\*harm Humdrum representation, written for python and extending the syntax based on other projects like the RomanText and the MuseScore roman numeral notations. cf|jj}td}tjd}|j D]Q}|j }d}|dk(rn|jdrC|tvr2|jdr|dd}tj|}|}nt|}n|jdrt||}|}n|jd r t|}nj|j }tj|} tj| |tj j"tj j$ }||j&||<|j&|_|j*j-|T|j*j/y) NrLCrr#rr[rZrMrN) sixthMinor seventhMinor)r#rOrPrKeyr1rrQrendswithr7rRrconvertHarmToRomanr RomanNumeralMinor67DefaultFLATSHARPrrrrr) r;rOrT currentKeyrrUrV keyStringharmStrromanStrs r,rHzHarmSpine.parse sr!77JJ)$/ WWS\ ^^E^^F26J}""3'00??3' &q I!$!3J!+J",F!3J""3' 1&- H * ""3')&1 ..%88A"//$3388!&!5!5!;!;  %161A1A":.&+&6&6 # &&z2E$F '')r+Nrrr*r+r,rrs  '*r+rc4eZdZdZdddZd dZd dZd d dZy) ra A SpineEvent is an event in a HumdrumSpine or ProtoSpine. It's .contents property contains the contents of the spine, or it could be '.', in which case it means that a particular event appears after the last event in a different spine. It could also be "None" indicating that there is no event at all at this moment in the humdrum file. Happens if no ProtoSpine exists at this point in the file in this tab position. Should be initialized with its contents and 1-based source line number. These attributes are optional but likely to be very helpful:: lineNumber -- 1-based source line number in the humdrum file protoSpineId -- ProtoSpine id (0 to N) spineId -- id of HumdrumSpine actually attached to (after SpinePaths are parsed) The `toNote()` method converts the contents into a music21 note as if it's kern -- useful to have in all spine types. >>> se1 = humdrum.spineParser.SpineEvent('EEE-8') >>> se1.lineNumber = 40 >>> se1.contents 'EEE-8' >>> se1 >>> n = se1.toNote() >>> n c<||_||_d|_d|_yr0)rrrr)r;rrs r,r<zSpineEvent.__init__Ys% )!"!% r+c|jSrrr?s r,rzSpineEvent._reprInternal_ }}r+c|jSrrr?s r,__str__zSpineEvent.__str__brr+NcF|t|jSt|S)aP parse the object as a \*\*kern note and return a :class:`~music21.note.Note` object (or Rest, or Chord) >>> se = humdrum.spineParser.SpineEvent('DD#4') >>> n = se.toNote() >>> n >>> n.octave 2 >>> n.duration.type 'quarter' )rur)r; convertStrings r,toNotezSpineEvent.toNotees$  !$--0 0!-0 0r+)rvr)rr7rrrrrr)r str | Nonerr)r&r'r(r)r<rrrr*r+r,rr9s>& 1r+rceZdZdZddZddZejfddZddZ ddZ ddZ ddZ dd Z dd Z dd Zdd Z dd ZddZddZddZddZy)ra A SpineCollection is a set of HumdrumSpines with relationships to each other and where their position attributes indicate simultaneous onsets. When you iterate over a SpineCollection, it goes from right to left, since that's the order that humdrum expects. cng|_d|_d|_d|_t j |_y)NrF)spines nextFreeIdspineReclassDonerweakrefWeakKeyDictionaryrOr?s r,r<zSpineCollection.__init__s5*,  &++/   % % ' r+c,t|jS)zK Iterates spines right-to-left, the order humdrum expects. )reversedrr?s r,rzSpineCollection.__iter__s $$r+ct|j|||_|jj |j|xjdz c_|jS)a creates a new spine in the collection and returns it. By default, the underlying music21 class of the spine is :class:`~music21.stream.Part`. This can be overridden by passing in a different streamClass. Automatically sets the id of the Spine. >>> hsc = humdrum.spineParser.SpineCollection() >>> newSpine = hsc.addSpine() >>> newSpine.id 0 >>> newSpine.stream >>> newSpine2 = hsc.addSpine(streamClass=stream.Stream) >>> newSpine2.id 1 >>> newSpine2 >>> newSpine2.stream )rr#r[)rrrrra)r;rs r,rzSpineCollection.addSpinesM0% OO#"&  4==) 1}}r+c:|jj|y)z~ appendSpine(spine) -- appends an already existing HumdrumSpine to the SpineCollection. Returns void N)rra)r;spines r, appendSpinezSpineCollection.appendSpines 5!r+c`|jD]}|j|k(s|cStd)z returns the HumdrumSpine with the given id. raises a HumdrumException if the spine with a given id is not found z#Could not find a Spine with that ID)rrQr%)r;rrWs r, getSpineByIdzSpineCollection.getSpineByIds2 I||w&  %DEEr+c|jD].}|j|k(s|jj|ytdt)az Deletes a spine from the SpineCollection (after inserting, integrating, etc.) >>> hsc = humdrum.spineParser.SpineCollection() >>> newSpine = hsc.addSpine() >>> newSpine.id 0 >>> newSpine2 = hsc.addSpine() >>> newSpine2.id 1 >>> hsc.spines [, ] >>> hsc.removeSpineById(newSpine.id) >>> hsc.spines [] raises a HumdrumException if the spine with a given id is not found Nz$Could not find a Spine with that ID )rrQrr%)r;rrs r,removeSpineByIdzSpineCollection.removeSpineByIdsG(Attw ""1%!EbTJKKr+c|j|j|j|j|j |j |j y)aC Create Music21 Stream objects from spineCollections by running: self.reclassSpines() self.parseMusic21() self.performInsertions() self.moveObjectsToMeasures() self.attachNonKernEvents() self.makeVoices() self.assignIds() N) reclassSpines parseMusic21performInsertionsmoveObjectsToMeasuresattachNonKernEvents makeVoices assignIdsr?s r,rOz$SpineCollection.createMusic21StreamssT     ""$   "  r+cddi}i}|jD]}|j}|jtj}|sd}n|dj }||vr|||<d||<|S||_[|!|dxxdz cc<t|d|_~||dk(r"||}t|j dz|_||xxdz cc<|dzt||z|_y)a Assign an ID based on the instrument, or just a string of a number if there is no instrument. >>> hsc = humdrum.spineParser.SpineCollection() >>> newSpineDefault = hsc.addSpine() >>> newSpineDefault2 = hsc.addSpine() >>> newSpineOboe1 = hsc.addSpine() >>> newSpineOboe2 = hsc.addSpine() >>> newSpineTrumpet = hsc.addSpine() >>> newSpineOboe1.stream.append(instrument.Oboe()) >>> newSpineOboe2.stream.append(instrument.Oboe()) >>> newSpineTrumpet.stream.append(instrument.Trumpet()) >>> hsc.assignIds() >>> for sp in hsc.spines: ... print(sp.stream.id) 1 2 Oboe-1 Oboe-2 Trumpet Nrr[z-1-)rrr:r InstrumentinstrumentNamerQr7)r;usedIdsfirstStreamForEachInstrumentrW spineStreaminstrumentsStreamspineInstrument myFirstStreams r,rzSpineCollection.assignIdss.)-ayFH$I#**K + > >z?T?T U $"&"3A"6"E"Eg-@K,_=+,(".%4KN ( " !$WT]!3 ?+q0$@$QM'*=+;+;'LM#2m%'P ,;;! !$ ,;;! !s*N,63N103O 1O O O" !O" cd|jD]}|jdk7s |j |j}|j tj D]M}d}d}|D] }d|j vsd}|j}n|s0tdDcgc]}d}}|j} | D]}|j } | r| djds&| d} t| d } || } | 4tj} | || <| j j| tjr| J|j}|j!|| j#||z ||D]'} | | j%|j#|| )|j%Pycc}w) z make voices for each kernSpine -- why not just run stream.makeVoices() ? because we have more information here that lets us make voices more intelligently Should be done after measures have been made. rKNFrvoice1T r)rrSrRrr:r8rrrbelementsrQrrrarZ TYPE_CHECKINGrrr)r;rW thisStreamr hasVoiceslowestVoiceOffsetmElrevoicesrG mElGroups voiceNamer voicePart mElOffsets r,rzSpineCollection.makeVoicessI""f, 0E0E0Q"))J 33FNNC! $%!C3::-$( ,/JJ)  !AFr2KA42K"$++*C # I$IaL,C,CG,L )! I"%il"3K &{ 3I ($*LLN .7{+!((// :(444 # IIIcN((5F)FL%+("(I ,!557 &7C "( &&(MD %3Ls F-cF|jD]}|jy)zl runs spine.parse() for each Spine. thus populating the spine.stream for each Spine N)rrHrs r,rzSpineCollection.parseMusic219s I OO %r+Nr)rzt.Iterator[HumdrumSpine])rrWrr)rrrr)rrrr)rrrr)rWrrrYrrrr)rz4dict[int, tuple[OffsetQL, list[base.Music21Object]]])r&r'r(r)r<rrrrrrrrOrrrrrrrrrr*r+r,rr{s % ;A++B" FL4(.W`$DR((!( (  (6 % =./,]M~2)jr+rcReZdZdZd d dZd dZddZddZddZddZ ddZ dd Z y )ra6 An EventCollection holds every event that appears on a single source line of a humdrum file -- one cell per spine, in their `events` array. If a spine's cell on this line is '.' or a comment (no new event), use `lastEvents[spineNum]` to retrieve the previous event still sounding. `getSpineOccurring` returns either the current event or the last event that's still active. Theses events should happen at the same time (offset) but they are not necessarily the only events to happen at that same time. E.g. a clef change and the note that follows it on the next line take place at the same musical time but live in different EventCollections. These objects normally get created by :meth:`~music21.humdrum.spineParser.HumdrumDataCollection.parseProtoSpinesAndEventCollections` so you won't need to do all the setup. Assume that ec1 is C4 pp on source line 4, and ec2 is D4 . on source line 5: >>> SE = humdrum.spineParser.SpineEvent >>> eventList1 = [SE('C4', lineNumber=4), SE('pp', lineNumber=4)] >>> eventList2 = [SE('D4', lineNumber=5), SE('.', lineNumber=5)] >>> ec1 = humdrum.spineParser.EventCollection(maxSpines=2, lineNumber=4) >>> ec1.events = eventList1 >>> ec2 = humdrum.spineParser.EventCollection(maxSpines=2, lineNumber=5) >>> ec2.events = eventList2 >>> ec2.lastEvents[1] = eventList1[1] >>> ec2.maxSpines 2 >>> ec2.lineNumber 5 >>> ec2.getAllOccurring() [, ] If there were spine path markers this next boolean would be true: >>> ec2.spinePathData False In the future, EventCollection may enforce that all events have the same lineNumber * New in v10: lineNumber. ctjd|_tjd|_||_||_d|_y)Ncyrr*r*r+r,rz*EventCollection.__init__..zsTr+cyrr*r*r+r,rz*EventCollection.__init__..{sr+F)r rr lastEventsr2rr)r;r2rs r,r<zEventCollection.__init__ys<*0*<*<\*J .4.@.@.N')#(r+chd|jdt|jd|jdS)Nrz, z events, z spines)rr>rr2r?s r,rzEventCollection._reprInternals2t'r#dkk*:);9T^^DTT[\\r+c"||j|<yrrr;spineNum spineEvents r,rzEventCollection.addSpineEvents * Hr+c"||j|<yr)r,r0s r,rz!EventCollection.addLastSpineEvents$.!r+cVt|jD]}||j|<yr)rbr2r)r; globalEventres r,rzEventCollection.addGlobalEvents"t~~&A(DKKN'r+c |j|Srr/r;r1s r, getSpineEventzEventCollection.getSpineEvents{{8$$r+c\|j||j|S|j|Sr)r,rr7s r,rz!EventCollection.getSpineOccurrings1 ??8 $ 0??8, ,;;x( (r+c~g}t|jD]"}|j|j|$|Sr)rbr2rar)r; retEventsres r,getAllOccurringzEventCollection.getAllOccurrings9+- t~~&A   T33A6 7'r+N)rr)r2rrrrrr)r1rr2rrr)r5rrr)r1rrr)rzlist[SpineEvent | None]) r&r'r(r)r<rrrrr8rr<r*r+r,rrDs13h)]+/)%)r+rctjd|}d|vrtj}nz|ri|j d}|dj }||dk(rdt |z}ndt |z }tj|}||_|}ntd|d tjd |}tjd |}t|tjr[|r!|j d|j_ n8|r!|j d|j_ nd |vrd |j_ t|jd D]} t|jdD]} t|jdD]} t|jdD]} d|vrtj d|_n=d|vrtj d|_nd|vrtj d|_d|vr.|j"j%t#j&n1d|vr-|j"j%t#j(d|vr.|j"j%t#j*nd|vr.|j"j%t#j,ncd|vr.|j"j%t#j.n1d|vr-|j"j%t#j0d|vr.|j"j%t#j2nld|vr.|j"j%t#j4n:d|vr6t#j2} d | _|j"j%| d!|vr d"|vr-|j"j%t#j8d#|vr-|j:j%t;j<d$|vr-|j:j%t;j>d%|vr-|j:j%t;j@d&|vr-|j:j%t;jBd'|vr-|j:j%t;jDd(|vr-|j"j%t#jFd)|vr.|j:j%t;jHn1d*|vr-|j:j%t;jJt|tjLrd+|vrd,|_'n d-|vrd.|_'tjd/|} tjd0|} | r{tQ| j d} tQ| j d1}tSd|z| z |jT_+d2|vr|jd2|jT_,n| rtQ| j d}|dk(rw| j d}|d3k(rd4|jT_-n(|d5k(rd6|jT_-nd7|jT_-d2|vr=|jd2|jT_,n|tTj\vrItTj\||jT_-d2|vr|jd2|jT_,ntQ|d8z}t_j`t_jb|\}}d1|z}tTj\tQ||jT_-tUjd}tUjf|jTjZd|_4tUjf|jTjZd|_5t_jltQ|tQ|}tQ||z |_7tQtq||z |_9ttd9}|sBd2|vr>tUjf|jjjZ|jd2|_5|jTjw||r$d2|vr |jd2|jT_,d:|vr"|jy}d;|jT_-n]d<|vr=|jy}|jT}t|tzsJd=|_>d;|_-nd>|vr|jyd ?}nd@|vr t|tjLrt|jdAD]} |j~j%dt|jdBD]} |j~j%dt|jdCD]} |j~j%dDdE t|jdFD]} |j~j%dDdE |S)Gaw returns a :class:`~music21.note.Note` (or Rest or Unpitched, etc.) matching the current SpineEvent. Does not check to see that it is sane or part of a :samp:`**kern` spine, etc. New rhythmic extensions formerly defined in `wiki.humdrum.org/index.php/Rational_rhythms` and now at https://extras.humdrum.org/man/rscale/ are fully implemented: >>> n = humdrum.spineParser.hdStringToNote('CC3%2') >>> n.duration.quarterLength Fraction(8, 3) >>> n.duration.fullName 'Whole Triplet (2 2/3 QL)' >>> n = humdrum.spineParser.hdStringToNote('e-00.') >>> n.pitch >>> n.duration.quarterLength 24.0 >>> n.duration.fullName 'Perfect Longa' >>> n = humdrum.spineParser.hdStringToNote('F#000') >>> n.duration.quarterLength 32.0 >>> n.duration.fullName 'Imperfect Maxima' Note that the following example is interpreted as one note in the time of a double-dotted quarter not a double-dotted quarter-note triplet. I believe that the latter definition, though used in https://kern.humdrum.org/cgi-bin/ksdata?l=musedata/mozart/quartet&file=k421-01.krn&f=kern and the Josquin Research Project [JRP] is incorrect, seeing as it contradicts the specification in https://web.archive.org/web/20100203144730/http://www.music-cog.ohio-state.edu/Humdrum/representations/kern.html#N-Tuplets >>> storedFlavors = humdrum.spineParser.flavors['JRP'] #_DOCS_HIDE This is the default: >>> humdrum.spineParser.flavors['JRP'] = False >>> n = humdrum.spineParser.hdStringToNote('6..fff') >>> n.duration.quarterLength Fraction(7, 6) >>> n.duration.dots 0 >>> n.duration.tuplets[0].durationNormal.dots 2 If you want the JRP definition, set humdrum.spineParser.flavors['JRP'] = True before calling converter.parse() or anything like that: >>> humdrum.spineParser.flavors['JRP'] = True >>> n = humdrum.spineParser.hdStringToNote('6..fff') >>> n.duration.quarterLength Fraction(7, 6) >>> n.duration.dots 2 >>> n.duration.tuplets[0].durationNormal.dots 0 >>> n = humdrum.spineParser.hdStringToNote('gg#q/LL') >>> n.duration >>> n.duration.isGrace True >>> humdrum.spineParser.flavors['JRP'] = storedFlavors #_DOCS_HIDE z ([a-gA-G]+)rr[r)octavezCould not parse z for note informationz(#+)z(-+)r{}()[rrr_rrZTwWrMS$RTrO'"`~^;vurup\downz (\d+)%(\d+)z(\d+)rYr000maxima00longabrever6rqeighthQFP) appoggiaturapLJkpartialrightK)@r_r`rRestr*lowerr>r{stepr%r6pitch accidentalrbcountrTierra HalfStepTrillWholeStepTrillHalfStepInvertedMordentWholeStepInvertedMordentHalfStepMordentWholeStepMordentTurn InvertedTurnconnectedToPreviousOrnamentrStaccato Pizzicato StaccatissimoTenutoAccentFermataUpBowDownBowNotRest stemDirectionrrr r9dotsrtypeFromNumDictmathmodflog2TupletdurationTupleFromTypeDotsdurationActualdurationNormalgcdnumberNotesActualfloatnumberNotesNormalflavors appendTupletgetGracerslashrz)r matchedNoterV kernNoteNamernrA builtNote matchedSharp matchedFlatret1 foundRational foundNumber durationFirstdurationSecond durationTypedurationStringdTunused_remainder exponents baseValuenewTuprrdurs r,rurusd))M84K hYY[ "((+ A$$& <? "\**F\**FIIV,   !1(;PQRR99Wh/L))GX.K*dii( *6*<*J   ' H_*-J   '8>>#& ' ( 8>>#& ' ( 8>>#& ' ( 8>>#& ' ( h)    ,  h%%k&?&?&AB %%k&@&@&BC h%%k&I&I&KL %%k&J&J&LM %%k&A&A&CD %%k&B&B&DE h%%k&6&6&89 %%k&>&>&@A     !%%%b) h  h%%k&:&:&<= h  '' (>(>(@A h  '' (?(?(AB h   '' (C(C(EF h  '' (<(<(>? h  '' (<(<(>? h%%k&9&9&;< h  '' (;(;(=>   '' (=(=(?@*dll+ (?'+J $ X '-J $ IInh7M))Hh/KM//23 ]0034,21~3E 3U,V ) (?'/~~c':J   $ ;,,Q/0 1 (..q1N&+3 ##(4'+2 ##(+2 ##(h+3>>#+> ##( X55 5'/'?'? 'MJ   $h+3>>#+> ##(\"S(B,0IIdiim,D ) yYI'/'?'?I'OJ   $__&F$,$F$FzGZGZG_G_ab$cF !$,$F$FzGZGZG_G_ab$cF !((3r7C N3C'*28}F $'*5+;c+A'BF $ %.C3(?(0(J(J))..s0C)E%    , ,V 4sh+3>>#+> ##( h((* #+  ((* !!#}---  ((d(;  *dll+x~~c*+A    # #G ,,x~~c*+A    # #F +,x~~c*+A    # #Iw 7,x~~c*+A    # #Iw 7, r+c |dk(rtjdtj}t j d|}|rFt |jd|_|jdr|jd|_ d d|vrd n4d |vrd n-d |vrd n&d |vsd|vrd nd|vrd nd|vrd n d|vrd nd|vrd |jddkD}|xstt j d|}|xstt j d|}d fd }||rdnd}d|vrtj|_|||_|r |d|_|S|r|dn||_|S)!a kern uses an equals sign followed by processing instructions to create new measures. * Changed in v10: repeat dots are encoded as :class:`~music21.bar.Repeat` objects instead of being stuffed into a non-existent ``Barline.repeatDots`` attribute. ``:|:`` now produces an end-Repeat on the previous measure's right barline AND a start-Repeat on the new measure's left barline. z==|zd"Double bar visually rendered as a single bar" is not supported in music21; storing as a double bar.z (\d+)([a-z]?)r[rYrvrnonerPshortrRtickz||z==doublerwz heavy-heavyz|!r[z!|z heavy-light|regularrz:[|!=]z[|!=]:ct|tj|}ntj}r|_|S)N) direction)rRepeatBarliner)rbbarTypes r,makeBarz"hdStringToMeasure..makeBar s1   ZZ)|St3|S#tj$rtd |d wxYw#t$rItj dd|}tj dd|}tj|}|cYSwxYw#t,j0$rt3| cYSwxYw#t,j0$rt3|cYSwxYw)*a Kern uses symbols such as :samp:`*M5/4` and :samp:`*clefG2`, etc., to control processing This method converts them to music21 objects. >>> m = humdrum.spineParser.kernTandemToObject('*M3/1') >>> m Unknown objects are converted to MiscTandem objects: >>> m2 = humdrum.spineParser.kernTandemToObject('*TandyUnk') >>> m2 Nz*clefrrXGv2GvzG^2zG^Fv4FvzUnknown clef type z foundz*MMr?)rmz^\[rvz]\s*$)rz*MrYz (\d+)/(\d+)r[)0r]r[rr]r@r[rzIncorrect meter: z*ICz*IGz*ITrz*Iz*k#rrZr) rrQr NoClefPercussionClef Treble8vbClef Treble8vaClef Bass8vbClefclefFromString ClefExceptionr%rr MetronomeMark ValueErrorr_rryrr*r TimeSignaturerfromHumdrumClassHumdrumInstrumentExceptionr7fromHumdrumInstrumentrqr KeySignaturerr)rclefTypermetronomeMarkTextmetronomeMarkNumberMMMS meterTypetsTemp numeratordenominatorStr denominatorinstrumentClassiObj instrumentStr numSharpsthisKeys r,rfrf s"$$   7 #!": s?;;= _&&( (  %%' '  %%' '  %%' '  %%' '  ##% %  ##% % L!%!4!4X!>%%   5 !"12J "'(9": $$,?@BI   4 12J .)4 FLLO,I#\\!_N%77**955 !S(NI#t+NI#u,NI**i[++GHH"%6vhf#EF F   5 ! * ///@DK   5 !&!!   6 "&!!   4 qr  -44]CDK   4 LL% >fll3/0I **  2,www&!!C%% L&);F86'JKK L  "vr3D E  "x5F G $$*;55 /o. . /55 -m, , -sC)L"L7N 4N0#L47AN N  N-,N-0OOc*eZdZddfd ZddZxZS)r7c 2t|di|||_y)Nr*)rr<r)r;rkeywordsrs r,r<zMiscTandem.__init__~ s $8$! r+c|jSr)rr?s r,rzMiscTandem._reprInternal s++r+rX)rr7rrr)r&r'r(r<rrrs@r,r7r7} s " r+r7c.eZdZdZddfd ZddZxZS)rRa A Music21Object that represents a comment in a single spine. >>> sc = humdrum.spineParser.SpineComment('! this is a spine comment') >>> sc >>> sc.comment 'this is a spine comment' c `t|di|tjdd|}||_y)Nz^!+\s?rvr*)rr<r_rrgr;rgr commentPartrs r,r<zSpineComment.__init__ s, $8$ffYG4 ' r+c,t|jSrr rgr?s r,rzSpineComment._reprInternal DLL!!r+rXrgr7rrrr&r'r(r)r<rrrs@r,rRrR s( "r+rRc.eZdZdZddfd ZddZxZS)ra A Music21Object that represents a comment for the whole score >>> sc = humdrum.spineParser.GlobalComment('!! this is a global comment') >>> sc >>> sc.comment 'this is a global comment' c t|di|tjdd|}|j }||_y)Nr rvr*)rr<r_rrrgrs r,r<zGlobalComment.__init__ s: $8$ffZW5 !'') ' r+c,t|jSrrr?s r,rzGlobalComment._reprInternal rr+rXrrrrs@r,rr s( "r+rc ~eZdZUdZ d dfd Zidddddd d d d d ddddddddddddddddddddddd did!d"d#dd$d%d&dd'd(d)dd*dd+dd,dd-dd.dd/dd0d1d2dd3dd4d5d6d7id8d9d:d;dd?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPddQdRdSdTdUdVdWdXidYdZd[d\d]dd^dd_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxidyddzdd{dd|d}d~ddddddddddddddddddddddddddddddddddddd Zded<ddZddZxZ S)ra& A Music21Object that represents a reference in the score, called a "reference record" in Humdrum. See Humdrum User's Guide Chapter 2. >>> sc = humdrum.spineParser.GlobalReference('!!!REF:this is a global reference') >>> sc >>> sc.code 'REF' >>> sc.value 'this is a global reference' Alternate form: >>> sc = humdrum.spineParser.GlobalReference('REF', 'this is a global reference') >>> sc >>> sc.code 'REF' >>> sc.value 'this is a global reference' Language codes are parsed: >>> sc = humdrum.spineParser.GlobalReference('!!!OPT@@RUS: Vesna svyashchennaya') >>> sc.code 'OPT' >>> sc.language 'RUS' >>> sc.isPrimary True >>> sc = humdrum.spineParser.GlobalReference('!!!OPT@FRE: Le sacre du printemps') >>> sc.code 'OPT' >>> sc.language 'FRE' >>> sc.isPrimary False rvc t|d i|tjdd|}|j }|2d|vr.tjdd|}tjdd|}||_||_d|_d|_d|j vr(d|_|j jdd |_d |j vr)|j jd \|_|_yy) Nrrvrz^.*?:z:.*$Fz@@T@r*) rr<r_rrrrlanguage isPrimaryreplacer)r; codeOrAll valueOrNonerrs r,r<zGlobalReference.__init__ s $8$FF8R3 OO%  3)#3&&2y9KwI6I" * "& $ 499 !DN ))$4DI $)) '+yys'; $DIt} r+COMcomposerCOAattributedComposerCOSsuspectedComposerCOL composerAliasCOCcomposerCorporateCDTCBLCDLCNTLYRlyricistLIB librettistLARarrangerLOR orchestratorTXOtextOriginalLanguageTXL textLanguageTRN translatorRTLRMM manufacturerzRC#RRD dateIssuedRLCRNPproducerRDTzRT#MGNMPNMPSMRDMLCMCN conductorMPDMDTOTLtitleOTP popularTitleOTAalternativeTitleOPR parentTitleOAC actNumberOSC sceneNumberOMVmovementNumberOMD movementNameOPS opusNumberONMrmOVM volumeNumberODE dedicatedToOCO commissionOCL transcriberONBODT dateCreatedOCYcountryOfCompositionOPClocaleOfCompositionGTL groupTitleGAWassociatedWorkGCOcollectionDesignationPUBPEDPPRfirstPublisherPDTdateFirstPublishedPTLpublicationTitlePPPplaceFirstPublishedzPC#publishersCatalogNumberSCTscholarlyCatalogAbbreviationSCAscholarlyCatalogNameSMSmanuscriptSourceNameSMLmanuscriptLocationSMAmanuscriptAccessAcknowledgementYEPelectronicPublisherYEC copyrightYERelectronicReleaseDateYEMYENYORYOOoriginalDocumentOwnerYOYYOEoriginalEditorEEDelectronicEditorENCelectronicEncoderENDEMDEEVEFLESTVTSACOAFRAGN) ASTAMDAMTAINAREARLHAOHTXRLNRNBRWBzdict[str, str]humdrumKeyToUniqueNamec|j}|j}|jj|d}|r|j ||y||jvr|j d|z|y|j ||y)z update a metadata object according to information in this GlobalReference See humdrum guide Appendix I for information rvzhumdrum:N)rrrradd addCustom)r;rcrV uniqueNames r,rzGlobalReference.updateMetadata[ so II JJ5599!R@  FF:q ! $-- - LLa + LLA r+c8|jd|jS)Nrrr?s r,rzGlobalReference._reprInternaln s))Adjj^,,r+)rvN)rr7rrrr)rzmetadata.Metadatarrr) r&r'r(r)r<rrrrrrs@r,rr sZ'T $<<<  <,l. zl. # l. " l.  l. "l. rl. rl. rl. rl. zl. |l. zl. ~l. %!l." ~#l.( |)l.* r+l., ~-l.. r/l.0 |1l.2 r3l.4 z5l.6 r7l.8 r9l.< r=l.> r?l.@ rAl.B rCl.D rEl.F {Gl.H rIl.J rKl.N wOl.P ~Ql.R !Sl.T }Ul.V {Wl.X }Yl.Z [l.\ ~]l.^ |_l.` xal.b ~cl.d }el.f |gl.h }il.j rkl.l }ml.n %ol.p $ql.t |ul.v wl.x &yl.| r}l.~ rl.@ Al.B #Cl.D !El.F $Gl.H (Il.J -Kl.L %Ml.N %Ol.P #Ql.R 0Sl.T $Ul.V {Wl.X &Yl.Z r[l.\ r]l.^ r_l.` &al.b rcl.d el.f !gl.h "il.j rkl.l rml.n rol.p rql.r rsl.t rul.x ryl.z r{l.| r}l.~Wl.Nl\&-r+rceZdZdZddZy)Testz Note: most spineParser tests are in :mod:`music21.humdrum.tests`. Only `testCopyAndDeepcopy` lives here so that `globals()` resolves. c2ddlm}||ty)Nr) testCopyAll)music21.test.commonTestrglobals)r;rs r,testCopyAndDeepcopyzTest.testCopyAndDeepcopyw s7D')$r+Nr)r&r'r(r)rr*r+r,rrr s %r+r__main__)rr7rrr)rr7rr^rzstream.Measure)rr7rzbase.Music21Object | None)Mr) __future__rrnrr_typingrZunittestrmusic21.common.numberToolsrmusic21.common.typesrmusic21rrrr r r r r rrrrrrrrrrrrrmusic21.durationrmusic21.humdrumrrrpathlib EnvironmentrlrrMusic21Exceptionr%ProtoM21Objectr.rrr|rzr{rxrrr]rrrrrrurPrf Music21Objectr7rRrrTestCaserr&mainTestr*r+r,rsY/`# -)! *&'??&{&&'<= %.9 |44 A /G22A /H'>'((&C C><.+<.~" " J) )0/''/:N*7))N*b^+ ^+B.*.*b2* 2*n=1''=1DDg,,DR[g,,[|Ur,0I I (I I Vj"r ## "4%%"&"D&&"(B-d((B-J%8  % zGTr+