import re, thread import numpy import maskedarray as ma import timeseries as ts from timeseries import const as _c import cfame from const import * __all__ = [ 'FameDb', 'set_option', 'license_expires', 'DBError' ] def reverse_dict(d): return dict([(y, x) for x, y in d.iteritems()]) basis_map = { HBSUND:_c.FR_UND, HBSDAY:_c.FR_DAY, HBSBUS:_c.FR_BUS} basis_revmap = reverse_dict(basis_map) observed_map = { HOBUND:ts.check_observed("UNDEFINED"), HOBBEG:ts.check_observed("BEGINNING"), HOBEND:ts.check_observed("ENDING"), HOBAVG:ts.check_observed("AVERAGED"), HOBSUM:ts.check_observed("SUMMED"), HOBANN:"ANNUALIZED", #ts.check_observed("ANNUALIZED"), HOBFRM:"FORMULA", #ts.check_observed("FORMULA"), HOBHI:ts.check_observed("MAXIMUM"), HOBLO:ts.check_observed("MINIMUM")} observed_revmap = reverse_dict(observed_map) observed_revmap['HIGH'] = HOBHI observed_revmap['LOW'] = HOBLO def translate_basis(basis): "translate user specified basis to FAME constant" if isinstance(basis, str): freq = ts.check_freq(basis) try: return basis_revmap[freq] except KeyError: raise ValueError("Basis must be " + \ "'DAILY', 'BUSINESS', or 'UNDEFINED'") else: if basis in basis_map: return basis elif basis == _c.FR_DAY: return HBSDAY elif basis == _c.FR_BUS: return HBSBUS elif basis == _c.FR_UND: return HBSUND else: raise ValueError("Invalid Basis value") def translate_observed(observed): "translate user specified observed to FAME constant" if isinstance(observed, str): return observed_revmap[ts.check_observed(observed)] elif observed in (observed_map): return observed else: raise ValueError("Invalid Observed value") freq_map = { HDAILY:_c.FR_DAY, HBUSNS:_c.FR_BUS, HMONTH:_c.FR_MTH, HWKSUN:_c.FR_WKSUN, HWKMON:_c.FR_WKMON, HWKTUE:_c.FR_WKTUE, HWKWED:_c.FR_WKWED, HWKTHU:_c.FR_WKTHU, HWKFRI:_c.FR_WKFRI, HWKSAT:_c.FR_WKSAT, HSEC :_c.FR_SEC, HMIN :_c.FR_MIN, HHOUR :_c.FR_HR, HQTOCT:_c.FR_QTR, HQTNOV:_c.FR_QTR, HQTDEC:_c.FR_QTR, HANJAN:_c.FR_ANNJAN, HANFEB:_c.FR_ANNFEB, HANMAR:_c.FR_ANNMAR, HANAPR:_c.FR_ANNAPR, HANMAY:_c.FR_ANNMAY, HANJUN:_c.FR_ANNJUN, HANJUL:_c.FR_ANNJUL, HANAUG:_c.FR_ANNAUG, HANSEP:_c.FR_ANNSEP, HANOCT:_c.FR_ANNOCT, HANNOV:_c.FR_ANNNOV, HANDEC:_c.FR_ANNDEC } freq_revmap = reverse_dict(freq_map) freq_revmap[_c.FR_QTR] = HQTDEC date_value_adjust = { _c.FR_ANNJAN:1849, _c.FR_ANNFEB:1849, _c.FR_ANNMAR:1849, _c.FR_ANNAPR:1849, _c.FR_ANNMAY:1849, _c.FR_ANNJUN:1849, _c.FR_ANNJUL:1849, _c.FR_ANNAUG:1849, _c.FR_ANNSEP:1849, _c.FR_ANNOCT:1849, _c.FR_ANNNOV:1849, _c.FR_ANNDEC:1849, _c.FR_QTR:7396, _c.FR_MTH:22188, _c.FR_WKSUN:96477, _c.FR_WKMON:96477, _c.FR_WKTUE:96477, _c.FR_WKWED:96477, _c.FR_WKTHU:96477, _c.FR_WKFRI:96477, _c.FR_WKSAT:96477, _c.FR_BUS:482381, _c.FR_DAY:675333, _c.FR_HR:87648, _c.FR_MIN:5258880, _c.FR_SEC:315532800} def fametype_fromdata(data): """determine fame type code from a data object""" if isinstance(data, ts.DateArray) or isinstance(data, ts.Date): return freq_revmap[data.freq] elif hasattr(data, 'dtype'): dtypeStr = str(data.dtype) if dtypeStr[:5] == "float": if int(dtypeStr[5:]) > 32: return HPRECN else: return HNUMRC elif dtypeStr[:3] == "int": if int(dtypeStr[3:]) > 32: return HPRECN else: return HNUMRC elif dtypeStr[:4] == "uint": if int(dtypeStr[4:]) >= 32: return HPRECN else: return HNUMRC elif dtypeStr[:2] == "|S" or dtypeStr == 'object': return HSTRNG elif dtypeStr == "bool": return HBOOLN else: raise ValueError("Unsupported dtype for fame database: %s", dtypeStr) elif isinstance(data, str): return HSTRNG elif isinstance(data, (int, float)): return HPRECN elif isinstance(data, bool): return HBOOLN elif isinstance(data, list): return HNAMEL else: raise ValueError("Unrecognized data type") def fametype_tonumpy(fametype): if fametype >= 8: # date types return numpy.int32 elif fametype == HNAMEL: return None else: typeMap = { HNUMRC:numpy.float32, HBOOLN:numpy.int32, HSTRNG:numpy.object_, HPRECN:numpy.float64} return typeMap[fametype] class CaseInsensitiveDict(dict): def __init__(self, data={}): for i, v in data.iteritems(): self[i.upper()] = v def __getitem__(self, key): if hasattr(key, 'upper'): key = key.upper() return super(CaseInsensitiveDict, self).__getitem__(key) def __setitem__(self, key, item): if hasattr(key, 'upper'): key = key.upper() super(CaseInsensitiveDict, self).__setitem__(key, item) def _famedate_to_tsdate(fame_date, freq): "convert integer fame date to a timeseries Date" value = fame_date + date_value_adjust[freq] return ts.Date(freq=freq, value=value) def _fame_params_from_pyobj_scalar(pyobj): return { 'cls':HSCALA, 'freq':HUNDFX, 'type':fametype_fromdata(pyobj), 'basis':HBSUND, 'observed':HOBUND} def _fame_params_from_pyobj_tser(pyobj): if hasattr(pyobj, "observed"): fame_observed = observed_revmap[pyobj.observed] if fame_observed == 0: fame_observed = HOBEND else: fame_observed = HOBEND return { 'cls':HSERIE, 'freq':freq_revmap[pyobj.freq], 'type':fametype_fromdata(pyobj._data), 'basis':HBSDAY, 'observed':fame_observed} def _fame_params_from_pyobj_cser(pyobj): if hasattr(pyobj, "_data"): fame_data = pyobj._data else: fame_data = pyobj return { 'cls':HSERIE, 'freq':HCASEX, 'type':fametype_fromdata(fame_data), 'basis':HBSUND, 'observed':HOBUND} class DBError(Exception): pass class FameDb(object): """Fame database object. :Construction: x = FameDb(conn_str, mode='r') :Parameters: - `conn_str` (str) : valid connection string. Can be a physical path, or channel specification, etc. See FAME documentation on cfmopdb for valid connection strings. - `mode` (str, *['r']*) : method of access to the database. Can be one of the following: 'r' => read only 's' => shared 'o' => overwrite 'c' => create 'u' => update 'w' => write 'd' => direct Notes - For changes to be posted, you must explictly use the "post" or "close" methods (changes are posted on close).""" def __init__(self, conn_str, mode='r'): mode = mode.lower() if mode == 'r': intmode = HRMODE elif mode == 's': intmode = HSMODE elif mode == 'u': intmode = HUMODE elif mode == 'w': intmode = HWMODE elif mode == 'd': intmode = HDMODE elif mode == 'c': intmode = HCMODE elif mode == 'o': intmode = HOMODE else: raise ValueError, "Database access mode not supported." self.mode = mode self.dbkey = cf_open(conn_str, intmode) def read(self, name, start_date=None, end_date=None, start_case=None, end_case=None, max_string_len=65): """read specified object(s) from database :Parameters: - `name` (string or list of strings) : names of objects that will be read from the database - `start_date` (int, *[None]*) : Applies only when reading time series. If specified, only data points on or after `start_date` will be read. If None, data will be read from the first value of the series. - `end_date` (int, *[None]*) : Applies only when reading time series. If specified, only data points on or before `end_date` will be read. If None, data will be read to the last value of the series. - `start_case` (int, *[None]*) : Applies only when reading case series. If specified, only data points on or after `start_case` will be read. If None, data will be read starting from case index 1 - `end_case` (int, *[None]*) : Applies only when reading case series. If specified, only data points on or before `end_case` will be read. If None, data will be read to the last value of the series. - `max_string_len` (int, *[65]*) : Applies only when readings strings or series of strings. This is the maximum length of string that can be read. Lower values result in less memory usage, so you should specify this as low as is reasonable for your data. :Return: if `name` is a list of strings: case insensitive dictionary of the objects if `name` is a single string: object from database that is stored as `name`""" isSingle = False if isinstance(name, str): names = [name] isSingle = True else: names = name items = CaseInsensitiveDict() #default to -1. This will get the entire range _start_case = _end_case = -1 _start_date = _end_date = -1 range_freq = None if start_date is not None: _start_date = start_date.value - date_value_adjust[start_date.freq] range_freq = freq_revmap[start_date.freq] if end_date is not None: if start_date is not None and start_date.freq != end_date.freq: raise ValueError("start_date and end_date must be same frequency") _end_date = end_date.value - date_value_adjust[end_date.freq] if range_freq is None: range_freq = freq_revmap[end_date.freq] if start_case is not None: _start_case = start_case if end_case is not None: _end_case = end_case if len(set([_start_case, _end_case, _start_date, _end_date, -1])) != 1: checkFreq = True else: checkFreq = False for objName in names: objName = objName.upper() if checkFreq: objFreq = self.obj_size(objName)['freq'] if objFreq == range_freq: start_index, end_index = _start_date, _end_date elif objFreq == HCASEX: start_index, end_index = _start_case, _end_case else: start_index, end_index = -1, -1 else: start_index, end_index = -1, -1 result = cf_read(self.dbkey, objName, start_index, end_index, max_string_len) if result['type'] == HBOOLN: numpyType = numpy.bool_ else: numpyType = fametype_tonumpy(result['type']) if result['type'] == HNAMEL: pyObj = [x for x in result['data'][1:-1].split(", ") \ if x != ''] elif result['class'] == HSCALA: if isinstance(result['data'], str): if result['mask']: pyObj = None else: pyObj = result['data'] else: if result['mask'][0]: pyObj = None else: pyObj = result['data'][0] if result['type'] >= 8: # date type value = pyObj+ \ date_value_adjust[freq_map[result['type']]] pyObj = ts.Date( freq=freq_map[result['type']], value=value) else: pyObj = numpyType(pyObj) elif result['class'] == HSERIE: if 'data' in result: vals = result['data'] mask = result['mask'] if not mask.any(): mask = ma.nomask else: vals = [] mask = ma.nomask if result['type'] >= 8: # date type valadj = date_value_adjust[freq_map[result['type']]] if len(vals) > 0: vals += valadj data = ts.DateArray(vals, freq=freq_map[result['type']]) else: data = numpy.array(vals, dtype=numpyType) if result['freq'] == HCASEX: pyObj = ma.array(data, mask=mask) else: observed = observed_map[result['observed']] freq = freq_map[result['freq']] if 'data' in result: start_date = ts.Date( freq=freq, value=result['startindex']+date_value_adjust[freq]) else: start_date = None pyObj = ts.time_series(data, freq=freq, start_date=start_date, observed=observed, mask=mask) items[objName] = pyObj if isSingle: return items.values()[0] return items #.............................................................................. def write_dict(self, objdict, overwrite=False, assume_exists=False, start_date=None, end_date=None, zero_represents=1, start_case=None, end_case=None): """for each key, value pair in the dictionary `objdict` write value to the database as key, as appropriate type (calls FameDb.write on each key, value pair) :Parameters: - `objdict` (dict) : dictionary of objects to be written. Object names for keys and objects to be written for values - `overwrite` (boolean, *[False]*) : See documentation for write_tser and write_cser - `assume_exists` (boolean, *[False]*) : See documentation for write_tser and write_cser - `start_date` (Date, *[None]*) : See documentation for write_tser - `end_date` (Date, *[None]*) : See documentation for write_tser - `zero_represents` (int, *[1]*) : See documentation for write_cser - `start_case` (int, *[None]*) : See documentation for write_cser - `end_case` (int, *[None]*) : See documentation for write_cser """ for key, obj in objdict.iteritems(): self.write(key, obj, overwrite=overwrite, assume_exists=assume_exists, start_date=start_date, end_date=end_date, zero_represents=zero_represents, start_case=start_case, end_case=end_case) #.............................................................................. def write_tser_dict(self, objdict, overwrite=False, assume_exists=False, start_date=None, end_date=None): """for each key, value pair in the dictionary `objdict` write value to the database as key, as a time series (calls FameDb.write_tser on each key, value pair) :Parameters: - `objdict` (dict) : dictionary of TimeSeries objects to be written. Object names for keys and TimeSeries objects for values - `overwrite` (boolean, *[False]*) : See documentation for write_tser - `assume_exists` (boolean, *[False]*) : See documentation for write_tser - `start_date` (Date, *[None]*) : See documentation for write_tser - `end_date` (Date, *[None]*) : See documentation for write_tser """ for key, obj in objdict.iteritems(): self.write_tser(key, obj, overwrite=overwrite, assume_exists=assume_exists, start_date=start_date, end_date=end_date) #.............................................................................. def write_cser_dict(self, objdict, overwrite=False, assume_exists=False, zero_represents=1, start_case=None, end_case=None): """for each key, value pair in the dictionary `objdict` write value to the database as key, as a case series (calls FameDb.write_tser on each key, value pair) :Parameters: - `objdict` (dict) : dictionary of arrays to be written as Case Series. Object names for keys and arrays for values - `overwrite` (boolean, *[False]*) : See documentation for write_cser - `assume_exists` (boolean, *[False]*) : See documentation for write_cser - `zero_represents` (int, *[1]*) : See documentation for write_cser - `start_case` (int, *[None]*) : See documentation for write_cser - `end_case` (int, *[None]*) : See documentation for write_cser """ for key, obj in objdict.iteritems(): self.write_cser(key, obj, overwrite=overwrite, assume_exists=assume_exists, zero_represents=zero_represents, start_case=start_case, end_case=end_case) #.............................................................................. def write_scalar_dict(self, objdict): """for each key, value pair in the dictionary `objdict` write value to the database as key, as a scalar (calls FameDb.write_scalar on each key, value pair) :Parameters: - `objdict` (dict) : dictionary of items to be written as scalars. Object names for keys and scalar items for values """ for key, obj in objdict.iteritems(): self.write_scalar(key, obj) #.............................................................................. def write(self, name, pyobj, overwrite=False, assume_exists=False, start_date=None, end_date=None, zero_represents=1, start_case=None, end_case=None): """wrapper for write_tser, write_cser, and write_scalar which chooses appropriate method by inspecting `pyobj` :Parameters: - `name` (string) : database key that the object will be written to - `pyobj` (object) : any valid object that can be written by write_scalar, write_tser, or write_cser - `overwrite` (boolean, *[False]*) : See documentation for write_tser and write_cser - `assume_exists` (boolean, *[False]*) : See documentation for write_tser and write_cser - `start_date` (Date, *[None]*) : See documentation for write_tser - `end_date` (Date, *[None]*) : See documentation for write_tser - `zero_represents` (int, *[1]*) : See documentation for write_cser - `start_case` (int, *[None]*) : See documentation for write_cser - `end_case` (int, *[None]*) : See documentation for write_cser """ if isinstance(pyobj, ts.TimeSeries): self.write_tser(name, pyobj, overwrite=overwrite, assume_exists=assume_exists, start_date=start_date, end_date=end_date) elif isinstance(pyobj, numpy.ndarray) and pyobj.ndim == 1: self.write_cser(name, pyobj, overwrite=overwrite, assume_exists=assume_exists, zero_represents=zero_represents, start_case=start_case, end_case=end_case) else: self.write_scalar(name, pyobj) #.............................................................................. 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) #.............................................................................. 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_scalar(self, name, scalar): """write `scalar` to the database as `name` as a scalar object. If an object already exists in the database named as `name` then it is over-written, otherwise it is created. :Parameters: - `name` (string) : database key that the object will be written to - `scalar` : one of the following: string, numpy scalar, int, float, list of strings (for name lists), Date, boolean""" fame_params = _fame_params_from_pyobj_scalar(scalar) fame_type = fame_params['type'] if isinstance(scalar, ts.Date): fame_data = numpy.int32(scalar.value - date_value_adjust[scalar.freq]) elif hasattr(scalar, "dtype"): if scalar.ndim != 0: raise ValueError("received non-scalar data") newType = fametype_tonumpy(fame_type) if newType != scalar.dtype: fame_data = scalar.astype(newType) else: fame_data = scalar elif fame_type == HSTRNG: fame_data = scalar elif fame_type == HPRECN: fame_data = numpy.float64(scalar) elif fame_type == HBOOLN: fame_data = numpy.int32(scalar) elif fame_type == HNAMEL: fame_data = "{" + ", ".join(scalar) + "}" else: raise ValueError("Unrecognized data type") if self.obj_exists(name): self.delete_obj(name) cf_create(self.dbkey, name, fame_params['cls'], fame_params['freq'], fame_params['type'], fame_params['basis'], fame_params['observed']) # convert integer types to floats since FAME does not have an integer type newType = fametype_tonumpy(fame_type) if hasattr(fame_data, 'dtype') and newType != fame_data.dtype: fame_data = fame_data.astype(newType) if fame_type == HNAMEL: cf_write_namelist(self.dbkey, name, fame_data) else: cf_write_scalar(self.dbkey, name, fame_data, fame_type) #.............................................................................. def delete_obj(self, name, must_exist=True): """Deletes the specified object(s) from the database :Parameters: - `name` (string of list of strings) : name of object(s) to delete from database - `must_exist` (boolean, *[True]*) : If True, an error will be raised if you try to delete an object that does not exists. If False, deletion will only be attempted for objects that actually exist, and other entries will be ignored. """ if isinstance(name, str): name = [name] [cf_delete_obj(self.dbkey, n) for n in name if must_exist or self.obj_exists(n)] def _create_obj(self, name, cls, type, freq=None, basis=None, observed=None): """create object in database with specified attributes as `name`. You must use the fame constants defined in mapping.py for each of the parameters. Generally speaking, it is easier to use initialize_obj with a prototype object. """ if cls not in (HSERIE, HSCALA): raise ValueError("unrecognized object class: "+str(cls)) if freq is None: if cls == HSCALA: freq = HUNDFX else: raise ValueError("freq must be specified for series") if freq in (HUNDFX, HCASEX): basis = HBSUND observed = HOBUND else: if basis is None: basis = HBSDAY if observed is None: observed = HOBEND cf_create(self.dbkey, name, cls, freq, type, basis, observed) def initialize_obj(self, name, pyobj): """initialize object of appropriate type in database based on the python object `pyobj` as `name`. Does not write any data to the database, simply initializes the object in the database.""" if isinstance(pyobj, ts.TimeSeries): param_func = _fame_params_from_pyobj_tser elif isinstance(pyobj, numpy.ndarray): param_func = _fame_params_from_pyobj_cser else: param_func = _fame_params_from_pyobj_scalar fame_params = param_func(pyobj) cf_create(self.dbkey, name, fame_params['cls'], fame_params['freq'], fame_params['type'], fame_params['basis'], fame_params['observed']) def rename_obj(self, name, new_name): """rename fame object in database""" cf_rename_obj(self.dbkey, name, new_name) def copy_obj(self, target_db, source_name, target_name=None): """copy fame object to another destination""" if target_name is None: target_name = source_name cf_copy(self.dbkey, target_db.dbkey, source_name, target_name) #.............................................................................. def set_obj_desc(self, name, desc): "set 'description' attribute of object in database" cf_set_obj_desc(self.dbkey, name, desc) def set_obj_doc(self, name, doc): "set 'documentation' attribute of object in database" cf_set_obj_doc(self.dbkey, name, doc) def set_obj_basis(self, name, basis): "set 'basis' attribute of object in database" basis = translate_basis(basis) cf_set_obj_basis(self.dbkey, name, basis) def set_obj_observed(self, name, observed): "set 'observed' attribute of object in database" observed = translate_observed(observed) cf_set_obj_observed(self.dbkey, name, observed) #.............................................................................. def _whats(self, name): """Preforms a fame "whats" command on the provided name Note: Returns FAME constants which are not directly interpretable in the context of the timeseries module. For this reason, it is recommended that you use the obj_* methods to retrieve the desired information about an object. """ return cf_whats(self.dbkey, name) def __ser_date(self, name, date_type): """helper method for start_date and end_date""" obj_sz = self.obj_size(name) fame_freq = obj_sz['freq'] if fame_freq == 0: return None try: ts_freq = freq_map[obj_sz['freq']] except KeyError: raise DBError("unsupported FAME frequency: %i", fame_freq) if obj_sz[date_type+'_year'] == -1: return None annDate = ts.Date(freq='A', year=obj_sz[date_type+'_year']) return annDate.asfreq(ts_freq, relation='BEFORE') + (obj_sz[date_type+'_period'] - 1) def obj_size(self, name): """basic information about the size of an object in a database""" return cf_obj_size(self.dbkey, name) def obj_desc(self, name): """get desc attribute for an object""" return self._whats(name)['desc'] def obj_doc(self, name): """get doc attribute for an object""" return self._whats(name)['doc'] def obj_exists(self, name): return cf_exists(self.dbkey, name) def obj_freq(self, name): """get frequency of a FAME time series object in the database""" obj_sz = self.obj_size(name) fame_freq = obj_sz['freq'] if fame_freq == 0: return None return freq_map[obj_sz['freq']] def obj_basis(self, name): """get basis attribute of a FAME time series object in the database""" return self._whats(name)['basis'] def obj_observed(self, name): """get observed attribute of a FAME time series object in the database""" return observed_map[self._whats(name)['observ']] def obj_start_date(self, name): """get start_date of a FAME time series object""" return self.__ser_date(name, 'start') def obj_end_date(self, name): """get end_date of a FAME time series object""" return self.__ser_date(name, 'end') def obj_created(self, name): "get 'created' attribute of object in database" fame_date = cf_get_obj_attr(self.dbkey, name, "CREATED") return _famedate_to_tsdate(fame_date, _c.FR_SEC) def obj_modified(self, name): "get 'modified' attribute of object in database" fame_date = cf_get_obj_attr(self.dbkey, name, "MODIFIED") return _famedate_to_tsdate(fame_date, _c.FR_SEC) #.............................................................................. def db_desc(self): "get 'description' attribute of database" return cf_get_db_attr(self.dbkey, "DESC") def db_doc(self): "get 'doc' attribute of database" return cf_get_db_attr(self.dbkey, "DOC") def db_created(self): "get 'created' attribute of database" fame_date = cf_get_db_attr(self.dbkey, "CREATED") return _famedate_to_tsdate(fame_date, _c.FR_SEC) def db_modified(self): "get 'modified' attribute of database" fame_date = cf_get_db_attr(self.dbkey, "MODIFIED") return _famedate_to_tsdate(fame_date, _c.FR_SEC) def db_is_open(self): "returns True if database is open. False otherwise" return cf_get_db_attr(self.dbkey, "ISOPEN") def set_db_desc(self, desc): "set description attribute of database" cf_set_db_desc(self.dbkey, desc) def set_db_doc(self, doc): "set doc attribute of database" cf_set_db_doc(self.dbkey, doc) #.............................................................................. def wildlist(self, exp, wildonly=False): """performs a wildlist lookup on the database, using Fame syntax ("?" and "^"), returns a normal python list of strings""" res = cf_wildlist(self.dbkey, exp) if wildonly: exp = exp.replace("?", "(.*)") exp = exp.replace("^", "(.)") exp = exp.replace("$","\$") regex = re.compile(exp) res = ["".join(regex.match(res[i]).groups()) \ for i in range(len(res))] return res #.............................................................................. def close(self): """Closes the database. Changes will be posted.""" if self.db_is_open(): cf_close(self.dbkey) def post(self): cf_post(self.dbkey) def restore(self): """Discard any changes made to the database since it was last opened or posted.""" cf_restore(self.dbkey) class cFameCall: """wrapper for cfame functions that acquires and releases a resource lock. This is needed because the Fame C api is not thread safe.""" fameLock = thread.allocate_lock() def __init__ (self, func): self.f = func self.__doc__ = getattr(func, "__doc__", str(func)) self.__name__ = getattr(func, "__name__", str(func)) def __call__ (self, *args, **kwargs): "Execute the call behavior." tmp = self.fameLock.acquire() try: result = self.f(*args, **kwargs) self.fameLock.release() except: self.fameLock.release() raise return result cf_open = cFameCall(cfame.open) cf_set_option = cFameCall(cfame.set_option) cf_close = cFameCall(cfame.close) cf_post = cFameCall(cfame.post) cf_restore = cFameCall(cfame.restore) cf_obj_size = cFameCall(cfame.obj_size) cf_whats = cFameCall(cfame.whats) cf_delete_obj = cFameCall(cfame.delete_obj) cf_create = cFameCall(cfame.create) cf_read = cFameCall(cfame.read) cf_write_scalar = cFameCall(cfame.write_scalar) cf_write_series = cFameCall(cfame.write_series) cf_write_namelist = cFameCall(cfame.write_namelist) cf_wildlist = cFameCall(cfame.wildlist) cf_exists = cFameCall(cfame.exists) cf_get_db_attr = cFameCall(cfame.get_db_attr) cf_get_obj_attr = cFameCall(cfame.get_obj_attr) cf_copy = cFameCall(cfame.copy) cf_rename_obj = cFameCall(cfame.rename_obj) cf_license_expires = cFameCall(cfame.license_expires) cf_set_db_desc = cFameCall(cfame.set_db_desc) cf_set_db_doc = cFameCall(cfame.set_db_doc) cf_set_obj_desc = cFameCall(cfame.set_obj_desc) cf_set_obj_doc = cFameCall(cfame.set_obj_doc) cf_set_obj_basis = cFameCall(cfame.set_obj_basis) cf_set_obj_observed = cFameCall(cfame.set_obj_observed) set_option = cf_set_option set_option.__doc__ = \ """Set an option in the C HLI. See the FAME documentation for cfmsopt for a listing of allowable option settings. :Parameters: - option (str) : name of the option to set - setting (str) : value of the option to set :Example: set_option("DBSIZE", "LARGE") """ def license_expires(): """get date that license expires on""" fame_date = cf_license_expires() adj_val = date_value_adjust[_c.FR_DAY] return ts.Date(freq=_c.FR_DAY, value=fame_date+adj_val)