def write_cser(self, name, cser, overwrite=False, assume_exists=False, zero_represents=1, start_case=None, end_case=None): """write `cser` to the database as `name` as a case series. :Parameters: - `name` (string) : database key that the object will be written to - `cser` (ndarray) : 1-dimensional ndarray (or subclass of ndarray) object to be written. If `cser` is a MaskedArray, then masked values will be written as ND. - `overwrite (boolean, *[False]*) : If True, if `name` exists in the database it will be overwritten. If False, data will be added to series that already exist (data in `cser` will be given priority over pre-existing data in the db where there is overlap) - `assume_exists` (boolean, *[False]*) : If True, an error will be raised if the series does not exist. If False, the series will be created if it does not exist already. - `zero_represents` (int, *[1]*) : the case index for FAME that index zero in the array represents - `start_case` (int, *[None]*) : If None, data will be written from the start of `cser`. If specified, only data points on or after start_case will be written. - `end_case` (int, *[None]*) : If None, data will be written until the end of `cser`. If specified, only data points on or before end_case will be written. """ if not isinstance(cser, numpy.ndarray): raise ValueError("cser is not a valid ndarray") elif cser.ndim != 1: raise ValueError("FAME db only supports 1-dimensional arrays") exists = self.obj_exists(name) if assume_exists and not exists: raise DBError("%s does not exist" % name) if overwrite or not exists: create = True else: create = False fame_params = _fame_params_from_pyobj_cser(cser) fame_cls = fame_params['cls'] fame_type = fame_params['type'] fame_freq = fame_params['freq'] fame_basis = fame_params['basis'] fame_observed = fame_params['observed'] if hasattr(cser, "_data"): fame_data = cser._data if cser._mask is ma.nomask: fame_mask = numpy.zeros(fame_data.shape, dtype=numpy.bool_) else: fame_mask = cser._mask else: fame_data = cser fame_mask = numpy.zeros(fame_data.shape, dtype=numpy.bool_) if create: if exists: self.delete_obj(name) cf_create(self.dbkey, name, fame_cls, fame_freq, fame_type, fame_basis, fame_observed) def get_boundary_case(bcase, attr): if bcase is not None: idx = bcase - zero_represents if idx < 0 or idx > cser.size: raise ValueError("%s outside range of series" % attr) return bcase else: if cser.size == 0: return None else: if attr == 'start_case': return zero_represents elif attr == 'end_case': return zero_represents + cser.size - 1 else: raise ValueError("unexpected argument: %s " % attr) start_case = get_boundary_case(start_case, "start_case") end_case = get_boundary_case(end_case, "end_case") if start_case is not None: # convert integer types to floats since FAME does not have an integer type s = start_case - zero_represents e = end_case - zero_represents fame_data = fame_data[s:e+1] fame_mask = fame_mask[s:e+1] newType = fametype_tonumpy(fame_type) if fame_type >= 8: # date type fame_data = fame_data - date_value_adjust[fame_data.freq] elif newType != fame_data.dtype: fame_data = fame_data.astype(newType) cfame.write_series(self.dbkey, name, fame_data, fame_mask, start_case, end_case, fame_type, fame_freq)
def write_tser(self, name, tser, overwrite=False, assume_exists=False, start_date=None, end_date=None): """write `tser` to the database as `name` as a time series. :Parameters: - `name` (string) : database key that the object will be written to - `tser` (TimeSeries) : TimeSeries object to be written. Cannot have missing dates. Use fill_missing_dates first on your series if you suspect this is the situation. TimeSeries must be 1-dimensional - `overwrite (boolean, *[False]*) : If True, if `name` exists in the database it will be overwritten. If False, data will be added to series that already exist (data in `tser` will be given priority over pre-existing data in the db where there is overlap) - `assume_exists` (boolean, *[False]*) : If True, an error will be raised if the series does not exist. If False, the series will be created if it does not exist already. - `start_date` (Date, *[None]*) : If None, data will be written from the start of `tser`. If specified, only data points on or after start_date will be written. - `end_date` (Date, *[None]*) : If None, data will be written until the end of `tser`. If specified, only data points on or before end_date will be written. """ if not isinstance(tser, ts.TimeSeries): raise ValueError("tser is not a valid time series") elif tser.has_missing_dates(): raise ValueError("tser must not have any missing dates") elif tser.ndim != 1: raise ValueError("FAME db only supports 1-dimensional time series") exists = self.obj_exists(name) if assume_exists and not exists: raise DBError("%s does not exist" % name) if overwrite or not exists: create = True else: create = False fame_params = _fame_params_from_pyobj_tser(tser) fame_cls = fame_params['cls'] fame_type = fame_params['type'] fame_freq = fame_params['freq'] fame_basis = fame_params['basis'] fame_observed = fame_params['observed'] if create: if exists: self.delete_obj(name) cf_create(self.dbkey, name, fame_cls, fame_freq, fame_type, fame_basis, fame_observed) def get_boundary_date(bdate, attr): if bdate is not None: if bdate.freq != tser.freq: raise ValueError(attr+" frequency must be same as tser frequency") if tser.start_date > bdate or tser.end_date < bdate: raise ValueError(attr+" outside range of series") return bdate else: return getattr(tser, attr) start_date = get_boundary_date(start_date, "start_date") end_date = get_boundary_date(end_date, "end_date") if start_date is not None: towrite = tser[start_date:end_date+1] start_index = start_date.value end_index = end_date.value # convert integer types to floats since FAME does not have an integer type newType = fametype_tonumpy(fame_type) if fame_type >= 8: # date type fame_data = towrite._data - date_value_adjust[towrite._data.freq] elif newType != tser._data.dtype: fame_data = towrite._data.astype(newType) else: fame_data = towrite._data if towrite._mask is ma.nomask: fame_mask = numpy.zeros(towrite._data.shape, dtype=numpy.bool_) else: fame_mask = towrite._mask start_index -= date_value_adjust[towrite.freq] end_index -= date_value_adjust[towrite.freq] cfame.write_series(self.dbkey, name, fame_data, fame_mask, start_index, end_index, fame_type, fame_freq)