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 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 read(self, filePath=None):
r'''
Load cached metadata from the file path suggested by the name of this
MetadataBundle ('core', 'local', or 'virtual').
If a specific filepath is given with the `filePath` keyword, attempt to
load cached metadata from the file at that location.
If `filePath` is None, and `self.filePath` is also None, do nothing.
::
>>> from music21 import metadata
>>> virtualBundle = metadata.MetadataBundle('virtual').read()
If a metadata is unnamed, and no file path is specified, an exception
will be thrown:
::
>>> anonymousBundle = metadata.MetadataBundle().read()
Traceback (most recent call last):
MetadataException: Unnamed MetadataBundles have no default file path to read from.
'''
timer = common.Timer()
timer.start()
if filePath is None:
filePath = self.filePath
if filePath is None and self.name is None:
raise exceptions21.MetadataException(
'Unnamed MetadataBundles have no default file path to read '
'from.')
if not os.path.exists(filePath):
environLocal.printDebug(
'no metadata found for: {0!r}; '
'try building cache with corpus.cacheMetadata({1!r})'.format(
self.name, self.name))
return self
jst = freezeThaw.JSONThawer(self)
jst.jsonRead(filePath)
environLocal.printDebug([
'MetadataBundle: loading time:', self.name, timer, 'md items:',
len(self._metadataEntries)
])
return self
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')
