def testJSONSerializationMetadata(self):
from music21.musicxml import xmlHandler
from music21.musicxml import fromMxObjects
from music21.musicxml import testFiles
from music21 import metadata
md = metadata.Metadata(
title='Concerto in F',
date='2010',
composer='Frank',
)
#environLocal.printDebug([str(md.json)])
self.assertEqual(md.composer, 'Frank')
#md.jsonPrint()
mdNew = metadata.Metadata()
jsonString = freezeThaw.JSONFreezer(md).json
freezeThaw.JSONThawer(mdNew).json = jsonString
self.assertEqual(mdNew.date, '2010/--/--')
self.assertEqual(mdNew.composer, 'Frank')
self.assertEqual(mdNew.title, 'Concerto in F')
# test getting meta data from an imported source
d = xmlHandler.Document()
d.read(testFiles.mozartTrioK581Excerpt) # @UndefinedVariable
mxScore = d.score # get the mx score directly
md = fromMxObjects.mxScoreToMetadata(mxScore)
self.assertEqual(md.movementNumber, '3')
self.assertEqual(md.movementName,
'Menuetto (Excerpt from Second Trio)')
self.assertEqual(md.title, 'Quintet for Clarinet and Strings')
self.assertEqual(md.number, 'K. 581')
self.assertEqual(md.composer, 'Wolfgang Amadeus Mozart')
# convert to json and see if data is still there
#md.jsonPrint()
mdNew = metadata.Metadata()
jsonString = freezeThaw.JSONFreezer(md).json
freezeThaw.JSONThawer(mdNew).json = jsonString
self.assertEqual(mdNew.movementNumber, '3')
self.assertEqual(mdNew.movementName,
'Menuetto (Excerpt from Second Trio)')
self.assertEqual(mdNew.title, 'Quintet for Clarinet and Strings')
self.assertEqual(mdNew.number, 'K. 581')
self.assertEqual(mdNew.composer, 'Wolfgang Amadeus Mozart')
def testRichMetadata01(self):
from music21 import corpus
from music21 import metadata
score = corpus.parse('jactatur')
self.assertEqual(score.metadata.composer, 'Johannes Ciconia')
richMetadata = metadata.RichMetadata()
richMetadata.merge(score.metadata)
self.assertEqual(richMetadata.composer, 'Johannes Ciconia')
# update richMetadata with stream
richMetadata.update(score)
self.assertEqual(
richMetadata.keySignatureFirst,
'<music21.key.KeySignature of 1 flat, mode major>',
)
self.assertEqual(str(richMetadata.timeSignatureFirst), '2/4')
rmdNew = metadata.RichMetadata()
jsonString = freezeThaw.JSONFreezer(richMetadata).json
freezeThaw.JSONThawer(rmdNew).json = jsonString
self.assertEqual(rmdNew.composer, 'Johannes Ciconia')
self.assertEqual(str(rmdNew.timeSignatureFirst), '2/4')
self.assertEqual(
str(rmdNew.keySignatureFirst),
'<music21.key.KeySignature of 1 flat, mode major>',
)
score = corpus.parse('bwv66.6')
richMetadata = metadata.RichMetadata()
richMetadata.merge(score.metadata)
richMetadata.update(score)
self.assertEqual(
str(richMetadata.keySignatureFirst),
'<music21.key.KeySignature of 3 sharps, mode minor>',
)
self.assertEqual(str(richMetadata.timeSignatureFirst), '4/4')
jsonString = freezeThaw.JSONFreezer(richMetadata).json
freezeThaw.JSONThawer(rmdNew).json = jsonString
self.assertEqual(str(rmdNew.timeSignatureFirst), '4/4')
self.assertEqual(
str(rmdNew.keySignatureFirst),
'<music21.key.KeySignature of 3 sharps, mode minor>',
)
def write(self, filePath=None):
r'''
Write the metadata bundle to disk as a JSON file.
If `filePath` is None, use `self.filePath`.
Returns the metadata bundle.
>>> from music21 import metadata
>>> bachBundle = corpus.corpora.CoreCorpus().metadataBundle.search(
... 'bach',
... 'composer',
... )
>>> bachBundle.filePath is None
True
>>> import os
>>> import tempfile
>>> tempFilePath = tempfile.mkstemp()[1]
>>> bachBundle.write(filePath=tempFilePath)
<music21.metadata.bundles.MetadataBundle {25 entries}>
>>> os.remove(tempFilePath)
'''
filePath = filePath or self.filePath
if self.filePath is not None:
filePath = self.filePath
environLocal.printDebug(['MetadataBundle: writing:', filePath])
jsf = freezeThaw.JSONFreezer(self)
return jsf.jsonWrite(filePath)
return self
def getFormat(score):
from music21 import freezeThaw
sf = freezeThaw.JSONFreezer(score)
frozen = json.dumps(
sf.getJSONDict(includeVersion=True),
sort_keys=True,
)
return "var dataAssignment = '" + frozen + "'"
def testRichMetadata02(self):
from music21 import VERSION
from music21 import corpus
from music21 import metadata
from music21 import test
score = corpus.parse('bwv66.6')
richMetadata = metadata.RichMetadata()
richMetadata.merge(score.metadata)
richMetadata.update(score)
self.assertEqual(richMetadata.noteCount, 165)
self.assertEqual(richMetadata.quarterLength, 36.0)
self.assertMultiLineEqual(
freezeThaw.JSONFreezer(richMetadata).prettyJson,
test.dedent(
'''
{
"__attr__": {
"_urls": [],
"_workIds": {
"movementName": {
"__attr__": {
"_data": "bwv66.6.mxl"
},
"__class__": "music21.metadata.primitives.Text"
}
},
"ambitus": {
"__attr__": {
"_priority": 0,
"offset": 0.0
},
"__class__": "music21.interval.Interval"
},
"contributors": [],
"keySignatureFirst": "<music21.key.Key of f# minor>",
"keySignatures": [
"<music21.key.Key of f# minor>"
],
"noteCount": 165,
"numberOfParts": 4,
"pitchHighest": "E5",
"pitchLowest": "F#2",
"quarterLength": 36.0,
"sourcePath": "bach/bwv66.6.mxl",
"tempos": [],
"timeSignatureFirst": "4/4",
"timeSignatures": [
"4/4"
]
},
"__class__": "music21.metadata.RichMetadata",
"__version__": [
''' + str(VERSION[0]) + ''',
''' + str(VERSION[1]) + ''',
''' + str(VERSION[2]) + '''
]
}
''', ))
def testDate(self):
from music21 import freezeThaw
from music21 import metadata
date1 = metadata.primitives.Date(year=1843, yearError='approximate')
date2 = metadata.primitives.Date(year='1843?')
dateNew = metadata.primitives.Date()
jsonStr = freezeThaw.JSONFreezer(date1).json
freezeThaw.JSONThawer(dateNew).json = jsonStr
self.assertEqual(dateNew.year, 1843)
self.assertEqual(dateNew.yearError, 'approximate')
dateNew = metadata.primitives.Date()
jsonStr = freezeThaw.JSONFreezer(date2).json
freezeThaw.JSONThawer(dateNew).json = jsonStr
self.assertEqual(dateNew.year, '1843')
self.assertEqual(dateNew.yearError, 'uncertain')
def testBasicB(self):
from music21 import chord
c1 = chord.Chord(['c2', 'a4', 'e5'], quarterLength=1.25)
c2 = chord.Chord()
raw = freezeThaw.JSONFreezer(c1).json
freezeThaw.JSONThawer(c2).json = raw
self.assertEqual(
str(c1.pitches),
'(<music21.pitch.Pitch C2>, <music21.pitch.Pitch A4>, <music21.pitch.Pitch E5>)'
)
self.assertEqual(c1.quarterLength, 1.25)
def testContributor(self):
from music21 import freezeThaw
from music21 import metadata
contributor = metadata.primitives.Contributor(
role='composer',
name='Gilles Binchois',
)
self.assertEqual(contributor.role, 'composer')
self.assertEqual(contributor.relevance, 'contributor')
jsonStr = freezeThaw.JSONFreezer(contributor).json
contributorNew = metadata.primitives.Contributor()
freezeThaw.JSONThawer(contributorNew).json = jsonStr
self.assertEqual(contributorNew.role, 'composer')
self.assertEqual(contributorNew.name, 'Gilles Binchois')
self.assertEqual(contributorNew.relevance, 'contributor')
def testText(self):
from music21 import freezeThaw
from music21 import metadata
import json
text = metadata.primitives.Text('my text')
text.language = 'en'
jsf = freezeThaw.JSONFreezer(text)
jsonDict = json.loads(jsf.json)
self.assertEqual(sorted(list(jsonDict['__attr__'].keys())), [u'_data', u'_language'])
textNew = metadata.primitives.Text()
jst = freezeThaw.JSONThawer(textNew)
jst.json = jsf.json
self.assertEqual(textNew._data, 'my text')
self.assertEqual(textNew._language, 'en')
def testDateRelative(self):
from music21 import freezeThaw
from music21 import metadata
dateRelative = metadata.primitives.DateRelative('2001/12/31', 'prior')
self.assertEqual(str(dateRelative), 'prior to 2001/12/31')
self.assertEqual(dateRelative.relevance, 'prior')
self.assertEqual(len(dateRelative._data), 1)
dateSingleNew = metadata.primitives.DateSingle()
jsonStr = freezeThaw.JSONFreezer(dateRelative).json
freezeThaw.JSONThawer(dateSingleNew).json = jsonStr
self.assertEqual(len(dateSingleNew._data), 1)
self.assertEqual(dateSingleNew._relevance, 'prior')
self.assertEqual(dateSingleNew._dataError, [])
self.assertEqual(str(dateSingleNew), '2001/12/31')
def testBasicA(self):
from music21 import note
unused_t1 = note.Lyric('test')
#print t1.json
n1 = note.Note('G#3', quarterLength=3)
n1.lyric = 'testing'
self.assertEqual(n1.pitch.nameWithOctave, 'G#3')
self.assertEqual(n1.quarterLength, 3.0)
self.assertEqual(n1.lyric, 'testing')
n2 = note.Note()
raw = freezeThaw.JSONFreezer(n1).json
freezeThaw.JSONThawer(n2).json = raw
self.assertEqual(n2.pitch.nameWithOctave, 'G#3')
self.assertEqual(n2.quarterLength, 3.0)
def testDateSingle(self):
from music21 import freezeThaw
from music21 import metadata
dateSingle = metadata.primitives.DateSingle(
'2009/12/31', 'approximate')
self.assertEqual(str(dateSingle), '2009/12/31')
self.assertEqual(len(dateSingle._data), 1)
dateSingleNew = metadata.primitives.DateSingle()
self.assertEqual(len(dateSingleNew._data), 1)
jsonStr = freezeThaw.JSONFreezer(dateSingle).json
freezeThaw.JSONThawer(dateSingleNew).json = jsonStr
self.assertEqual(len(dateSingleNew._data), 1)
self.assertEqual(dateSingleNew._relevance, 'approximate')
self.assertEqual(dateSingleNew._dataError, ['approximate'])
self.assertEqual(str(dateSingleNew), '2009/12/31')
def testDateBetween(self):
from music21 import freezeThaw
from music21 import metadata
dateBetween = metadata.primitives.DateBetween(
('2009/12/31', '2010/1/28'))
self.assertEqual(str(dateBetween), '2009/12/31 to 2010/01/28')
self.assertEqual(dateBetween.relevance, 'between')
self.assertEqual(dateBetween._dataError, [None, None])
self.assertEqual(len(dateBetween._data), 2)
dateBetweenNew = metadata.primitives.DateBetween()
jsonStr = freezeThaw.JSONFreezer(dateBetween).json
freezeThaw.JSONThawer(dateBetweenNew).json = jsonStr
self.assertEqual(len(dateBetweenNew._data), 2)
self.assertEqual(dateBetweenNew._relevance, 'between')
self.assertEqual(dateBetweenNew._dataError, [None, None])
self.assertEqual(str(dateBetweenNew), '2009/12/31 to 2010/01/28')
def testDateSelection(self):
from music21 import freezeThaw
from music21 import metadata
dateSelection = metadata.primitives.DateSelection(
['2009/12/31', '2010/1/28', '1894/1/28'],
'or',
)
self.assertEqual(str(dateSelection),
'2009/12/31 or 2010/01/28 or 1894/01/28')
self.assertEqual(dateSelection.relevance, 'or')
self.assertEqual(dateSelection._dataError, [None, None, None])
self.assertEqual(len(dateSelection._data), 3)
dateSelectionNew = metadata.primitives.DateSelection()
jsonStr = freezeThaw.JSONFreezer(dateSelection).json
freezeThaw.JSONThawer(dateSelectionNew).json = jsonStr
self.assertEqual(len(dateSelectionNew._data), 3)
self.assertEqual(dateSelectionNew._relevance, 'or')
self.assertEqual(dateSelectionNew._dataError, [None, None, None])
self.assertEqual(str(dateSelectionNew),
'2009/12/31 or 2010/01/28 or 1894/01/28')
