def test_is_match(self):
from sciunit import Model
m = Model()
m2 = Model()
self.assertFalse(m.is_match(m2))
self.assertTrue(m.is_match(m))
self.assertTrue(m.is_match("Model"))
def test_error_types(self):
from sciunit.errors import CapabilityError, BadParameterValueError,\
PredictionError, InvalidScoreError
from sciunit import Model, Capability
CapabilityError(Model(), Capability)
PredictionError(Model(), 'foo')
InvalidScoreError()
BadParameterValueError('x', 3)
def test_error_types(self):
from sciunit.errors import (
CapabilityError,
BadParameterValueError,
PredictionError,
InvalidScoreError,
)
from sciunit import Model, Capability
CapabilityError(Model(), Capability)
CapabilityError(Model(), Capability, "this is a test detail")
PredictionError(Model(), "foo")
InvalidScoreError()
BadParameterValueError("x", 3)
def test_Test(self):
pv = config["PREVALIDATE"]
config["PREVALIDATE"] = 1
with self.assertRaises(ObservationError):
t = Test(None)
with self.assertRaises(ObservationError):
class Test2(Test):
observation_schema = None
score_type = ZScore
units = pq.pA
def generate_prediction(self):
return 1
t = Test2({"mean": 5 * pq.pA})
t = Test({})
self.assertRaises(ObservationError, t.validate_observation,
"I am not an observation")
t.observation_schema = {}
t.validate_observation({0: 0, 1: 1})
Test.observation_schema = [{}, {}]
self.assertListEqual(t.observation_schema_names(),
["Schema 1", "Schema 2"])
config["PREVALIDATE"] = pv
self.assertRaises(ParametersError, t.validate_params, None)
self.assertRaises(ParametersError, t.validate_params,
"I am not an observation")
t.params_schema = {}
t.validate_params({0: 1, 1: 2})
self.assertRaises(Error, t.check_capabilities, "I am not a model")
t.condition_model(Model())
self.assertRaises(NotImplementedError, t.generate_prediction, Model())
self.assertRaises(NotImplementedError, t.optimize, Model())
self.assertTrue(t.compute_score({0: 2, 1: 2}, {0: 2, 1: 2}).score)
self.assertFalse(t.compute_score({0: -2, 1: 2}, {0: 2, 1: -2}).score)
t.score_type = None
self.assertRaises(NotImplementedError, t.compute_score, {}, {})
t.score_type = BooleanScore
self.assertRaises(InvalidScoreError, t.check_score_type,
FloatScore(0.5))
def test_ProtocolToFeaturesTest(self):
t = ProtocolToFeaturesTest([1, 2, 3])
m = Model()
m.run = lambda: 0
self.assertIsInstance(t.generate_prediction(m), NotImplementedError)
self.assertIsInstance(t.setup_protocol(m), NotImplementedError)
self.assertIsInstance(t.get_result(m), NotImplementedError)
self.assertIsInstance(t.extract_features(m, list()),
NotImplementedError)
def test_backends_init_caches(self):
myModel = Model()
backend = Backend()
backend.model = myModel
backend.init_backend(use_disk_cache=True, use_memory_cache=True)
backend.init_backend(use_disk_cache=False, use_memory_cache=True)
backend.init_backend(use_disk_cache=True, use_memory_cache=False)
backend.init_backend(use_disk_cache=False, use_memory_cache=False)
backend.init_cache()
def test_fake_test(self):
from neuronunit.tests import FakeTest
from sciunit import Model
observation = {'a' : 1, 'b' : 1}
ft = FakeTest(observation, name="a_b_test")
m = Model(name="a_b_model")
m.attrs = {'a' : 1, 'b' : 1}
prediction = ft.generate_prediction(m)
score = ft.compute_score([0.9, 1.1], prediction).score
self.assertAlmostEqual(score, 0.09, 2)
def test_Test(self):
config_set("PREVALIDATE", True)
with self.assertRaises(ObservationError):
t = Test(None)
config_set("PREVALIDATE", False)
t = Test(None)
self.assertRaises(ObservationError, t.validate_observation, None)
self.assertRaises(ObservationError, t.validate_observation,
"I am not an observation")
self.assertRaises(ObservationError, t.validate_observation,
{"mean": None})
t = Test([0, 1])
t.observation_schema = {}
t.validate_observation({0: 0, 1: 1})
Test.observation_schema = [{}, {}]
self.assertListEqual(t.observation_schema_names(),
["Schema 1", "Schema 2"])
self.assertRaises(ParametersError, t.validate_params, None)
self.assertRaises(ParametersError, t.validate_params,
"I am not an observation")
t.params_schema = {}
t.validate_params({0: 1, 1: 2})
self.assertRaises(Error, t.check_capabilities, "I am not a model")
t.condition_model(Model())
self.assertRaises(NotImplementedError, t.generate_prediction, Model())
self.assertRaises(NotImplementedError, t.optimize, Model())
self.assertTrue(t.compute_score({0: 2, 1: 2}, {0: 2, 1: 2}).score)
self.assertFalse(t.compute_score({0: -2, 1: 2}, {0: 2, 1: -2}).score)
t.score_type = None
self.assertRaises(NotImplementedError, t.compute_score, {}, {})
t.score_type = BooleanScore
self.assertRaises(InvalidScoreError, t.check_score_type,
FloatScore(0.5))
self.assertRaises(ObservationError, t.judge, [Model(), Model()])
def test_backends_set_caches(self):
myModel = Model()
backend = Backend()
backend.model = myModel
# backend.init_memory_cache()
self.assertIsNone(backend.get_disk_cache("key1"))
self.assertIsNone(backend.get_disk_cache("key2"))
self.assertIsNone(backend.get_memory_cache("key1"))
self.assertIsNone(backend.get_memory_cache("key2"))
backend.set_disk_cache("value1", "key1")
backend.set_memory_cache("value1", "key1")
self.assertEqual(backend.get_memory_cache("key1"), "value1")
self.assertEqual(backend.get_disk_cache("key1"), "value1")
backend.set_disk_cache("value2")
backend.set_memory_cache("value2")
self.assertEqual(backend.get_memory_cache(myModel.hash), "value2")
self.assertEqual(backend.get_disk_cache(myModel.hash), "value2")
backend.load_model()
backend.set_attrs(test_attribute="test attribute")
backend.set_run_params(test_param="test parameter")
backend.init_backend(use_disk_cache=True, use_memory_cache=True)
def test_get_model_state(self):
from sciunit import Model
m = Model()
state = m.__getstate__()
self.assertEqual(m.__dict__, state)
class MyBackend(Backend):
model = Model()
def _backend_run(self) -> str:
return "test result"
def test_getattr(self):
from sciunit import Model
m = Model()
self.assertEqual(m.name, m.__getattr__("name"))