def testType(self):
opt = Parameter('foo', vtype=int)
self.assertIsNone(opt.default)
self.assertIsNone(opt.value)
opt.value = 1
self.assertEqual(opt.value, 1)
with self.assertLogs(level=logging.WARNING) as cm:
opt.value = 's'
self.assertEqual(len(cm.output), 1)
self.assertIn(
"'foo' must be of type (<class 'int'>,) but <class 'str'> provided.",
cm.output[0])
def testAllow(self):
opt = Parameter('foo', allow=(1, 'two'))
self.assertIsNone(opt.default)
self.assertIsNone(opt.value)
opt.value = 1
self.assertEqual(opt.value, 1)
opt.value = 'two'
self.assertEqual(opt.value, 'two')
with self.assertLogs(level=logging.WARNING) as cm:
opt.value = 4
self.assertEqual(len(cm.output), 1)
self.assertIn(
"Attempting to set 'foo' to a value of 4 but only the following are allowed: (1, 'two')",
cm.output[0])
def testDefault(self):
opt = Parameter('foo', default=12345)
self.assertEqual(opt.name, 'foo')
self.assertEqual(opt.default, 12345)
self.assertEqual(opt.value, 12345)
opt.value = '12345'
self.assertEqual(opt.default, 12345)
self.assertEqual(opt.value, '12345')
def testVerify(self):
opt = Parameter('year',
verify=(lambda v: v > 1980,
"The year must be greater than 1980."))
self.assertEqual(opt.value, None)
opt.value = 1990
self.assertEqual(opt.value, 1990)
with self.assertLogs(level=logging.WARNING) as cm:
opt.value = 1949
self.assertEqual(len(cm.output), 1)
self.assertIn(
"Verify function failed with the given value of 1949\nThe year must be greater than 1980.",
cm.output[0])
with self.assertRaises(TypeError) as e:
Parameter('year', verify="wrong")
self.assertIn(
"The supplied 'verify' argument must be a 'tuple' with callable function and 'str' error message, but <class 'str'> was provided.",
str(e.exception))
with self.assertRaises(TypeError) as e:
Parameter('year', verify=("wrong", 1, 2))
self.assertIn(
"The supplied 'verify' argument must be a 'tuple' with two items a callable function and 'str' error message, but <class 'tuple'> with 3 items was provided.",
str(e.exception))
with self.assertRaises(TypeError) as e:
Parameter('year', verify=("wrong", "message"))
self.assertIn(
"The first item in the 'verify' argument tuple must be a callable function with a single argument, but <class 'str'> was provided",
str(e.exception))
with self.assertRaises(TypeError) as e:
Parameter('year', verify=(lambda x, y: True, "message"))
self.assertIn(
"The first item in the 'verify' argument tuple must be a callable function with a single argument, but <class 'function'> was provided that has 2 arguments.",
str(e.exception))
with self.assertRaises(TypeError) as e:
Parameter('year', verify=(lambda v: True, 42))
self.assertIn(
"The second item in the 'verify' argument tuple must be a string, but <class 'int'> was provided",
str(e.exception))
def testSize(self):
opt = Parameter('foo', size=4)
self.assertEqual(opt._Parameter__array, True)
self.assertEqual(opt._Parameter__size, 4)
with self.assertLogs(level=logging.WARNING) as cm:
opt.value = (1, 2, 3)
self.assertIn(
"'foo' was defined as an array with length 4 but a value with length 3 was provided.",
cm.output[0])
def testDefault(self):
opt = Parameter('foo', default=12345)
self.assertEqual(opt.name, 'foo')
self.assertEqual(opt.default, 12345)
self.assertEqual(opt.value, 12345)
opt.value = '12345'
self.assertEqual(opt.default, 12345)
self.assertEqual(opt.value, '12345')
opt = Parameter('bar', default=1980, vtype=int)
with self.assertLogs(level=logging.WARNING) as cm:
opt.default = 'nope'
self.assertEqual(len(cm.output), 1)
self.assertIn(
"'bar' must be of type (<class 'int'>,) but <class 'str'> provided.",
cm.output[0])
def parameters_from_df(df, model, user_id):
df = df[(df.model == model) & (df.user_id == user_id)]
parameters = Parameters(name=model)
n_row = df.shape[0]
for i in range(0, n_row):
parameter = Parameter()
parameter.name = df.at[i, 'parameter']
parameter.value = df.at[
i,
'value'] #float( df.at[i, 'value'] ) if '.' in df.at[i, 'value'] else int( df.at[i, 'value'] )
# parameter.min = float( df[i, 'value'] ) if '.' in row[2] else int( row[2] )
# parameter.max = float( row[3] ) if '.' in row[3] else int( row[3] )
# parameter.step = float( row[4] ) if '.' in row[4] else int( row[4] )
parameter.freedom = int(df.at[i, 'freedom'])
# parameter.comment = row[ 6 ]
parameters[parameter.name] = parameter
return parameters
def testRequired(self):
opt = Parameter('year', required=True)
self.assertEqual(opt.required, True)
with self.assertLogs(level=logging.WARNING) as cm:
retcode = opt.validate()
self.assertEqual(retcode, 1)
self.assertEqual(len(cm.output), 1)
self.assertIn(
"The Parameter 'year' is marked as required, but no value is assigned.",
cm.output[0])
with self.assertRaises(TypeError) as e:
Parameter('year', required="wrong")
self.assertIn(
"The supplied 'required' argument must be a 'bool', but <class 'str'> was provided.",
str(e.exception))
opt.value = 1980
self.assertEqual(opt.validate(), 0)
def testToString(self):
opt = Parameter('year')
s = str(opt)
self.assertIn('Value: None', s)
self.assertNotIn('Default', s)
self.assertNotIn('Type', s)
self.assertNotIn('Allow', s)
opt = Parameter('year',
default=1980,
vtype=int,
allow=(1949, 1954, 1975, 1980))
opt.value = 1954
s = str(opt)
self.assertIn('Value: 1954', s)
self.assertIn('Default: 1980', s)
self.assertIn("Type(s): ('int',)", s)
self.assertIn('Allow: (1949, 1954, 1975, 1980)', s)
opt = Parameter('year', default=1980, doc="The best year.")
s = str(opt)
self.assertIn("best", s)
def testArray(self):
opt = Parameter('foo', default=(1, 2), array=True)
self.assertEqual(opt._Parameter__array, True)
self.assertEqual(opt.value, (1, 2))
with self.assertLogs(level=logging.WARNING) as cm:
opt.value = 4
self.assertIn(
"'foo' was defined as an array, which require <class 'tuple'> for assignment, but a <class 'int'> was provided.",
cm.output[0])
opt.value = (3, 4)
self.assertEqual(opt.value, (3, 4))
opt.value = ('1', )
self.assertEqual(opt.value, ('1', ))
opt = Parameter('foo', vtype=int, array=True)
self.assertEqual(opt._Parameter__array, True)
self.assertIsNone(opt.value)
with self.assertLogs(level=logging.WARNING) as cm:
opt.value = 4
self.assertEqual(len(cm.output), 1)
self.assertIn(
"'foo' was defined as an array, which require <class 'tuple'> for assignment, but a <class 'int'> was provided.",
cm.output[0])
with self.assertLogs(level=logging.WARNING) as cm:
opt.value = ('x', )
self.assertEqual(len(cm.output), 1)
self.assertIn(
"The values within 'foo' must be of type (<class 'int'>,) but <class 'str'> provided.",
cm.output[0])
self.assertIsNone(opt.value)
opt.value = (1, )
self.assertEqual(opt.value, (1, ))