def test_requires_stop_and_get_value(self) -> None:
with self.assertWarns(DeprecationWarning):
p = MappedParameter(Expression("foo + bar * hugo"))
with self.assertRaises(ParameterNotProvidedException):
p.requires_stop
with self.assertRaises(ParameterNotProvidedException):
p.get_value()
foo = DummyParameter(-1.1)
bar = DummyParameter(0.5)
hugo = DummyParameter(5.2, requires_stop=True)
ilse = DummyParameter(2356.4, requires_stop=True)
p._namespace = {'foo': foo, 'bar': bar, 'ilse': ilse}
with self.assertRaises(ParameterNotProvidedException):
p.requires_stop
with self.assertRaises(ParameterNotProvidedException):
p.get_value()
p._namespace = {'foo': foo, 'bar': bar, 'hugo': hugo}
self.assertTrue(p.requires_stop)
hugo = DummyParameter(5.2, requires_stop=False)
p._namespace = {'foo': foo, 'bar': bar, 'hugo': hugo, 'ilse': ilse}
self.assertFalse(p.requires_stop)
self.assertEqual(1.5, p.get_value())
def test_equality(self):
with self.assertWarns(DeprecationWarning):
p1 = MappedParameter(Expression("foo + 1"),
{'foo': ConstantParameter(3)})
p2 = MappedParameter(Expression("foo + 1"),
{'foo': ConstantParameter(4)})
p3 = MappedParameter(Expression("foo + 1"),
{'foo': ConstantParameter(3)})
self.assertEqual(p1, p3)
self.assertNotEqual(p1, p2)
def map_parameter_objects(
self, parameters: Dict[str, Parameter]) -> Dict[str, Parameter]:
"""Map parameter objects (instances of Parameter class) according to the defined mappings.
Args:
parameters: Dictionary with parameter objects
Returns:
A new dictionary with mapped parameter objects
"""
self._validate_parameters(parameters=parameters)
return {
parameter: MappedParameter(mapping_function, {
name: parameters[name]
for name in mapping_function.variables
})
for (parameter,
mapping_function) in self.__parameter_mapping.items()
}
def map_parameter_objects(
self,
parameters: Dict[str, Parameter],
volatile: Set[str] = frozenset()
) -> Dict[str, Parameter]:
"""Map parameter objects (instances of Parameter class) according to the defined mappings.
Args:
parameters: Dictionary with parameter objects
volatile(Optional): Forwarded to `validate_parameter_constraints`
Returns:
A new dictionary with mapped parameter objects
"""
self._validate_parameters(parameters=parameters, volatile=volatile)
return {
parameter: MappedParameter(mapping_function, {
name: parameters[name]
for name in mapping_function.variables
})
for (parameter,
mapping_function) in self.__parameter_mapping.items()
}
def map_parameters(
self, parameters: Dict[str, Union[Parameter, numbers.Real]]
) -> Dict[str, Parameter]:
"""Map parameter values according to the defined mappings.
Args:
parameters (Dict(str -> Parameter)): A mapping of parameter names to Parameter
objects/values.
Returns:
A new dictionary which maps parameter names to parameter values which have been
mapped according to the mappings defined for template.
"""
missing = set(self.__external_parameters) - set(parameters.keys())
if missing:
raise ParameterNotProvidedException(missing.pop())
self.validate_parameter_constraints(parameters=parameters)
if all(
isinstance(parameter, Parameter)
for parameter in parameters.values()):
return {
parameter: MappedParameter(mapping_function, {
name: parameters[name]
for name in mapping_function.variables
})
for (parameter,
mapping_function) in self.__parameter_mapping.items()
}
if all(
isinstance(parameter, numbers.Real)
for parameter in parameters.values()):
return {
parameter: mapping_function.evaluate_numeric(**parameters)
for parameter, mapping_function in
self.__parameter_mapping.items()
}
raise TypeError(
'Values of parameter dict are neither all Parameter nor Real')
def test_repr(self) -> None:
with self.assertWarns(DeprecationWarning):
p = MappedParameter(Expression("foo + bar * hugo"))
self.assertIsInstance(repr(p), str)
def test_repr(self) -> None:
p = MappedParameter(Expression("foo + bar * hugo"))
self.assertIsInstance(repr(p), str)