Как правильно запускать несколько ботов в asyncio

async def main():
    # Создаем единый event loop
    loop = asyncio.get_running_loop()
    
    # Настраиваем группы
    await group_manager.setup_group_clones()
    
    # Запускаем все задачи в одном цикле
    tasks = [
        check_old_tokens(),
        periodic_check(),
        periodic_refresh_groups(),
        *group_manager.get_all_bot_tasks()
    ]
    
    await asyncio.gather(*tasks)

class GroupCloneManager:
    def __init__(self):
        self.group_bots: Dict[int, Bot] = {}
        self.group_tasks: Dict[int, asyncio.Task] = {}
        self._main_task = None

    async def start_all_bots(self):
        """Запускает всех ботов в рамках единого event loop"""
        self._main_task = asyncio.create_task(self._manage_bots())

    async def _manage_bots(self):
        """Централизованное управление ботами"""
        while True:
            try:
                # Обновляем список ботов
                await self.refresh_group_clones()
                
                # Проверяем состояние каждого бота
                for group_id, task in list(self.group_tasks.items()):
                    if task.done():
                        # Бот упал, перезапускаем
                        await self.restart_bot(group_id)
                
                await asyncio.sleep(30)  # Период проверки
            except Exception as e:
                logger.error(f"Error in bot management: {e}")
                await asyncio.sleep(10)

async def add_group_clone(self, group_data: ConnectedGroups):
    group_id = group_data.group_id
    token = ssl_crypter.decrypt(group_data.access_token).decode('utf-8')

    try:
        group_api = API(token=token)
        group_bot = Bot(
            api=group_api,
            labeler=deepcopy(labeler),
            state_dispenser=deepcopy(state_dispenser)
        )

        # Вместо run_forever, используем polling через задачу
        self.group_bots[group_id] = group_bot
        self.group_tasks[group_id] = asyncio.create_task(
            self._run_group_bot_polling(group_bot, group_id)
        )

        logger.debug(f"Group {group_id} added and successfully started")
        return True
    except Exception as e:
        logger.debug(f"Group {group_id} failed to start, unavailable token ({e})")
        return False

async def _run_group_bot_polling(self, group_bot: Bot, group_id: int):
    """Запускает polling для конкретного бота"""
    try:
        # Используем polling с таймаутом для возможности перезапуска
        await groupBot.run_polling(
            skip_updates=True,  # Пропускаем старые обновления
            timeout=20
        )
    except asyncio.CancelledError:
        logger.info(f"Group {group_id} polling cancelled")
        raise
    except Exception as e:
        logger.debug(f"Group {group_id} polling error: {e}")
        # Бот упал, будет перезапущен через менеджер

async def shutdown_all_bots(self):
    """Корректное завершение работы всех ботов"""
    logger.info("Shutting down all bots...")
    
    # Отменяем все задачи ботов
    for task in self.group_tasks.values():
        task.cancel()
    
    # Ждем завершения
    await asyncio.gather(*self.group_tasks.values(), return_exceptions=True)
    
    # Закрываем соединения
    for bot in self.group_bots.values():
        if hasattr(bot, '_connection'):
            await bot._connection.close()
    
    logger.info("All bots shutdown completed")

import asyncio
from typing import Dict
from aiogram import Bot, API
from aiogram.dispatcher import Dispatcher
from aiogram.dispatcher.filters.state import StateDispenser
from aiogram.utils.keyboard import InlineKeyboardBuilder
from copy import deepcopy

class GroupCloneManager:
    def __init__(self):
        self.group_bots: Dict[int, Bot] = {}
        self.group_tasks: Dict[int, asyncio.Task] = {}
        self.labeler = InlineKeyboardBuilder()
        self.state_dispenser = StateDispenser()
    
    async def start(self):
        """Запускает менеджер"""
        # Создаем один event loop для всего приложения
        loop = asyncio.get_event_loop()
        
        # Настраиваем боты
        await self.setup_group_clones()
        
        # Запускаем все задачи в одном цикле
        tasks = [
            self.check_old_tokens(),
            self.periodic_check(),
            self.periodic_refresh_groups(),
            self._monitor_bots()
        ]
        
        try:
            await asyncio.gather(*tasks)
        except KeyboardInterrupt:
            await self.shutdown()
    
    async def _monitor_bots(self):
        """Мониторинг состояния ботов"""
        while True:
            try:
                # Проверяем упавшие боты
                for group_id in list(self.group_tasks.keys()):
                    task = self.group_tasks[group_id]
                    if task.done() and not task.cancelled():
                        try:
                            await task  # Проверяем исключение
                        except Exception as e:
                            logger.error(f"Bot {group_id} failed: {e}")
                            await self.restart_bot(group_id)
                
                await asyncio.sleep(30)
            except Exception as e:
                logger.error(f"Monitor error: {e}")
                await asyncio.sleep(10)
    
    async def restart_bot(self, group_id: int):
        """Перезапускает конкретного бота"""
        if group_id in self.group_tasks:
            self.group_tasks[group_id].cancel()
        
        if group_id in self.group_bots:
            del self.group_bots[group_id]
        
        # Получаем данные группы из БД
        group_data = await get_group_by_id(group_id)
        if group_data:
            await self.add_group_clone(group_data)

async def main():
    """Основная функция запуска"""
    manager = GroupCloneManager()
    
    try:
        await manager.start()
    except KeyboardInterrupt:
        await manager.shutdown()
    except Exception as e:
        logger.error(f"Fatal error: {e}")
        await manager.shutdown()

if __name__ == "__main__":
    # Используем стандартный запуск asyncio
    asyncio.run(main())

from multiprocessing import Process

def run_bot(token: str):
    """Запускает бота в отдельном процессе"""
    asyncio.run(bot_main(token))

def main():
    processes = []
    for token in tokens:
        p = Process(target=run_bot, args=(token,))
        p.start()
        processes.append(p)
    
    for p in processes:
        p.join()