rh0SSKJr SSKrSSKrSSKrSSKJr SSKJr SSKJr SSKJ r SSKJ r "SS 5r "S S 5r "S S \ 5r"SS\R5r"SS\R5r\S:XaSSKr\R&"\5 gg)) annotationsN)chord)key)interval)note)streamc\rSrSrSrSrSrSSjrSSjrSSjr SS jr SS jr SS jr SS jr SS jrSSjrSSjrSSjrSSjrSrSrSrSrSrSrSrSSjrSrg)HasheraJ 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. c[R[R[R/UlSUlSUlSUlSUl SUl SUl SUl SUl SUlSUlSUlSUlSUlSUlSUlSUl/UlSUl0Ul0Ulg)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 W/home/james-whalen/.local/lib/python3.13/site-packages/music21/alpha/analysis/hasher.py__init__Hasher.__init__Fs 99dii=!& "' &*#(-% % "&"'%*"#(  "cUR(aSURS'UR(a9URR [ R 5 SURS'gg)a 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(setupValidTypesAndStateVars"Hasher.setupValidTypesAndStateVarstsP(  ( (59DNN1 2  OO " "3#3#3 4-1DNN> * !r+NchU(aURR$URR$)aJ 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( _hashDurationHasher._hashDurations) %%33 3zz'''r+cU(a.UR[URR55$UR[URR55URlURR$)z TODO: Check if this is working )_getApproxDurOrOffsetfloatr3r4r5s r(_hashRoundedDurationHasher._hashRoundedDurations_ --eI4F4F4T4T.UV V#'#=#=eAJJD\D\>]#^  zz'''r+cU(aUR(ag[U[R5(agURR $)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 isinstancerrpitchmidir5s r(_hashMIDIPitchNameHasher._hashMIDIPitchNames4( 00 499 % %ww||r+cU(aUR(ag[U[R5(ag[ UR 5$)a 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' zrrrArrstrrBr5s r(_hashPitchNameHasher._hashPitchNames4& 00 499 % %177|r+cU(aUR(ag[U[R5(ag[ UR 5SS$)a 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' rGrHNrIr5s r(_hashPitchNameNoOctaveHasher._hashPitchNameNoOctaves;& 00 499 % %177|CR  r+c[U[R5(aUR(ag[U[R 5(agUR $)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 rN)rArrrrroctaver5s r( _hashOctaveHasher._hashOctaves=$ a % %$*A*A 499 % %xxr+cgNr5s r(_hashIsAccidentalHasher._hashIsAccidentals r+cU(aURUR5$URUR5UlUR$)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 )r;offsetr5s r(_hashRoundedOffsetHasher._hashRoundedOffsets= --i.>.>? ?--ahh7xxr+c@U(a UR$UR$)zG returns an unrounded floating point representation of a note's offset )r[r5s r( _hashOffsetHasher._hashOffsets ## #xxr+cZ[U[R5(a{URS5bhURS5nUcg[R "UUS9R n[R"[R "U5R 5$gg![a gf=f)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 rNr) noteStartnoteEnd) rArrpreviousrInterval intervalClassconvertGeneric TypeError)r'r6r7 previousNoteintFromLastNotes r(_hashIntervalFromLastNote Hasher._hashIntervalFromLastNote's 1dii(( 6*6 zz&1 '"*"3"3l<=#??L} ..x/@/@/Q/_/_`` 7)  sABAB B*)B*c*U(a UR$g)zO returns prime form of a chord as a string e.g. '<037>' returns '<>' otherwise <>)primeFormStringr5s r(_hashPrimeFormStringHasher._hashPrimeFormString9s ,, ,r+cHU(aURUR5$g)zQ returns normal order of a chord as a string e.g. '<047>' returns '<>' otherwise rn)formatVectorString normalOrderr5s r(_hashChordNormalOrderString"Hasher._hashChordNormalOrderStringBs! // 0E0EF Fr+c/nUR(aURS5 UR(aURURS'OwUR(d+UR (dUR URS'O;UR(d*UR (aURURS'UR(a*URS5 URURS'UR(a*URS5 URURS'UR(aOUR(avUR(a*URS5 URURS'UR (a*URS5 UR"URS'UR$(aUURS5 UR&(aUR(URS'OUR*URS'UR,(aUURS5 UR&(aUR.URS'OUR0URS'UR2(a*URS5 UR4URS'Xl:"S U5Ulg ) 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/rrDr%rrKrOrrXrrSrrr rur!rprrr=r8rr\r_rrkr" collections namedtupler#)r'r"s r(setupTupleListHasher.setupTupleListMs. >>   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 4Y9 U  ' ' =r+cH[U5nX4lURU5 g)a8 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(r*Hasher.addNoteHashWithReferenceToFinalHashs!&%Y/"r+c<[U5nURU5 g)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)rr/)r'rrnhs r(rHasher.addNoteHashToFinalHashs i r+cJ[XR-5UR- $rV)roundr)r' durOrOffsets r(r;Hasher._getApproxDurOrOffsets![#3#334t7G7GGGr+c^X:H=(d# [USU--5[USU--5:H$z 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(_approximatelyEqualHasher._approximatelyEqual2 vIQw./3q2=7H3IIIr+)rrrrrrrrr rrrrr!r%rrr$r#r"rrV))__name__ __module__ __qualname____firstlineno____doc__r)r0r8r=rDrKrOrSrXr\r_rkrprurrrrrrr;r__static_attributes__rWr+r(r r s}+Z,#\28(&(42!20  $9Hv $L>.HHJr+r c*\rSrSrSrSrSrSrSrg)ria 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 cSUlUR5nUHn[XX#5 M [UR 55UlgrV)r_asdictsetattrrkeys hashItemsKeys)r' hashItemsNT hashItemsDictxs r(r)NoteHashWithReference.__init__ sD#++- A D]- ."=#5#5#78r+c#L# URHn[X5v M g7frV)rgetattr)r'keyNames r(__iter__NoteHashWithReference.__iter__'s ))G$( (*s"$cSn/nURH2nUnUS- nU[[X55- nURU5 M4 USR U5- nUS- nU$)NzNoteHashWithReference(=z, ))rrJrr/join)r'nhStrAllvalsrnhStrs r(__repr__NoteHashWithReference.__repr__+sl+##AE SLE S)* *E KK  $ DIIdO#Cr+)rrN) rrrrrr)rrrrWr+r(rrs89) r+rc,^\rSrSrSrU4SjrSrU=r$)ri9z >>> 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>>[[U] U[U55$rV)superr__new__r)clstupEls __class__s r(rNoteHash.__new__GsXs+Cv??r+rW)rrrrrrr __classcell__)rs@r(rr9s @@r+rcN\rSrSrSrS SjrSrSrSrSr Sr S r S r S r g )TestiKc2SSKJn U"U[55 g)Nr) testCopyAll)music21.test.commonTestrglobals)r'rs r(testCopyAndDeepcopyTest.testCopyAndDeepcopyLs7D')$r+c^X:H=(d# [USU--5[USU--5:H$rrrs r(rTest._approximatelyEqualPrr+c [R"5n[R"S5nSURl[R"S5n[R"S5n[ R"/SQ5nSURl[R"SS9nURU5 URU5 URU5 URU5 URU5 [5n/SQn[R"S /S Q5n UV V V s/sH upn U "XU S 9PM n n n n URURU5U 5 g s sn n n f) zb test for hasher with basic settings: pitch, rounded duration, offset with notes, chord, and rest C4halfzF#4zB-2rG4zE-5?)r4))<@)B?r).rg@)rr@)Crr)Krr)rrg@rrxr}r~N)rStreamrrr3typerrrr/r rr assertEqualr)r's1note1note2note3cMinorrHhhashes_plain_numbers CNoteHashryrGhashes_in_formats r( testBasicHashTest.testBasicHashWs ]]_ $$ %  % 01% IIC ( % % % & ! H O**:7VW -AC-A q&A!D-A C b)+;<Cs(E"c [R"5n[R"S5nSURl[ R"/SQ5nSURl[ R"/SQ5nSURlURU5 URU5 URU5 [5nSUl SUl SUl [R"S/S Q5n/S QnUVV V V s/sH uppU"XXS 9PM n n n nn URUR!U5U 5 g s sn n n nf) zI test to make sure that hashing works when trying to hash chord as chord rrr)rrE4wholeTFr)rxr|r}r~)rrnrrr@<037>rr)r@r rrN)rrrrr3rrrr/r rrr!rrrr) r'rrrcMajorrrrrrrGrrs r(%testHashChordsAsChordsPrimeFormString*Test.testHashChordsAsChordsPrimeFormStringts]]_ $$01%/0& % & & H## $**:8NO  81EF0D q&A1W0D F b)+;<FsE c [R"5n[R"S5nSURl[ R"/SQ5nSURl[ R"/SQ5nSURlURU5 URU5 URU5 [5nSUl SUl SUl SUl [R"S/S Q5n/S QnUVV V V s/sH uppU"XXS 9PM n n n nn UR!UR#U5U 5 gs sn n n nf) Nrrr)rrE3rTFr)rxr{r}r~)r r )r@z<047>rr)rrrrr3rrrr/r rrr!r rrrr) r's2rrr rrrrrrGrrs r(!testHashChordsAsChordsNormalOrder&Test.testHashChordsAsChordsNormalOrders ]]_ $$01%/0& % & & H## %"&**:8NO  81EF0D q&AQY0D F b)+;<Fs E c ^[R"5n[R"S5n[R"S5n[R "SS/5nSUR lSUR lSUR lURU5 URU5 URU5 [5nSUl [R"S/SQ5n/S QnUVV V s/sH upn U"XU S9PM n n nn URU5n U S S U S S U S S U S S /n U S S U S S U S S U S S /n[U4Sj[!X555(degs sn n nf)NrrI +?UUUUUU?rFrr))rrr)rrr)rr2z[@)rrrrr@c3B># UHnTR"U6v M g7frV)r).0valuesr's r( 1Test.testHashUnroundedDuration..s$A!?v++V4!?s)rrrrrrr3r4rr/r rrrrallzip)r's3rrrrrrrrGrrh3 h3_floatsanswers_floatss` r(testHashUnroundedDurationTest.testHashUnroundedDurations ]]_ $ $dD\*',$',$% % % & H#( **:7VW  :.BC-A q&A!D-A C \\" U1Xr!uQxAq2a58< *1-a0*1-a0*1-a0*1-a02A!$Y!?AAA AACs5Fc [R"5n[R"S5n[R"S5n[R "SS/5nSUR lSUR lSUR lURU5 URU5 URU5 [5nSUl [R"S/SQ5n/S QnUVV V s/sH upn U"XU S9PM n n nn URU5n URX5 S Ul/S Qn URU5nURX5 gs sn n nf) NrrrrrTrr))r?r)rg?r()rr@)rrr)))r?r)rg?r+)rr@)rrr,)rrrrrrr3r4rr/r rrrrrr)r'r!rrrrrrrrGrrr"new_hashes_in_formath4s r(testHashRoundedDurationTest.testHashRoundedDurations* ]]_ $ $dD\*',$',$% % % & H#' **:7VW  3.BC-A q&A!D-A C \\"  .  0\\"  2Cs4Ec[R"5n[R"S5n[R"S5nUR X#/5 [ 5nSUlURU5nUSRnUSRnURURUR5 URURUR5 g)NrrTrr@) rrrrr/r rrrrid)r'rrrrhashesnote1refnote2refs r(testReferencesTest.testReferencess MMO $ $ % H!a!9&&!9&& 8;;/ 8;;/r+cF[R"5n[R"S5n[R"S5n[R"S5nUR X#U/5 [ 5nSUlSUlSUlSUl URU5ng)NE5D5A5TF) rrrrr/r rrrrr)r'rrrrr unused_hashess r( testIntervalsTest.testIntervalssv MMO $ $ $ %&' H  %)" Q r+rWN)r)rrrrrrrr rr%r/r6r=rrWr+r(rrKs1%J=:=6=0A63:0 (r+rc$\rSrSrSrSrSrSrg) TestExternaliTcSSKJn [5nSUlSUlUR SS5R R5nUR SS5R R5nUR S5R R5nURU5nURU5nURU5nUR(a[[R"XgS9R55 [[R"XhS9R55 [[R"XxS9R55 UR5 SUlS UlS UlURU5nURU5nURU5nUR(a[[R"XgS9R55 [[R"XhS9R55 [[R"XxS9R55 gg) NrcorpusF schoenbergrbwv66.6rrT)music21rCr rrparsepartsfirstrshowprintdifflibSequenceMatcherratior) r'rCrrrr!hashes1hashes2hashes3s r( testBvSvSTestExternal.testBvSvS@s" H \\, * 0 0 6 6 8 \\, * 0 0 6 6 8 \\) $ * * 0 0 2,,r",,r",,r" 99 '))G?EEG H '))G?EEG H '))G?EEG H GGI  ,,r",,r",,r" 99 '))G?EEG H '))G?EEG H '))G?EEG H r+c|SSKJn [5nURS5RR 5nURS5RR 5R S5nURU5nURU5nUR(a+[[R"XVS9R55 SUl SUlURU5nURU5nUR(a,[[R"XVS9R55 gg)NrrBrFM2rGTF)rHrCr rIrJrK transposerrLrMrNrOrPrr)r'rCrr!s4rShashes4s r( testIntervalTestExternal.testInterval_s" H \\) $ * * 0 0 2 \\) $ * * 0 0 2 < Ir+r@__main__) __future__rrrNunittestrHrrrrrr rrrTestCaserr@rmainTestrWr+r(rbs#eJeJT44n@u@$o(8  o(duI8$$uIp z Tr+