def do_analysis(self):
"""Метод подготовки прогнозов"""
# Получаем свечи разной длинны
# candles = Candle.get_last(self.quotation.ts, self.task.setting.analyzer_deep,
# self.task.setting.instrument_id, "parent")
candles = Candle.get_last_with_nesting(
self.quotation.ts, self.task.setting.analyzer_deep,
self.task.setting.instrument_id,
self.task.setting.candles_durations, "parent")
# Получаем разные вариации последовательностей c глубиной вхождения
sequences = Sequence.get_sequences_json(self.task, candles)
sequences_models = []
for sequence in sequences:
if len(sequence) >= self.task.setting.analyzer_min_deep:
sequences_models.append(Sequence.make(sequence))
if len(sequences_models) > 0:
patterns_models = []
predictions_models = []
for time_bid in self.task.setting.analyzer_bid_times:
for seq_raw in sequences_models:
prediction = Prediction.make(self.task, time_bid,
self.quotation)
# Проверка оставшегося времени до ставки
if prediction.time_to_expiration >= (
time_bid['time'] - time_bid['admission']):
pattern = Pattern.make(self.task, seq_raw, time_bid,
self.quotation)
predictions_models.append(prediction)
patterns_models.append(pattern)
if len(patterns_models) > 0:
patterns = Pattern.save_many(patterns_models)
i = 0
for pat_rec in patterns:
predictions_models[i].pattern_id = pat_rec.id
if Controller.check_on_make_prediction(self.task, pat_rec):
self.task.storage.predictions.append(
predictions_models[i])
if Controller.check_on_make_signal(self.task, pat_rec,
predictions_models[i],
self.quotation):
# Проверка условий вероятности при создании сигнала
direction = Signaler.check(self.task, pat_rec)
if direction:
Signaler.make_and_save(self.task, direction,
pat_rec,
predictions_models[i])
if self.task.get_param("history_num", 0) > 0:
signals_count = self.task.get_status(
"checker_signals_count", 0)
self.task.update_status(
"checker_signals_count", signals_count + 1)
i += 1
def load_pattern(self, name):
directory = os.path.join(PATTERNS_DIR, name)
pattern = Pattern(name)
if os.path.exists(directory):
pattern.image = cv2.imread(
os.path.join(directory, BINARY_FILENAME), cv2.IMREAD_GRAYSCALE)
with open(os.path.join(directory, KEYPOINTS_FILENAME), 'r') as f:
pattern.keypoints = self._json_to_keypoints(json.load(f))
pattern.descriptors = np.load(
os.path.join(directory, DESCRIPTORS_FILENAME))
return pattern
def __init__(self, task):
self.task = task
self.instrument = task.setting.instrument
start = self.task.get_param("start")
end = self.task.get_param("end")
quotations = Quotation.get_from_interval(start, end,
self.instrument.id)
self.task.update_status("checker_total_quotations", len(quotations))
last_quotation = None
if Providers.config().flush_history:
Prediction.empty_table(task)
Pattern.empty_table(task)
Signal.empty_table(task)
if len(quotations) > 0:
checked_quotations = self.task.get_param(
"checker_checked_quotations")
if not checked_quotations:
checked_quotations = 0
for row in quotations:
analyzer = Analyzer(task)
analyzer.quotation = row
analyzer.do_analysis()
last_quotation = analyzer.quotation
Prediction.calculation_cost_for_topical(task, last_quotation)
Controller.update_expired_signals(self.task, last_quotation)
checked_quotations += 1
if checked_quotations % 10 == 0:
# Обновляем параметры стоимости прогнозов
self.task.update_status("checker_checked_quotations",
checked_quotations)
# Запускаем демона для проверки кеша и получения результата торгов
self.checker_predictions(last_quotation)
if checked_quotations % 100 == 0:
success_percent = Signal.get_success_percent(self.task)
print(datetime.datetime.fromtimestamp(last_quotation.ts),
success_percent)
# Обновляем параметры стоимости прогнозов
if last_quotation:
self.checker_predictions(last_quotation)
def __init__(self, app):
super().__init__()
self.app = app
self.showMaximized()
self.image_service = ImageService()
self.storage_service = StorageService()
self.stacked_widget = QStackedWidget()
self.stacked_widget.showMaximized()
self.main_widget = MainWidget(self)
self.settings_widget = SettingsWidget(self, Settings())
self.pattern_widget = PatternWidget(self, Pattern())
self.stacked_widget.addWidget(self.main_widget)
self.stacked_widget.addWidget(self.pattern_widget)
self.stacked_widget.addWidget(self.settings_widget)
self.setCentralWidget(self.stacked_widget)
self.selected_pattern_name = None
self.selected_settings_name = None
self.pattern = None
self.settings = None
self._create_actions()
self._set_menu_bar()
self._set_tool_bar()
self.errors_color = QColor(255, 0, 0)
def create_pattern(self, pattern_name):
bin_image = np.random.randint(2, size=(20, 10))
bin_image[bin_image == 1] = 255
keypoints = [
cv2.KeyPoint(5, 5, 2, -1, 0, 0, -1),
cv2.KeyPoint(2, 2, 1, -1, 1, 1, -1)
]
descriptors = np.random.randint(256, size=(len(keypoints), 32))
return Pattern(pattern_name, bin_image, keypoints, descriptors)
def check_on_make_signal(task, pat: Pattern, prediction: Prediction, q):
# Проверка на минимальное время работы паттерна
if not Pattern.check_on_min_work_time(task, pat,
prediction.sequence_duration, q):
return False
# Проверка на существование сигнала по паттерну за время прогноза
for signal_item in task.storage.signals:
if pat.id == signal_item.pattern_id:
return False
return True
def _new_pattern_action_handler(self):
file_dialog = QFileDialog(self)
file_dialog.setNameFilters(["All Files (*)", "Images (*.png *.jpg)"])
file_dialog.selectNameFilter("Images (*.png *.jpg)")
if file_dialog.exec_():
filename = file_dialog.selectedFiles()[0]
with wait_cursor():
image_orig = cv2.imread(filename, cv2.IMREAD_COLOR)
self.stacked_widget.removeWidget(self.pattern_widget)
self.settings_widget = PatternWidget(self, Pattern())
self.stacked_widget.addWidget(self.pattern_widget)
self.stacked_widget.setCurrentWidget(self.pattern_widget)
self.pattern_widget.setImage(image_orig)
self.pattern_widget.update()
def pattern(self):
if not self._pattern:
self._pattern = Pattern.get_by_id(self.pattern_id)
return self._pattern