def get_trading_mode(self):
try:
first_exchange_manager = trading_api.get_exchange_manager_from_exchange_id(
next(iter(self.exchange_producer.exchange_manager_ids)))
return trading_api.get_trading_modes(first_exchange_manager)[0]
except StopIteration:
return None
async def _register_on_channels(self, exchange_id):
try:
if trading_api.is_exchange_trading(trading_api.get_exchange_manager_from_exchange_id(exchange_id)):
await trading_api.subscribe_to_trades_channel(self._web_trades_callback, exchange_id)
await trading_api.subscribe_to_ohlcv_channel(self._web_ohlcv_empty_callback, exchange_id)
except ImportError:
self.logger.error("Watching trade channels requires OctoBot-Trading package installed")
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
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."
)
async def _order_notification_callback(self, exchange, exchange_id, cryptocurrency, symbol, order,
is_new, is_from_bot):
exchange_manager = trading_api.get_exchange_manager_from_exchange_id(exchange_id)
# Do not notify on existing pre-start orders
if is_from_bot and not trading_api.get_is_backtesting(exchange_manager):
order_identifier = f"{exchange}_{order[trading_enums.ExchangeConstantsOrderColumns.ID.value]}"
# find the last notification for this order if any
linked_notification = self.previous_notifications_by_identifier[order_identifier] \
if order_identifier in self.previous_notifications_by_identifier else None
await self._handle_order_notification(order, linked_notification, order_identifier,
exchange_manager, exchange)
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_currency_price_graph_update(exchange_id,
symbol,
time_frame,
list_arrays=True,
backtesting=False,
minimal_candles=False,
ignore_trades=False):
bot_api = interfaces_util.get_bot_api()
# TODO: handle on the fly backtesting price graph
# if backtesting and WebInterface and WebInterface.tools[BOT_TOOLS_BACKTESTING]:
# bot = WebInterface.tools[BOT_TOOLS_BACKTESTING].get_bot()
symbol = parse_get_symbol(symbol)
in_backtesting = backtesting_api.is_backtesting_enabled(
interfaces_util.get_global_config()) or backtesting
exchange_manager = trading_api.get_exchange_manager_from_exchange_id(
exchange_id)
if time_frame is not None:
try:
symbol_data = trading_api.get_symbol_data(exchange_manager,
symbol,
allow_creation=False)
limit = 1 if minimal_candles else -1
historical_candles = trading_api.get_symbol_historical_candles(
symbol_data, time_frame, limit=limit)
kline = [math.nan]
if trading_api.has_symbol_klines(symbol_data, time_frame):
kline = trading_api.get_symbol_klines(symbol_data, time_frame)
if historical_candles is not None:
return _create_candles_data(symbol, time_frame,
historical_candles, kline, bot_api,
list_arrays, in_backtesting,
ignore_trades)
except KeyError:
traded_pairs = trading_api.get_trading_pairs(exchange_manager)
if not traded_pairs or symbol in traded_pairs:
# not started yet
return None
else:
return {"error": f"no data for {symbol}"}
return None
