3jdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl m Z ddl mZddl mZddl mZdd l mZdd l mZej&d ZGd d ej*ZGddZGddeZGddeZGdde j4Zedk(rddl Z e j:eyy)a/ This module contains objects for storing complete `Music21Objects`, especially `Stream` and `Score` objects on disk. Freezing (or "pickling") refers to writing the object to a file on disk (or to a string). Thawing (or "unpickling") refers to reading in a string or file and returning a Music21 object. This module offers alternatives to writing a `Score` to `MusicXML` with `s.write('musicxml')`. `FreezeThaw` has some advantages over using `.write()`: virtually every aspect of a music21 object is retained when Freezing. So objects like `roman.RomanNumeral`, which aren't supported by most formats, can be stored with `FreezeThaw` and then read back again. Freezing is also much faster than most conversion methods. But there's a big downside: only `music21` and `Python` can use the `Thaw` side to get back `Music21Objects` (though more information can be brought out of the JSONFreeze format through any .json reader). In fact, there's not even a guarantee that future versions of music21 will be able to read a frozen version of a `Stream`. So the advantages and disadvantages of this model definitely need to be kept in mind. There are two formats that `freezeThaw` can produce: "Pickle" or JSON (for JavaScript Object Notation -- essentially a string representation of the JavaScript equivalent of a Python dictionary). Pickle is a Python-specific idea for storing objects. The `pickle` module stores objects as a text file that can't be easily read by non-Python applications; it also isn't guaranteed to work across Python versions or even computers. However, it works well, is fast, and is a standard part of python. JSON was originally created to pass JavaScript objects from a web server to a web browser, but its utility (combining the power of XML with the ease of use of objects) has made it a growing standard for other languages. (see https://docs.python.org/3/library/json.html). Music21 has two implementations of JSON (confusing, no?) because we weren't sure and are still not sure which will be best in the long-run: the first approach uses explicit lists of attributes that need to be stored and just saves those. This uses a homemade set of methods that are specifically tailored for music21; but it misses some things that may be important to you. The second approach uses the freely distributable `jsonpickle` module. This approach probably stores more data than a person not using music21 or python is likely to want, but can be used to get back an entire music21 Stream with no conversion. Both JSON and Pickle files can be huge, but `freezeThaw` can compress them with `gzip` or `ZipFile` and thus they're not that large at all. Streams need to be run through .setupSerializationScaffold and .teardownSerializationScaffold before and after either Pickle or jsonpickle in order to restore all the weakrefs that we use. The name freezeThaw comes from Perl's implementation of similar methods -- I like the idea of thawing something that's frozen; "unpickling" just doesn't seem possible. In any event, I needed a name that wouldn't already exist in the Python namespace. ) annotationsN)base)common) derivation) environment) exceptions21)spanner)variant freezeThawc eZdZy)FreezeThawExceptionN)__name__ __module__ __qualname__?/DATA/.local/lib/python3.12/site-packages/music21/freezeThaw.pyr r [srr c&eZdZdZdZddZddZy)StreamFreezeThawBasezZ Contains a few methods that are used for both StreamFreezer and StreamThawer cd|_yNstream)selfs r__init__zStreamFreezeThawBase.__init__gs  rct|tjstj|}tt j}|dt j |zdzz S)Nzm21-z.p) isinstancepathlibPathstrtimergetMd5)r directory streamStrs r getPickleFpz StreamFreezeThawBase.getPickleFpjsN)W\\2 Y/I $ FV]]9%==DEErcB|j|jdS)Nz.p.json)r% with_suffix)rr#s r getJsonFpzStreamFreezeThawBase.getJsonFprs *66yAArN)r#zstr | pathlib.Pathreturnz pathlib.Path)rrr__doc__rr%r(rrrrras FBrrcneZdZdZd fd Zd dZd dZdZdZdZ d ddZ d Z dd Z d d Z xZS) StreamFreezera} This class is used to freeze a Stream, preparing it for serialization and providing conversion routines. In general, use :func:`~music21.converter.freeze` for serializing to a file. Use the :func:`~music21.converter.unfreeze` to read from a serialized file >>> s = stream.Stream() >>> s.repeatAppend(note.Note('C4'), 8) >>> temp = [s[n].transpose(n, inPlace=True) for n in range(len(s))] >>> sf = freezeThaw.StreamFreezer(s) # provide a Stream at init >>> data = sf.writeStr(fmt='pickle') # pickle is default format >>> st = freezeThaw.StreamThawer() >>> st.openStr(data) >>> s = st.stream >>> s.show('t') {0.0} {1.0} {2.0} {3.0} {4.0} {5.0} {6.0} {7.0} >>> sf2 = freezeThaw.StreamFreezer(s) # do not reuse StreamFreezers >>> data2 = sf2.writeStr(fmt='jsonpickle') >>> st2 = freezeThaw.StreamThawer() >>> st2.openStr(data2) >>> s2 = st2.stream >>> s2.show('t') {0.0} {1.0} {2.0} {3.0} {4.0} {5.0} {6.0} {7.0} >>> c = corpus.parse('luca/gloria') >>> sf = freezeThaw.StreamFreezer(c) >>> data = sf.writeStr(fmt='pickle') >>> st = freezeThaw.StreamThawer() >>> st.openStr(data) >>> s2 = st.stream >>> len(s2.parts[0].measure(7).notes) == 6 True JSONPickle is also an acceptable way of Freezing streams. Especially for going to music21j in Javascript: >>> sf2 = freezeThaw.StreamFreezer(c) # do not reuse StreamFreezers >>> data2 = sf2.writeStr(fmt='jsonpickle') >>> st2 = freezeThaw.StreamThawer() >>> st2.openStr(data2) >>> s3 = st2.stream >>> len(s3.parts[0].measure(7).notes) == 6 True Or by writing to disk: >>> sf2 = freezeThaw.StreamFreezer(c) # do not reuse StreamFreezers >>> fp2 = sf2.write(fmt='jsonpickle') >>> st2 = freezeThaw.StreamThawer() >>> st2.open(fp2) >>> s3 = st2.stream >>> len(s3.parts[0].measure(7).notes) == 6 True OMIT_FROM_DOCS >>> import os >>> os.remove(fp2) ct|d|_||_||_i|_||durt j||_y|||_yy)NF)superrrtopLevel streamIdssubStreamFreezerscopydeepcopy)r streamObj fastButUnsafer/r0 __class__s rrzStreamFreezer.__init__s\    "!#  ]e%;-- 2DK  "#DK#rcj| |j}|j||tjd}|S)a Prepare the passed in Stream in place, return storage dictionary format. >>> from pprint import pprint >>> s = stream.Stream() >>> n = note.Note('D#4') >>> s.append(n) >>> sf = freezeThaw.StreamFreezer(s) >>> pprint(sf.packStream()) {'m21Version': (...), 'stream': } )r m21Version)rsetupSerializationScaffoldrVERSION)rr4storages r packStreamzStreamFreezer.packStreams4   I '' 2&dllCrc||j}| tdt|jd}|jdur|j ||D]}t |tjr4t|jd|jd}|jQt |tjr4t|jd|jd}|j|j s|j#||j#||j%||jdur|j'|yy)a Prepare this stream and all of its contents for pickle/pickling, that is, serializing and storing an object representation on file or as a string. The `topLevel` and `streamIdsFound` arguments are used to keep track of recursive calls. Note that this is a destructive process: elements contained within this Stream will have their sites cleared of all contents not in the hierarchy of the Streams. Thus, when doing a normal .write('pickle') the Stream is deepcopied before this method is called. The attribute `fastButUnsafe = True` setting of StreamFreezer ignores the destructive effects of these processes and skips the deepcopy. >>> a = stream.Stream() >>> n = note.Note() >>> n.duration.type = 'whole' >>> a.repeatAppend(n, 10) >>> sf = freezeThaw.StreamFreezer(a) >>> sf.setupSerializationScaffold() N2You need to pass in a stream when creating to workF)restoreActiveSitesT)r5r0r/)rr listrecurser/findActiveStreamIdsInHierarchyrr Variantr,_streamr0r9r SpannerspannerStorageisStreamremoveStreamStatusClientsetupStoredElementOffsetTuplesrecursiveClearSites)rr4allElselsubSFs rr9z(StreamFreezer.setupSerializationScaffolds)*   I )*^__i''5'AB ==D  / / :B"goo.%JJ"&"nn"  002B0%%%"&"nn"  002--b1). %%i0 ++I6 ==D  $ $Y / !rc@t|drd|j_yy)z if s is a stream then s.streamStatus._client is s this can be hard to pickle, so this method removes the streamStatus._client from the streamObj (not recursive). Called by setupSerializationScaffold. streamStatusNhasattrrOclientrr4s rrHz&StreamFreezer.removeStreamStatusClient/s! 9n -,0I " " ) .rct|dr1|j}|D]\}}|jr|j|t |t j r|j|jt |tjr|j|jt|drtj|_ t|dri|_|jj!d|_tj|_ |jj!d|_yy)ak recursively clear all sites, including activeSites, taking into account that spanners and variants behave differently. Called by setupSerializationScaffold. To be run after setupStoredElementOffsetTuples() has been run >>> n = note.Note('D#4') >>> len(n.sites) 1 >>> s = stream.Stream() >>> s.id = 'stream s' >>> s.insert(10, n) >>> len(n.sites) 2 >>> s2 = stream.Stream() >>> s2.insert(20, n) >>> s2.id = 'stream s2' >>> len(n.sites) 3 >>> n.getOffsetBySite(s) 10.0 >>> n.getOffsetBySite(s2) 20.0 >>> sf = freezeThaw.StreamFreezer() This will remove n from s but leave the rest of the sites intact: >>> sf.setupStoredElementOffsetTuples(s) >>> len(n.sites) 2 >>> n.getOffsetBySite(s) Traceback (most recent call last): music21.sites.SitesException: an entry for this object is not stored in stream >>> n.getOffsetBySite(s2) 20.0 After recursiveClearSites n will be not know its location anywhere: >>> sf.recursiveClearSites(s) >>> len(n.sites) # just the None site 1 This leaves n and s2 in strange positions, because n is in s2.elements still: >>> n in s2.elements True This predicament is why when the standard freezeThaw call is made, what is frozen is a deepcopy of the Stream so that nothing is left in an unusable position _storedElementOffsetTuples _derivation _offsetDictN)rQrUrGrJrr rErFr rCrDr DerivationrVrWsitesclear activeSite)rstartObjstoredElementOffsetTuplesrL unused_offsets rrJz!StreamFreezer.recursiveClearSites;sp 89 :(0(K(K %%>!M;;,,R0b'//2,,R->->?b'//2,,RZZ82}-%/%:%:%>> s = stream.Measure() >>> n1 = note.Note('C#') >>> n2 = note.Note('E-') >>> bl1 = bar.Barline() >>> s.insert(0.0, n1) >>> s.insert(1.0, n2) >>> s.storeAtEnd(bl1) >>> sFreeze = freezeThaw.StreamFreezer() >>> sFreeze.setupStoredElementOffsetTuples(s) >>> s._elements, s._endElements ([], []) >>> s._storedElementOffsetTuples [(, 0.0), (, 1.0), (, 'end')] >>> n1.getOffsetBySite(s) Traceback (most recent call last): music21.sites.SitesException: an entry for this object is not stored in stream Trying it again, but now with substreams: >>> s2 = stream.Measure() >>> n1 = note.Note('C#') >>> n2 = note.Note('E-') >>> bl1 = bar.Barline() >>> v1 = stream.Voice() >>> n3 = note.Note('F#') >>> v1.insert(2.0, n3) >>> s2.insert(0.0, n1) >>> s2.insert(1.0, n2) >>> s2.storeAtEnd(bl1) >>> s2.insert(2.0, v1) >>> sFreeze.setupStoredElementOffsetTuples(s2) >>> v1._storedElementOffsetTuples [(, 2.0)] >>> s2._storedElementOffsetTuples [(, 0.0), (, 1.0), (, 2.0), (, 'end')] >>> s2._storedElementOffsetTuples[2][0] is v1 True rUNend) rQ _elements elementOffsetappendrGrIrYremover[ _endElementsrUrWcoreElementsChanged)rr4r]e elementTuples rrIz,StreamFreezer.setupStoredElementOffsetTuplessp 9: ; $&!$$Ay66q9:L % , ,\ :zz33A6 GGNN9 %AL %''Au:L % , ,\ :zz33A6 GGNN9 %AL(0I , "  !# %%'rc| |j}n|}|jddd}|Dcgc] }t|}}|dur|j}||j z }|durR|jdj t jD] } ||j| jz }"tt|}||_ |Scc}w)a Return a list of all Stream ids anywhere in the hierarchy. By id, we mean `id(s)` not `s.id` -- so they are memory locations and unique. Stores them in .streamIds. if hierarchyObject is None, uses self.stream. >>> sc = stream.Score() >>> p1 = stream.Part() >>> p2 = stream.Part() >>> m1 = stream.Measure() >>> v1 = stream.Voice() >>> m1.insert(0, v1) >>> p2.insert(0, m1) >>> sc.insert(0, p1) >>> sc.insert(0, p2) >>> shouldFindIds = [id(sc), id(p1), id(p2), id(m1), id(v1)] fastButUnsafe is needed because it does not make a deepcopy and thus lets you compare ids before and after. >>> sf = freezeThaw.StreamFreezer(sc, fastButUnsafe=True) >>> foundIds = sf.findActiveStreamIdsInHierarchy() >>> for thisId in shouldFindIds: ... if thisId not in foundIds: ... raise ValueError('Missing Id') >>> for thisId in foundIds: ... if thisId not in shouldFindIds: ... raise ValueError('Additional Id Found') Spanners are included unless getSpanners is False >>> staffGroup = layout.StaffGroup([p1, p2]) >>> sc.insert(0, staffGroup) :class:`~music21.layout.StaffGroup` is a spanner, so it should be found >>> sf2 = freezeThaw.StreamFreezer(sc, fastButUnsafe=True) >>> foundIds = sf2.findActiveStreamIdsInHierarchy() But you won't find the id of the spanner itself in the foundIds: >>> id(staffGroup) in foundIds False instead it's the id of the storage object: >>> id(staffGroup.spannerStorage) in foundIds True Variants are treated similarly: >>> s = stream.Stream() >>> m = stream.Measure() >>> m.append(note.Note(type='whole')) >>> s.append(m) >>> s2 = stream.Stream() >>> m2 = stream.Measure() >>> n2 = note.Note('D#4') >>> n2.duration.type = 'whole' >>> m2.append(n2) >>> s2.append(m2) >>> v = variant.Variant(s2.elements) >>> s.insert(0, v) >>> sf = freezeThaw.StreamFreezer(s, fastButUnsafe=True) >>> allIds = sf.findActiveStreamIdsInHierarchy() >>> len(allIds) 4 >>> for streamElement in [s, m, m2, v._stream]: ... if id(streamElement) not in allIds: ... print('this should not happen!', allIds, id(streamElement)) N.B. with variants: >>> id(s2) == id(v._stream) False The method also sets self.streamIds to the returned list: >>> sf.streamIds is allIds True TF) streamsOnlyr? includeSelf)rk) rrAid spannerBundlegetSpannerStorageIdsgetElementsByClassr rCrBrDr@setr0) rhierarchyObject getSpanners getVariantsr4streamsFoundGeneratorsr0rmrLs rrBz,StreamFreezer.findActiveStreamIdsInHierarchysx  " I'I ) 1 1dEJ>B!2!D%::$9qRU$9 : $ %33M ;;= =I $ ''D'9LLW__]T@@LL ^ Y( ";sCcZ|y|jj}|dvry|dvryy)aA Parse a passed-in write format >>> sf = freezeThaw.StreamFreezer() >>> sf.parseWriteFmt(None) 'pickle' >>> sf.parseWriteFmt('JSON') 'jsonpickle' Anything else returns 'pickle' as a default: >>> sf.parseWriteFmt('inconceivable') 'pickle' pickle)prw) jsonpicklejsonry)striplower)rfmts r parseWriteFmtzStreamFreezer.parseWriteFmtVs: ;iik! / ! * *rc |dvr td|j|}|Itj}|j dr|j |}nx|j |}nft|trtj|}t|tjr'|jstj|z }|j|j}t|tjr tjdt|g|dk(rtj |}|dk(rt#j$|}t|t&j(s(t+|d5}|j-|ddd|S|j-||S|d k(rid dl} | j0|fi|} |dk(r#t#j$| j1} t+|d d 5}|j-| ddd|Std|#1swY|SxYw#1swY|SxYw)a For a supplied Stream, write a serialized version to disk in either 'pickle' or 'jsonpickle' format and return the filepath to the file. jsonpickle is the better format for transporting from one computer to another, but slower and may have some bugs. If zipType == 'zlib' then zlib compression is done after serializing. No other compression types are currently supported. )Nzlibz!Cannot zip files except zlib typeNrzz writing fprwrwbryrwutf-8encodingbad StreamFreezer format: )r r~ environLocalgetRootTempDir startswithr(r%rr rr is_absoluter<r printDebugrwdumpsrcompressioBytesIOopenwriteryencode) rr}fpzipTypekeywordsr#r; pickleStringfrydatas rrzStreamFreezer.writeos . (%&IJ J  % :$335I~~f%^^I.%%i0"c"\\"%"gll+BNN4D!002R7//$++. b',, '  # #\3r7$; < (?"<<0L& #}}\: b"**-"d^qGGL)$$ & L $:$$W99D& }}T[[]3b#0A 1 &(B3%&HI I$$ 1 sH,H9,H69Ic |j|}|j|j}|dk(rtj|d}|S|dk(rddl}|j |fi|}|Std|)zb Convert the object to a pickled/jsonpickled string and return the string rwprotocolryrNr)r~r<rrwrryrr )rr}rr;outrys rwriteStrzStreamFreezer.writeStrs   %//$++. (?,,w4C L #*##G8x8C  &(B3%&HI Ir)NFTNr)NTT)r)z list[int])rwNN)rrrr*rr<r9rHrJrIrBr~rr __classcell__r6s@rr,r,wsZQf$$*;0z 1J'XW(v r  rl2>@rr,cTeZdZdZfdZd dZdZdZdZdZ d dZ d d d Z xZ S) StreamThawera, This class is used to thaw a data string into a Stream In general user :func:`~music21.converter.parse` to read from a serialized file. >>> s = stream.Stream() >>> s.repeatAppend(note.Note('C4'), 8) >>> temp = [s[n].transpose(n, inPlace=True) for n in range(len(s))] >>> sf = freezeThaw.StreamFreezer(s) # provide a Stream at init >>> data = sf.writeStr(fmt='pickle') # pickle is default format >>> sfOut = freezeThaw.StreamThawer() >>> sfOut.openStr(data) >>> s = sfOut.stream >>> s.show('t') {0.0} {1.0} {2.0} {3.0} {4.0} {5.0} {6.0} {7.0} c0t|d|_yr)r.rr)rr6s rrzStreamThawer.__init__s  rc ||j}| td|j}d|_|j||j |t |j }|D]}|j}d|vr-t}|j|ji|_ @d|vr-t}|j|ji|_ q|js~|j |||_y)a After rebuilding this Stream from pickled storage, prepare this as a normal `Stream`. If streamObj is None, runs it on the embedded stream >>> a = stream.Stream() >>> n = note.Note() >>> n.duration.type = 'whole' >>> a.repeatAppend(n, 10) >>> sf = freezeThaw.StreamFreezer(a) >>> sf.setupSerializationScaffold() >>> st = freezeThaw.StreamThawer() >>> st.teardownSerializationScaffold(a) Nr>FrCrE)rr autoSortrestoreElementsFromTuplesrestoreStreamStatusClientr@rAclassesrteardownSerializationScaffoldrD_cacherFrG)rr4storedAutoSortrKrgeClassesrMs rrz*StreamThawer.teardownSerializationScaffolds   I )*^__"++"  &&y1 &&y1i'')*AyyHH$$33AII>h&$33A4D4DE..q1(, rct|drP|jD]/\}}|dk7r |j|||j |1|`|j|D]"}|jdus|j|$y#t$r9t dt ||t |t |j wxYw)a Take a Stream with elements and offsets stored in a list of tuples (element, offset or 'end') at _storedElementOffsetTuples and restore it to the ._elements and ._endElements lists in the proper locations: >>> s = stream.Measure() >>> s._elements, s._endElements ([], []) >>> n1 = note.Note('C#') >>> n2 = note.Note('E-') >>> bl1 = bar.Barline() >>> tupleList = [(n1, 0.0), (n2, 1.0), (bl1, 'end')] >>> s._storedElementOffsetTuples = tupleList >>> sThaw = freezeThaw.StreamThawer() >>> sThaw.restoreElementsFromTuples(s) >>> s.show('text') {0.0} {1.0} {2.0} >>> s._endElements [] >>> s[1].getOffsetBySite(s) 1.0 Trying it again, but now with substreams: >>> s2 = stream.Measure() >>> v1 = stream.Voice() >>> n3 = note.Note('F#') >>> v1._storedElementOffsetTuples = [(n3, 2.0)] >>> tupleList = [(n1, 0.0), (n2, 1.0), (bl1, 'end'), (v1, 2.0)] >>> s2._storedElementOffsetTuples = tupleList >>> sThaw.restoreElementsFromTuples(s2) >>> s2.show('text') {0.0} {1.0} {2.0} {2.0} {5.0} rUr`z-Problem in decoding. Here is some debug info:TN) rQrU coreInsertAttributeErrorprintr[coreStoreAtEndrfrGr)rr4rgoffset subElements rrz&StreamThawer.restoreElementsFromTuplessZ 9: ;&AA 6U?!,,VQ7,,Q/B4  ) ) +#J""d*..z: $*MNfa(i(i223 s BACc@t|dr||j_yy)z Restore the streamStatus client to point to the Stream (do we do this for derivations? No: there should not be derivations stored. Other objects? Unclear at present.) rONrPrSs rrz&StreamThawer.restoreStreamStatusClient^s! 9n -,5I " " ) .rc|d}|tjk7rtjd|d}|j ||S)z< Convert from storage dictionary to Stream. r8z?this pickled file is out of date and may not function properly.r)rr:rwarnr)rr;versionr4s r unpackStreamzStreamThawer.unpackStreamgsG,' dll "   _ `H%  **95rcnt|tr|jdryy|jdryy)z; Look at the file and determine the format s{"ryrwz{")rbytesr)rr;s r parseOpenFmtzStreamThawer.parseOpenFmtss6 gu %!!%(#!!$'#rctjj|stj }||z }t |d5}|j }ddd|j}|dk(rtjt |d5}|tj|}nc|dk(r<|j }tj|} tj| }n"tjt!d||j#||_dddtjy|dk(rSddl} t |d d 5}|j } ddd| j) }|j#||_yt!d |#1swYUxYw#t$r(} tjt!d| | d} ~ wwxYw#1swYxYw#1swYxYw) zH For a supplied file path to a pickled stream, unpickle rbNrwrzProblem in decoding: zUnknown zipType ryrrrrr)ospathexistsrrrreadrr!restorePathClassesAfterUnpicklingrwloadr decompressloadsrr rrrydecode) rrrr#rfileDatar}r;compressedString uncompressedrgryrs rrzStreamThawer.opensww~~b!$335IRB "d^qvvxH) (?  4 4 6b$1?$kk!nG&'(vvx$#'??3C#DL!"(,,|"<<<>-0@ .JKK"//8 ! "  4 4 6 L b#0Avvx1 ''-G++G4DK%(B3'&JK KA^*!@@B13A37 !! (10sIF)AG*F6-9G*G6)F36 G'?#G""G''G**G36G?c||}n|j|}|dk(rtj|}n)|dk(rddl}|j |}nt d|t jd||j||_ y)a^ Take bytes representing a Frozen(pickled/jsonpickled) Stream and convert it to a normal Stream. if format is None then the format is automatically determined from the bytes contents. The name of the function is a legacy of Py2. With pickle (not jsonpickle), it works on bytes, not strings. Nrwryrrz"StreamThawer:openStr: storage is: ) rrwrryrr rrrr)rr pickleFormatr}r;rys ropenStrzStreamThawer.openStrs  #C##H-C (?ll8,G L  ''1G%(B3%&HI I"DWI NO''0 rr)rr) rrrr*rrrrrrrrrrs@rrrs:6 2,hC;J6  "(LV11rrcNeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z y ) Testcddlm}ddlm}|j}|j}|j }|j d||j d|t |}|j}~~~t}|j||j} |jt| d|j| djdy)Nrrnote@@) music21rrStreamNoteinsertr,rrr assertEquallenr) rrrrusDummynsfrst outStreams rtestSimpleFreezeThawzTest.testSimpleFreezeThaws" MMO IIK a c1 1 kkm  ^ 3II  Y+ 1,,c2rcddlm}ddlm}|j}|j}|j }t j |g}|jd||jd||jd||j|jdj|jdt|}|jd}~~~t} | j|| j} |j!t#| d |j!| jdj$d|j| jdj| jdy) Nrrrgrrryr})rrrrrr SlurrassertIsspannersgetFirstnotesr,rrrrrr) rrrrurrsl1rrrrs rtestFreezeThawWithSpannerzTest.testFreezeThawWithSpanners&" MMO IIKllA3 c a c1 ajjm,,. ; 1 kklk+  ^ 3II  Y+ +22C8 i((+446 8JKrcddlm}|jdjdj dd}t |}|j d}t}|j|y) zs Versions of jsonpickle prior to 0.9.3 were having problems serializing Enums. Works now rcorpus luca/gloriarrryrN) rrparsepartsmeasuresr,rrr)rrcsf2data2st2s rtestFreezeThawJsonPickleEnumz!Test.testFreezeThawJsonPickleEnumsZ # LL ' - -a 0 9 9!Q ?A  .n Erc<ddlm}|jd}t|}|j d}t }|j ||j}|jt|jdjdjdy)Nrrrrwr) rrrr,rrrrrrrmeasurer)rrrrrrrus r$testFreezeThawCorpusFileWithSpannersz)Test.testFreezeThawCorpusFileWithSpannerssw" LL ' 1 {{x{( ^ 4 II QWWQZ//28891=rc~ddlm}ddlm}|jdjdj dj }|d}|d}|j|d}|j|jjD]}|jjD]}tj|d }y) Nrr rzbwv66.6rTr5rr) rr rrrrrr,r9rYsiteDictrwr)rr rrn1n2rdummys rx_testSimplePicklezTest.x_testSimplePickles&" LL # ) )! , 4 4Q 7 = =qT qT  % %at % < %%'XX&&E 'XX&&E '  Q,rcddlm}ddlm}|jd}|j |d}|j }|j }|j||j}|jD]}y)NrrrrTr) rr rrr,rrrrrA) rr rrrdrrurs rx_testFreezeThawPicklezTest.x_testFreezeThawPickleBsq&" LL ' % %at % < KKM $ $ & 1 IIYY[E !rc~ddlm}ddlm}ddlm}|j }|j }|j |jd|j ||j }|j }|jd}d|j_ |j ||j |tj|} |jd| |j|} | j} |j} | j!| | j}y)Nrrrrwhole)typezD#4)rr rrrMeasurercrdurationr r rCrr,rrr) rr rrrums2m2rvrrrs rtestFreezeThawSimpleVariantz Test.testFreezeThawSimpleVariantUs&" MMO NN  ()  ]]_ ^^  YYu "  "  " OOB  A  % %a ( KKM  $ $ & 1 IIrcpddlm}ddlm}ddlm}ddlm}|j d}gd}|j }|j}|D]8\} } |j| } | | j_ |j| :|j|tj|jdd|d d |jjj!tj"j} |j%|d } | j'}|j)}|j+||j}|jd}|j!tj"}|d}|j-|j.ddj0dy)Nrrrrrr))reighth)rquarter)ar)rrg@rhythmic_switchr) variantNamereplacementQuarterLengthTrrg?)rr rrrrrr rr r rcr addVariantrfirstrorCr,rrrrrDr)rr rrrrdata2M2stream2r  pitchNamedurTyper unused_v1rrrrup0variantsv2s rtestFreezeThawVariantzTest.testFreezeThawVariantpsV&"" LL 'X--/ NN ") Iw )$A%AJJO HHQK#* q1771:sG'8SV XGGMMO66wGMMO  % %at % < KKM  $ $ & 1 II WWQZ((9 a[ Aq)00#6rc^ddlm}ddlm}ddlm}|j }|j }|j }|j ||j ||j|d}|j|j||v|j||vy)NrrrrFr) rrrr rrrcr,r9 assertTrue)rrrr rs1rrs rtestSerializationScaffoldAzTest.testSerializationScaffoldAs "& YY[ ]]_ ]]_ "  "  % %b % > %%' b! b!rchddlm}ddlm}ddlm}|j d}|j d}|j }t j||g}|jd||j||j||j|d}|j|} y)Nr converterrrCD jsonPickle) rr*rrrrr Linerrc freezeStrthawStr) rr*rrrrr&spfrozen unused_thaweds rtestJSONPickleSpannerzTest.testJSONPickleSpanners% " YYs^ YYs^ ]]_ \\2r( # !R "  " $$R6!))&1 rc~ddlm}ddlm}tt j dz dz dz }|j |}|j|}|j|}|j|jdjjdjj|jy) Nrr)rmidi testPrimitivez test03.midr)rr*rr rgetSourceFilePathrr/r0assertIsInstancerflattenrvolumerRNotRest)rr*rrrrrs rtestPickleMidizTest.testPickleMidis% ((*!"*+(( ) OOA     "   a   GGAJ   & &r * 1 1 8 8 LL rN)rrrrrrrrrrr#r'r4r>rrrrrs<3,L6  >-R&6%7P"( 2rr__main__)r* __future__rr2rrrrwr!unittestrrrrrrrr r EnvironmentrMusic21Exceptionr rr,rTestCaserrmainTestrrrrFs6n#    &{&&|4  ,77 BB,I (I XD1'D1V|8  |@ zGTr