def get_exchange_holdings_per_symbol():
holdings_per_symbol = {}
for exchange_manager in interfaces_util.get_exchange_managers():
if trading_api.is_trader_existing_and_enabled(exchange_manager):
portfolio = trading_api.get_portfolio(exchange_manager)
_add_exchange_portfolio(portfolio, trading_api.get_exchange_name(exchange_manager), holdings_per_symbol)
return holdings_per_symbol
def get_exchange_time_frames(exchange_id):
try:
exchange_manager = trading_api.get_exchange_manager_from_exchange_id(
exchange_id)
return trading_api.get_watched_timeframes(
exchange_manager), trading_api.get_exchange_name(exchange_manager)
except KeyError:
return [], ""
def _get_exchanges_report(self, reference_market, trading_mode):
SYMBOL_REPORT = "symbol_report"
BOT_REPORT = "bot_report"
CHART_IDENTIFIERS = "chart_identifiers"
ERRORS_COUNT = "errors_count"
report = {
SYMBOL_REPORT: [],
BOT_REPORT: {},
CHART_IDENTIFIERS: [],
ERRORS_COUNT: logging.get_backtesting_errors_count()
}
profitabilities = {}
market_average_profitabilities = {}
starting_portfolios = {}
end_portfolios = {}
for exchange_id in self.octobot_backtesting.exchange_manager_ids:
exchange_manager = trading_api.get_exchange_manager_from_exchange_id(
exchange_id)
_, profitability, _, market_average_profitability, _ = trading_api.get_profitability_stats(
exchange_manager)
min_timeframe = time_frame_manager.find_min_time_frame(
trading_api.get_watched_timeframes(exchange_manager))
exchange_name = trading_api.get_exchange_name(exchange_manager)
for symbol in self.symbols_to_create_exchange_classes[
exchange_name]:
market_delta = self._get_market_delta(symbol, exchange_manager,
min_timeframe)
report[SYMBOL_REPORT].append({symbol: market_delta * 100})
report[CHART_IDENTIFIERS].append({
"symbol":
symbol,
"exchange_id":
exchange_id,
"exchange_name":
exchange_name,
"time_frame":
min_timeframe.value
})
profitabilities[exchange_name] = profitability
market_average_profitabilities[
exchange_name] = market_average_profitability
starting_portfolios[
exchange_name] = trading_api.get_origin_portfolio(
exchange_manager)
end_portfolios[exchange_name] = trading_api.get_portfolio(
exchange_manager)
report[BOT_REPORT] = {
"profitability": profitabilities,
"market_average_profitability": market_average_profitabilities,
"reference_market": reference_market,
"end_portfolio": end_portfolios,
"starting_portfolio": starting_portfolios,
"trading_mode": trading_mode
}
return report
def get_exchanges_load():
return {
trading_api.get_exchange_name(exchange_manager): {
"load": trading_api.get_currently_handled_pair_with_time_frame(exchange_manager),
"max_load": trading_api.get_max_handled_pair_with_time_frame(exchange_manager),
"overloaded": trading_api.is_overloaded(exchange_manager),
"has_websocket": trading_api.get_has_websocket(exchange_manager)
}
for exchange_manager in interfaces_util.get_exchange_managers()
}
async def _subscribe_exchange_id_mark_price(self, exchange_id):
await exchanges_channel.get_chan(trading_constants.MARK_PRICE_CHANNEL,
exchange_id).new_consumer(
self._mark_price_callback,
symbol=self.trading_mode.symbol)
registered_exchange_name = trading_api.get_exchange_name(
trading_api.get_exchange_manager_from_exchange_id(exchange_id))
self.logger.info(
f"Arbitrage trading for {self.trading_mode.symbol} on {self.exchange_name}: registered "
f"{registered_exchange_name} exchange as price data feed reference to identify arbitrage opportunities."
)
def log_report(self):
self.logger.info(" **** Backtesting report ****")
for exchange_id in self.octobot_backtesting.exchange_manager_ids:
exchange_manager = trading_api.get_exchange_manager_from_exchange_id(exchange_id)
exchange_name = trading_api.get_exchange_name(exchange_manager)
self.logger.info(f" ========= Trades on {exchange_name} =========")
self._log_trades_history(exchange_manager, exchange_name)
self.logger.info(f" ========= Prices evolution on {exchange_name} =========")
min_timeframe = time_frame_manager.find_min_time_frame(trading_api.get_watched_timeframes(exchange_manager))
for symbol in self.symbols_to_create_exchange_classes[exchange_name]:
self._log_symbol_report(symbol, exchange_manager, min_timeframe)
self.logger.info(" ========= Octobot end state =========")
self._log_global_report(exchange_manager)
def _get_supports(self):
supporting_exchanges = []
for exchange_manager in self.exchange_managers:
exchange_name = trading_api.get_exchange_name(exchange_manager)
if self.has_real_trader \
and trading_api.is_sponsoring(exchange_name) \
and trading_api.is_valid_account(exchange_manager):
supporting_exchanges.append(exchange_name)
supports = self.octobot_api.get_community_auth().supports
return {
community_fields.CommunityFields.EXCHANGES.value:
supporting_exchanges,
community_fields.CommunityFields.ROLES.value:
[supports.support_role],
community_fields.CommunityFields.DONATIONS.value:
[str(donation) for donation in supports.donations]
}
async def test_finalize():
try:
currency = "BTC"
symbol = "BTC/USDT"
producer, consumer, trader = await _get_tools()
matrix_id = evaluators_api.create_matrix()
await producer.finalize(trading_api.get_exchange_name(trader.exchange_manager), matrix_id, currency, symbol)
assert producer.final_eval == commons_constants.INIT_EVAL_NOTE
await producer._set_state(currency, symbol, trading_enums.EvaluatorStates.SHORT)
assert producer.state == trading_enums.EvaluatorStates.SHORT
# let both other be created
await asyncio_tools.wait_asyncio_next_cycle()
await asyncio.create_task(_check_open_orders_count(trader, 2)) # has stop loss
await producer._set_state(currency, symbol, trading_enums.EvaluatorStates.SHORT)
await asyncio.create_task(
_check_open_orders_count(trader, 2)) # ensure did not change orders because neutral state
finally:
await _stop(trader)
def get_currencies_with_status():
evaluations_by_exchange_by_pair = {}
for exchange_manager in interfaces.get_exchange_managers():
trading_modes = trading_api.get_trading_modes(exchange_manager)
for pair in trading_api.get_trading_pairs(exchange_manager):
if pair not in evaluations_by_exchange_by_pair:
evaluations_by_exchange_by_pair[pair] = {}
status_explanation = "N/A"
status = "N/A"
for trading_mode in trading_modes:
if trading_api.get_trading_mode_symbol(trading_mode) == pair:
status_explanation, status = trading_api.get_trading_mode_current_state(
trading_mode)
try:
status = round(status, 3)
except TypeError:
pass
break
evaluations_by_exchange_by_pair[pair][trading_api.get_exchange_manager_id(exchange_manager)] = \
[status_explanation.replace("_", " "), status,
trading_api.get_exchange_name(exchange_manager).capitalize()]
return evaluations_by_exchange_by_pair
def _get_first_exchange_identifiers():
for exchange_manager in interfaces_util.get_exchange_managers():
return exchange_manager, trading_api.get_exchange_name(
exchange_manager), trading_api.get_exchange_manager_id(
exchange_manager)
raise KeyError("No exchange to be found")
