j:ddlmZddlZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z Gdd Z Gd d Z Gd d e ZGddejZGddejZedkrddlZejedSdS)) annotationsN)chord)key)interval)note)streamceZdZdZdZdZddZddZddZddZ dd Z dd Z dd Z dd Z dd ZddZddZddZdZdZdZdZdZdZdZddZdS)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. cntjtjtjg|_d|_d|_d|_d|_ d|_ d|_ d|_ d|_ d|_d|_d|_d|_d|_d|_d|_d|_g|_d|_i|_i|_dS)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 /Users/tedpeters/Documents/Projects/Claude Projects/Misc Tools/notename-sheets/.venv/lib/python3.11/site-packages/music21/alpha/analysis/hasher.py__init__zHasher.__init__Es 9di=!& "' &*#(-% % "&"'%*"#(  "c|jr d|jd<|jr0|jt jd|jd<dSdS)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.setupValidTypesAndStateVarsss\(  ( :59DN1 2   2 O " "3#3 4 4 4-1DN> * * * 2 2r)Nc6|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#  4%3 3z''r)c|r,|t|jjS|t|jj|j_|jjS)z0 TODO: Check if this is working )_getApproxDurOrOffsetfloatr0r1r2s r'_hashRoundedDurationzHasher._hashRoundedDurations_  W--eI4F4T.U.UVV V#'#=#=eAJD\>]>]#^#^  z''r)ch|r |jrdSt|tjrdS|jjS)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._hashMIDIPitchNames>(  0 1 49 % % 1w|r)cx|r |jrdSt|tjrdSt |jS)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._hashPitchNamesB&  0 3 49 % % 317||r)c|r |jrdSt|tjrdSt |jddS)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._hashPitchNameNoOctavesK&  0 3 49 % % 317||CRC  r)ct|tjr |jrdSt|tjrdS|jS)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._hashOctavesG$ a % % $*A 2 49 % % 2xr)cdSNr2s r'_hashIsAccidentalzHasher._hashIsAccidentals r)c|r||jS||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._hashRoundedOffsetsB  @--i.>?? ?--ah77xr)c"|r|jS|jS)zW returns an unrounded floating point representation of a note's offset )rQr2s r' _hashOffsetzHasher._hashOffsets  $# #xr)cJ t|tjrt|da|d}|dSt j||j}t jt j|jSdSdS#t$rYdSwxYw)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 1di(( a 6**6 zz&11 '1"*"3l<=#?#?#??L .x/@/Q/Q/_``` a a66   11 sAB AB B"!B"c|r|jSdS)zg returns prime form of a chord as a string e.g. '<037>' returns '<>' otherwise <>)primeFormStringr2s r'_hashPrimeFormStringzHasher._hashPrimeFormString8s  -, ,tr)c>|r||jSdS)zi returns normal order of a chord as a string e.g. '<047>' returns '<>' otherwise ra)formatVectorString normalOrderr2s r'_hashChordNormalOrderStringz"Hasher._hashChordNormalOrderStringAs)  G// 0EFF Ftr)cg}|jr|d|jr|j|jd<n;|js|js|j|jd<n|js|jr|j|jd<|jr$|d|j |jd<|j r$|d|j |jd<|j rn]|j rV|jr$|d|j|jd<|jr$|d|j|jd<|jr;|d|jr|j|jd<n|j|jd<|jr;|d|jr|j|jd<n|j|jd<|jr$|d|j|jd<||_t9jd ||_d S) 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.setupTupleListLs` > O   W % % %} M151H%g..] M4+B M151D%g..] Mt'> M151L%g.$ O  0008<8N%n5 ? ?   X & & &.2.>D !( +  ! U   $ U) ^  !4555=A=]%&9:' U  !2333;?;T%&78   G   Z ( ( (* G484M%j11484F%j1 ? C   X & & &* C262I%h//262B%h/  ( [   3 4 4 4<@z%Hasher.hashStream..s(SSSsJsM4R4RSsSSSr) currKeySigc@g|]}j|S)r4r$)ry hashPropertyrznr&s r'r|z%Hasher.hashStream..sH*P*P*P0<+N$*? *Ma[^*_*_*_*P*P*Pr)c@g|]}j|dS)Nrrryrrzr&s r'r|z%Hasher.hashStream..sH&L&L&L,8'Jd&;L&I$Z]&^&^&^&L&L&Lr)c<g|]}j|SrNrrs r'r|z%Hasher.hashStream..sB"H"H"H(4#F$"7 "Ec"J"J"H"H"Hr))r.recursetuplerrsrr<rr,r#rrrr!addHashToFinalHashr) r&ru finalHashssfinalEltsToBeHashedsingleNoteHashrzrr{s ` @@@r' hashStreamzHasher.hashStreams  ((*** YY[[do.. SSSSbSSS ' H HC$ HC9I)J)J H/2|,,C-- H) L NN*P*P*P*P*P*P@D*P*P*P// 1MMMM N ,L&L&L&L&L&L<@N&L&L&LN++NIsKKK"H"H"H"H"H8<"H"H"H'' 3GGGGr)c|j|}|jr||||dS|||dSrM)r"_maker#addNoteHashWithReferenceToFinalHashaddNoteHashToFinalHash)r&rr reference tupleHashs r'rzHasher.addHashToFinalHashs\_**>::   >  4 4Y 9 U U U U U  ' ' 9 = = = = =r)c\t|}||_||dS)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&rrrnhwrs r'rz*Hasher.addNoteHashWithReferenceToFinalHashs2&%Y//"r)cNt|}||dS)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&rrnhs r'rzHasher.addNoteHashToFinalHashs+ i r)c@t||jz|jz SrM)roundr)r& durOrOffsets r'r7zHasher._getApproxDurOrOffsets [4#3344t7GGGr)cf||kp+t|d|zzt|d|zzkSz 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._approximatelyEqual: AvIQw.//3q2=7H3I3IIIr)rM)r)__name__ __module__ __qualname____doc__r(r.r5r9r?rErHrKrOrRrTr_rcrgrsrvrrrrr7rrNr)r'r r s++Z,#,#,#\2228((((&((((42!!!!20        $9H9H9Hv   $$$L>>>.HHHHJJJJJJr)r c$eZdZdZdZdZdZdS)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|_|}|D]}t||||t||_dSrM)r_asdictsetattrrkeys hashItemsKeys)r& hashItemsNT hashItemsDictxs r'r(zNoteHashWithReference.__init__se#++--  / /A D!]1- . . . ."=#5#5#7#788r)c#BK|jD]}t||VdSrM)rgetattr)r&keyNames r'__iter__zNoteHashWithReference.__iter__&s;) ) )G$(( ( ( ( ( ) )r)cd}g}|jD]>}|}|dz }|tt||z }||?|d|z }|dz }|S)NzNoteHashWithReference(=z, ))rrDrr-join)r&nhStrAllvalsrnhStrs r'__repr__zNoteHashWithReference.__repr__*s+#  AE SLE Sq))** *E KK    DIIdOO#Cr)N)rrrrr(rrrNr)r'rrsK8999)))     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'> cptt||t|SrM)superrp__new__r)clstupEls __class__s r'rzNoteHash.__new__Fs)Xs##++Cv???r))rrrrr __classcell__)rs@r'rprp8sK  @@@@@@@@@r)rpcFeZdZdZd dZdZdZdZdZdZ d Z d Z d S) TestcBddlm}||tdS)Nr) testCopyAll)music21.test.commonTestrglobals)r&rs r'testCopyAndDeepcopyzTest.testCopyAndDeepcopyKs0777777 D'))$$$$$r)cf||kp+t|d|zzt|d|zzkSrrrs r'rzTest._approximatelyEqualOrr)c tj}tjd}d|j_tjd}tjd}t jgd}d|j_tjd}| || || || || |t}gd}tj d gd  fd |D} | ||| d S) 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@rprirnroc4g|]\}}}|||SrrN)ryryrA CNoteHashs r'r|z&Test.testBasicHash..nFCCC )Aq&IA!DDDCCCr)N)rStreamrr r0typerrrr-r rqrr assertEqualr) r&s1note1note2note3cMinorrBhhashes_plain_numbershashes_in_formatrs @r' testBasicHashzTest.testBasicHashVs` ]__ $$ %   %  00011% IC ( ( ( % % % & ! HH O O O*:7V7V7VWW CCCC-ACCC b))+;<<<<rr)r;rrrc8g|]\}}}}||||S)rrNryrrrArrs r'r|z>Test.testHashChordsAsChordsPrimeFormString..sKFFF ,Aq!&IAq1UVWWWFFFr)N)rrrr r0rrrr-r rrr rqrrrr) r&rrrcMajorrrrrs @r'%testHashChordsAsChordsPrimeFormStringz*Test.testHashChordsAsChordsPrimeFormStringssS]__ $$00011%///00& % & & HH## $*:8N8N8NOO  8 8 8FFFF0DFFF b))+;<<<<rrc8g|]\}}}}||||S)rrNrs r'r|z:Test.testHashChordsAsChordsNormalOrder..sKFFF ,Aq!&IAQWXYYYFFFr))rrrr r0rrrr-r rrr rrqrrrr) r&s2rrrrrrrs @r'!testHashChordsAsChordsNormalOrderz&Test.testHashChordsAsChordsNormalOrdersW ]__ $$00011%///00& % & & HH## %"&*:8N8N8NOO  8 8 8FFFF0DFFF b))+;<<<<.rr)rrr;c3,K|]}j|VdSrM)r)ryvaluesr&s r' z1Test.testHashUnroundedDuration..sIAA,4+V4AAAAAAr))rrrr rrr0r1rr-r rrqrrrallzip) r&s3rrrrrrh3 h3_floatsanswers_floatsrs ` @r'testHashUnroundedDurationzTest.testHashUnroundedDurations ]__ $ $dD\**',$',$% % % & HH#( *:7V7V7VWW  : : :CCCC-ACCC \\"  U1Xr!uQxAq2a58< *1-a0*1-a0*1-a0*1-a02AAAA!$Y!?!?AAAAA A AA A Ar)c tj}tjd}tjd}t jddg}d|j_d|j_d|j_| || || |t}d|_ tj dgd gd } fd |D}||}|||d |_gd } ||} || | dS) NrrrrrTrpr))r?r)rg?r)rr@)rrrc4g|]\}}}|||SrrNr s r'r|z0Test.testHashRoundedDuration..rr)))r?r)rg?r)rr@)rrr)rrrr rrr0r1rr-r rrqrrrrr) r&rrrrrrrrnew_hashes_in_formath4rs @r'testHashRoundedDurationzTest.testHashRoundedDurationsl ]__ $ $dD\**',$',$% % % & HH#' *:7V7V7VWW  3 3 3CCCC-ACCC \\"   -...  0 0 0\\"   122222r)ctj}tjd}tjd}|||gt }d|_||}|dj}|dj}| |j |j | |j |j dS)NrrTrr;) rrrr r-r rrrrid)r&rurrrhashesnote1refnote2refs r'testReferenceszTest.testReferencess MOO $ $ %   HH!a!9&!9& 8;/// 8;/////r)cRtj}tjd}tjd}tjd}||||gt }d|_d|_d|_d|_ | |}dS)NE5D5A5TF) rrrr r-r rrrrr)r&rurrrr unused_hashess r' testIntervalszTest.testIntervalss MOO $ $ $ %&''' HH  %)" Q r)N)r) rrrrrrrrrrr$r*rNr)r'rrJs%%%JJJJ===:===6===0AAA6333:000 ( ( ( ( (r)rceZdZdZdZdZdS) TestExternalTc@ddlm}t}d|_d|_|ddj}|ddj}|dj}||}||}||}|j rttj || ttj || ttj || | d|_d |_d |_||}||}||}|j rttj || ttj || ttj || dSdS) NrcorpusF schoenbergrbwv66.6rrT)music21r/r rrparsepartsfirstrshowprintdifflibSequenceMatcherratior) r&r/rrrrhashes1hashes2hashes3s r' testBvSvSzTestExternal.testBvSvS?s:"""""" HH \\, * * 0 6 6 8 8 \\, * * 0 6 6 8 8 \\) $ $ * 0 0 2 2,,r"",,r"",,r"" 9  ')Gw???EEGG H H H ')Gw???EEGG H H H ')Gw???EEGG H H H GGIII  ,,r"",,r"",,r"" 9 I ')Gw???EEGG H H H ')Gw???EEGG H H H ')Gw???EEGG H H H H H I Ir)cddlm}t}|dj}|djd}||}||}|jr5ttj || d|_ d|_||}||}|jr7ttj || dSdS)Nrr.r2M2r3TF)r4r/r r5r6r7 transposerr8r9r:r;r<rr)r&r/rrs4r?hashes4s r' testIntervalzTestExternal.testInterval^s:"""""" HH \\) $ $ * 0 0 2 2 \\) $ $ * 0 0 2 2 < IIIIIr)r,__main__) __future__rrqr:unittestr4rrrrrr rrrpTestCaserr,rmainTestrNr)r'rLs#"""""eJeJeJeJeJeJeJeJT44444444n@@@@@u@@@$o(o(o(o(o(8 o(o(o(duIuIuIuIuI8$uIuIuIp zNNNGTr)