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)