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