def test_NonExistentParameterError_withStringModel(self):
try:
raise errors.NonExistentParameterError("foo", 'iaf_neuron')
except errors.NonExistentParameterError as err:
self.assertEqual(err.model_name, 'iaf_neuron')
self.assertEqual(err.parameter_name, 'foo')
self.assertEqual(err.valid_parameter_names, ['unknown'])
assert len(str(err)) > 0
def __getattr__(self, name):
try:
val = self.__getattribute__(name)
except AttributeError:
try:
val = self.get_parameters()[name]
except KeyError:
raise errors.NonExistentParameterError(
name, self.__class__.__name__, self.get_parameter_names())
return val
def test_NonExistentParameterError_withStandardModel(self):
try:
raise errors.NonExistentParameterError("foo", cells.IF_cond_alpha)
except errors.NonExistentParameterError as err:
self.assertEqual(err.model_name, 'IF_cond_alpha')
self.assertEqual(err.parameter_name, 'foo')
self.assertEqual(err.valid_parameter_names, [
'cm', 'e_rev_E', 'e_rev_I', 'i_offset', 'tau_m', 'tau_refrac',
'tau_syn_E', 'tau_syn_I', 'v_reset', 'v_rest', 'v_thresh'
])
assert len(str(err)) > 0
def update(self, **parameters):
"""
Update the contents of the parameter space according to the
`(key, value)` pairs in ``**parameters``. All values will be turned into
lazy arrays.
If the :class:`ParameterSpace` has a schema, the keys and the data types
of the values will be checked against the schema.
"""
if self.schema:
for name, value in parameters.items():
try:
expected_dtype = self.schema[name]
except KeyError:
if self.component:
model_name = self.component.__name__
else:
model_name = 'unknown'
raise errors.NonExistentParameterError(
name,
model_name,
valid_parameter_names=self.schema.keys())
if issubclass(expected_dtype, ArrayParameter) and isinstance(
value, collections.Sized):
if len(value) == 0:
value = ArrayParameter([])
elif not isinstance(
value[0], ArrayParameter
): # may be a more generic way to do it, but for now this special-casing seems like the most robust approach
if isinstance(
value[0],
collections.Sized): # e.g. list of tuples
value = type(value)(
[ArrayParameter(x) for x in value])
else:
value = ArrayParameter(value)
try:
self._parameters[name] = LazyArray(value,
shape=self._shape,
dtype=expected_dtype)
except (TypeError, errors.InvalidParameterValueError):
raise errors.InvalidParameterValueError(
"For parameter %s expected %s, got %s" %
(name, expected_dtype, type(value)))
except ValueError as err:
raise errors.InvalidDimensionsError(
err
) # maybe put the more specific error classes into lazyarray
else:
for name, value in parameters.items():
self._parameters[name] = LazyArray(value, shape=self._shape)
def __getattr__(self, name):
if name == "set":
errmsg = "For current sources, set values using the parameter name directly, " \
"e.g. source.amplitude = 0.5, or use 'set_parameters()' " \
"e.g. source.set_parameters(amplitude=0.5)"
raise AttributeError(errmsg)
try:
val = self.__getattribute__(name)
except AttributeError:
try:
val = self.get_parameters()[name]
except KeyError:
raise errors.NonExistentParameterError(
name, self.__class__.__name__, self.get_parameter_names())
return val
def check_parameters(cls, supplied_parameters, with_defaults=False):
"""
Returns a parameter dictionary, checking that each
supplied_parameter is in the default_parameters and
converts to the type of the latter.
If with_defaults==True, parameters not in
supplied_parameters are in the returned dictionary
as in default_parameters.
"""
default_parameters = cls.default_parameters
if with_defaults:
parameters = copy.copy(default_parameters)
else:
parameters = {}
if supplied_parameters:
for k in supplied_parameters.keys():
if k in default_parameters.keys():
err_msg = "For %s in %s, expected %s, got %s (%s)" % \
(k, cls.__name__, type(default_parameters[k]),
type(supplied_parameters[k]), supplied_parameters[k])
# same type
if type(supplied_parameters[k]) == type(
default_parameters[k]):
parameters[k] = supplied_parameters[k]
# float and something that can be converted to a float
elif isinstance(default_parameters[k], float):
try:
parameters[k] = float(supplied_parameters[k])
except (ValueError, TypeError):
raise errors.InvalidParameterValueError(err_msg)
# list and something that can be transformed to a list
elif isinstance(default_parameters[k], list):
try:
parameters[k] = list(supplied_parameters[k])
except TypeError:
raise errors.InvalidParameterValueError(err_msg)
else:
raise errors.InvalidParameterValueError(err_msg)
else:
raise errors.NonExistentParameterError(
k, cls, cls.default_parameters.keys())
return parameters
