3j.ddlmZddlZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z Gdd Z Gd d Z Gd d e ZGddejZGddejZedk(rddlZej&eyy)) annotationsN)chord)key)interval)note)streamceZdZdZdZdZddZddZddZddZ dd Z dd Z dd Z dd Z dd ZddZddZddZdZdZdZdZdZdZdZddZy)Hashera This is a modular hashing object that can hash notes, chords, and rests, and some of their properties. Steps to using and calling the hasher: 1) Initialize a hasher object 2) Set the properties that you want to hash. There are 4 main groups of properties/settings:: a) self.validTypes should be some combination of notes, chords, rests b) general hashing settings include self.includeReference. if self.includeReference is True, a reference to the original note/rest/chord is created and kept track of during the hashing process. c) note properties are things like pitch, duration, offset, and some slightly fancier properties d) self.stateVars is a dictionary of things you might want to hash that require some memory e.g. current key signature, interval from the last note 3) call the hashStream() function on the stream you want to hash. This is what the Hasher object does the in background once hashStream() is called: 1) It runs self.setupValidTypesAndStateVars() and sets up properties from (a) and (d) from above based on your settings 2) It runs self.preprocessStream() and based on settings from (d) 3) It determines which objects in the passed-in stream should be hashed 4) It runs self.setupTupleList() and sets up self.tupleList, self.hashingFunctions and self.tupleClass, all related to each other. self.tupleList is a list of all the properties that are hashed. self.hashingFunctions is a dictionary of which hashing function should be used for each property (there are multiple ways of hashing a note's pitch, for example, by MIDI number, or by a string representation). self.tupleClass is a NamedTuple that is constructed ad hoc based on which properties are to be hashed. 5) For all the elements from the stream that are to be hashed, the hasher hashes every one of its properties that are to be hashed using the hashing function listed in self.hashingFunctions. It creates a single NamedTuple called a NoteHash for each element from the stream. However, if self.includeReference is set to True, a NoteHashWithReference tuple is created instead. ctjtjtjg|_d|_d|_d|_d|_ d|_ d|_ d|_ d|_ d|_d|_d|_d|_d|_d|_d|_d|_g|_d|_i|_i|_y)z The Hasher object is initialized with defaults of what objects should be hashed, and what properties of those objects should be hashed. FT N)rNoteRestrChord validTypesincludeReference hashPitchhashMIDIhashNoteNameOctave hashOctave hashDurationroundDurationAndOffset hashOffset granularityhashIntervalFromLastNotehashIsAccidental hashIsTiedhashChordsAsNoteshashChordsAsChordshashNormalOrderStringhashPrimeFormString tupleList tupleClass stateVarshashingFunctionsselfs J/DATA/.local/lib/python3.12/site-packages/music21/alpha/analysis/hasher.py__init__zHasher.__init__Es 99dii=!& "' &*#(-% % "&"'%*"#(  "c|jrd|jd<|jr9|jj t j d|jd<yy)aa Sets up the self.stateVars dictionary depending on how the flags for self.hashIntervalFromLastNote and self.hashIsAccidental are set. >>> h = alpha.analysis.hasher.Hasher() >>> h.hashIntervalFromLastNote = True >>> h.setupValidTypesAndStateVars() >>> h.stateVars {'IntervalFromLastNote': None} >>> h2 = alpha.analysis.hasher.Hasher() >>> h2.hashIsAccidental = True >>> h2.setupValidTypesAndStateVars() >>> h2.stateVars {'KeySignature': None} >>> key.KeySignature in h2.validTypes True NIntervalFromLastNote KeySignature)rr#rrappendrr,r%s r'setupValidTypesAndStateVarsz"Hasher.setupValidTypesAndStateVarsssP(  ( (59DNN1 2  OO " "3#3#3 4-1DNN> * !r)Nc^|r|jjS|jjS)a returns the duration of a chord object passed in, otherwise the duration of a note object passed in. >>> h = alpha.analysis.hasher.Hasher() >>> n = note.Note('A-', quarterLength=2.5) >>> h._hashDuration(n) 2.5 >>> d = duration.Duration(2.0) >>> c = chord.Chord('A-4 C#5 E5', duration=d) >>> h._hashDuration(n, thisChord=c) 2.0 )duration quarterLengthr&e thisChords r' _hashDurationzHasher._hashDurations) %%33 3zz'''r)c|r.|jt|jjS|jt|jj|j_|jjS)z0 TODO: Check if this is working )_getApproxDurOrOffsetfloatr0r1r2s r'_hashRoundedDurationzHasher._hashRoundedDurations_ --eI4F4F4T4T.UV V#'#=#=eAJJD\D\>]#^  zz'''r)c|r |jryt|tjry|jj S)a, returns midi pitch value (21-108) of a note returns 0 if rest returns 1 if not hashing individual notes of a chord >>> n = note.Note(72) >>> c = chord.Chord('A-4 C#5 E5') >>> h = alpha.analysis.hasher.Hasher() >>> h.hashChordsAsChords = True >>> h._hashMIDIPitchName(n, thisChord=c) 1 >>> h.hashChordsAsChords = False >>> h._hashMIDIPitchName(n, thisChord=c) 72 >>> r = note.Rest() >>> h._hashMIDIPitchName(r, thisChord=c) 0 r)r isinstancerrpitchmidir2s r'_hashMIDIPitchNamezHasher._hashMIDIPitchNames1( 00 499 %ww||r)c|r |jryt|tjryt |j S)aQ returns string representation of a note e.g. 'F##4' returns 'r' if rest returns 'z' if not hashing individual notes of a chord (i.e. hashing chords as chords) >>> n = note.Note(72) >>> c = chord.Chord('A-4 C#5 E5') >>> h = alpha.analysis.hasher.Hasher() >>> h.hashChordsAsChords = True >>> h._hashPitchName(n, thisChord=c) 'z' >>> h.hashChordsAsChords = False >>> h._hashPitchName(n, thisChord=c) 'C5' >>> r = note.Rest() >>> h._hashPitchName(r, thisChord=c) 'r' zrrr<rrstrr=r2s r'_hashPitchNamezHasher._hashPitchNames1& 00 499 %177|r)c|r |jryt|tjryt |j ddS)aZ returns string representation of a note without the octave e.g. 'F##' returns 'r' if rest returns 'z' if not hashing individual notes of a chord >>> n = note.Note(72) >>> c = chord.Chord('A-4 C#5 E5') >>> h = alpha.analysis.hasher.Hasher() >>> h.hashChordsAsChords = True >>> h._hashPitchNameNoOctave(n, thisChord=c) 'z' >>> h.hashChordsAsChords = False >>> h._hashPitchNameNoOctave(n, thisChord=c) 'C' >>> r = note.Rest() >>> h._hashPitchNameNoOctave(r, thisChord=c) 'r' rArBNrCr2s r'_hashPitchNameNoOctavezHasher._hashPitchNameNoOctaves8& 00 499 %177|CR  r)ct|tjr |jryt|tj ry|j S)a returns octave number of a note returns -1 if rest or not hashing individual notes of a chord >>> n = note.Note(72) >>> c = chord.Chord('A-4 C#5 E5') >>> h = alpha.analysis.hasher.Hasher() >>> h.hashChordsAsChords = True >>> h._hashOctave(c, thisChord=c) -1 >>> h.hashChordsAsChords = False >>> h._hashOctave(n, thisChord=c) 5 >>> r = note.Rest() >>> h._hashOctave(r, thisChord=c) -1 rG)r<rrrrroctaver2s r' _hashOctavezHasher._hashOctaves7$ a %$*A*A 499 %xxr)cyNr2s r'_hashIsAccidentalzHasher._hashIsAccidentals r)c|r|j|jS|j|j|_|jS)z Returns offset rounded to the nearest subdivided beat. The subdivided beat is indicated with self.granularity. By default, the granularity is set to 32, or 32nd notes )r7offsetr2s r'_hashRoundedOffsetzHasher._hashRoundedOffsets= --i.>.>? ?--ahh7xxr)c6|r |jS|jS)zW returns an unrounded floating point representation of a note's offset )rQr2s r' _hashOffsetzHasher._hashOffsets ## #xxr)cJ t|tjry|jdg|jd}|yt j ||j }t jt j |j Syy#t$rYywxYw)z returns the interval between last note and current note, if extant known issues with first note of every measure in transposed pieces returns 0 if things don't work r Nr) noteStartnoteEnd) r<rr previousrInterval intervalClassconvertGeneric TypeError)r&r3r4 previousNoteintFromLastNotes r'_hashIntervalFromLastNotez Hasher._hashIntervalFromLastNote&s 1dii( 6*6 zz&1 '"*"3"3l<=#??L} ..x/@/@/Q/_/_`` 7)  s>BAB B"!B"c |r |jSy)zg returns prime form of a chord as a string e.g. '<037>' returns '<>' otherwise <>)primeFormStringr2s r'_hashPrimeFormStringzHasher._hashPrimeFormString8s ,, ,r)c>|r|j|jSy)zi returns normal order of a chord as a string e.g. '<047>' returns '<>' otherwise ra)formatVectorString normalOrderr2s r'_hashChordNormalOrderStringz"Hasher._hashChordNormalOrderStringAs! // 0E0EF Fr)cVg}|jr|jd|jr|j|jd<nc|js&|j s|j |jd<n1|js%|j r|j|jd<|jr*|jd|j|jd<|jr*|jd|j|jd<|jrnx|jrl|jr*|jd|j|jd<|j r*|jd|j"|jd<|j$rP|jd|j&r|j(|jd<n|j*|jd<|j,rP|jd|j&r|j.|jd<n|j0|jd<|j2r*|jd|j4|jd<||_t9j:d ||_y ) a Sets up self.hashingFunctions, a dictionary of which properties of self.validTypes should be hashed and which hashing functions should be used for those properties. Creates a tupleList of all the properties that are hashed and uses that to create a named tuple NoteHash with those properties. This is how we can generate a malleable named tuple NoteHash that is different depending upon which properties a particular instance of Hasher object hashes. Pitch IsAccidentalOctaveNormalOrderStringPrimeFormStringDurationOffsetr+NoteHashN)rr-rr?r$rrErHrrOrrKrrrrgr rcrrr9r5rrRrTrr_r! collections namedtupler")r&r!s r'setupTupleListzHasher.setupTupleListLs0 >>   W %}}151H1H%%g.]]4+B+B151D1D%%g.]]t'>'>151L1L%%g.$$  08<8N8N%%n5 ??   X &.2.>.>D ! !( +  ! !   $ $))  !45=A=]=]%%&9:''  !23;?;T;T%%&78      Z (**484M4M%%j1484F4F%%j1 ??   X &**262I2I%%h/262B2B%%h/  ( (   3 4<@:   4 4Y 9 U  ' ' 9 =r)cJt|}||_|j|y)a creates a NoteHashWithReference object from tupleHash and with the reference pass in and adds the NoteHashWithReference object to the end of finalHash >>> from collections import namedtuple >>> n = note.Note('C4') >>> NoteHash = namedtuple('NoteHash', ['Pitch', 'Duration']) >>> nh = NoteHash(n.pitch, n.duration) >>> finalHash = [] >>> h = alpha.analysis.hasher.Hasher() >>> h.addNoteHashWithReferenceToFinalHash(finalHash, nh, n) >>> finalHash [NoteHashWithReference(Pitch=C4, Duration=)] >>> finalHash[0].reference.id == n.id True N)NoteHashWithReferencerr-)r&r|rrnhwrs r'rz*Hasher.addNoteHashWithReferenceToFinalHashs#&%Y/"r)c<t|}|j|y)a creates a NoteHash object from tupleHash and adds the NoteHash object to the end of finalHash >>> from collections import namedtuple >>> n = note.Note('C4') >>> NoteHash = namedtuple('NoteHash', ['Pitch', 'Duration']) >>> nh = NoteHash(n.pitch, n.duration) >>> finalHash = [] >>> h = alpha.analysis.hasher.Hasher() >>> h.addNoteHashToFinalHash(finalHash, nh) >>> finalHash [(, )] N)rpr-)r&r|rnhs r'rzHasher.addNoteHashToFinalHashs i r)cLt||jz|jz SrM)roundr)r& durOrOffsets r'r7zHasher._getApproxDurOrOffsets#[4#3#334t7G7GGGr)cV||k(xs#t|d|zzt|d|zzk(Sz use to look at whether beat lengths are close, within a certain range probably can use for other things that are approx. equal intr&absig_figs r'_approximatelyEqualzHasher._approximatelyEqual4 AvIQw./3q2=7H3IIIr)rM))__name__ __module__ __qualname____doc__r(r.r5r9r?rErHrKrOrRrTr_rcrgrsrvrr{rrr7rrNr)r'r r s}+Z,#\28(&(42!20  $9Hv $L>.HHJr)r c"eZdZdZdZdZdZy)raT returns tuple with reference to original note or chord or rest >>> from collections import namedtuple >>> NoteHash = namedtuple('NoteHash', ['Pitch', 'Duration']) >>> nh = NoteHash(60, 4) >>> nhwr = alpha.analysis.hasher.NoteHashWithReference(nh) >>> nhwr.reference = note.Note('C4') >>> nhwr NoteHashWithReference(Pitch=60, Duration=4) >>> nhwr.Pitch 60 >>> nhwr.Duration 4 >>> nhwr.hashItemsKeys ('Pitch', 'Duration') >>> for val in nhwr: ... print(val) 60 4 >>> nhwr.reference cd|_|j}|D]}t||||t|j |_yrM)r_asdictsetattrrzkeys hashItemsKeys)r& hashItemsNT hashItemsDictxs r'r(zNoteHashWithReference.__init__sH#++- A D!]1- ."=#5#5#78r)c#JK|jD]}t||ywrM)rgetattr)r&keyNames r'__iter__zNoteHashWithReference.__iter__&s#))G$( (*s!#cd}g}|jD]2}|}|dz }|tt||z }|j|4|dj |z }|dz }|S)NzNoteHashWithReference(=z, ))rrDrr-join)r&nhStrAllvalsrnhStrs r'__repr__zNoteHashWithReference.__repr__*sn+##AE SLE Sq)* *E KK  $ DIIdO#Cr)N)rrrrr(rrrNr)r'rrs89) r)rc"eZdZdZfdZxZS)rpz >>> note1 = note.Note('C4') >>> nh = alpha.analysis.hasher.NoteHash((1, 2)) >>> nh (1, 2) >>> a, b = nh >>> a 1 >>> b 2 >>> nh.__class__ <... 'music21.alpha.analysis.hasher.NoteHash'> c>tt| |t|SrM)superrp__new__rz)clstupEls __class__s r'rzNoteHash.__new__FsXs+Cv??r))rrrrr __classcell__)rs@r'rprp8s @@r)rpcDeZdZdZd dZdZdZdZdZdZ dZ d Z y ) Testc2ddlm}||ty)Nr) testCopyAll)music21.test.commonTestrglobals)r&rs r'testCopyAndDeepcopyzTest.testCopyAndDeepcopyKs7D')$r)cV||k(xs#t|d|zzt|d|zzk(Srrrs r'rzTest._approximatelyEqualOrr)c tj}tjd}d|j_tjd}tjd}t jgd}d|j_tjd}|j||j||j||j||j|t}gd}tjd gd } |D cgc]\} } } | | | | } } } } |j|j|| y cc} } } w) zz test for hasher with basic settings: pitch, rounded duration, offset with notes, chord, and rest C4halfzF#4zB-2rG4zE-5?)r1))<@)B?r).rg@)rr@)Crr)Krr)rrg@rprirnroN)rStreamrr r0typerrrr-r rqrr assertEqualr)r&s1note1note2note3cMinorrBhhashes_plain_numbers CNoteHashryrAhashes_in_formats r' testBasicHashzTest.testBasicHashVs ]]_ $$ %  % 01% IIC ( % % % & ! H O**:7VW -AC-A Aq&A!D-A C b)+;<Cs$E c tj}tjd}d|j_t jgd}d|j_t jgd}d|j_|j||j||j|t}d|_ d|_ d|_ tjdgd }gd }|D cgc]\}} } } ||| | | } } } }} |j|j!|| y cc} } } }w) zY test to make sure that hashing works when trying to hash chord as chord rrr)rrE4wholeTFrp)rirmrnro)rrarrr;<037>rr)r;rrrN)rrrr r0rrrr-r rrr rqrrrr) r&rrrcMajorrrrrrrArrs r'%testHashChordsAsChordsPrimeFormStringz*Test.testHashChordsAsChordsPrimeFormStringss]]_ $$01%/0& % & & H## $**:8NO  81EF0D Aq!&Aq1UVW0D F b)+;<FsD? c tj}tjd}d|j_t jgd}d|j_t jgd}d|j_|j||j||j|t}d|_ d|_ d|_ d|_ tjdgd }gd }|D cgc]\}} } } ||| | | } } } }} |j!|j#|| ycc} } } }w) Nrrr)rrE3rTFrp)rirlrnro)rr)r;z<047>rr)rrrr r0rrrr-r rrr rrqrrrr) r&s2rrrrrrrrrArrs r'!testHashChordsAsChordsNormalOrderz&Test.testHashChordsAsChordsNormalOrders! ]]_ $$01%/0& % & & H## %"&**:8NO  81EF0D Aq!&AQWXY0D F b)+;<FsE c tj}tjd}tjd}t j ddg}d|j _d|j _d|j _|j||j||j|t}d|_ tjdgd}gd }|D cgc]\}} } ||| | } } }} |j|} | d d | d d | d d | d d g} | d d | d d | d d | d d g}tfdt!| |DsJycc} } }w)NrrI +?UUUUUU?rFrpr))rrr)rrr)rr2z[@)rrrrr;c3<K|]}j|ywrM)r).0valuesr&s r' z1Test.testHashUnroundedDuration..s'A!?v,4++V4!?s)rrrr rrr0r1rr-r rrqrrrallzip)r&s3rrrrrrrrArrh3 h3_floatsanswers_floatss` r'testHashUnroundedDurationzTest.testHashUnroundedDurations ]]_ $ $dD\*',$',$% % % & H#( **:7VW  :.BC-A Aq&A!D-A C \\" U1Xr!uQxAq2a58< *1-a0*1-a0*1-a0*1-a02A!$Y!?AA AACs0E8c tj}tjd}tjd}t j ddg}d|j _d|j _d|j _|j||j||j|t}d|_ tjdgd}gd }|D cgc]\}} } ||| | } } }} |j|} |j| | d |_gd } |j|}|j|| ycc} } }w) NrrrrrTrpr))r?r)rg?r)rr@)rrr))r?r)rg?r)rr@)rrr)rrrr rrr0r1rr-r rrqrrrrr)r&rrrrrrrrrArrrnew_hashes_in_formath4s r'testHashRoundedDurationzTest.testHashRoundedDurations4 ]]_ $ $dD\*',$',$% % % & H#' **:7VW  3.BC-A Aq&A!D-A C \\"  -.  0\\"  12Cs/Ectj}tjd}tjd}|j ||gt }d|_|j|}|dj}|dj}|j|j|j|j|j|jy)NrrTrr;) rrrr r-r rrrrid)r&rurrrhashesnote1refnote2refs r'testReferenceszTest.testReferencess MMO $ $ % H!a!9&&!9&& 8;;/ 8;;/r)c@tj}tjd}tjd}tjd}|j |||gt }d|_d|_d|_d|_ |j|}y)NE5D5A5TF) rrrr r-r rrrrr)r&rurrrr unused_hashess r' testIntervalszTest.testIntervalssx MMO $ $ $ %&' H  %)" Q r)N)r) rrrrrrrrrr rrrNr)r'rrJs1%J=:=6=0A63:0 (r)rceZdZdZdZdZy) TestExternalTcddlm}t}d|_d|_|j ddj j}|j ddj j}|j dj j}|j|}|j|}|j|}|jrttj||jttj||jttj||j|jd|_d |_d |_|j|}|j|}|j|}|jrttj||jttj||jttj||jyy) NrcorpusF schoenbergrbwv66.6rrT)music21rr rrparsepartsfirstrshowprintdifflibSequenceMatcherratior) r&rrrrrhashes1hashes2hashes3s r' testBvSvSzTestExternal.testBvSvS?s" H \\, * 0 0 6 6 8 \\, * 0 0 6 6 8 \\) $ * * 0 0 2,,r",,r",,r" 99 '))Gw?EEG H '))Gw?EEG H '))Gw?EEG H GGI  ,,r",,r",,r" 99 '))Gw?EEG H '))Gw?EEG H '))Gw?EEG H r)ctddlm}t}|jdjj }|jdjj j d}|j|}|j|}|jr.ttj||jd|_ d|_|j|}|j|}|jr/ttj||jyy)NrrrM2r TF)r!rr r"r#r$ transposerr%r&r'r(r)rr)r&rrrs4r,hashes4s r' testIntervalzTestExternal.testInterval^s" H \\) $ * * 0 0 2 \\) $ * * 0 0 2 < Ir)r__main__) __future__rrqr'unittestr!rrrrrr rrzrpTestCaserrrmainTestrNr)r'r9s#eJeJT44n@u@$o(8  o(duI8$$uIp zGTr)