def tsa_group_by(self, datestring, tsa, subkeys, group_func): """ TODO: make this method static, inteval should be in tsa group given tsa by subkeys, and use group_func to aggregate data first all Timeseries will be aligned in time, to get proper points in timeline parameters: tsa <TimeseriesArrayLazy> subkey <tuple> could also be empty, to aggregate everything group_func <func> like lambda a,b : (a+b)/2 to get averages slotlength <int> interval in seconds to correct every timeseries to returns: <TimeseriesArrayLazy> """ # intermediated tsa tsa2 = TimeseriesArrayLazy(index_keys=subkeys, value_keys=tsa.value_keys, ts_key=tsa.ts_key, datatypes=tsa.datatypes) start_ts, _ = DataLogger.get_ts_for_datestring(datestring) ts_keyname = tsa.ts_key for data in tsa.export(): # align timestamp nearest_slot = round((data[ts_keyname] - start_ts) / self.__interval) data[ts_keyname] = int(start_ts + nearest_slot * self.__interval) #data[ts_keyname] = align_timestamp(data[ts_keyname]) tsa2.group_add(data, group_func) return tsa2
def import_tsa(self, datestring, tsa): """ store tsa given in parameter in global_cache to make the data available usually this could be modfied existing tsa extended by some keys, or filtered or ... the structure has to be predefined in meta data the tsa can afterwards be accessed via normal frontends (web, api) parameters: tsa <TimeseriesArrayLazy> object """ assert self.__index_keynames == tsa.index_keynames assert self.__value_keynames == tuple(tsa.value_keynames) cachedir = self.__get_cachedir(datestring) cachefilename = os.path.join(cachedir, TimeseriesArrayLazy.get_dumpfilename(tsa.index_keynames)) if not os.path.isfile(cachefilename): tsa.dump_split(cachedir) tsastats = TimeseriesArrayStats(tsa) tsastats.dump(cachedir) qantile = QuantileArray(tsa, tsastats) q_cachefilename = os.path.join(cachedir, "quantile.json") qantile.dump(open(q_cachefilename, "wb")) else: raise StandardError("TSA Archive %s exists already in cache" % cachefilename)
def load_tsa_raw(self, datestring, timedelta=0): """ read data from raw input files and return TimeseriesArrayLazy object parameters: datestring <str> isodate representation of date like 2015-12-31 timedelta <int> amount second to correct raw input timestamps returns: <TimeseriesArrayLazy> object wich holds all data of this day """ tsa = TimeseriesArrayLazy(self.__index_keynames, self.__value_keynames, datatypes=self.__datatypes) for rowdict in self.__get_raw_data_dict(datestring, timedelta): try: tsa.add(rowdict) except ValueError as exc: logging.exception(exc) logging.error("ValueError by adding this data to TimeseriesArrayLazy: %s", rowdict) raise exc except AssertionError as exc: logging.exception(exc) logging.error("AssertionError by adding this data to TimeseriesArrayLazy: %s", rowdict) raise exc return tsa
def fallback(): """ fallback method to use, if reading from cache data is not possible """ tsa = self.load_tsa_raw(datestring, timedelta) tsa.dump_split(cachedir) # save full data # read the data afterwards to make sure there is no problem, if validate is True: tsa = TimeseriesArrayLazy.load_split(cachedir, self.__index_keynames, filterkeys=filterkeys, index_pattern=index_pattern, datatypes=self.__datatypes) # also generate TSASTATS and dump to cache directory tsastats = TimeseriesArrayStats(tsa) # generate full Stats tsastats.dump(cachedir) # save # and at last but not least quantile qantile = QuantileArray(tsa, tsastats) cachefilename = os.path.join(cachedir, "quantile.json") qantile.dump(open(cachefilename, "wb")) # finally return tsa return tsa
def load_tsa(self, datestring, filterkeys=None, index_pattern=None, timedelta=0, cleancache=False, validate=False): """ caching version to load_tsa_raw if never called, get ts from load_tsa_raw, and afterwards dump_tsa on every consecutive call read from cached version use cleancache to remove caches parameters: datestring <str> filterkeys <tuple> or None default None index_pattern <str> or None default None timedelta <int> default 0 cleancache <bool> default False validate <bool> if data is read from raw, dump it after initail read, and reread it afterwards to make sure the stored tsa is OK thats an performance issue returns <TimeseriesArrayLazy> object read from cachefile or from raw data """ try: assert not_today(datestring) except AssertionError: raise DataLoggerLiveDataError("Reading from live data is not allowed") cachedir = self.__get_cachedir(datestring) cachefilename = os.path.join(cachedir, TimeseriesArrayLazy.get_dumpfilename(self.__index_keynames)) def fallback(): """ fallback method to use, if reading from cache data is not possible """ tsa = self.load_tsa_raw(datestring, timedelta) tsa.dump_split(cachedir) # save full data # read the data afterwards to make sure there is no problem, if validate is True: tsa = TimeseriesArrayLazy.load_split(cachedir, self.__index_keynames, filterkeys=filterkeys, index_pattern=index_pattern, datatypes=self.__datatypes) # also generate TSASTATS and dump to cache directory tsastats = TimeseriesArrayStats(tsa) # generate full Stats tsastats.dump(cachedir) # save # and at last but not least quantile qantile = QuantileArray(tsa, tsastats) cachefilename = os.path.join(cachedir, "quantile.json") qantile.dump(open(cachefilename, "wb")) # finally return tsa return tsa if not os.path.isfile(cachefilename): logging.info("cachefile %s does not exist, fallback read from raw data file", cachefilename) return fallback() if (os.path.isfile(cachefilename)) and (cleancache == True): logging.info("deleting cachefile %s and read from raw data file", cachefilename) os.unlink(cachefilename) return fallback() logging.debug("loading stored TimeseriesArrayLazy object file %s", cachefilename) try: tsa = TimeseriesArrayLazy.load_split(cachedir, self.__index_keynames, filterkeys=filterkeys, index_pattern=index_pattern, datatypes=self.__datatypes) return tsa except IOError: logging.error("IOError while reading from %s, using fallback", cachefilename) os.unlink(cachefilename) return fallback() except EOFError: logging.error("EOFError while reading from %s, using fallback", cachefilename) os.unlink(cachefilename) return fallback()