def setUp(self):
self.jobj = JObject(a=1, b=None, _c="a", d="")
self.obs = Observation(value="monkey", confidence=1.0, secondary_value=7)
self.event = Event(time=Observation(0.5, 1.0), label=Observation("dog bark", 0.5))
self.chord = Range(start=Observation(0.0, 1.0), end=Observation(0.6, 0.8), label=Observation("C:maj", 0.15))
self.series = TimeSeries(value=[x for x in "abc"], time=[0.1, 0.5, 0.9])
self.curator = Curator(name="J. Doe", email="*****@*****.**")
self.ameta = AnnotationMetadata(curator=self.curator, version="0.0.1", corpus="testing")
self.obs_annot = ObservationAnnotation(data=[self.obs], annotation_metadata=self.ameta, sandbox=self.jobj)
self.event_annot = EventAnnotation(data=[self.event])
self.range_annot = RangeAnnotation(data=[self.chord])
self.series_annot = TimeSeriesAnnotation(data=[self.series])
self.fmeta = FileMetadata(title="Pachuca Sunrise", artist="Minus the Bear")
self.sandbox = Sandbox(a=1, b=None, _c="a", d="")
class JamsTests(unittest.TestCase):
def setUp(self):
self.jobj = JObject(a=1, b=None, _c="a", d="")
self.obs = Observation(value="monkey", confidence=1.0, secondary_value=7)
self.event = Event(time=Observation(0.5, 1.0), label=Observation("dog bark", 0.5))
self.chord = Range(start=Observation(0.0, 1.0), end=Observation(0.6, 0.8), label=Observation("C:maj", 0.15))
self.series = TimeSeries(value=[x for x in "abc"], time=[0.1, 0.5, 0.9])
self.curator = Curator(name="J. Doe", email="*****@*****.**")
self.ameta = AnnotationMetadata(curator=self.curator, version="0.0.1", corpus="testing")
self.obs_annot = ObservationAnnotation(data=[self.obs], annotation_metadata=self.ameta, sandbox=self.jobj)
self.event_annot = EventAnnotation(data=[self.event])
self.range_annot = RangeAnnotation(data=[self.chord])
self.series_annot = TimeSeriesAnnotation(data=[self.series])
self.fmeta = FileMetadata(title="Pachuca Sunrise", artist="Minus the Bear")
self.sandbox = Sandbox(a=1, b=None, _c="a", d="")
def tearDown(self):
pass
def test_JObject_equivalence(self):
self.assertEqual(self.jobj.a, 1, "Failed to initialize properly.")
self.assertEqual(self.jobj.b, None, "Failed to initialize properly.")
self.assertEqual(self.jobj._c, "a", "Failed to initialize properly.")
self.assertEqual(self.jobj.d, "", "Failed to initialize properly.")
self.assertEqual(self.jobj.type, "JObject", "Failed to encode type.")
# Equivalence Tests
self.assertNotEqual(self.jobj, None)
self.assertNotEqual(self.jobj, dict(a=1))
self.assertEqual(self.jobj, JObject(a=1))
def test_JObject_serialization(self):
# JObjects do not serialize Nones, private vars (_xxx), or empty strs.
self.assertEqual(self.jobj.__json__, dict(a=1), "Failed to properly serialize.")
# Verify pass-through loop.
jobj2 = JObject(**_loads(_dumps(self.jobj)))
self.assertEqual(
self.jobj,
jobj2,
"Failed to properly recreate the object." "Expected: %s\nReceived: %s" % (self.jobj, jobj2),
)
self.jobj.e = 1234
self.assertNotEqual(
self.jobj,
jobj2,
"Assigned attribute failed to propagate." "Expected: %s\nReceived: %s" % (self.jobj, jobj2),
)
def test_Observation_init(self):
self.assertEqual(self.obs.value, "monkey", "Failed to initialize 'value' properly.")
self.assertEqual(self.obs.confidence, 1.0, "Failed to initialize 'confidence' properly.")
self.assertEqual(self.obs.secondary_value, 7, "Failed to initialize 'value' properly.")
def test_Observation_init_none(self):
obs2 = Observation("monkey", 1.0)
self.assertEqual(obs2.secondary_value, None, "Failed to initialize 'secondary_value' with None.")
def test_Observation_serialization(self):
obs2 = Observation(**_loads(_dumps(self.obs)))
self.assertEqual(
self.obs, obs2, "Failed to properly recreate the object." "Expected: %s\nReceived: %s" % (self.obs, obs2)
)
def test_Observation_invalid_attr(self):
obs = Observation()
with self.assertRaises(ValueError):
obs.bad_attr = "some value"
def test_Event_init(self):
self.assertEqual(self.event.time.value, 0.5, "Failed to initialize 'time.value' properly.")
self.assertEqual(self.event.time.confidence, 1.0, "Failed to initialize 'time.confidence' properly.")
self.assertEqual(self.event.time.secondary_value, None, "Failed to assign None to 'time.secondary_value'.")
self.assertEqual(self.event.label.value, "dog bark", "Failed to initialize 'label.value' properly.")
self.assertEqual(self.event.label.confidence, 0.5, "Failed to initialize 'label.confidence' properly.")
def test_Event_serialization(self):
event2 = Event(**_loads(_dumps(self.event)))
self.assertEqual(
self.event,
event2,
"Failed to properly recreate the object." "Expected: %s\nReceived: %s" % (self.event, event2),
)
def test_Event_invalid_attr(self):
event = Event()
with self.assertRaises(ValueError):
event.bad_attr = "some value"
def test_Range_init(self):
self.assertEqual(self.chord.start.value, 0.0, "Failed to initialize 'start.value' properly.")
self.assertEqual(self.chord.end.value, 0.6, "Failed to initialize 'start.value' properly.")
self.assertEqual(self.chord.label.value, "C:maj", "Failed to initialize 'label.value' properly.")
def test_Range_serialization(self):
chord2 = Range(**_loads(_dumps(self.chord)))
self.assertEqual(
self.chord,
chord2,
"Failed to properly recreate the object." "Expected: %s\nReceived: %s" % (self.chord, chord2),
)
def test_Range_duration(self):
expected_duration = 0.6
self.assertEqual(
self.chord.duration,
expected_duration,
"Failed to compute duration correctly."
"Expected: %s\nReceived: %s" % (self.chord.duration, expected_duration),
)
def test_Range_inc_monotonic(self):
# Start / End times should be monotonically increasing.
with self.assertRaises(ValueError):
Range(Observation(1.0), Observation(0.0))
def test_Range_invalid_attr(self):
arange = Range()
with self.assertRaises(ValueError):
arange.bad_attr = "some value"
def test_TimeSeries_init(self):
value = [x for x in "abc"]
time = [0.1, 0.5, 0.9]
self.assertEqual(self.series.value, value, "Failed to initialize 'value' properly.")
self.assertEqual(self.series.time, time, "Failed to initialize 'start.value' properly.")
self.assertEqual(self.series.confidence, [], "Failed to initialize 'label.value' properly.")
def test_TimeSeries_serialization(self):
series2 = TimeSeries(**_loads(_dumps(self.series)))
self.assertEqual(
self.series,
series2,
"Failed to properly recreate the object." "Expected: %s\nReceived: %s" % (self.series, series2),
)
def test_TimeSeries_observation_lengths_match(self):
# Lists of different lengths should raise a ValueError.
self.assertRaises(ValueError, TimeSeries, range(3), range(2))
def test_TimeSeries_invalid_attr(self):
tseries = TimeSeries()
with self.assertRaises(ValueError):
tseries.bad_attr = "some value"
def test_ObservationAnnotation_init(self):
self.assertEqual(self.obs_annot.data, [self.obs], "Failed to initialize 'data' properly.")
self.assertEqual(
self.obs_annot.annotation_metadata, self.ameta, "Failed to initialize 'annotation_metadata' properly."
)
self.assertEqual(self.obs_annot.sandbox.__json__, {"a": 1}, "Failed to initialize 'sandbox' properly. ")
def test_ObservationAnnotation_serialization(self):
# Test that Annotations can be deserialized without a class wrapper.
annot2 = _loads(_dumps(self.obs_annot))
self.assertEqual(
self.obs_annot,
annot2,
"Failed to properly recreate the object." "Expected: %s\nReceived: %s" % (self.obs_annot, annot2),
)
def test_ObservationAnnotation_factory(self):
# Verify persistence of objects created via the factory method.
exp_value = "testing"
obs2 = self.obs_annot.create_datapoint()
obs2.value = exp_value
self.assertEqual(
self.obs_annot.data[1].value,
exp_value,
"Failed to maintain a handle of the factory-created datapoint."
"Expected: %s\nReceived: %s" % (exp_value, self.obs_annot.data[1].value),
)
def test_ObservationAnnotation_datatype_validation(self):
# Annotations should fail if the data types are not Observations.
self.assertRaises(TypeError, ObservationAnnotation, [self.event])
self.assertRaises(TypeError, ObservationAnnotation, [self.chord])
self.assertRaises(TypeError, ObservationAnnotation, [self.series])
def test_ObservationAnnotation_invalid_attr(self):
annot = ObservationAnnotation()
with self.assertRaises(ValueError):
annot.bad_attr = "some value"
def test_EventAnnotation_init(self):
self.assertEqual(self.event_annot.data, [self.event], "Failed to initialize 'data' properly.")
def test_EventAnnotation_serialization(self):
# Test that Annotations can be deserialized without a class wrapper.
annot2 = _loads(_dumps(self.event_annot))
self.assertEqual(
self.event_annot,
annot2,
"Failed to properly recreate the object." "Expected: %s\nReceived: %s" % (self.event_annot, annot2),
)
def test_EventAnnotation_factory(self):
# Verify persistence of objects created via the factory method.
event2 = self.event_annot.create_datapoint()
event2.label = self.event.label
event2.time = self.event.time
self.assertEqual(
self.event_annot.data[1],
self.event,
"Failed to maintain a handle of the factory-created datapoint. "
"Expected: %s\nReceived: %s" % (self.event, self.event_annot.data[1]),
)
del self.event_annot.data[1]
def test_EventAnnotation_datatype_validation(self):
# Annotations should fail if the data types are not Events.
self.assertRaises(TypeError, EventAnnotation, [Observation(1.0)])
self.assertRaises(TypeError, EventAnnotation, [Range(Observation(1.0))])
self.assertRaises(TypeError, EventAnnotation, [TimeSeries(range(10))])
def test_EventAnnotation_labels(self):
# Populate
expected_labels = Observation(value=["dog bark"], confidence=[0.5], secondary_value=[None])
self.assertEqual(
self.event_annot.labels,
expected_labels,
"Failed to collect all label fields properly.\n"
"Expected:\n%s\nReceived:\n%s" % (expected_labels, self.event_annot.labels),
)
def test_EventAnnotation_times(self):
expected_times = Observation(value=[0.5], confidence=[1.0], secondary_value=[None])
self.assertEqual(
self.event_annot.times,
expected_times,
"Failed to collect all label fields properly. \n"
"Expected:\n%s\nReceived:\n%s" % (expected_times, self.event_annot.times),
)
def test_EventAnnotation_invalid_attr(self):
annot = EventAnnotation()
with self.assertRaises(ValueError):
annot.bad_attr = "some value"
def test_RangeAnnotation_init(self):
self.assertEqual(self.range_annot.data, [self.chord], "Failed to initialize 'data' properly.")
def test_RangeAnnotation_serialization(self):
# Test that Annotations can be deserialized without a class wrapper.
annot2 = _loads(_dumps(self.range_annot))
self.assertEqual(
self.range_annot,
annot2,
"Failed to properly recreate the object." "Expected:\n%s\nReceived:\n%s" % (self.range_annot, annot2),
)
def test_RangeAnnotation_factory(self):
# Verify persistence of objects created via the factory method.
chord2 = self.range_annot.create_datapoint()
chord2.label.value = "blah blah"
self.assertEqual(
chord2.label.value,
self.range_annot.data[1].label.value,
"Failed to maintain a handle of the factory-created datapoint. "
"Expected:\n%s\nReceived:\n%s" % (chord2.label.value, self.range_annot.data[1].label.value),
)
self.range_annot.data = self.range_annot.data[:1]
def test_RangeAnnotation_datatype_validation(self):
# Annotations should fail if the data types are not Events.
self.assertRaises(TypeError, RangeAnnotation, [Observation(1.0)])
self.assertRaises(TypeError, RangeAnnotation, [Event(Observation(1.0))])
self.assertRaises(TypeError, RangeAnnotation, [TimeSeries(range(10))])
def test_RangeAnnotation_labels(self):
# Populate
expected_labels = Observation(value=["C:maj"], confidence=[0.15], secondary_value=[None])
self.assertEqual(
self.range_annot.labels,
expected_labels,
"Failed to collect all label fields properly. "
"Expected: %s\nReceived: %s" % (expected_labels, self.range_annot.labels),
)
def test_RangeAnnotation_starts(self):
expected_starts = Observation(value=[0.0], confidence=[1.0], secondary_value=[None])
self.assertEqual(
self.range_annot.starts,
expected_starts,
"Failed to collect all start fields properly. "
"Expected: %s\nReceived: %s" % (expected_starts, self.range_annot.starts),
)
def test_RangeAnnotation_ends(self):
expected_ends = Observation(value=[0.6], confidence=[0.8], secondary_value=[None])
self.assertEqual(
self.range_annot.ends,
expected_ends,
"Failed to collect all end fields properly. "
"Expected: %s\nReceived: %s" % (expected_ends, self.range_annot.ends),
)
def test_RangeAnnotation_intervals(self):
expected_intervals = [(0.0, 0.6)]
self.assertEqual(
self.range_annot.intervals,
expected_intervals,
"Failed to collect all start fields properly. "
"Expected: %s\nReceived: %s" % (expected_intervals, self.range_annot.intervals),
)
def test_RangeAnnotation_invalid_attr(self):
annot = RangeAnnotation()
with self.assertRaises(ValueError):
annot.bad_attr = "some value"
def test_TimeSeriesAnnotation_init(self):
self.assertEqual(self.series_annot.data, [self.series], "Failed to initialize 'data' properly.")
def test_TimeSeriesAnnotation_serialization(self):
"""Verify XAnnotation can be deserialized without a class wrapper."""
annot2 = _loads(_dumps(self.series_annot))
self.assertEqual(
self.series_annot,
annot2,
"Failed to properly recreate the object." "Expected: %s\nReceived: %s" % (self.series_annot, annot2),
)
def test_TimeSeriesAnnotation_factory(self):
"""Verify persistence of objects created via the factory method."""
series = self.series_annot.create_datapoint()
series.value = range(5)
self.assertEqual(
self.series_annot.data[-1].value,
range(5),
"Failed to maintain a handle of the factory-created datapoint. "
"Expected: %s\nReceived: %s" % (range(5), self.series_annot.data[-1].value),
)
def test_TimeSeriesAnnotation_datatype_validation(self):
"""Annotations should fail if the data types are not TimeSeries."""
self.assertRaises(TypeError, TimeSeriesAnnotation, [Observation(1.0)])
self.assertRaises(TypeError, TimeSeriesAnnotation, [Event(Observation(1.0))])
self.assertRaises(TypeError, TimeSeriesAnnotation, [Range(Observation(1.0))])
def test_TimeSeriesAnnotation_invalid_attr(self):
annot = TimeSeriesAnnotation()
with self.assertRaises(ValueError):
annot.bad_attr = "some value"
# TODO(ejhumphrey): This is too implicit a test for my tastes, but it's
# not obvious at the moment how to ensure that the tasks receive the
# proper annotation types.
def test_JAMS_invalid_annotations(self):
with self.assertRaises(TypeError):
JAMS(beat=[self.range_annot])
with self.assertRaises(TypeError):
JAMS(chord=[self.obs_annot])
with self.assertRaises(TypeError):
JAMS(genre=[self.event_annot])
def test_JAMS_invalid_attr(self):
jam = JAMS()
with self.assertRaises(ValueError):
jam.bad_attr = "some value"
def test_JAMS_serialization(self):
jam = JAMS(
beat=[self.event_annot],
chord=[self.range_annot],
tag=[self.obs_annot],
melody=[self.series_annot],
file_metadata=self.fmeta,
sandbox=self.sandbox,
)
jam2 = JAMS(**_loads(_dumps(jam)))
self.assertEqual(
jam, jam2, "Failed to properly recreate the JAMS object." "Expected: %s\nReceived: %s" % (jam, jam2)
)
def test_ObservationAnnotation_invalid_attr(self):
annot = ObservationAnnotation()
with self.assertRaises(ValueError):
annot.bad_attr = "some value"
