def __init__(self, config, crypto_currency, dispatchers_list):
self.crypto_currency = crypto_currency
self.trader_simulator = None
self.config = config
self.traders = None
self.trader_simulators = None
self.finalize_enabled = False
self.dispatchers_list = dispatchers_list
self.evaluator_threads = []
self.matrix = EvaluatorMatrix()
self.social_eval_list = EvaluatorCreator.create_social_eval(
self.config, self.crypto_currency, self.dispatchers_list)
self.social_not_threaded_list = EvaluatorCreator.create_social_not_threaded_list(
self.social_eval_list)
self.strategies_eval_list = EvaluatorCreator.create_strategies_eval_list(
self.config)
self.social_evaluator_refresh = SocialEvaluatorNotThreadedUpdateThread(
self.social_not_threaded_list)
self.global_social_updater = SocialGlobalUpdaterThread(self)
self.evaluator_order_creator = EvaluatorOrderCreator()
self.final_evaluator = FinalEvaluator(self)
def get_evaluator_graph_in_matrix_history(symbol, exchange_name,
evaluator_type, evaluator_name,
time_frame, cryptocurrency_name):
symbol_evaluator_list = get_bot().get_symbol_evaluator_list()
exchange_list = get_bot().get_exchanges_list()
if evaluator_name is not None and exchange_name and len(
symbol_evaluator_list) > 0:
matrix = symbol_evaluator_list[symbol].get_matrix(
exchange_list[exchange_name])
add_to_matrix_history(matrix)
formatted_matrix_history = {"timestamps": [], "evaluator_data": []}
for matrix in get_matrix_history():
if evaluator_type == EvaluatorMatrixTypes.TA:
eval_note = EvaluatorMatrix.get_eval_note(
matrix["matrix"], evaluator_type, evaluator_name,
time_frame)
else:
eval_note = EvaluatorMatrix.get_eval_note(
matrix["matrix"], evaluator_type, evaluator_name)
if eval_note is not None:
formatted_matrix_history["evaluator_data"].append(eval_note)
formatted_matrix_history["timestamps"].append(
matrix["timestamp"])
data = plotly.graph_objs.Scatter(
x=formatted_matrix_history["timestamps"],
y=formatted_matrix_history["evaluator_data"],
name='Scatter',
mode='lines+markers')
return {
'data': [data],
'layout':
go.Layout(title="{} strategy".format(cryptocurrency_name),
xaxis=dict(
range=[get_bot().get_start_time(),
time.time()],
title=TIME_AXIS_TITLE),
yaxis=dict(range=[-1.1, 1.1], title="Buy or sell"))
}
return None
def get_evaluator_graph_in_matrix_history(symbol,
exchange_name,
evaluator_type,
evaluator_name,
time_frame,
cryptocurrency_name):
symbol_evaluator_list = get_bot().get_symbol_evaluator_list()
exchange_list = get_bot().get_exchanges_list()
if evaluator_name is not None and len(symbol_evaluator_list) > 0:
matrix = symbol_evaluator_list[symbol].get_matrix(exchange_list[exchange_name])
add_to_matrix_history(matrix)
formatted_matrix_history = {
"timestamps": [],
"evaluator_data": []
}
for matrix in get_matrix_history():
if evaluator_type == EvaluatorMatrixTypes.TA:
eval_note = EvaluatorMatrix.get_eval_note(matrix["matrix"], evaluator_type, evaluator_name, time_frame)
else:
eval_note = EvaluatorMatrix.get_eval_note(matrix["matrix"], evaluator_type, evaluator_name)
if eval_note is not None:
formatted_matrix_history["evaluator_data"].append(eval_note)
formatted_matrix_history["timestamps"].append(matrix["timestamp"])
data = plotly.graph_objs.Scatter(
x=formatted_matrix_history["timestamps"],
y=formatted_matrix_history["evaluator_data"],
name='Scatter',
mode='lines+markers'
)
return {'data': [data],
'layout': go.Layout(
title="{} strategy".format(cryptocurrency_name),
xaxis=dict(range=[get_bot().get_start_time(), time.time()],
title=TIME_AXIS_TITLE),
yaxis=dict(range=[-1.1, 1.1],
title="Buy or sell")
)}
return None
def add_evaluator_thread_manager(self, exchange, time_frame, trading_mode, evaluator_thread):
if exchange.get_name() in self.evaluator_thread_managers:
self.evaluator_thread_managers[exchange.get_name()][time_frame] = evaluator_thread
else:
self.evaluator_thread_managers[exchange.get_name()] = {time_frame: evaluator_thread}
self.matrices[exchange.get_name()] = EvaluatorMatrix(self.config)
self.strategies_eval_lists[exchange.get_name()] = EvaluatorCreator.create_strategies_eval_list(self.config)
self.finalize_enabled_list[exchange.get_name()] = False
self.init_evaluator_instances_by_strategies()
self.trading_mode_instances[exchange.get_name()] = trading_mode
trading_mode.add_symbol_evaluator(self)
def add_evaluator_thread_manager(self, exchange, symbol, time_frame,
evaluator_thread):
if exchange.get_name() in self.evaluator_thread_managers:
self.evaluator_thread_managers[
exchange.get_name()][time_frame] = evaluator_thread
else:
self.evaluator_thread_managers[exchange.get_name()] = {
time_frame: evaluator_thread
}
self.final_evaluators[exchange.get_name()] = FinalEvaluator(
self, exchange, symbol)
self.matrices[exchange.get_name()] = EvaluatorMatrix(self.config)
self.strategies_eval_lists[exchange.get_name(
)] = EvaluatorCreator.create_strategies_eval_list(self.config)
self.finalize_enabled_list[exchange.get_name()] = False
def _get_tools():
config = load_test_config()
matrix_inst = EvaluatorMatrix(config)
matrix = matrix_inst.matrix
return matrix_inst, matrix, config
class Symbol_Evaluator:
def __init__(self, config, crypto_currency, dispatchers_list):
self.crypto_currency = crypto_currency
self.trader_simulator = None
self.config = config
self.traders = None
self.trader_simulators = None
self.finalize_enabled = False
self.dispatchers_list = dispatchers_list
self.evaluator_threads = []
self.matrix = EvaluatorMatrix()
self.social_eval_list = EvaluatorCreator.create_social_eval(
self.config, self.crypto_currency, self.dispatchers_list)
self.social_not_threaded_list = EvaluatorCreator.create_social_not_threaded_list(
self.social_eval_list)
self.strategies_eval_list = EvaluatorCreator.create_strategies_eval_list(
self.config)
self.social_evaluator_refresh = SocialEvaluatorNotThreadedUpdateThread(
self.social_not_threaded_list)
self.global_social_updater = SocialGlobalUpdaterThread(self)
self.evaluator_order_creator = EvaluatorOrderCreator()
self.final_evaluator = FinalEvaluator(self)
def start_threads(self):
self.social_evaluator_refresh.start()
self.global_social_updater.start()
def stop_threads(self):
for thread in self.social_eval_list:
thread.stop()
self.social_evaluator_refresh.stop()
self.global_social_updater.stop()
def join_threads(self):
for thread in self.social_eval_list:
thread.join()
self.social_evaluator_refresh.join()
self.global_social_updater.join()
def set_traders(self, trader):
self.traders = trader
def set_trader_simulators(self, simulator):
self.trader_simulators = simulator
def add_evaluator_thread(self, evaluator_thread):
self.evaluator_threads.append(evaluator_thread)
def update_strategies_eval(self, new_matrix, ignored_evaluator=None):
for strategies_evaluator in self.strategies_eval_list:
strategies_evaluator.set_matrix(new_matrix)
if not strategies_evaluator.get_name(
) == ignored_evaluator and strategies_evaluator.get_is_evaluable():
strategies_evaluator.eval()
# update matrix
self.matrix.set_eval(EvaluatorMatrixTypes.STRATEGIES,
strategies_evaluator.get_name(),
strategies_evaluator.get_eval_note())
def finalize(self, exchange, symbol):
if not self.finalize_enabled:
self.check_finalize()
if self.finalize_enabled:
self.final_evaluator.add_to_queue(exchange, symbol)
def check_finalize(self):
self.finalize_enabled = True
for evaluator_thread in self.evaluator_threads:
if evaluator_thread.get_data_refresher().get_refreshed_times(
) == 0:
self.finalize_enabled = False
def get_trader(self, exchange):
return self.traders[exchange.get_name()]
def get_trader_simulator(self, exchange):
return self.trader_simulators[exchange.get_name()]
def get_final(self):
return self.final_evaluator
def get_matrix(self):
return self.matrix
def get_config(self):
return self.config
def get_evaluator_order_creator(self):
return self.evaluator_order_creator
def get_strategies_eval_list(self):
return self.strategies_eval_list
def get_social_eval_list(self):
return self.social_eval_list
def get_dispatchers_list(self):
return self.dispatchers_list
def get_social_not_threaded_list(self):
return self.social_not_threaded_list
def get_symbol_pairs(self):
return self.config["crypto_currencies"][self.crypto_currency]["pairs"]