fix: 插件列表显示错误问题

liteyuki/plugins/liteyuki_markdowntest.py

@@ -0,0 +1,59 @@
+import nonebot
+from nonebot import on_command, on_message
+from nonebot.adapters.onebot.v11 import MessageSegment
+from nonebot.exception import FinishedException
+from nonebot.params import CommandArg
+from nonebot.permission import SUPERUSER
+from nonebot.plugin import PluginMetadata
+
+from liteyuki.utils.message import send_markdown
+from liteyuki.utils.ly_typing import T_Message, T_Bot, v11, T_MessageEvent
+
+md_test = on_command("mdts", aliases={"会话md"}, permission=SUPERUSER)
+md_group = on_command("mdg", aliases={"群md"}, permission=SUPERUSER)
+md_conv = on_command("md", block=False, permission=SUPERUSER)
+
+placeholder = {
+        "[": "[",
+        "]": "]",
+        "&": "&",
+        ",": ",",
+        "\n"   : r"\n",
+        "\""   : r'\\\"'
+}
+
+
+@md_test.handle()
+async def _(bot: T_Bot, event: T_MessageEvent, arg: v11.Message = CommandArg()):
+    await send_markdown(
+        str(arg),
+        bot,
+        message_type=event.message_type,
+        session_id=event.user_id if event.message_type == "private" else event.group_id
+    )
+
+
+ignore_msg_ids = []
+last_sent = None
+
+
+@md_conv.handle()
+async def _(bot: v11.Bot, event: T_MessageEvent, arg: v11.Message = CommandArg()):
+    if str(event.user_id) == str(bot.self_id) and str(bot.self_id) in ["2751454815"]:
+        nonebot.logger.info("开始处理：%s" % str(event.message_id))
+
+        data = await send_markdown(str(arg), bot, message_type=event.message_type,
+                                   session_id=event.user_id if event.message_type == "private" else event.group_id)
+        await bot.delete_msg(message_id=event.message_id)
+
+
+__author__ = "snowykami"
+__plugin_meta__ = PluginMetadata(
+    name="轻雪Markdown测试",
+    description="用于测试Markdown的插件",
+    usage="",
+    homepage="https://github.com/snowykami/LiteyukiBot",
+    extra={
+            "liteyuki": True,
+    }
+)

liteyuki/plugins/liteyuki_minigame/__init__.py

@@ -0,0 +1,14 @@
+from nonebot.plugin import PluginMetadata
+
+__plugin_meta__ = PluginMetadata(
+    name="轻雪小游戏",
+    description="内置了一些小游戏",
+    usage="",
+    type="application",
+    homepage="https://github.com/snowykami/LiteyukiBot",
+    extra={
+            "liteyuki": True,
+            "toggleable"     : True,
+            "default_enable" : True,
+    }
+)

liteyuki/plugins/liteyuki_npm/__init__.py

@@ -0,0 +1,23 @@
+from nonebot.plugin import PluginMetadata
+from .manager import *
+from .installer import *
+from .helper import *
+
+__author__ = "snowykami"
+__plugin_meta__ = PluginMetadata(
+    name="轻雪插件管理",
+    description="本地插件管理和插件商店支持，支持启用/停用，安装/卸载插件",
+    usage=(
+            "npm list\n"
+            "npm enable/disable <plugin_name>\n"
+            "npm search <keywords...>\n"
+            "npm install/uninstall <plugin_name>\n"
+    ),
+    type="application",
+    homepage="https://github.com/snowykami/LiteyukiBot",
+    extra={
+            "liteyuki": True,
+            "toggleable"     : False,
+            "default_enable" : True,
+    }
+)

liteyuki/plugins/liteyuki_npm/common.py

@@ -0,0 +1,107 @@
+import json
+from typing import Optional
+
+import aiofiles
+import nonebot.plugin
+
+from liteyuki.utils.data import Database, LiteModel
+from liteyuki.utils.data_manager import GroupChat, InstalledPlugin, User, group_db, plugin_db, user_db
+from liteyuki.utils.ly_typing import T_MessageEvent
+
+LNPM_COMMAND_START = "lnpm"
+
+
+class PluginTag(LiteModel):
+    label: str
+    color: str = '#000000'
+
+
+class StorePlugin(LiteModel):
+    name: str
+    desc: str
+    module_name: str
+    project_link: str = ''
+    homepage: str = ''
+    author: str = ''
+    type: str | None = None
+    version: str | None = ''
+    time: str = ''
+    tags: list[PluginTag] = []
+    is_official: bool = False
+
+
+async def get_store_plugin(plugin_module_name: str) -> Optional[StorePlugin]:
+    """
+    获取插件信息
+
+    Args:
+        plugin_module_name (str): 插件模块名
+
+    Returns:
+        Optional[StorePlugin]: 插件信息
+    """
+    async with aiofiles.open("data/liteyuki/plugins.json", "r", encoding="utf-8") as f:
+        plugins: list[StorePlugin] = [StorePlugin(**pobj) for pobj in json.loads(await f.read())]
+    for plugin in plugins:
+        if plugin.module_name == plugin_module_name:
+            return plugin
+    return None
+
+
+def get_plugin_default_enable(plugin_module_name: str) -> bool:
+    """
+    获取插件默认启用状态，由插件定义，不存在则默认为启用
+
+    Args:
+        plugin_module_name (str): 插件模块名
+
+    Returns:
+        bool: 插件默认状态
+    """
+    plug = nonebot.plugin.get_plugin_by_module_name(plugin_module_name)
+    return (plug.metadata.extra.get('default_enable', True)
+            if plug.metadata else True) if plug else True
+
+
+def get_plugin_session_enable(event: T_MessageEvent, plugin_module_name: str) -> bool:
+    """
+    获取插件当前会话启用状态
+
+    Args:
+        event: 会话事件
+        plugin_module_name (str): 插件模块名
+
+    Returns:
+        bool: 插件当前状态
+    """
+    if event.message_type == "group":
+        session: GroupChat = group_db.first(GroupChat, 'group_id = ?', event.group_id, default=GroupChat(group_id=event.group_id))
+    else:
+        session: User = user_db.first(User, 'user_id = ?', event.user_id, default=User(user_id=event.user_id))
+    # 默认停用插件在启用列表内表示启用
+    # 默认停用插件不在启用列表内表示停用
+    # 默认启用插件在停用列表内表示停用
+    # 默认启用插件不在停用列表内表示启用
+    default_enable = get_plugin_default_enable(plugin_module_name)
+    if default_enable:
+        return plugin_module_name not in session.disabled_plugins
+    else:
+        return plugin_module_name in session.enabled_plugins
+
+
+def get_plugin_global_enable(plugin_module_name: str) -> bool:
+    return True
+
+
+def get_plugin_can_be_toggle(plugin_module_name: str) -> bool:
+    """
+    获取插件是否可以被启用/停用
+
+    Args:
+        plugin_module_name (str): 插件模块名
+
+    Returns:
+        bool: 插件是否可以被启用/停用
+    """
+    plug = nonebot.plugin.get_plugin_by_module_name(plugin_module_name)
+    return plug.metadata.extra.get('toggleable', True) if plug and plug.metadata else True

liteyuki/plugins/liteyuki_npm/installer.py

@@ -0,0 +1,231 @@
+import os.path
+import sys
+from io import StringIO
+
+import aiohttp
+import nonebot
+import pip
+from arclet.alconna import Arparma, MultiVar
+from nonebot.permission import SUPERUSER
+from nonebot_plugin_alconna import Alconna, Args, Subcommand, on_alconna
+
+from liteyuki.utils.language import get_user_lang
+from liteyuki.utils.ly_typing import T_Bot
+from liteyuki.utils.message import Markdown as md, send_markdown
+from .common import *
+
+npm_alc = on_alconna(
+    Alconna(
+        ["npm", "插件"],
+        Subcommand(
+            "update",
+            alias=["u"],
+        ),
+        Subcommand(
+            "search",
+            Args["keywords", MultiVar(str)]["page", int, 1],
+            alias=["s", "搜索"],
+        ),
+        Subcommand(
+            "install",
+            Args["plugin_name", str],
+            alias=["i", "安装"],
+        ),
+        Subcommand(
+            "uninstall",
+            Args["plugin_name", str],
+            alias=["rm", "移除", "卸载"],
+        ),
+        Subcommand(
+            "list",
+            alias=["l", "ls", "列表"],
+        )
+    ),
+    permission=SUPERUSER
+)
+
+
+@npm_alc.handle()
+async def _(result: Arparma, event: T_MessageEvent, bot: T_Bot):
+    ulang = get_user_lang(str(event.user_id))
+
+    if not os.path.exists("data/liteyuki/plugins.json"):
+        await npm_update()
+
+    if result.subcommands.get("update"):
+        r = await npm_update()
+        if r:
+            await npm_alc.finish(ulang.get("npm.store_update_success"))
+        else:
+            await npm_alc.finish(ulang.get("npm.store_update_failed"))
+
+    elif result.subcommands.get("search"):
+        keywords: list[str] = result.subcommands["search"].args.get("keywords")
+        rs = await npm_search(keywords)
+        max_show = 10
+        if len(rs):
+            reply = f"{ulang.get('npm.search_result')} | {ulang.get('npm.total', TOTAL=len(rs))}\n***"
+            for plugin in rs[:min(max_show, len(rs))]:
+                btn_install = md.button(ulang.get('npm.install'), 'npm install %s' % plugin.module_name)
+                link_page = md.link(ulang.get('npm.homepage'), plugin.homepage)
+                link_pypi = md.link(ulang.get('npm.pypi'), plugin.homepage)
+
+                reply += (f"\n# **{plugin.name}**\n"
+                          f"\n> **{plugin.desc}**\n"
+                          f"\n> {ulang.get('npm.author')}: {plugin.author}"
+                          f"\n> *{md.escape(plugin.module_name)}*"
+                          f"\n> {btn_install}    {link_page}    {link_pypi}\n\n***\n")
+            if len(rs) > max_show:
+                reply += f"\n{ulang.get('npm.too_many_results', HIDE_NUM=len(rs) - max_show)}"
+        else:
+            reply = ulang.get("npm.search_no_result")
+        await send_markdown(reply, bot, event=event)
+
+    elif result.subcommands.get("install"):
+        plugin_module_name: str = result.subcommands["install"].args.get("plugin_name")
+        store_plugin = await get_store_plugin(plugin_module_name)
+        await npm_alc.send(ulang.get("npm.installing", NAME=plugin_module_name))
+        r, log = npm_install(plugin_module_name)
+        log = log.replace("\\", "/")
+
+        if not store_plugin:
+            await npm_alc.finish(ulang.get("npm.plugin_not_found", NAME=plugin_module_name))
+
+        homepage_btn = md.button(ulang.get('npm.homepage'), store_plugin.homepage)
+        if r:
+
+            r_load = nonebot.load_plugin(plugin_module_name)  # 加载插件
+            installed_plugin = InstalledPlugin(module_name=plugin_module_name)  # 构造插件信息模型
+            found_in_db_plugin = plugin_db.first(InstalledPlugin, "module_name = ?", plugin_module_name)  # 查询数据库中是否已经安装
+
+            if r_load:
+                if found_in_db_plugin is None:
+                    plugin_db.upsert(installed_plugin)
+                    info = ulang.get('npm.install_success', NAME=store_plugin.name).replace('_', r'\\_')  # markdown转义
+                    await send_markdown(
+                        f"{info}\n\n"
+                        f"```\n{log}\n```",
+                        bot,
+                        event=event
+                    )
+                else:
+                    await npm_alc.finish(ulang.get('npm.plugin_already_installed', NAME=store_plugin.name))
+            else:
+                info = ulang.get('npm.load_failed', NAME=plugin_module_name, HOMEPAGE=homepage_btn).replace('_', r'\\_')
+                await send_markdown(
+                    f"{info}\n\n"
+                    f"```\n{log}\n```\n",
+                    bot,
+                    event=event
+                )
+        else:
+            info = ulang.get('npm.install_failed', NAME=plugin_module_name, HOMEPAGE=homepage_btn).replace('_', r'\\_')
+            await send_markdown(
+                f"{info}\n\n"
+                f"```\n{log}\n```",
+                bot,
+                event=event
+            )
+
+    elif result.subcommands.get("uninstall"):
+        plugin_module_name: str = result.subcommands["uninstall"].args.get("plugin_name")
+        found_installed_plugin: InstalledPlugin = plugin_db.first(InstalledPlugin, "module_name = ?", plugin_module_name)
+        if found_installed_plugin:
+            plugin_db.delete(InstalledPlugin, "module_name = ?", plugin_module_name)
+            reply = f"{ulang.get('npm.uninstall_success', NAME=found_installed_plugin.module_name)}"
+            await npm_alc.finish(reply)
+        else:
+            await npm_alc.finish(ulang.get("npm.plugin_not_installed", NAME=plugin_module_name))
+
+
+async def npm_update() -> bool:
+    """
+    更新本地插件json缓存
+
+    Returns:
+        bool: 是否成功更新
+    """
+    url_list = [
+            "https://registry.nonebot.dev/plugins.json",
+    ]
+    for url in url_list:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as resp:
+                if resp.status == 200:
+                    async with aiofiles.open("data/liteyuki/plugins.json", "wb") as f:
+                        data = await resp.read()
+                        await f.write(data)
+                    return True
+    return False
+
+
+async def npm_search(keywords: list[str]) -> list[StorePlugin]:
+    """
+    搜索插件
+
+    Args:
+        keywords (list[str]): 关键词列表
+
+    Returns:
+        list[StorePlugin]: 插件列表
+    """
+    results = []
+    async with aiofiles.open("data/liteyuki/plugins.json", "r", encoding="utf-8") as f:
+        plugins: list[StorePlugin] = [StorePlugin(**pobj) for pobj in json.loads(await f.read())]
+    for plugin in plugins:
+        plugin_text = ' '.join(
+            [
+                    plugin.name,
+                    plugin.desc,
+                    plugin.author,
+                    plugin.module_name,
+                    plugin.project_link,
+                    plugin.homepage,
+                    ' '.join([tag.label for tag in plugin.tags])
+            ]
+        )
+        if all([keyword in plugin_text for keyword in keywords]):
+            results.append(plugin)
+    return results
+
+
+def npm_install(plugin_module_name) -> tuple[bool, str]:
+    """
+    Args:
+        plugin_module_name:
+
+    Returns:
+        tuple[bool, str]:
+
+    """
+    buffer = StringIO()
+    sys.stdout = buffer
+    sys.stderr = buffer
+
+    mirrors = [
+            "https://pypi.tuna.tsinghua.edu.cn/simple",  # 清华大学
+            "https://pypi.mirrors.cqupt.edu.cn/simple",  # 重庆邮电大学
+            "https://pypi.liteyuki.icu/simple",  # 轻雪镜像
+            "https://pypi.org/simple",  # 官方源
+    ]
+
+    # 使用pip安装包，对每个镜像尝试一次，成功后返回值
+    success = False
+    for mirror in mirrors:
+        try:
+            nonebot.logger.info(f"npm_install try mirror: {mirror}")
+            result = pip.main(['install', plugin_module_name, "-i", mirror])
+            success = result == 0
+            if success:
+                break
+            else:
+                nonebot.logger.warning(f"npm_install failed, try next mirror.")
+        except Exception as e:
+
+            success = False
+            continue
+
+    sys.stdout = sys.__stdout__
+    sys.stderr = sys.__stderr__
+
+    return success, buffer.getvalue()

liteyuki/plugins/liteyuki_npm/manager.py

@@ -0,0 +1,175 @@
+import os
+
+import nonebot.plugin
+from nonebot import on_command
+from nonebot.exception import FinishedException
+from nonebot.internal.matcher import Matcher
+from nonebot.message import run_preprocessor
+from nonebot.permission import SUPERUSER
+from nonebot_plugin_alconna import on_alconna, Alconna, Args, Arparma
+
+from liteyuki.utils.data_manager import GroupChat, InstalledPlugin, User, group_db, plugin_db, user_db
+from liteyuki.utils.message import Markdown as md, send_markdown
+from liteyuki.utils.permission import GROUP_ADMIN, GROUP_OWNER
+from liteyuki.utils.ly_typing import T_Bot, T_MessageEvent
+from liteyuki.utils.language import get_user_lang
+from .common import get_plugin_can_be_toggle, get_plugin_global_enable, get_plugin_session_enable, get_plugin_default_enable
+from .installer import get_store_plugin, npm_update
+
+list_plugins = on_alconna(
+    Alconna(
+        ['list-plugins', "插件列表", "列出插件"],
+    )
+)
+
+toggle_plugin = on_alconna(
+    Alconna(
+        ['enable-plugin', 'disable-plugin'],
+        Args['plugin_name', str],
+    )
+)
+
+global_toggle = on_alconna(
+    Alconna(
+        ['toggle-global'],
+        Args['plugin_name', str],
+    ),
+    permission=SUPERUSER
+)
+
+
+@list_plugins.handle()
+async def _(event: T_MessageEvent, bot: T_Bot):
+    if not os.path.exists("data/liteyuki/plugins.json"):
+        await npm_update()
+    lang = get_user_lang(str(event.user_id))
+    reply = f"# {lang.get('npm.loaded_plugins')} | {lang.get('npm.total', TOTAL=len(nonebot.get_loaded_plugins()))} \n***\n"
+    for plugin in nonebot.get_loaded_plugins():
+        # 检查是否有 metadata 属性
+        # 添加帮助按钮
+        btn_usage = md.button(lang.get('npm.usage'), f'help {plugin.module_name}', False)
+        store_plugin = await get_store_plugin(plugin.module_name)
+
+        session_enable = get_plugin_session_enable(event, plugin.module_name)
+        default_enable = get_plugin_default_enable(plugin.module_name)
+        print(session_enable, default_enable, plugin.module_name)
+
+        if store_plugin:
+            btn_homepage = md.link(lang.get('npm.homepage'), store_plugin.homepage)
+            show_name = store_plugin.name
+            show_desc = store_plugin.desc
+        elif plugin.metadata:
+            if plugin.metadata.extra.get('liteyuki'):
+                btn_homepage = md.link(lang.get('npm.homepage'), "https://github.com/snowykami/LiteyukiBot")
+            else:
+                btn_homepage = lang.get('npm.homepage')
+            show_name = plugin.metadata.name
+            show_desc = plugin.metadata.description
+        else:
+            btn_homepage = lang.get('npm.homepage')
+            show_name = plugin.name
+            show_desc = lang.get('npm.no_description')
+
+        if plugin.metadata:
+            reply += (f"\n**{md.escape(show_name)}**\n"
+                      f"\n > {md.escape(show_desc)}")
+        else:
+            reply += (f"**{md.escape(show_name)}**\n"
+                      f"\n > {md.escape(show_desc)}")
+
+        reply += f"\n > {btn_usage}  {btn_homepage}"
+
+        if await GROUP_ADMIN(bot, event) or await GROUP_OWNER(bot, event) or await SUPERUSER(bot, event):
+            # 添加启用/停用插件按钮
+            cmd_toggle = f"{'disable' if session_enable else 'enable'}-plugin {plugin.module_name}"
+            text_toggle = lang.get('npm.disable' if session_enable else 'npm.enable')
+            can_be_toggle = get_plugin_can_be_toggle(plugin.module_name)
+            btn_toggle = text_toggle if not can_be_toggle else md.button(text_toggle, cmd_toggle)
+
+            reply += f"  {btn_toggle}"
+
+            if await SUPERUSER(bot, event):
+                plugin_in_database = plugin_db.first(InstalledPlugin, 'module_name = ?', plugin.module_name)
+                # 添加移除插件和全局切换按钮
+                global_enable = get_plugin_global_enable(plugin.module_name)
+                btn_uninstall = (
+                        md.button(lang.get('npm.uninstall'), f'npm uninstall {plugin.module_name}')) if plugin_in_database else lang.get(
+                    'npm.uninstall')
+
+                btn_toggle_global_text = lang.get('npm.disable_global' if global_enable else 'npm.enable_global')
+                cmd_toggle_global = f'npm toggle-global {plugin.module_name}'
+                btn_toggle_global = btn_toggle_global_text if not can_be_toggle else md.button(btn_toggle_global_text, cmd_toggle_global)
+
+                reply += f"  {btn_uninstall}  {btn_toggle_global}"
+
+        reply += "\n\n***\n"
+    await send_markdown(reply, bot, event=event)
+
+
+@toggle_plugin.handle()
+async def _(result: Arparma, event: T_MessageEvent, bot: T_Bot):
+    if not os.path.exists("data/liteyuki/plugins.json"):
+        await npm_update()
+    # 判断会话类型
+    ulang = get_user_lang(str(event.user_id))
+    plugin_module_name = result.args.get("plugin_name")
+
+    toggle = result.header_result == 'enable-plugin'  # 判断是启用还是停用
+    current_enable = get_plugin_session_enable(event, plugin_module_name)  # 获取插件当前状态
+
+    default_enable = get_plugin_default_enable(plugin_module_name)  # 获取插件默认状态
+
+    can_be_toggled = get_plugin_can_be_toggle(plugin_module_name)  # 获取插件是否可以被启用/停用
+
+    if not can_be_toggled:
+        await toggle_plugin.finish(ulang.get("npm.plugin_cannot_be_toggled", NAME=plugin_module_name))
+
+    if current_enable == toggle:
+        await toggle_plugin.finish(
+            ulang.get("npm.plugin_already", NAME=plugin_module_name, STATUS=ulang.get("npm.enable") if toggle else ulang.get("npm.disable")))
+
+    if event.message_type == "private":
+        session = user_db.first(User, "user_id = ?", event.user_id, default=User(user_id=event.user_id))
+    else:
+        if await GROUP_ADMIN(bot, event) or await GROUP_OWNER(bot, event) or await SUPERUSER(bot, event):
+            session = group_db.first(GroupChat, "group_id = ?", event.group_id, default=GroupChat(group_id=event.group_id))
+        else:
+            raise FinishedException(ulang.get("Permission Denied"))
+    try:
+        if toggle:
+            if default_enable:
+                session.disabled_plugins.remove(plugin_module_name)
+            else:
+                session.enabled_plugins.append(plugin_module_name)
+        else:
+            if default_enable:
+                session.disabled_plugins.append(plugin_module_name)
+            else:
+                session.enabled_plugins.remove(plugin_module_name)
+    except Exception as e:
+        await toggle_plugin.finish(
+            ulang.get(
+                "npm.toggle_failed",
+                NAME=plugin_module_name,
+                STATUS=ulang.get("npm.enable") if toggle else ulang.get("npm.disable"),
+                ERROR=str(e))
+        )
+
+    await toggle_plugin.finish(
+        ulang.get(
+            "npm.toggle_success",
+            NAME=plugin_module_name,
+            STATUS=ulang.get("npm.enable") if toggle else ulang.get("npm.disable"))
+    )
+
+    if event.message_type == "private":
+        user_db.upsert(session)
+    else:
+        group_db.upsert(session)
+
+
+@run_preprocessor
+async def _(event: T_MessageEvent, matcher: Matcher):
+    plugin = matcher.plugin
+    # TODO 插件启用/停用检查hook
+    nonebot.logger.info(f"Plugin Callapi: {plugin.module_name}")

liteyuki/plugins/liteyuki_npm/permission.py

@@ -0,0 +1,8 @@
+# 插件权限管理器，对api调用进行hook限制，防止插件滥用api
+from liteyuki.utils.data import LiteModel
+
+
+class PermissionAllow(LiteModel):
+    plugin_name: str
+    api_name: str
+    allow: bool

liteyuki/plugins/liteyuki_user/__init__.py

@@ -0,0 +1,16 @@
+from nonebot.plugin import PluginMetadata
+
+from .profile_manager import *
+
+__author__ = "snowykami"
+__plugin_meta__ = PluginMetadata(
+    name="轻雪用户管理",
+    description="用户管理插件",
+    usage="",
+    homepage="https://github.com/snowykami/LiteyukiBot",
+    extra={
+            "liteyuki": True,
+            "toggleable"     : False,
+            "default_enable" : True,
+    }
+)

liteyuki/plugins/liteyuki_user/input_handle.py

@@ -0,0 +1,2 @@
+def detect_lang(input_str: str) -> str:
+    return "zh-CN" if input_str == "zh" else "en"

liteyuki/plugins/liteyuki_user/profile_manager.py

@@ -0,0 +1,135 @@
+from typing import Optional
+
+from nonebot_plugin_alconna import Alconna, Args, Arparma, Subcommand, on_alconna
+
+from liteyuki.utils.data import LiteModel
+from liteyuki.utils.data_manager import User, user_db
+from liteyuki.utils.language import Language, get_all_lang, get_user_lang
+from liteyuki.utils.ly_typing import T_Bot, T_MessageEvent
+from liteyuki.utils.message import Markdown as md, send_markdown
+
+profile_alc = on_alconna(
+    Alconna(
+        ["profile", "个人信息"],
+        Subcommand(
+            "set",
+            Args["key", str]["value", str, None],
+            alias=["s", "设置"],
+        ),
+        Subcommand(
+            "get",
+            Args["key", str],
+            alias=["g", "查询"],
+        ),
+    )
+)
+
+
+# json储存
+class Profile(LiteModel):
+    lang: str = "zh-CN"
+    nickname: str = ""
+    timezone: str = "Asia/Shanghai"
+    location: str = ""
+
+
+@profile_alc.handle()
+async def _(result: Arparma, event: T_MessageEvent, bot: T_Bot):
+    user: User = user_db.first(User, "user_id = ?", event.user_id, default=User(user_id=str(event.user_id)))
+    ulang = get_user_lang(str(event.user_id))
+    if result.subcommands.get("set"):
+        if result.subcommands["set"].args.get("value"):
+            # 对合法性进行校验后设置
+            r = set_profile(result.args["key"], result.args["value"])
+            if r:
+                user.profile[result.args["key"]] = result.args["value"]
+                user_db.upsert(user)  # 数据库保存
+                await profile_alc.finish(
+                    ulang.get(
+                        "user.profile.set_success",
+                        ATTR=ulang.get(f"user.profile.{result.args['key']}"),
+                        VALUE=result.args["value"]
+                    )
+                )
+            else:
+                await profile_alc.finish(ulang.get("user.profile.set_failed", ATTR=ulang.get(f"user.profile.{result.args['key']}")))
+        else:
+            # 未输入值，尝试呼出菜单
+            menu = get_profile_menu(result.args["key"], ulang)
+            if menu:
+                await send_markdown(menu, bot, event=event)
+            else:
+                await profile_alc.finish(ulang.get("user.profile.input_value", ATTR=ulang.get(f"user.profile.{result.args['key']}")))
+
+        user.profile[result.args["key"]] = result.args["value"]
+
+    elif result.subcommands.get("get"):
+        if result.args["key"] in user.profile:
+            await profile_alc.finish(user.profile[result.args["key"]])
+        else:
+            await profile_alc.finish("无此键值")
+    else:
+        profile = Profile(**user.profile)
+
+        for k, v in user.profile.items():
+            profile.__setattr__(k, v)
+
+        reply = f"# {ulang.get('user.profile.info')}\n***\n"
+
+        hidden_attr = ["id"]
+        enter_attr = ["lang", "timezone"]
+
+        for key in sorted(profile.dict().keys()):
+            if key in hidden_attr:
+                continue
+            val = profile.dict()[key]
+            key_text = ulang.get(f"user.profile.{key}")
+            btn_set = md.button(ulang.get("user.profile.edit"), f"profile set {key}",
+                                enter=True if key in enter_attr else False)
+            reply += (f"\n**{key_text}**    **{val}**\n"
+                      f"\n > {btn_set}  {ulang.get(f'user.profile.{key}.desc')}\n\n***\n")
+        await send_markdown(reply, bot, event=event)
+
+
+def get_profile_menu(key: str, ulang: Language) -> Optional[str]:
+    """获取属性的markdown菜单
+    Args:
+        ulang: 用户语言
+        key: 属性键
+
+    Returns:
+
+    """
+    setting_name = ulang.get(f"user.profile.{key}")
+
+    no_menu = ["id", "nickname", "location"]
+
+    if key in no_menu:
+        return None
+
+    reply = f"{setting_name} {ulang.get('user.profile.settings')}\n***\n"
+    if key == "lang":
+        for lang_code, lang_name in get_all_lang().items():
+            btn_set = md.button(ulang.get('user.profile.set'), f"profile set {key} {lang_code}")
+            reply += (f"\n**{lang_name}**    **{lang_code}**\n"
+                      f"\n> {btn_set}\n\n***")
+    return reply
+
+
+def set_profile(key: str, value: str) -> bool:
+    """设置属性，使用if分支对每一个合法性进行检查
+    Args:
+        key:
+        value:
+
+    Returns:
+        是否成功设置，输入合法性不通过返回False
+
+    """
+    if key == 'lang':
+        if value in get_all_lang():
+            return True
+        return False
+    elif key == 'timezone':
+        # TODO 其他个人信息项目的实现
+        pass

liteyuki/plugins/liteyuki_weather/__init__.py

@@ -0,0 +1,15 @@
+from nonebot.plugin import PluginMetadata
+
+__plugin_meta__ = PluginMetadata(
+    name="轻雪天气",
+    description="基于和风天气api的天气插件",
+    usage="",
+    type="application",
+    homepage="https://github.com/snowykami/LiteyukiBot",
+    extra={
+            "liteyuki": True,
+            "toggleable"     : True,
+            "default_enable" : True,
+    }
+)
+