Is there any way to dynamically manage strategies in Nautilus?

[graceyangfan]

I am attempting to build dynamic strategies for multiple instruments. The main idea is to rescreen certain instruments every day for running specific strategies. Previously, I would stop all strategies when switching and then reconstruct the new strategies. However, there are cases where some instruments need to be run continuously without stopping, which feels unnatural. My current goal is to achieve dynamic stopping and creation of strategies.

I have noticed that Nautilus includes a built-in Controller, but it is too simplistic to meet my requirements. My current approach is to add dynamic tasks within the NautilusKernel, similar to:

async def start_async(self) -> None:
    """
    Start the Nautilus system kernel in an asynchronous context with an event loop.

    Raises
    ------
    RuntimeError
        If no event loop has been assigned to the kernel.
    """
    if self.loop is None:
        raise RuntimeError("no event loop has been assigned to the kernel")

    self._log.info("STARTING")

    self._start_engines()
    self._connect_clients()
    if not await self._await_engines_connected():
        return

    if not await self._await_execution_reconciliation():
        return

    self._emulator.start()
    self._initialize_portfolio()

    if not await self._await_portfolio_initialization():
        return

    periodic_task = self._loop.create_task(self.periodic_task(), name="periodic_task")

async def periodic_task(self):
    self._log.debug("Periodic task processing starting")
    try:
        while True:
            current_long_instruments, current_short_instruments = self._trader.get_current_long_short_instruments()

            # Stop and remove strategies that are no longer in the long or short instruments list
            for strategy in self._trader._long_short_strategies:
                if strategy.instrument not in current_long_instruments:
                    self._trader.stop_strategy(strategy.id)
                    self._trader.remove_strategy(strategy.id)
                if strategy.instrument not in current_short_instruments:
                    self._trader.stop_strategy(strategy.id)
                    self._trader.remove_strategy(strategy.id)

            # Create new strategies for the instruments that are in the long or short instruments list but not running
            for instrument in current_long_instruments:
                if instrument not in self._trader._long_strategies:
                    strategy = self._trader.create_strategy(instrument, "long")
                    self._trader.add_strategy(strategy)
                    strategy.register_executor(self._loop, self._executor)
                    strategy.start()
            for instrument in current_short_instruments:
                if instrument not in self._trader._short_strategies:
                    strategy = self._trader.create_strategy(instrument, "short")
                    self._trader.add_strategy(strategy)
                    strategy.register_executor(self._loop, self._executor)
                    strategy.start()

    except asyncio.CancelledError:
        self._log.warning("Periodic task canceled")
    except RuntimeError as e:
        self._log.error(f"RuntimeError: {e}")
    finally:
        self._log.debug("Periodic task stopped")

I'm curious if anyone else is attempting something similar and would be glad to hear any opinions or suggestions.

[limx0]

Hi @graceyangfan !

Which specific part of the controller is too simplistic? The intention of the module is for exactly this use case, so keen to hear what would be required to help clean this up ?

[cuberone]

@graceyangfan just add timer for periodic tasks to controller and manage your strategies dynamically.

[graceyangfan]

@cuberone thanks for your suggestion! so you mean create_task in on_start function of Controller?

[limx0]

@graceyangfan the controller has access to everything the actors do - you can subscribe to any sort of events (trade ticks, etc) you want that you might want to create/start/stop strategies on and the controller has access to the trader (which is all you need)