def test_numpy_parameter(self): name = 'dummy' data = np.array([1.1, 1.2, 1.3, 1.4]) alignment = np.array([0.01, 0.02, 0.03, 0.04]) misalignment = np.array([0.01, 0.02, 0.03]) with self.assertRaises(TypeError): pd = NumpyParameterData(1, data, alignment) with self.assertRaises(TypeError): pd = NumpyParameterData(name, 'hi', alignment) with self.assertRaises(TypeError): pd = NumpyParameterData(name, data, 'hi') with self.assertRaises(ValueError): pd = NumpyParameterData(name, data, misalignment) pd = NumpyParameterData(name, data, alignment) self.assertEqual(id(data), id(pd.get_data_as_numpy_array(pd.get_alignment()))) self.assertEqual(0, pd.get_data_as_numpy_array(np.array([0.05, 0.015])).size) self.assertEqual(np.array([1.2, 1.4]).all(), pd.get_data_as_numpy_array(np.array([0.04, 0.02])).all())
def write_parameters(self, write_id, values): if not isinstance(values, dict): raise TypeError("values must be dict type. Found %s" % type(values)) arr_len = -1 all_values_constant_over_time = True write_time = get_current_ntp_time() bad_keys = [] mutable_params = {} for k, v in values.iteritems(): if isinstance(v, NumpyParameterData): arr_len = v.get_data().shape[0] elif isinstance(v, np.ndarray): arr_len = v.shape[0] elif isinstance(v, ConstantOverTime): continue break if arr_len > 0: values[Span.ingest_time_str] = NumpyParameterData(Span.ingest_time_str, self.master_manager.parameter_metadata[Span.ingest_time_str].parameter_context.param_type.create_filled_array(arr_len, write_time)) for key, arr in values.iteritems(): if key not in self.value_list: raise KeyError("Parameter, %s, has not been initialized" % (key)) param_type = self.master_manager.parameter_metadata[key].parameter_context.param_type if isinstance(param_type, ParameterFunctionType): bad_keys.append(key) continue #TODO: throw error instead if isinstance(arr, np.ndarray): arr = NumpyParameterData(key, arr) values[key] = arr if not isinstance(arr, ParameterData): raise TypeError("Value for %s must implement <%s>, found <%s>" % (key, ParameterData.__name__, arr.__class__.__name__)) if not isinstance(arr, ConstantOverTime): if self.master_manager.parameter_metadata[key].parameter_context.param_type.validate_value_set(arr.get_data()): self.master_manager.parameter_metadata[key].read_only = False self.master_manager.parameter_metadata[key].flush() self.master_manager.parameter_metadata[key].read_only = True all_values_constant_over_time = False elif isinstance(arr, NumpyParameterData) and arr.get_data().shape[0] != arr_len: raise ValueError("Array size for %s is inconsistent. Expected %s elements, found %s." % (key, str(arr_len), str(arr.get_data().size))) min_val, max_val = self.value_list[key].get_statistics(arr) self.update_parameter_bounds(key, (min_val, max_val)) if param_type.is_mutable: mutable_params[key] = values[key] for key in bad_keys: values.pop(key) for key in mutable_params: values.pop(key) if len(mutable_params) > 0 and self.alignment_parameter in values: mutable_params[self.alignment_parameter] = values[self.alignment_parameter] mutable_params[Span.ingest_time_str] = values[Span.ingest_time_str] if not all_values_constant_over_time and self.alignment_parameter not in values: raise LookupError("Array must be supplied for parameter, %s, to ensure alignment" % self.alignment_parameter) write_span = False if len(values) > 1 and self.alignment_parameter in values: if len(values) == 2 and len(mutable_params) > 0: pass else: write_span = True elif all_values_constant_over_time: write_span = True if write_span: span = Span(write_id, self.master_manager.guid, values, compressors=self.value_list) span_table = SpanStorageFactory.get_span_storage_obj(self.storage_name) span_table.write_span(span) if len(mutable_params) > 2: self._write_mutable_params(mutable_params, write_id + '_mutable', self.master_manager.guid)