def row(self, column_name, time):
if column_name not in self.cache:
self.cache[column_name] = {}
res = Storage.select_interval(self.con,
self.start,
self.end,
column_name,
self.table_name,
without_none_value=False)
actual_timestamp = self.start
for row in res:
if row is None:
self.cache[column_name][actual_timestamp] = None
else:
self.cache[column_name][actual_timestamp] = float(row)
actual_timestamp += 1
if time in self.cache[column_name]:
value = self.cache[column_name][time]
else:
value = super(CachedRowWithIntervalSelector,
self).row(column_name, time)
if value is None:
t = DateTimeUtil.utc_timestamp_to_str(time, '%Y/%m/%d %H:%M:%S')
raise ValueError('empty value at %s' % t)
return value
def row(self, column_name, time):
if column_name not in self.cache:
self.cache[column_name] = {}
if time in self.cache[column_name]:
value = self.cache[column_name][time]
else:
start = time - self.half_window_size
end = time + self.half_window_size
res = Storage.select_interval(self.con, start, end, column_name, self.table_name,
without_none_value=False)
error = False
if res is None or None in res:
error = True
if error:
self.cache[column_name][time] = None
t = DateTimeUtil.utc_timestamp_to_str(time, '%Y/%m/%d %H:%M:%S')
raise ValueError('empty value at %s' % t)
x = []
y = []
for i in range(0, len(res)):
x.append(i)
y.append(res[i])
slope, intercept, _, _, _ = stats.linregress(x, y)
value = intercept + slope * self.half_window_size
self.cache[column_name][time] = value
if value is None:
t = DateTimeUtil.utc_timestamp_to_str(time, '%Y/%m/%d %H:%M:%S')
raise ValueError('empty value at %s' % t)
return value
def interval(self, column_name, start, end):
return Storage.select_interval(self.con, start, end, column_name,
self.table_name)
def prepare_derivation_lin_reg(con, events: list, intervals_before: list,
intervals_after: list, table_name: str,
precision: int, derivation_attr_name: str,
lin_window_size: tuple):
for i in range(0, len(events)):
event = events[i]
no_event_shift = event['no_event_time_shift']
start = event['e_start']['timestamp']
values1 = Storage.select_interval(con, start - lin_window_size[0],
start + lin_window_size[1],
derivation_attr_name, table_name)
values2 = Storage.select_interval(
con, start + no_event_shift - lin_window_size[0],
start + no_event_shift + lin_window_size[1],
derivation_attr_name, table_name)
if not values2 or not values1:
event['valid_event'] = False
continue
open_value = lin_reg(values1, lin_window_size[0] - 1)
no_event_open_value = lin_reg(values2, lin_window_size[0] - 1)
if no_event_open_value is None:
t = DateTimeUtil.utc_timestamp_to_str(start + no_event_shift,
'%Y-%m-%d %H:%M:%S')
logging.warning('no_event value is None: %s' % t)
# derivacia pred otvorenim okna
# generovanie derivacii medzi hodnou otvorenia okna a hodnotou niekde
# v minulosti, ktora je posunuta o zadany interval dozadu
for interval in intervals_before:
value_time = start - interval
v = Storage.select_interval(con,
value_time - lin_window_size[0],
value_time + lin_window_size[1],
derivation_attr_name, table_name)
if not v:
event['valid_event'] = False
break
value = lin_reg(v, lin_window_size[0] - 1)
derivation = None
if value is not None and value is not None:
derivation = round((open_value - value) / interval,
precision)
event['derivation']['before'].append(derivation)
# derivacia po otvoreni okna
# generovanie derviacii medzi hodnotou otvorenia okna a hodnotou niekde,
# v buducnosti, ktora je posunuta o zadany interval dopredu
for interval in intervals_after:
value_time = start + interval
v = Storage.select_interval(con,
value_time - lin_window_size[0],
value_time + lin_window_size[1],
derivation_attr_name, table_name)
if not v:
event['valid_event'] = False
break
value = lin_reg(v, lin_window_size[0] - 1)
derivation = None
if value is not None and value is not None:
derivation = round((value - open_value) / interval,
precision)
event['derivation']['after'].append(derivation)
# derivacia pred no_event
# generovanie derivacii medzi hodnou otvorenia okna a hodnotou niekde
# v minulostia, ktora je posunuta o zadany interval dozadu
# tento cas je posunuty este aj o posun danej udalosti
for interval in intervals_before:
value_time = start + no_event_shift - interval
v = Storage.select_interval(con,
value_time - lin_window_size[0],
value_time + lin_window_size[1],
derivation_attr_name, table_name)
if not v:
event['valid_event'] = False
break
value = lin_reg(v, lin_window_size[0] - 1)
derivation = None
if value is not None and value is not None and no_event_open_value is not None:
derivation = round(
(no_event_open_value - value) / interval, precision)
else:
event['valid_event'] = False
event['derivation']['no_event_before'].append(derivation)
# derivacia pred po no_event
# generovanie derivacii medzi hodnou otvorenia okna a hodnotou niekde
# v minulostia, ktora je posunuta o zadany interval dozadu
# tento cas je posunuty este aj o posun danej udalosti
for interval in intervals_after:
value_time = start + no_event_shift + interval
v = Storage.select_interval(con,
value_time - lin_window_size[0],
value_time + lin_window_size[1],
derivation_attr_name, table_name)
if not v:
event['valid_event'] = False
break
value = lin_reg(v, lin_window_size[0] - 1)
derivation = None
if value is not None and value is not None and no_event_open_value is not None:
derivation = round(
(value - no_event_open_value) / interval, precision)
else:
event['valid_event'] = False
event['derivation']['no_event_after'].append(derivation)
event['derivation']['intervals_before'] = intervals_before
event['derivation']['intervals_after'] = intervals_after
event['derivation']['intervals_no_event_before'] = intervals_before
event['derivation']['intervals_no_event_after'] = intervals_after