def test_interval_all_normal_value(self):
data = [1, 2, 1, 2, 4, 1, 2, 4, 5, 6]
data = pd.Series(data)
center = 4
window_size = 2
result = [1, 2, 4, 1, 2]
self.assertEqual(list(utils.get_interval(data, center, window_size)), result)
def do_fit(self, dataframe: pd.DataFrame,
labeled_segments: List[AnalyticSegment],
deleted_segments: List[AnalyticSegment],
learning_info: LearningInfo) -> None:
data = utils.cut_dataframe(dataframe)
data = data['value']
last_pattern_center = self.state.pattern_center
self.state.pattern_center = utils.remove_duplicates_and_sort(
last_pattern_center + learning_info.segment_center_list)
self.state.pattern_model = utils.get_av_model(
learning_info.patterns_list)
convolve_list = utils.get_convolve(self.state.pattern_center,
self.state.pattern_model, data,
self.state.window_size)
correlation_list = utils.get_correlation(self.state.pattern_center,
self.state.pattern_model,
data, self.state.window_size)
del_conv_list = []
delete_pattern_timestamp = []
for segment in deleted_segments:
del_mid_index = segment.center_index
delete_pattern_timestamp.append(segment.pattern_timestamp)
deleted_pat = utils.get_interval(data, del_mid_index,
self.state.window_size)
deleted_pat = utils.subtract_min_without_nan(deleted_pat)
del_conv_pat = scipy.signal.fftconvolve(deleted_pat,
self.state.pattern_model)
if len(del_conv_pat): del_conv_list.append(max(del_conv_pat))
self.state.convolve_min, self.state.convolve_max = utils.get_min_max(
convolve_list, self.state.window_size / 3)
self.state.conv_del_min, self.state.conv_del_max = utils.get_min_max(
del_conv_list, self.state.window_size)
def do_fit(self, dataframe: pd.DataFrame, labeled_segments: list,
deleted_segments: list, learning_info: dict) -> None:
data = utils.cut_dataframe(dataframe)
data = data['value']
window_size = self.state['WINDOW_SIZE']
last_pattern_center = self.state.get('pattern_center', [])
self.state['pattern_center'] = list(
set(last_pattern_center + learning_info['segment_center_list']))
self.state['pattern_model'] = utils.get_av_model(
learning_info['patterns_list'])
convolve_list = utils.get_convolve(self.state['pattern_center'],
self.state['pattern_model'], data,
window_size)
correlation_list = utils.get_correlation(self.state['pattern_center'],
self.state['pattern_model'],
data, window_size)
height_list = learning_info['patterns_value']
del_conv_list = []
delete_pattern_width = []
delete_pattern_height = []
delete_pattern_timestamp = []
for segment in deleted_segments:
del_min_index = segment.center_index
delete_pattern_timestamp.append(segment.pattern_timestamp)
deleted = utils.get_interval(data, del_min_index, window_size)
deleted = utils.subtract_min_without_nan(deleted)
del_conv = scipy.signal.fftconvolve(deleted,
self.state['pattern_model'])
if len(del_conv): del_conv_list.append(max(del_conv))
delete_pattern_height.append(utils.find_confidence(deleted)[1])
delete_pattern_width.append(utils.find_width(deleted, False))
self._update_fiting_result(self.state, learning_info['confidence'],
convolve_list, del_conv_list, height_list)
def test_interval_wrong_ws(self):
data = [1, 2, 4, 1, 2, 4]
data = pd.Series(data)
center = 3
window_size = 6
result = [1, 2, 4, 1, 2, 4]
self.assertEqual(list(utils.get_interval(data, center, window_size)), result)
def do_fit(
self,
dataframe: pd.DataFrame,
labeled_segments: List[AnalyticSegment],
deleted_segments: List[AnalyticSegment],
learning_info: LearningInfo
) -> None:
data = utils.cut_dataframe(dataframe)
data = data['value']
self.state.pattern_center = list(set(self.state.pattern_center + learning_info.segment_center_list))
self.state.pattern_model = utils.get_av_model(learning_info.patterns_list)
convolve_list = utils.get_convolve(self.state.pattern_center, self.state.pattern_model, data, self.state.window_size)
correlation_list = utils.get_correlation(self.state.pattern_center, self.state.pattern_model, data, self.state.window_size)
height_list = learning_info.patterns_value
del_conv_list = []
delete_pattern_width = []
delete_pattern_height = []
delete_pattern_timestamp = []
for segment in deleted_segments:
delete_pattern_timestamp.append(segment.pattern_timestamp)
deleted = utils.get_interval(data, segment.center_index, self.state.window_size)
deleted = utils.subtract_min_without_nan(deleted)
del_conv = scipy.signal.fftconvolve(deleted, self.state.pattern_model)
if len(del_conv):
del_conv_list.append(max(del_conv))
delete_pattern_height.append(utils.find_confidence(deleted)[1])
self._update_fiting_result(self.state, learning_info.confidence, convolve_list, del_conv_list, height_list)
def get_parameters_from_segments(self, dataframe: pd.DataFrame, labeled: List[dict], deleted: List[dict], model: ModelType) -> dict:
logging.debug('Start parsing segments')
learning_info = LearningInfo()
data = dataframe['value']
for segment in labeled:
confidence = utils.find_confidence(segment.data)[0]
learning_info.confidence.append(confidence)
segment_center = segment.center_index
learning_info.segment_center_list.append(segment_center)
learning_info.pattern_timestamp.append(segment.pattern_timestamp)
aligned_segment = utils.get_interval(data, segment_center, self.state.window_size)
aligned_segment = utils.subtract_min_without_nan(aligned_segment)
if len(aligned_segment) == 0:
logging.warning('cant add segment to learning because segment is empty where segments center is: {}, window_size: {}, and len_data: {}'.format(
segment_center, self.state.window_size, len(data)))
continue
learning_info.patterns_list.append(aligned_segment)
# TODO: use Triangle/Stair types
if model == ModelType.PEAK or model == ModelType.TROUGH:
learning_info.pattern_height.append(utils.find_confidence(aligned_segment)[1])
learning_info.patterns_value.append(aligned_segment.values.max())
if model == ModelType.JUMP or model == ModelType.DROP:
pattern_height, pattern_length = utils.find_parameters(segment.data, segment.from_index, model.value)
learning_info.pattern_height.append(pattern_height)
learning_info.pattern_width.append(pattern_length)
learning_info.patterns_value.append(aligned_segment.values[self.state.window_size])
logging.debug('Parsing segments ended correctly with learning_info: {}'.format(learning_info))
return learning_info
def __init__(self,
context,
path,
pd_path=None,
name=None,
loglevel=logging.INFO,
**kwargs):
self.context = context
self.path = os.path.expanduser(path)
if not name:
name = context
self.config = config.Config.instance()
lazy_write = utils.get_interval(self.config, "LAZY WRITE", (context))
self.pd_filename = f".cb.{context}-lite.json.bz2"
if pd_path:
pd_file = f"{pd_path}/{self.pd_filename}"
else:
pd_file = f"{self.path}/{self.pd_filename}"
super().__init__(pd_file, lazy_write=lazy_write)
self.logger = logging.getLogger(logger_str(__class__) + " " + name)
self.logger.setLevel(loglevel)
self.ignored_suffixes = {}
self.stat = stats.Statistic(buckets=(0, 5, 10, 30))
self.report_timer = elapsed.ElapsedTimer()
def _drop_incorrect_intervals(self):
"""
去除航信数据中时间间隔不为1分钟的数据点
"""
ts_timestamp_array = self.dataFrame["timestamp"].values
diffs = np.diff(ts_timestamp_array)
# TODO 后续优化可把 ！= 60 改为 % 60 ！= 0，以及如何适应间隔不是60的情况
self.interval = get_interval(ts_timestamp_array)
diffs_where = np.where(diffs != self.interval)[0]
remove_list = []
for i in diffs_where:
if i not in remove_list:
start_index = i
end_index = i + 1
if end_index == (len(self.dataFrame) - 1):
remove_list.append(end_index)
break
while ((ts_timestamp_array[end_index] -
ts_timestamp_array[end_index - 1]) != self.interval):
remove_list.append(end_index)
end_index = end_index + 1
gap = ts_timestamp_array[end_index] - ts_timestamp_array[start_index]
add_all = (self.interval - gap % self.interval) % self.interval
self.dataFrame.loc[end_index:, ["timestamp"]] += add_all
self.dataFrame = self.dataFrame.drop(remove_list)
self.dataFrame = self.dataFrame.reset_index(drop=True)
def ifr2(ticker):
yf_ticker = escape(ticker) + ".SA"
start, end = get_interval(50)
df = get_data(tickers=yf_ticker,
columns=["Open", "High", "Adj Close"],
start=start,
end=end)
ifr2_df = rsi(df, "Adj Close", 2)
return {"ifr2": int(round(ifr2_df[-1]))}
def detect(ts_data, ts_timestamp):
ts_data = is_array(ts_data)
ts_timestamp = is_array(ts_timestamp)
ts_data_ = ts_data - np.mean(ts_data)
lag, acf = interpolated_acf(ts_timestamp, ts_data_)
# TODO: 当使用csv_test.csv时，出现detected_period为non的情况
detected_period = dominant_period(lag, acf, plot=False)
interval = int(get_interval(ts_timestamp))
return int(detected_period // interval)
def indicators():
tickers = get_tickers('IBOV')
start, end = get_interval(365)
df = get_data(
tickers=tickers,
columns=["Open", "High", "Low", "Adj Close"],
start=start,
end=end,
)
ibov = get_data(tickers="^BVSP",
columns=["Adj Close"],
start=start,
end=end)
all_rsi = get_rsi_info(df.copy(), tickers)
all_stochastic = get_stochastic_info(df.copy(), tickers)
all_beta = get_beta_info(df.copy(), tickers, ibov["Adj Close"])
indicators = {}
for ticker in tickers:
ticker = ticker.replace(".SA", "")
# Get nested data
price = all_rsi[ticker]["price"]
variation = all_rsi[ticker]["variation"]
mme80_is_up = all_stochastic[ticker]["mme80_is_up"]
mm50_is_up = all_rsi[ticker]["mm50_is_up"]
beta = all_beta[ticker]["beta"]
corr = all_beta[ticker]["corr"]
std_asset = all_beta[ticker]["std_asset"]
std_bench = all_beta[ticker]["std_bench"]
# Delete unnecessary data
del all_rsi[ticker]["price"]
del all_rsi[ticker]["variation"]
del all_rsi[ticker]["mm50_is_up"]
del all_stochastic[ticker]["mme80_is_up"]
del all_stochastic[ticker]["price"]
del all_stochastic[ticker]["variation"]
indicators[ticker] = {
"price": price,
"variation": variation,
"mme80_is_up": mme80_is_up,
"mm50_is_up": mm50_is_up,
"beta": beta,
"corr": corr,
"std_asset": std_asset,
"std_bench": std_bench,
"rsi": all_rsi[ticker],
"stochastic": all_stochastic[ticker],
}
return jsonify(indicators)
def api():
tickers = get_tickers('IBOV')
start, end = get_interval(365)
df = get_data(tickers=tickers,
columns=["Open", "High", "Adj Close"],
start=start,
end=end)
all_rsi = get_rsi_info(df, tickers)
return jsonify(all_rsi)
def get_correlation(segments: list, av_model: list, data: pd.Series, window_size: int) -> list:
labeled_segment = []
correlation_list = []
p_value_list = []
for segment in segments:
labeled_segment = utils.get_interval(data, segment, window_size)
labeled_segment = utils.subtract_min_without_nan(labeled_segment)
labeled_segment = utils.check_nan_values(labeled_segment)
correlation = pearsonr(labeled_segment, av_model)
correlation_list.append(correlation[0])
p_value_list.append(correlation[1])
return correlation_list
def _get_interval(self):
self.ts_interval = get_interval(self.ts_timestamp_array)
self.ts_num = np.ceil(
(self.ts_timestamp_array[-1] - self.ts_timestamp_array[0]) /
self.ts_interval) + 1
print(
'''the time series in file : 所给数据时间区间内应有数据点个数 = %d,
实际数据点个数 = %d,
缺失个数 = %d,
数据采样间隔 = %d seconds''' %
(int(self.ts_num), len(self.ts_timestamp_array), int(self.ts_num) -
len(self.ts_timestamp_array), self.ts_interval))
def all_stochastic():
tickers = get_tickers('IBOV')
start, end = get_interval(120)
df = get_data(tickers=tickers,
columns=["High", "Low", "Adj Close"],
start=start,
end=end)
all_stochastic = get_stochastic_info(df, tickers)
return jsonify(all_stochastic)
def stochastic_calculation(ticker):
yf_ticker = escape(ticker) + ".SA"
start, end = get_interval(365)
df = get_data(tickers=yf_ticker,
columns=["High", "Low", "Adj Close"],
start=start,
end=end)
df = stochastic(df)
return {
"fast_k": int(round(df["%K"][-1])),
"fast_d": int(round(df["%D"][-1])),
"k": int(round(df["Slow %K"][-1])),
"d": int(round(df["Slow %D"][-1])),
}
def get_convolve(segments: list, av_model: list, data: pd.Series, window_size: int) -> list:
labeled_segment = []
convolve_list = []
for segment in segments:
labeled_segment = utils.get_interval(data, segment, window_size)
labeled_segment = utils.subtract_min_without_nan(labeled_segment)
labeled_segment = utils.check_nan_values(labeled_segment)
auto_convolve = scipy.signal.fftconvolve(labeled_segment, labeled_segment)
convolve_segment = scipy.signal.fftconvolve(labeled_segment, av_model)
if len(auto_convolve) > 0:
convolve_list.append(max(auto_convolve))
if len(convolve_segment) > 0:
convolve_list.append(max(convolve_segment))
return convolve_list
def run(self):
self.bailout = False
# pre-scan
self.scanner.scan()
self.logger.info("Ready to serve")
self.handling = True
while not self.bailout:
timer = elapsed.ElapsedTimer()
self.config.load()
self.rescan = utils.get_interval(self.config, "rescan",
self.context)
self.scanner.scan()
sleepy_time = max(self.rescan - timer.elapsed(), 10)
sleep_msg = utils.duration_to_str(sleepy_time)
self.logger.info(f"sleeping {sleep_msg} til next rescan")
time.sleep(sleepy_time)
def __filter_detection(self, segments_indexes: List[int], data: list):
delete_list = []
variance_error = self.state.window_size
close_segments = utils.close_filtering(segments_indexes,
variance_error)
segments_indexes = utils.best_pattern(close_segments, data,
self.get_extremum_type().value)
if len(segments_indexes) == 0 or len(self.state.pattern_center) == 0:
return []
pattern_data = self.state.pattern_model
for segment_index in segments_indexes:
if segment_index <= self.state.window_size or segment_index >= (
len(data) - self.state.window_size):
delete_list.append(segment_index)
continue
convol_data = utils.get_interval(data, segment_index,
self.state.window_size)
percent_of_nans = convol_data.isnull().sum() / len(convol_data)
if len(convol_data) == 0 or percent_of_nans > 0.5:
delete_list.append(segment_index)
continue
elif 0 < percent_of_nans <= 0.5:
nan_list = utils.find_nan_indexes(convol_data)
convol_data = utils.nan_to_zero(convol_data, nan_list)
pattern_data = utils.nan_to_zero(pattern_data, nan_list)
conv = scipy.signal.fftconvolve(convol_data, pattern_data)
if len(conv) == 0:
delete_list.append(segment_index)
continue
upper_bound = self.state.convolve_max * (
1 + POSITIVE_SEGMENT_MEASUREMENT_ERROR)
lower_bound = self.state.convolve_min * (
1 - POSITIVE_SEGMENT_MEASUREMENT_ERROR)
delete_up_bound = self.state.conv_del_max * (
1 + NEGATIVE_SEGMENT_MEASUREMENT_ERROR)
delete_low_bound = self.state.conv_del_min * (
1 - NEGATIVE_SEGMENT_MEASUREMENT_ERROR)
max_conv = max(conv)
if max_conv > upper_bound or max_conv < lower_bound:
delete_list.append(segment_index)
elif max_conv < delete_up_bound and max_conv > delete_low_bound:
delete_list.append(segment_index)
for item in delete_list:
segments_indexes.remove(item)
segments_indexes = utils.remove_duplicates_and_sort(segments_indexes)
return segments_indexes
def backtest_ifr2(ticker):
yf_ticker = escape(ticker) + ".SA"
start, end = get_interval(500)
df = get_data(
tickers=yf_ticker,
columns=["Open", "High", "Close", "Adj Close"],
start=start,
end=end,
)
df["IFR2"] = rsi(df, column="Adj Close")
entry = (None if request.args.get("entry") is None else int(
request.args.get("entry")))
df = strategy_points(data=df, rsi_parameter=entry)
all_profits, total_capital = backtest_algorithm(df)
statistics = strategy_test(all_profits, total_capital)
return jsonify(statistics)
def beta(ticker):
yf_ticker = escape(ticker) + ".SA"
interval = (365 if request.args.get("interval") is None else int(
request.args.get("interval")))
start, end = get_interval(interval)
benchmark = "^BVSP"
tickers = [yf_ticker, benchmark]
df = get_data(tickers=tickers, columns=["Adj Close"], start=start,
end=end)["Adj Close"]
df.dropna(inplace=True)
beta, corr, std_asset, std_bench = get_beta(df[yf_ticker], df[benchmark])
return jsonify({
"beta": round(beta, 2),
"corr": round(corr, 2),
"std_asset": round(std_asset, 4),
"std_bench": round(std_bench, 4),
})
def __filter_detection(self, segments: list, data: list) -> list:
delete_list = []
variance_error = self.state['WINDOW_SIZE']
close_patterns = utils.close_filtering(segments, variance_error)
segments = utils.best_pattern(close_patterns, data, 'min')
if len(segments) == 0 or len(self.state.get('pattern_center',
[])) == 0:
segments = []
return segments
pattern_data = self.state['pattern_model']
up_height = self.state['height_max'] * (1 + self.HEIGHT_ERROR)
low_height = self.state['height_min'] * (1 - self.HEIGHT_ERROR)
up_conv = self.state['convolve_max'] * (1 + 1.5 * self.CONV_ERROR)
low_conv = self.state['convolve_min'] * (1 - self.CONV_ERROR)
up_del_conv = self.state['conv_del_max'] * (1 + self.DEL_CONV_ERROR)
low_del_conv = self.state['conv_del_min'] * (1 - self.DEL_CONV_ERROR)
for segment in segments:
if segment > self.state['WINDOW_SIZE']:
convol_data = utils.get_interval(data, segment,
self.state['WINDOW_SIZE'])
convol_data = utils.subtract_min_without_nan(convol_data)
percent_of_nans = convol_data.isnull().sum() / len(convol_data)
if percent_of_nans > 0.5:
delete_list.append(segment)
continue
elif 0 < percent_of_nans <= 0.5:
nan_list = utils.find_nan_indexes(convol_data)
convol_data = utils.nan_to_zero(convol_data, nan_list)
pattern_data = utils.nan_to_zero(pattern_data, nan_list)
conv = scipy.signal.fftconvolve(convol_data, pattern_data)
pattern_height = convol_data.values.max()
if pattern_height > up_height or pattern_height < low_height:
delete_list.append(segment)
continue
if max(conv) > up_conv or max(conv) < low_conv:
delete_list.append(segment)
continue
if max(conv) < up_del_conv and max(conv) > low_del_conv:
delete_list.append(segment)
else:
delete_list.append(segment)
for item in delete_list:
segments.remove(item)
return set(segments)
def __filter_detection(self, segments, data):
delete_list = []
variance_error = self.state['WINDOW_SIZE']
close_patterns = utils.close_filtering(segments, variance_error)
segments = utils.best_pattern(close_patterns, data, 'max')
if len(segments) == 0 or len(self.state.get('pattern_center',
[])) == 0:
segments = []
return segments
pattern_data = self.state['pattern_model']
upper_bound = self.state['convolve_max'] * 1.2
lower_bound = self.state['convolve_min'] * 0.8
delete_up_bound = self.state['conv_del_max'] * 1.02
delete_low_bound = self.state['conv_del_min'] * 0.98
for segment in segments:
if segment > self.state['WINDOW_SIZE'] and segment < (
len(data) - self.state['WINDOW_SIZE']):
convol_data = utils.get_interval(data, segment,
self.state['WINDOW_SIZE'])
percent_of_nans = convol_data.isnull().sum() / len(convol_data)
if len(convol_data) == 0 or percent_of_nans > 0.5:
delete_list.append(segment)
continue
elif 0 < percent_of_nans <= 0.5:
nan_list = utils.find_nan_indexes(convol_data)
convol_data = utils.nan_to_zero(convol_data, nan_list)
pattern_data = utils.nan_to_zero(pattern_data, nan_list)
conv = scipy.signal.fftconvolve(convol_data, pattern_data)
try:
if max(conv) > upper_bound or max(conv) < lower_bound:
delete_list.append(segment)
elif max(conv) < delete_up_bound and max(
conv) > delete_low_bound:
delete_list.append(segment)
except ValueError:
delete_list.append(segment)
else:
delete_list.append(segment)
for item in delete_list:
segments.remove(item)
return set(segments)
def __filter_detection(self, segments: List[int], data: pd.Series) -> list:
delete_list = []
variance_error = self.state.window_size
close_patterns = utils.close_filtering(segments, variance_error)
segments = self.get_best_pattern(close_patterns, data)
if len(segments) == 0 or len(self.state.pattern_model) == 0:
return []
pattern_data = self.state.pattern_model
up_height = self.state.height_max * (1 + self.HEIGHT_ERROR)
low_height = self.state.height_min * (1 - self.HEIGHT_ERROR)
up_conv = self.state.convolve_max * (1 + 1.5 * self.CONV_ERROR)
low_conv = self.state.convolve_min * (1 - self.CONV_ERROR)
up_del_conv = self.state.conv_del_max * (1 + self.DEL_CONV_ERROR)
low_del_conv = self.state.conv_del_min * (1 - self.DEL_CONV_ERROR)
for segment in segments:
if segment > self.state.window_size:
convol_data = utils.get_interval(data, segment, self.state.window_size)
convol_data = utils.subtract_min_without_nan(convol_data)
percent_of_nans = convol_data.isnull().sum() / len(convol_data)
if percent_of_nans > 0.5:
delete_list.append(segment)
continue
elif 0 < percent_of_nans <= 0.5:
nan_list = utils.find_nan_indexes(convol_data)
convol_data = utils.nan_to_zero(convol_data, nan_list)
pattern_data = utils.nan_to_zero(pattern_data, nan_list)
conv = scipy.signal.fftconvolve(convol_data, pattern_data)
pattern_height = convol_data.values.max()
if pattern_height > up_height or pattern_height < low_height:
delete_list.append(segment)
continue
if max(conv) > up_conv or max(conv) < low_conv:
delete_list.append(segment)
continue
if max(conv) < up_del_conv and max(conv) > low_del_conv:
delete_list.append(segment)
else:
delete_list.append(segment)
for item in delete_list:
segments.remove(item)
return set(segments)
def __init__(self, context):
super().__init__()
self.context = context
logger_str = f"{utils.logger_str(__class__)} {context}"
self.logger = logging.getLogger(logger_str)
# self.logger.setLevel(logging.INFO)
self.config = config.Config.instance()
self.copies = int(self.config.get(self.context, "copies", 2))
self.path = config.path_for(self.config.get(self.context, "source"))
self.scanner = scanner.ScannerLite(self.context, self.path)
self.rescan = utils.get_interval(self.config, "rescan", self.context)
lazy_write = self.config.get(context, "LAZY WRITE", 5)
lazy_write = utils.str_to_duration(lazy_write)
# self.clients: { filename : { client: expiry_time, } }
clients_state = f"/tmp/cb.{context}-clients.json.bz2"
self.clients = PersistentDict(clients_state, lazy_write=5)
self.stats = stats.Stats()
self.handling = False
def do_fit(self, dataframe: pd.DataFrame, labeled_segments: list, deleted_segments: list, learning_info: dict) -> None:
data = utils.cut_dataframe(dataframe)
data = data['value']
last_pattern_center = self.state.get('pattern_center', [])
self.state['pattern_center'] = list(set(last_pattern_center + learning_info['segment_center_list']))
self.state['pattern_model'] = utils.get_av_model(learning_info['patterns_list'])
convolve_list = utils.get_convolve(self.state['pattern_center'], self.state['pattern_model'], data, self.state['WINDOW_SIZE'])
correlation_list = utils.get_correlation(self.state['pattern_center'], self.state['pattern_model'], data, self.state['WINDOW_SIZE'])
del_conv_list = []
delete_pattern_timestamp = []
for segment in deleted_segments:
del_mid_index = segment.center_index
delete_pattern_timestamp.append(segment.pattern_timestamp)
deleted_pat = utils.get_interval(data, del_mid_index, self.state['WINDOW_SIZE'])
deleted_pat = utils.subtract_min_without_nan(deleted_pat)
del_conv_pat = scipy.signal.fftconvolve(deleted_pat, self.state['pattern_model'])
if len(del_conv_pat): del_conv_list.append(max(del_conv_pat))
self.state['convolve_min'], self.state['convolve_max'] = utils.get_min_max(convolve_list, self.state['WINDOW_SIZE'] / 3)
self.state['conv_del_min'], self.state['conv_del_max'] = utils.get_min_max(del_conv_list, self.state['WINDOW_SIZE'])
def do_fit(self, dataframe: pd.DataFrame,
labeled_segments: List[AnalyticSegment],
deleted_segments: List[AnalyticSegment],
learning_info: LearningInfo) -> None:
data = utils.cut_dataframe(dataframe)
data = data['value']
window_size = self.state.window_size
last_pattern_center = self.state.pattern_center
self.state.pattern_center = utils.remove_duplicates_and_sort(
last_pattern_center + learning_info.segment_center_list)
self.state.pattern_model = utils.get_av_model(
learning_info.patterns_list)
convolve_list = utils.get_convolve(self.state.pattern_center,
self.state.pattern_model, data,
window_size)
correlation_list = utils.get_correlation(self.state.pattern_center,
self.state.pattern_model,
data, window_size)
height_list = learning_info.patterns_value
del_conv_list = []
delete_pattern_timestamp = []
for segment in deleted_segments:
segment_cent_index = segment.center_index
delete_pattern_timestamp.append(segment.pattern_timestamp)
deleted_stair = utils.get_interval(data, segment_cent_index,
window_size)
deleted_stair = utils.subtract_min_without_nan(deleted_stair)
del_conv_stair = scipy.signal.fftconvolve(deleted_stair,
self.state.pattern_model)
if len(del_conv_stair) > 0:
del_conv_list.append(max(del_conv_stair))
self._update_fitting_result(self.state, learning_info.confidence,
convolve_list, del_conv_list)
self.state.stair_height = int(
min(learning_info.pattern_height, default=1))
self.state.stair_length = int(
max(learning_info.pattern_width, default=1))
def bollinger_bands(ticker):
yf_ticker = escape(ticker) + ".SA"
start, end = get_interval(50)
df = get_data(tickers=yf_ticker,
columns=["Adj Close"],
start=start,
end=end)
k = 2 if request.args.get("k") is None else float(request.args.get("k"))
n = 20 if request.args.get("n") is None else int(request.args.get("n"))
bb_df = bb(df, k, n)
return jsonify({
"middle_band":
bb_df["Middle Band"][-1].round(2),
"upper_band":
bb_df["Upper Band"][-1].round(2),
"lower_band":
bb_df["Lower Band"][-1].round(2),
"current_price":
bb_df["Adj Close"][-1].round(2),
"text":
position_relative_to_bands(ticker, bb_df["Adj Close"], k, n),
})
