⚡ 添加进程及生命周期管理器，添加轻雪框架支持

liteyuki/__init__.py

@@ -0,0 +1,12 @@
+from liteyuki.bot import (
+    LiteyukiBot,
+    get_bot
+)
+
+# def get_bot_instance() -> LiteyukiBot | None:
+#     """
+#     获取轻雪实例
+#     Returns:
+#         LiteyukiBot: 当前的轻雪实例
+#     """
+#     return _BOT_INSTANCE

liteyuki/bot/__init__.py

@@ -0,0 +1,243 @@
+import asyncio
+import multiprocessing
+from typing import Any, Coroutine, Optional
+
+import nonebot
+
+from liteyuki.plugin.load import load_plugin, load_plugins
+from src.utils import (
+    adapter_manager,
+    driver_manager,
+)
+from src.utils.base.log import logger
+from liteyuki.bot.lifespan import (
+    Lifespan,
+    LIFESPAN_FUNC,
+)
+from liteyuki.core.spawn_process import nb_run, ProcessingManager
+
+__all__ = [
+        "LiteyukiBot",
+        "get_bot"
+]
+
+_MAIN_PROCESS = multiprocessing.current_process().name == "MainProcess"
+
+
+class LiteyukiBot:
+    def __init__(self, *args, **kwargs):
+
+        global _BOT_INSTANCE
+        _BOT_INSTANCE = self  # 引用
+        self.running = False
+        self.config: dict[str, Any] = kwargs
+        self.lifespan: Lifespan = Lifespan()
+        self.init(**self.config)  # 初始化
+
+        if not _MAIN_PROCESS:
+            pass
+        else:
+            print("\033[34m" + r"""
+ __        ______  ________  ________  __      __  __    __  __    __  ______ 
+/  |      /      |/        |/        |/  \    /  |/  |  /  |/  |  /  |/      |
+$$ |      $$$$$$/ $$$$$$$$/ $$$$$$$$/ $$  \  /$$/ $$ |  $$ |$$ | /$$/ $$$$$$/ 
+$$ |        $$ |     $$ |   $$ |__     $$  \/$$/  $$ |  $$ |$$ |/$$/    $$ |  
+$$ |        $$ |     $$ |   $$    |     $$  $$/   $$ |  $$ |$$  $$<     $$ |  
+$$ |        $$ |     $$ |   $$$$$/       $$$$/    $$ |  $$ |$$$$$  \    $$ |  
+$$ |_____  _$$ |_    $$ |   $$ |_____     $$ |    $$ \__$$ |$$ |$$  \  _$$ |_ 
+$$       |/ $$   |   $$ |   $$       |    $$ |    $$    $$/ $$ | $$  |/ $$   |
+$$$$$$$$/ $$$$$$/    $$/    $$$$$$$$/     $$/      $$$$$$/  $$/   $$/ $$$$$$/ 
+            """ + "\033[0m")
+
+    def run(self, *args, **kwargs):
+
+        if _MAIN_PROCESS:
+            load_plugins("liteyuki/plugins")
+            asyncio.run(self.lifespan.before_start())
+            self._run_nb_in_spawn_process(*args, **kwargs)
+        else:
+            # 子进程启动
+
+            driver_manager.init(config=self.config)
+            adapter_manager.init(self.config)
+            adapter_manager.register()
+            nonebot.load_plugin("src.liteyuki_main")
+
+    def _run_nb_in_spawn_process(self, *args, **kwargs):
+        """
+        在新的进程中运行nonebot.run方法
+        Args:
+            *args:
+            **kwargs:
+
+        Returns:
+        """
+
+        timeout_limit: int = 20
+        should_exit = False
+
+        while not should_exit:
+            ctx = multiprocessing.get_context("spawn")
+            event = ctx.Event()
+            ProcessingManager.event = event
+            process = ctx.Process(
+                target=nb_run,
+                args=(event,) + args,
+                kwargs=kwargs,
+            )
+            process.start()  # 启动进程
+
+            asyncio.run(self.lifespan.after_start())
+
+            while not should_exit:
+                if ProcessingManager.event.wait(1):
+                    logger.info("Receive reboot event")
+                    process.terminate()
+                    process.join(timeout_limit)
+                    if process.is_alive():
+                        logger.warning(
+                            f"Process {process.pid} is still alive after {timeout_limit} seconds, force kill it."
+                        )
+                        process.kill()
+                    break
+                elif process.is_alive():
+                    continue
+                else:
+                    should_exit = True
+
+    @property
+    def status(self) -> int:
+        """
+        获取轻雪状态
+        Returns:
+            int: 0:未启动 1:运行中
+        """
+        return 1 if self.running else 0
+
+    def restart(self):
+        """
+        停止轻雪
+        Returns:
+
+        """
+        logger.info("Stopping LiteyukiBot...")
+
+        logger.debug("Running before_restart functions...")
+        asyncio.run(self.lifespan.before_restart())
+        logger.debug("Running before_shutdown functions...")
+        asyncio.run(self.lifespan.before_shutdown())
+
+        ProcessingManager.restart()
+        self.running = False
+
+    def init(self, *args, **kwargs):
+        """
+        初始化轻雪, 自动调用
+        Returns:
+
+        """
+        self.init_config()
+        self.init_logger()
+        if not _MAIN_PROCESS:
+            nonebot.init(**kwargs)
+            asyncio.run(self.lifespan.after_nonebot_init())
+
+    def init_logger(self):
+        from src.utils.base.log import init_log
+        init_log()
+
+    def init_config(self):
+        pass
+
+    def register_adapters(self, *args):
+        pass
+
+    def on_before_start(self, func: LIFESPAN_FUNC):
+        """
+        注册启动前的函数
+        Args:
+            func:
+
+        Returns:
+
+        """
+        return self.lifespan.on_before_start(func)
+
+    def on_after_start(self, func: LIFESPAN_FUNC):
+        """
+        注册启动后的函数
+        Args:
+            func:
+
+        Returns:
+
+        """
+        return self.lifespan.on_after_start(func)
+
+    def on_before_shutdown(self, func: LIFESPAN_FUNC):
+        """
+        注册停止前的函数
+        Args:
+            func:
+
+        Returns:
+
+        """
+        return self.lifespan.on_before_shutdown(func)
+
+    def on_after_shutdown(self, func: LIFESPAN_FUNC):
+        """
+        注册停止后的函数：未实现
+        Args:
+            func:
+
+        Returns:
+
+        """
+        return self.lifespan.on_after_shutdown(func)
+
+    def on_before_restart(self, func: LIFESPAN_FUNC):
+        """
+        注册重启前的函数
+        Args:
+            func:
+
+        Returns:
+
+        """
+
+        return self.lifespan.on_before_restart(func)
+
+    def on_after_restart(self, func: LIFESPAN_FUNC):
+        """
+        注册重启后的函数：未实现
+        Args:
+            func:
+
+        Returns:
+
+        """
+        return self.lifespan.on_after_restart(func)
+
+    def on_after_nonebot_init(self, func: LIFESPAN_FUNC):
+        """
+        注册nonebot初始化后的函数
+        Args:
+            func:
+
+        Returns:
+
+        """
+        return self.lifespan.on_after_nonebot_init(func)
+
+
+_BOT_INSTANCE: Optional[LiteyukiBot] = None
+
+
+def get_bot() -> Optional[LiteyukiBot]:
+    """
+    获取轻雪实例
+    Returns:
+        LiteyukiBot: 当前的轻雪实例
+    """
+    return _BOT_INSTANCE

liteyuki/bot/lifespan.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (C) 2020-2024 LiteyukiStudio. All Rights Reserved 
+
+@Time    : 2024/7/23 下午8:24
+@Author  : snowykami
+@Email   : snowykami@outlook.com
+@File    : lifespan.py
+@Software: PyCharm
+"""
+from typing import Any, Awaitable, Callable, TypeAlias
+
+from liteyuki.utils import is_coroutine_callable
+
+SYNC_LIFESPAN_FUNC: TypeAlias = Callable[[], Any]
+ASYNC_LIFESPAN_FUNC: TypeAlias = Callable[[], Awaitable[Any]]
+LIFESPAN_FUNC: TypeAlias = SYNC_LIFESPAN_FUNC | ASYNC_LIFESPAN_FUNC
+
+
+class Lifespan:
+    def __init__(self) -> None:
+        """
+        轻雪生命周期管理，启动、停止、重启
+        """
+
+        self.life_flag: int = 0  # 0: 启动前，1: 启动后，2: 停止前，3: 停止后
+
+        self._before_start_funcs: list[LIFESPAN_FUNC] = []
+        self._after_start_funcs: list[LIFESPAN_FUNC] = []
+
+        self._before_shutdown_funcs: list[LIFESPAN_FUNC] = []
+        self._after_shutdown_funcs: list[LIFESPAN_FUNC] = []
+
+        self._before_restart_funcs: list[LIFESPAN_FUNC] = []
+        self._after_restart_funcs: list[LIFESPAN_FUNC] = []
+
+        self._after_nonebot_init_funcs: list[LIFESPAN_FUNC] = []
+
+    @staticmethod
+    async def _run_funcs(funcs: list[LIFESPAN_FUNC]) -> None:
+        """
+        运行函数
+        Args:
+            funcs:
+        Returns:
+        """
+        for func in funcs:
+            if is_coroutine_callable(func):
+                await func()
+            else:
+                func()
+
+    def on_before_start(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """
+        注册启动时的函数
+        Args:
+            func:
+        Returns:
+            LIFESPAN_FUNC:
+        """
+        self._before_start_funcs.append(func)
+        return func
+
+    def on_after_start(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """
+        注册启动时的函数
+        Args:
+            func:
+        Returns:
+            LIFESPAN_FUNC:
+        """
+        self._after_start_funcs.append(func)
+        return func
+
+    def on_before_shutdown(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """
+        注册停止前的函数
+        Args:
+            func:
+        Returns:
+            LIFESPAN_FUNC:
+        """
+        self._before_shutdown_funcs.append(func)
+        return func
+
+    def on_after_shutdown(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """
+        注册停止后的函数
+        Args:
+            func:
+
+        Returns:
+            LIFESPAN_FUNC:
+
+        """
+        self._after_shutdown_funcs.append(func)
+        return func
+
+    def on_before_restart(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """
+        注册重启时的函数
+        Args:
+            func:
+        Returns:
+            LIFESPAN_FUNC:
+        """
+        self._before_restart_funcs.append(func)
+        return func
+
+    def on_after_restart(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """
+        注册重启后的函数
+        Args:
+            func:
+        Returns:
+            LIFESPAN_FUNC:
+        """
+        self._after_restart_funcs.append(func)
+        return func
+
+    def on_after_nonebot_init(self, func):
+        """
+        注册 NoneBot 初始化后的函数
+        Args:
+            func:
+
+        Returns:
+
+        """
+        self._after_nonebot_init_funcs.append(func)
+        return func
+
+    async def before_start(self) -> None:
+        """
+        启动前
+        Returns:
+        """
+        await self._run_funcs(self._before_start_funcs)
+
+    async def after_start(self) -> None:
+        """
+        启动后
+        Returns:
+        """
+        await self._run_funcs(self._after_start_funcs)
+
+    async def before_shutdown(self) -> None:
+        """
+        停止前
+        Returns:
+        """
+        await self._run_funcs(self._before_shutdown_funcs)
+
+    async def after_shutdown(self) -> None:
+        """
+        停止后
+        Returns:
+        """
+        await self._run_funcs(self._after_shutdown_funcs)
+
+    async def before_restart(self) -> None:
+        """
+        重启前
+        Returns:
+        """
+        await self._run_funcs(self._before_restart_funcs)
+
+    async def after_restart(self) -> None:
+        """
+        重启后
+        Returns:
+
+        """
+        await self._run_funcs(self._after_restart_funcs)
+
+    async def after_nonebot_init(self) -> None:
+        """
+        NoneBot 初始化后
+        Returns:
+        """
+        await self._run_funcs(self._after_nonebot_init_funcs)

liteyuki/core/__init__.py

@@ -0,0 +1,3 @@
+from .spawn_process import *
+
+

liteyuki/core/spawn_process.py

@@ -0,0 +1,37 @@
+import threading
+from multiprocessing import get_context, Event
+
+import nonebot
+from nonebot import logger
+
+from liteyuki.plugin.load import load_plugins
+
+timeout_limit: int = 20
+__all__ = [
+        "ProcessingManager",
+        "nb_run",
+]
+
+
+class ProcessingManager:
+    event: Event = None
+
+    @classmethod
+    def restart(cls, delay: int = 0):
+        """
+        发送终止信号
+        Args:
+            delay: 延迟时间，默认为0，单位秒
+        Returns:
+        """
+        if cls.event is None:
+            raise RuntimeError("ProcessingManager has not been initialized.")
+        if delay > 0:
+            threading.Timer(delay, function=cls.event.set).start()
+            return
+        cls.event.set()
+
+
+def nb_run(event, *args, **kwargs):
+    ProcessingManager.event = event
+    nonebot.run(*args, **kwargs)

liteyuki/exception.py

@@ -0,0 +1,10 @@
+"""exception模块包含了liteyuki运行中的所有错误
+"""
+
+from typing import Any, Optional
+
+
+class LiteyukiException(BaseException):
+    """Liteyuki的异常基类。"""
+    def __str__(self) -> str:
+        return self.__repr__()

liteyuki/plugin/__init__.py

@@ -0,0 +1,17 @@
+from liteyuki.plugin.model import Plugin, PluginMetadata
+from liteyuki.plugin.load import load_plugin, _plugins
+
+__all__ = [
+        "PluginMetadata",
+        "Plugin",
+        "load_plugin",
+]
+
+
+def get_loaded_plugins() -> dict[str, Plugin]:
+    """
+    获取已加载的插件
+    Returns:
+        dict[str, Plugin]: 插件字典
+    """
+    return _plugins

liteyuki/plugin/load.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (C) 2020-2024 LiteyukiStudio. All Rights Reserved 
+
+@Time    : 2024/7/23 下午11:59
+@Author  : snowykami
+@Email   : snowykami@outlook.com
+@File    : load.py
+@Software: PyCharm
+"""
+import os
+import traceback
+from pathlib import Path
+from typing import Optional
+
+from nonebot import logger
+
+from liteyuki.plugin.model import Plugin, PluginMetadata
+from importlib import import_module
+
+from liteyuki.utils import path_to_module_name
+
+_plugins: dict[str, Plugin] = {}
+
+
+def load_plugin(module_path: str | Path) -> Optional[Plugin]:
+    """加载单个插件，可以是本地插件或是通过 `pip` 安装的插件。
+
+    参数:
+        module_path: 插件名称 `path.to.your.plugin`
+        或插件路径 `pathlib.Path(path/to/your/plugin)`
+    """
+    module_path = path_to_module_name(Path(module_path)) if isinstance(module_path, Path) else module_path
+    try:
+        module = import_module(module_path)
+        _plugins[module.__name__] = Plugin(
+            name=module.__name__,
+            module=module,
+            module_name=module_path,
+            metadata=module.__dict__.get("__plugin_metadata__", None)
+        )
+        logger.opt(colors=True).success(
+            f'Succeeded to load liteyuki plugin "<y>{module.__name__.split(".")[-1]}</y>"'
+        )
+        return _plugins[module.__name__]
+
+    except Exception as e:
+        logger.opt(colors=True).success(
+            f'Failed to load liteyuki plugin "<r>{module_path}</r>"'
+        )
+        traceback.print_exc()
+        return None
+
+
+def load_plugins(*plugin_dir: str) -> set[Plugin]:
+    """导入文件夹下多个插件
+
+    参数:
+        plugin_dir: 文件夹路径
+    """
+    plugins = set()
+    for dir_path in plugin_dir:
+        # 遍历每一个文件夹下的py文件和包含__init__.py的文件夹，不递归
+        for f in os.listdir(dir_path):
+            path = Path(os.path.join(dir_path, f))
+
+            module_name = None
+            if os.path.isfile(path) and f.endswith('.py') and f != '__init__.py':
+                module_name = f"{path_to_module_name(Path(dir_path))}.{f[:-3]}"
+
+            elif os.path.isdir(path) and os.path.exists(os.path.join(path, '__init__.py')):
+                module_name = path_to_module_name(path)
+
+            if module_name:
+                load_plugin(module_name)
+                if _plugins.get(module_name):
+                    plugins.add(_plugins[module_name])
+    return plugins

liteyuki/plugin/manager.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (C) 2020-2024 LiteyukiStudio. All Rights Reserved 
+
+@Time    : 2024/7/23 下午11:59
+@Author  : snowykami
+@Email   : snowykami@outlook.com
+@File    : manager.py
+@Software: PyCharm
+"""

liteyuki/plugin/model.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (C) 2020-2024 LiteyukiStudio. All Rights Reserved 
+
+@Time    : 2024/7/24 上午12:02
+@Author  : snowykami
+@Email   : snowykami@outlook.com
+@File    : model.py
+@Software: PyCharm
+"""
+from types import ModuleType
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class PluginMetadata(BaseModel):
+    """
+    轻雪插件元数据，由插件编写者提供
+    """
+    name: str
+    description: str
+    usage: str = ""
+    type: str = ""
+    homepage: str = ""
+    running_in_main: bool = True    # 是否在主进程运行
+
+
+class Plugin(BaseModel):
+    """
+    存储插件信息
+    """
+    model_config = {
+            'arbitrary_types_allowed': True
+    }
+    name: str
+    """插件名称 例如plugin_loader"""
+    module: ModuleType
+    """插件模块对象"""
+    module_name: str
+    """点分割模块路径 例如a.b.c"""
+    metadata: Optional[PluginMetadata] = None
+
+    def __hash__(self):
+        return hash(self.module_name)

liteyuki/plugins/plugin_loader/__init__.py

@@ -0,0 +1,33 @@
+import multiprocessing
+
+import nonebot
+from nonebot import get_driver
+
+from liteyuki.plugin import PluginMetadata
+from liteyuki import get_bot
+
+__plugin_metadata__ = PluginMetadata(
+    name="plugin_loader",
+    description="轻雪插件加载器",
+    usage="",
+    type="",
+    homepage=""
+)
+
+liteyuki = get_bot()
+
+
+@liteyuki.on_after_start
+def _():
+    print("轻雪启动完成，运行在进程", multiprocessing.current_process().name)
+
+
+@liteyuki.on_before_start
+def _():
+    print("轻雪启动中")
+
+
+@liteyuki.on_after_nonebot_init
+async def _():
+    print("NoneBot初始化完成")
+    nonebot.load_plugin("src.liteyuki_main")

liteyuki/plugins/plugin_loader/data_source.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (C) 2020-2024 LiteyukiStudio. All Rights Reserved 
+
+@Time    : 2024/7/23 下午11:21
+@Author  : snowykami
+@Email   : snowykami@outlook.com
+@File    : data_source.py
+@Software: PyCharm
+"""

liteyuki/utils.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+"""
+一些常用的工具类，部分来源于 nonebot 并遵循其许可进行修改
+"""
+import inspect
+from pathlib import Path
+from typing import Any, Callable
+
+
+def is_coroutine_callable(call: Callable[..., Any]) -> bool:
+    """
+    判断是否为协程可调用对象
+    Args:
+        call: 可调用对象
+    Returns:
+        bool: 是否为协程可调用对象
+    """
+    if inspect.isroutine(call):
+        return inspect.iscoroutinefunction(call)
+    if inspect.isclass(call):
+        return False
+    func_ = getattr(call, "__call__", None)
+    return inspect.iscoroutinefunction(func_)
+
+
+def path_to_module_name(path: Path) -> str:
+    """
+    转换路径为模块名
+    Args:
+        path: 路径a/b/c/d -> a.b.c.d
+    Returns:
+        str: 模块名
+    """
+    rel_path = path.resolve().relative_to(Path.cwd().resolve())
+    if rel_path.stem == "__init__":
+        return ".".join(rel_path.parts[:-1])
+    else:
+        return ".".join(rel_path.parts[:-1] + (rel_path.stem,))