async def _create_producer(exchange_manager,
producer) -> channel_producer.Producer:
"""
Create a producer instance
:param exchange_manager: the related exchange manager
:param producer: the producer to create
:return: the producer instance created
"""
producer_instance = producer(
exchange_channel.get_chan(producer.CHANNEL_NAME, exchange_manager.id))
if exchanges.is_exchange_managed_by_websocket(exchange_manager,
producer.CHANNEL_NAME):
# websocket is handling this channel: initialize data if required
if exchanges.is_websocket_feed_requiring_init(exchange_manager,
producer.CHANNEL_NAME):
try:
producer_instance.trigger_single_update()
except Exception as e:
exchange_manager.logger.exception(
e, True,
f"Error when initializing data for {producer.CHANNEL_NAME} "
f"channel required by websocket: {e}")
else:
# no websocket for this channel: start an producer
await producer_instance.run()
return producer_instance
async def create_producers(self) -> list:
mode_producer = ArbitrageModeProducer(
exchanges_channel.get_chan(trading_constants.MODE_CHANNEL,
self.exchange_manager.id), self.config,
self, self.exchange_manager)
await mode_producer.run()
return [mode_producer]
async def push_to_channel(self, channel_name, **kwargs):
try:
asyncio.run_coroutine_threadsafe(
exchange_channel.get_chan(channel_name, self.exchange_id).get_internal_producer().push(**kwargs),
self.bot_mainloop)
except Exception as e:
self.logger.error(f"Push to {channel_name} failed : {e}")
def _get_trading_producers(self):
import octobot_trading.exchange_channel as exchange_channel
return [
_get_channel_producers(
exchange_channel.get_chan(channel_name.value, exchange_id))
for exchange_id in self.exchange_ids
for channel_name in channels_name.OctoBotTradingChannelsName
]
async def _create_authenticated_producers(exchange_manager) -> None:
"""
Create real authenticated producers
:param exchange_manager: the related exchange manager
"""
import octobot_trading.personal_data as personal_data
for updater in personal_data.AUTHENTICATED_UPDATER_PRODUCERS:
if exchanges.is_exchange_managed_by_websocket(exchange_manager, updater.CHANNEL_NAME):
# websocket is handling this channel: initialize data if required
if exchanges.is_websocket_feed_requiring_init(exchange_manager, updater.CHANNEL_NAME):
try:
updater(exchange_channel.get_chan(updater.CHANNEL_NAME, exchange_manager.id)).trigger_single_update()
except Exception as e:
exchange_manager.logger.exception(e, True,
f"Error when initializing data for {updater.CHANNEL_NAME} "
f"channel required by websocket: {e}")
else:
# no websocket for this channel: start an updater
await updater(exchange_channel.get_chan(updater.CHANNEL_NAME, exchange_manager.id)).run()
def _ask_ticker_data_for_currency(self, symbols_to_add):
"""
Synchronously call TICKER_CHANNEL producer to add a list of new symbols to its watch list
:param symbols_to_add: the list of symbol to add to the TICKER_CHANNEL producer watch list
"""
asyncio.run_coroutine_threadsafe(
exchange_channel.get_chan(
constants.TICKER_CHANNEL,
self.portfolio_manager.exchange_manager.id).modify(
added_pairs=symbols_to_add), asyncio.get_running_loop())
async def create_backtesting_exchange_producers(self):
for importer in self.exchange_importers:
available_data_types = backtesting_api.get_available_data_types(importer)
at_least_one_updater = False
for channel_type, updater in exchange_data.UNAUTHENTICATED_UPDATER_SIMULATOR_PRODUCERS.items():
if self._are_required_data_available(channel_type, available_data_types):
await updater(exchange_channel.get_chan(updater.CHANNEL_NAME,
self.exchange_manager.id), importer).run()
at_least_one_updater = True
if not at_least_one_updater:
self.logger.error(f"No updater created for {importer.symbols} backtesting")
async def _create_mode_producer(self, mode_producer_class):
"""
Creates a new :mode_producer_class: instance and starts it
:param mode_producer_class: the trading mode producer class to create
:return: the producer class created
"""
mode_producer = mode_producer_class(
exchanges_channel.get_chan(constants.MODE_CHANNEL,
self.exchange_manager.id), self.config,
self, self.exchange_manager)
await mode_producer.run()
return mode_producer
async def create_exchange_producers(exchange_manager) -> None:
"""
Create exchange channels producers according to exchange manager context (backtesting, simulator, real)
:param exchange_manager: the related exchange manager
"""
# Always init exchange user data first on real trading
if _should_create_authenticated_producers(exchange_manager):
await _create_authenticated_producers(exchange_manager)
# Real data producers
if _should_create_unauthenticated_producers(exchange_manager):
import octobot_trading.exchange_data as exchange_data
for updater in exchange_data.UNAUTHENTICATED_UPDATER_PRODUCERS:
if not exchanges.is_exchange_managed_by_websocket(exchange_manager, updater.CHANNEL_NAME):
await updater(exchange_channel.get_chan(updater.CHANNEL_NAME, exchange_manager.id)).run()
# Simulated producers
if _should_create_simulated_producers(exchange_manager):
import octobot_trading.personal_data as personal_data
for updater in personal_data.AUTHENTICATED_UPDATER_SIMULATOR_PRODUCERS:
await updater(exchange_channel.get_chan(updater.CHANNEL_NAME, exchange_manager.id)).run()
async def update_order_from_exchange(
self,
order,
should_notify=False,
wait_for_refresh=False,
force_job_execution=False,
create_order_producer_if_missing=True):
"""
Update order from exchange
:param order: the order to update
:param wait_for_refresh: if True, wait until the order refresh task to finish
:param should_notify: if Orders channel consumers should be notified
:param force_job_execution: When True, order_update_job will bypass its dependencies check
:param create_order_producer_if_missing: Should be set to False when called by self to prevent spamming
:return: True if the order was updated
"""
try:
await (exchanges_channel.get_chan(
constants.ORDERS_CHANNEL, self.channel.exchange_manager.id).
producers[-1].update_order_from_exchange(
order=order,
should_notify=should_notify,
force_job_execution=force_job_execution,
wait_for_refresh=wait_for_refresh))
except IndexError:
if not self.channel.exchange_manager.is_simulated and create_order_producer_if_missing:
self.logger.debug("Missing orders producer, starting one...")
await exchanges.create_authenticated_producer_from_parent(
self.channel.exchange_manager,
self.__class__,
force_register_producer=True)
await self.update_order_from_exchange(
order=order,
should_notify=should_notify,
wait_for_refresh=wait_for_refresh,
force_job_execution=force_job_execution,
create_order_producer_if_missing=False)
async def _subscribe_to_channel(callback, exchange_id, channel):
channel = exchange_channel.get_chan(channel.get_name(), exchange_id)
await channel.new_consumer(callback)
