chore: import private baseline from gitea state

This commit is contained in:
Losita
2026-05-11 19:24:06 +08:00
parent 161fc42c52
commit 1ba863d135
111 changed files with 10873 additions and 7347 deletions

View File

@@ -0,0 +1,18 @@
"""NapCat API mixin 导出。"""
from .account import NapCatAccountApiMixin
from .file import NapCatFileApiMixin
from .group import NapCatGroupApiMixin
from .message import NapCatMessageApiMixin
from . import message_tool_patch as _message_tool_patch
from .support import NapCatApiSupportMixin
from .system import NapCatSystemApiMixin
__all__ = [
"NapCatAccountApiMixin",
"NapCatApiSupportMixin",
"NapCatFileApiMixin",
"NapCatGroupApiMixin",
"NapCatMessageApiMixin",
"NapCatSystemApiMixin",
]

View File

@@ -0,0 +1,366 @@
"""NapCat 账号与用户侧 API 端点。"""
from __future__ import annotations
from typing import Any, Dict, List, Optional
from maibot_sdk import API
from .support import NapCatApiIdInput, NapCatApiParamsInput, NapCatApiSupportMixin
class NapCatAccountApiMixin(NapCatApiSupportMixin):
"""NapCat 账号、好友与资料相关 API。"""
@API("adapter.napcat.account.set_qq_profile", description="设置 QQ 账号资料", version="1", public=True)
async def api_set_qq_profile(
self,
nickname: object,
personal_note: str = "",
sex: str = "",
) -> Dict[str, Any]:
"""设置 QQ 账号资料。
Args:
nickname: 新昵称。
personal_note: 个性签名。
sex: 性别,支持 ``male``、``female``、``unknown``。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
normalized_sex = str(sex or "").strip().lower()
if normalized_sex and normalized_sex not in {"male", "female", "unknown"}:
raise ValueError("sex 必须为 male、female 或 unknown")
return await self._require_query_service().set_qq_profile(
nickname=self._normalize_non_empty_string(nickname, "nickname"),
personal_note=str(personal_note or "").strip(),
sex=normalized_sex,
)
@API("adapter.napcat.account.get_stranger_info", description="获取陌生人信息", version="1", public=True)
async def api_get_stranger_info(
self,
user_id: NapCatApiIdInput,
no_cache: bool = False,
) -> Optional[Dict[str, Any]]:
"""获取陌生人信息。
Args:
user_id: 用户号。
no_cache: 是否禁用缓存。
Returns:
Optional[Dict[str, Any]]: 陌生人信息字典;失败时返回 ``None``。
"""
return await self._require_query_service().get_stranger_info(
str(self._normalize_positive_int(user_id, "user_id")),
no_cache=bool(no_cache),
)
@API("adapter.napcat.account.get_friend_list", description="获取好友列表", version="1", public=True)
async def api_get_friend_list(self, no_cache: bool = False) -> Optional[List[Dict[str, Any]]]:
"""获取好友列表。
Args:
no_cache: 是否禁用缓存。
Returns:
Optional[List[Dict[str, Any]]]: 好友信息列表;失败时返回 ``None``。
"""
return await self._require_query_service().get_friend_list(no_cache=bool(no_cache))
@API("adapter.napcat.account.create_collection", description="创建收藏", version="1", public=True)
async def api_action_create_collection(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``create_collection`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("create_collection", params)
@API("adapter.napcat.account.delete_friend", description="删除好友", version="1", public=True)
async def api_action_delete_friend(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``delete_friend`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("delete_friend", params)
@API("adapter.napcat.account.fetch_custom_face", description="获取自定义表情", version="1", public=True)
async def api_action_fetch_custom_face(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``fetch_custom_face`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("fetch_custom_face", params)
@API("adapter.napcat.account.get_ai_characters", description="获取AI角色列表", version="1", public=True)
async def api_action_get_ai_characters(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_ai_characters`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_ai_characters", params)
@API("adapter.napcat.account.get_clientkey", description="获取ClientKey", version="1", public=True)
async def api_action_get_clientkey(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_clientkey`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_clientkey", params)
@API("adapter.napcat.account.get_collection_list", description="获取收藏列表", version="1", public=True)
async def api_action_get_collection_list(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_collection_list`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_collection_list", params)
@API("adapter.napcat.account.get_cookies", description="获取 Cookies", version="1", public=True)
async def api_action_get_cookies(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_cookies`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_cookies", params)
@API(
"adapter.napcat.account.get_friends_with_category", description="获取带分组的好友列表", version="1", public=True
)
async def api_action_get_friends_with_category(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_friends_with_category`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_friends_with_category", params)
@API("adapter.napcat.account.get_mini_app_ark", description="获取小程序 Ark", version="1", public=True)
async def api_action_get_mini_app_ark(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_mini_app_ark`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_mini_app_ark", params)
@API("adapter.napcat.account.get_profile_like", description="获取资料点赞", version="1", public=True)
async def api_action_get_profile_like(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_profile_like`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_profile_like", params)
@API("adapter.napcat.account.get_recent_contact", description="获取最近会话", version="1", public=True)
async def api_action_get_recent_contact(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_recent_contact`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_recent_contact", params)
@API("adapter.napcat.account.get_rkey", description="获取扩展 RKey", version="1", public=True)
async def api_action_get_rkey(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_rkey`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_rkey", params)
@API("adapter.napcat.account.get_rkey_server", description="获取 RKey 服务器", version="1", public=True)
async def api_action_get_rkey_server(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_rkey_server`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_rkey_server", params)
@API(
"adapter.napcat.account.get_unidirectional_friend_list",
description="获取单向好友列表",
version="1",
public=True,
)
async def api_action_get_unidirectional_friend_list(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_unidirectional_friend_list`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_unidirectional_friend_list", params)
@API("adapter.napcat.account.internal_ocr_image", description="图片 OCR 识别 (内部)", version="1", public=True)
async def api_action_internal_ocr_image(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``.ocr_image`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action(".ocr_image", params)
@API("adapter.napcat.account.nc_get_rkey", description="获取 RKey", version="1", public=True)
async def api_action_nc_get_rkey(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``nc_get_rkey`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("nc_get_rkey", params)
@API("adapter.napcat.account.ocr_image", description="图片 OCR 识别", version="1", public=True)
async def api_action_ocr_image(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``ocr_image`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("ocr_image", params)
@API("adapter.napcat.account.send_like", description="点赞", version="1", public=True)
async def api_action_send_like(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_like`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_like", params)
@API("adapter.napcat.account.set_diy_online_status", description="设置自定义在线状态", version="1", public=True)
async def api_action_set_diy_online_status(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_diy_online_status`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_diy_online_status", params)
@API("adapter.napcat.account.set_friend_add_request", description="处理加好友请求", version="1", public=True)
async def api_action_set_friend_add_request(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_friend_add_request`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_friend_add_request", params)
@API("adapter.napcat.account.set_friend_remark", description="设置好友备注", version="1", public=True)
async def api_action_set_friend_remark(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_friend_remark`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_friend_remark", params)
@API("adapter.napcat.account.set_qq_avatar", description="设置QQ头像", version="1", public=True)
async def api_action_set_qq_avatar(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_qq_avatar`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_qq_avatar", params)
@API("adapter.napcat.account.set_self_longnick", description="设置个性签名", version="1", public=True)
async def api_action_set_self_longnick(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_self_longnick`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_self_longnick", params)
@API("adapter.napcat.account.translate_en2zh", description="英文单词翻译", version="1", public=True)
async def api_action_translate_en2zh(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``translate_en2zh`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("translate_en2zh", params)

View File

@@ -0,0 +1,535 @@
"""NapCat 文件与流式 API 端点。"""
from __future__ import annotations
from typing import Any, Dict, Optional
from maibot_sdk import API
from .support import NapCatApiParamsInput, NapCatApiSupportMixin
class NapCatFileApiMixin(NapCatApiSupportMixin):
"""NapCat 文件、媒体与流式相关 API。"""
@API("adapter.napcat.file.get_record", description="获取语音文件详情", version="1", public=True)
async def api_get_record(
self,
file: object = "",
file_id: str = "",
out_format: str = "wav",
) -> Optional[Dict[str, Any]]:
"""获取语音文件详情。
Args:
file: 语音文件名。
file_id: 可选文件 ID。
out_format: 输出格式;默认保持兼容旧行为的 ``wav``。
Returns:
Optional[Dict[str, Any]]: 语音文件详情;失败时返回 ``None``。
"""
normalized_file_name = str(file or "").strip() or None
normalized_file_id = str(file_id or "").strip() or None
normalized_out_format = str(out_format or "").strip()
if normalized_file_name is None and normalized_file_id is None:
raise ValueError("file 或 file_id 至少提供一个")
return await self._require_query_service().get_record_detail(
file_name=normalized_file_name,
file_id=normalized_file_id,
out_format=normalized_out_format,
)
@API("adapter.napcat.file.cancel_online_file", description="取消在线文件", version="1", public=True)
async def api_action_cancel_online_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``cancel_online_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("cancel_online_file", params)
@API("adapter.napcat.file.clean_stream_temp_file", description="清理流式传输临时文件", version="1", public=True)
async def api_action_clean_stream_temp_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``clean_stream_temp_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("clean_stream_temp_file", params)
@API("adapter.napcat.file.create_flash_task", description="创建闪传任务", version="1", public=True)
async def api_action_create_flash_task(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``create_flash_task`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("create_flash_task", params)
@API("adapter.napcat.file.create_group_file_folder", description="创建群文件目录", version="1", public=True)
async def api_action_create_group_file_folder(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``create_group_file_folder`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("create_group_file_folder", params)
@API("adapter.napcat.file.del_group_album_media", description="删除群相册媒体", version="1", public=True)
async def api_action_del_group_album_media(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``del_group_album_media`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("del_group_album_media", params)
@API("adapter.napcat.file.delete_group_file", description="删除群文件", version="1", public=True)
async def api_action_delete_group_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``delete_group_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("delete_group_file", params)
@API("adapter.napcat.file.delete_group_folder", description="删除群文件目录", version="1", public=True)
async def api_action_delete_group_folder(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``delete_group_folder`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("delete_group_folder", params)
@API("adapter.napcat.file.do_group_album_comment", description="发表群相册评论", version="1", public=True)
async def api_action_do_group_album_comment(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``do_group_album_comment`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("do_group_album_comment", params)
@API("adapter.napcat.file.download_file", description="下载文件", version="1", public=True)
async def api_action_download_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``download_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("download_file", params)
@API("adapter.napcat.file.download_file_image_stream", description="下载图片文件流", version="1", public=True)
async def api_action_download_file_image_stream(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``download_file_image_stream`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("download_file_image_stream", params)
@API("adapter.napcat.file.download_file_record_stream", description="下载语音文件流", version="1", public=True)
async def api_action_download_file_record_stream(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``download_file_record_stream`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("download_file_record_stream", params)
@API("adapter.napcat.file.download_file_stream", description="下载文件流", version="1", public=True)
async def api_action_download_file_stream(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``download_file_stream`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("download_file_stream", params)
@API("adapter.napcat.file.download_fileset", description="下载文件集", version="1", public=True)
async def api_action_download_fileset(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``download_fileset`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("download_fileset", params)
@API("adapter.napcat.file.get_file", description="获取文件", version="1", public=True)
async def api_action_get_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_file", params)
@API("adapter.napcat.file.get_fileset_id", description="获取文件集 ID", version="1", public=True)
async def api_action_get_fileset_id(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_fileset_id`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_fileset_id", params)
@API("adapter.napcat.file.get_fileset_info", description="获取文件集信息", version="1", public=True)
async def api_action_get_fileset_info(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_fileset_info`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_fileset_info", params)
@API("adapter.napcat.file.get_flash_file_list", description="获取闪传文件列表", version="1", public=True)
async def api_action_get_flash_file_list(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_flash_file_list`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_flash_file_list", params)
@API("adapter.napcat.file.get_flash_file_url", description="获取闪传文件链接", version="1", public=True)
async def api_action_get_flash_file_url(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_flash_file_url`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_flash_file_url", params)
@API("adapter.napcat.file.get_group_album_media_list", description="获取群相册媒体列表", version="1", public=True)
async def api_action_get_group_album_media_list(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_album_media_list`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_album_media_list", params)
@API("adapter.napcat.file.get_group_file_system_info", description="获取群文件系统信息", version="1", public=True)
async def api_action_get_group_file_system_info(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_file_system_info`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_file_system_info", params)
@API("adapter.napcat.file.get_group_file_url", description="获取群文件URL", version="1", public=True)
async def api_action_get_group_file_url(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_file_url`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_file_url", params)
@API("adapter.napcat.file.get_group_files_by_folder", description="获取群文件夹文件列表", version="1", public=True)
async def api_action_get_group_files_by_folder(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_files_by_folder`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_files_by_folder", params)
@API("adapter.napcat.file.get_group_root_files", description="获取群根目录文件列表", version="1", public=True)
async def api_action_get_group_root_files(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_root_files`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_root_files", params)
@API("adapter.napcat.file.get_image", description="获取图片", version="1", public=True)
async def api_action_get_image(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_image`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_image", params)
@API("adapter.napcat.file.get_online_file_msg", description="获取在线文件消息", version="1", public=True)
async def api_action_get_online_file_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_online_file_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_online_file_msg", params)
@API("adapter.napcat.file.get_private_file_url", description="获取私聊文件URL", version="1", public=True)
async def api_action_get_private_file_url(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_private_file_url`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_private_file_url", params)
@API("adapter.napcat.file.get_qun_album_list", description="获取群相册列表", version="1", public=True)
async def api_action_get_qun_album_list(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_qun_album_list`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_qun_album_list", params)
@API("adapter.napcat.file.get_share_link", description="获取文件分享链接", version="1", public=True)
async def api_action_get_share_link(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_share_link`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_share_link", params)
@API("adapter.napcat.file.move_group_file", description="移动群文件", version="1", public=True)
async def api_action_move_group_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``move_group_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("move_group_file", params)
@API("adapter.napcat.file.receive_online_file", description="接收在线文件", version="1", public=True)
async def api_action_receive_online_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``receive_online_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("receive_online_file", params)
@API("adapter.napcat.file.refuse_online_file", description="拒绝在线文件", version="1", public=True)
async def api_action_refuse_online_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``refuse_online_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("refuse_online_file", params)
@API("adapter.napcat.file.rename_group_file", description="重命名群文件", version="1", public=True)
async def api_action_rename_group_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``rename_group_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("rename_group_file", params)
@API("adapter.napcat.file.send_flash_msg", description="发送闪传消息", version="1", public=True)
async def api_action_send_flash_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_flash_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_flash_msg", params)
@API("adapter.napcat.file.send_online_file", description="发送在线文件", version="1", public=True)
async def api_action_send_online_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_online_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_online_file", params)
@API("adapter.napcat.file.send_online_folder", description="发送在线文件夹", version="1", public=True)
async def api_action_send_online_folder(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_online_folder`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_online_folder", params)
@API("adapter.napcat.file.set_group_album_media_like", description="点赞群相册媒体", version="1", public=True)
async def api_action_set_group_album_media_like(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_album_media_like`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_album_media_like", params)
@API("adapter.napcat.file.trans_group_file", description="传输群文件", version="1", public=True)
async def api_action_trans_group_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``trans_group_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("trans_group_file", params)
@API("adapter.napcat.file.upload_file_stream", description="上传文件流", version="1", public=True)
async def api_action_upload_file_stream(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``upload_file_stream`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("upload_file_stream", params)
@API("adapter.napcat.file.upload_group_file", description="上传群文件", version="1", public=True)
async def api_action_upload_group_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``upload_group_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("upload_group_file", params)
@API("adapter.napcat.file.upload_image_to_qun_album", description="上传图片到群相册", version="1", public=True)
async def api_action_upload_image_to_qun_album(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``upload_image_to_qun_album`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("upload_image_to_qun_album", params)
@API("adapter.napcat.file.upload_private_file", description="上传私聊文件", version="1", public=True)
async def api_action_upload_private_file(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``upload_private_file`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("upload_private_file", params)

View File

@@ -0,0 +1,593 @@
"""NapCat 群组与频道 API 端点。"""
from __future__ import annotations
from typing import Any, Dict, List, Optional
from maibot_sdk import API
from .support import NapCatApiIdInput, NapCatApiSupportMixin, NapCatApiParamsInput
class NapCatGroupApiMixin(NapCatApiSupportMixin):
"""NapCat 群组、频道与群扩展相关 API。"""
@API("adapter.napcat.group.set_group_ban", description="设置群成员禁言", version="1", public=True)
async def api_set_group_ban(
self,
group_id: NapCatApiIdInput,
user_id: NapCatApiIdInput,
duration: NapCatApiIdInput,
) -> Dict[str, Any]:
"""设置群成员禁言。
Args:
group_id: 群号。
user_id: 用户号。
duration: 禁言秒数。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
normalized_duration = self._normalize_non_negative_int(duration, "duration")
if normalized_duration > 2592000:
raise ValueError("duration 不能超过 2592000 秒")
return await self._require_query_service().set_group_ban(
group_id=self._normalize_positive_int(group_id, "group_id"),
user_id=self._normalize_positive_int(user_id, "user_id"),
duration=normalized_duration,
)
@API("adapter.napcat.group.set_group_whole_ban", description="设置群全体禁言", version="1", public=True)
async def api_set_group_whole_ban(self, group_id: NapCatApiIdInput, enable: bool) -> Dict[str, Any]:
"""设置群全体禁言。
Args:
group_id: 群号。
enable: 是否开启全体禁言。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._require_query_service().set_group_whole_ban(
group_id=self._normalize_positive_int(group_id, "group_id"),
enable=self._normalize_bool(enable, "enable"),
)
@API("adapter.napcat.group.set_group_kick", description="踢出单个群成员", version="1", public=True)
async def api_set_group_kick(
self,
group_id: NapCatApiIdInput,
user_id: NapCatApiIdInput,
reject_add_request: bool = False,
) -> Dict[str, Any]:
"""踢出单个群成员。
Args:
group_id: 群号。
user_id: 用户号。
reject_add_request: 是否拒绝再次加群。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._require_query_service().set_group_kick(
group_id=self._normalize_positive_int(group_id, "group_id"),
user_id=self._normalize_positive_int(user_id, "user_id"),
reject_add_request=bool(reject_add_request),
)
@API("adapter.napcat.group.set_group_kick_members", description="批量踢出群成员", version="1", public=True)
async def api_set_group_kick_members(
self,
group_id: NapCatApiIdInput,
user_id: object,
reject_add_request: bool = False,
) -> Dict[str, Any]:
"""批量踢出群成员。
Args:
group_id: 群号。
user_id: 用户号数组。
reject_add_request: 是否拒绝再次加群。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._require_query_service().set_group_kick_members(
group_id=self._normalize_positive_int(group_id, "group_id"),
user_ids=self._normalize_user_id_list(user_id, "user_id"),
reject_add_request=bool(reject_add_request),
)
@API("adapter.napcat.group.set_group_name", description="设置群名称", version="1", public=True)
async def api_set_group_name(self, group_id: NapCatApiIdInput, group_name: object) -> Dict[str, Any]:
"""设置群名称。
Args:
group_id: 群号。
group_name: 新群名称。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._require_query_service().set_group_name(
group_id=self._normalize_positive_int(group_id, "group_id"),
group_name=self._normalize_non_empty_string(group_name, "group_name"),
)
@API("adapter.napcat.group.get_group_info", description="获取群信息", version="1", public=True)
async def api_get_group_info(self, group_id: NapCatApiIdInput) -> Optional[Dict[str, Any]]:
"""获取群信息。
Args:
group_id: 群号。
Returns:
Optional[Dict[str, Any]]: 群信息字典;失败时返回 ``None``。
"""
return await self._require_query_service().get_group_info(
str(self._normalize_positive_int(group_id, "group_id"))
)
@API("adapter.napcat.group.get_group_detail_info", description="获取群详细信息", version="1", public=True)
async def api_get_group_detail_info(self, group_id: NapCatApiIdInput) -> Optional[Dict[str, Any]]:
"""获取群详细信息。
Args:
group_id: 群号。
Returns:
Optional[Dict[str, Any]]: 群详细信息字典;失败时返回 ``None``。
"""
return await self._require_query_service().get_group_detail_info(
str(self._normalize_positive_int(group_id, "group_id"))
)
@API("adapter.napcat.group.get_group_list", description="获取群列表", version="1", public=True)
async def api_get_group_list(self, no_cache: bool = False) -> Optional[List[Dict[str, Any]]]:
"""获取群列表。
Args:
no_cache: 是否禁用缓存。
Returns:
Optional[List[Dict[str, Any]]]: 群信息列表;失败时返回 ``None``。
"""
return await self._require_query_service().get_group_list(no_cache=bool(no_cache))
@API("adapter.napcat.group.get_group_at_all_remain", description="获取群 @ 全体剩余次数", version="1", public=True)
async def api_get_group_at_all_remain(self, group_id: NapCatApiIdInput) -> Optional[Dict[str, Any]]:
"""获取群 @ 全体剩余次数。
Args:
group_id: 群号。
Returns:
Optional[Dict[str, Any]]: 剩余次数信息;失败时返回 ``None``。
"""
return await self._require_query_service().get_group_at_all_remain(
str(self._normalize_positive_int(group_id, "group_id"))
)
@API("adapter.napcat.group.get_group_member_info", description="获取群成员信息", version="1", public=True)
async def api_get_group_member_info(
self,
group_id: NapCatApiIdInput,
user_id: NapCatApiIdInput,
no_cache: bool = True,
) -> Optional[Dict[str, Any]]:
"""获取群成员信息。
Args:
group_id: 群号。
user_id: 用户号。
no_cache: 是否禁用缓存。
Returns:
Optional[Dict[str, Any]]: 群成员信息字典;失败时返回 ``None``。
"""
return await self._require_query_service().get_group_member_info(
group_id=str(self._normalize_positive_int(group_id, "group_id")),
user_id=str(self._normalize_positive_int(user_id, "user_id")),
no_cache=bool(no_cache),
)
@API("adapter.napcat.group.get_group_member_list", description="获取群成员列表", version="1", public=True)
async def api_get_group_member_list(
self,
group_id: NapCatApiIdInput,
no_cache: bool = False,
) -> Optional[List[Dict[str, Any]]]:
"""获取群成员列表。
Args:
group_id: 群号。
no_cache: 是否禁用缓存。
Returns:
Optional[List[Dict[str, Any]]]: 群成员信息列表;失败时返回 ``None``。
"""
return await self._require_query_service().get_group_member_list(
group_id=str(self._normalize_positive_int(group_id, "group_id")),
no_cache=bool(no_cache),
)
@API("adapter.napcat.group.delete_essence_msg", description="移出精华消息", version="1", public=True)
async def api_action_delete_essence_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``delete_essence_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("delete_essence_msg", params)
@API("adapter.napcat.group.delete_group_notice", description="删除群公告", version="1", public=True)
async def api_action_delete_group_notice(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``_del_group_notice`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("_del_group_notice", params)
@API("adapter.napcat.group.get_essence_msg_list", description="获取群精华消息", version="1", public=True)
async def api_action_get_essence_msg_list(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_essence_msg_list`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_essence_msg_list", params)
@API("adapter.napcat.group.get_group_honor_info", description="获取群荣誉信息", version="1", public=True)
async def api_action_get_group_honor_info(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_honor_info`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_honor_info", params)
@API(
"adapter.napcat.group.get_group_ignore_add_request",
description="获取群被忽略的加群请求",
version="1",
public=True,
)
async def api_action_get_group_ignore_add_request(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_ignore_add_request`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_ignore_add_request", params)
@API("adapter.napcat.group.get_group_ignored_notifies", description="获取群忽略通知", version="1", public=True)
async def api_action_get_group_ignored_notifies(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_ignored_notifies`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_ignored_notifies", params)
@API("adapter.napcat.group.get_group_info_ex", description="获取群详细信息 (扩展)", version="1", public=True)
async def api_action_get_group_info_ex(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_info_ex`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_info_ex", params)
@API("adapter.napcat.group.get_group_notice", description="获取群公告", version="1", public=True)
async def api_action_get_group_notice(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``_get_group_notice`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("_get_group_notice", params)
@API("adapter.napcat.group.get_group_shut_list", description="获取群禁言列表", version="1", public=True)
async def api_action_get_group_shut_list(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_shut_list`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_shut_list", params)
@API("adapter.napcat.group.get_group_system_msg", description="获取群系统消息", version="1", public=True)
async def api_action_get_group_system_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_system_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_system_msg", params)
@API("adapter.napcat.group.get_guild_list", description="获取频道列表", version="1", public=True)
async def api_action_get_guild_list(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_guild_list`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_guild_list", params)
@API("adapter.napcat.group.get_guild_service_profile", description="获取频道个人信息", version="1", public=True)
async def api_action_get_guild_service_profile(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_guild_service_profile`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_guild_service_profile", params)
@API("adapter.napcat.group.group_poke", description="发送戳一戳", version="1", public=True)
async def api_action_group_poke(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``group_poke`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("group_poke", params)
@API("adapter.napcat.group.handle_quick_operation_internal", description="处理快速操作", version="1", public=True)
async def api_action_handle_quick_operation_internal(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``.handle_quick_operation`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action(".handle_quick_operation", params)
@API("adapter.napcat.group.send_group_msg", description="发送群消息", version="1", public=True)
async def api_action_send_group_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_group_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_group_msg", params)
@API("adapter.napcat.group.send_group_notice", description="发送群公告", version="1", public=True)
async def api_action_send_group_notice(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``_send_group_notice`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("_send_group_notice", params)
@API("adapter.napcat.group.send_group_sign", description="群打卡", version="1", public=True)
async def api_action_send_group_sign(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_group_sign`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_group_sign", params)
@API("adapter.napcat.group.set_essence_msg", description="设置精华消息", version="1", public=True)
async def api_action_set_essence_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_essence_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_essence_msg", params)
@API("adapter.napcat.group.set_group_add_option", description="设置群加群选项", version="1", public=True)
async def api_action_set_group_add_option(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_add_option`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_add_option", params)
@API("adapter.napcat.group.set_group_add_request", description="处理加群请求", version="1", public=True)
async def api_action_set_group_add_request(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_add_request`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_add_request", params)
@API("adapter.napcat.group.set_group_admin", description="设置群管理员", version="1", public=True)
async def api_action_set_group_admin(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_admin`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_admin", params)
@API("adapter.napcat.group.set_group_card", description="设置群名片", version="1", public=True)
async def api_action_set_group_card(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_card`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_card", params)
@API("adapter.napcat.group.set_group_leave", description="退出群组", version="1", public=True)
async def api_action_set_group_leave(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_leave`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_leave", params)
@API("adapter.napcat.group.set_group_portrait", description="设置群头像", version="1", public=True)
async def api_action_set_group_portrait(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_portrait`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_portrait", params)
@API("adapter.napcat.group.set_group_remark", description="设置群备注", version="1", public=True)
async def api_action_set_group_remark(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_remark`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_remark", params)
@API(
"adapter.napcat.group.set_group_robot_add_option", description="设置群机器人加群选项", version="1", public=True
)
async def api_action_set_group_robot_add_option(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_robot_add_option`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_robot_add_option", params)
@API("adapter.napcat.group.set_group_search", description="设置群搜索选项", version="1", public=True)
async def api_action_set_group_search(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_search`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_search", params)
@API("adapter.napcat.group.set_group_sign", description="群打卡", version="1", public=True)
async def api_action_set_group_sign(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_sign`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_sign", params)
@API("adapter.napcat.group.set_group_special_title", description="设置专属头衔", version="1", public=True)
async def api_action_set_group_special_title(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_special_title`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_special_title", params)
@API("adapter.napcat.group.set_group_todo", description="设置群待办", version="1", public=True)
async def api_action_set_group_todo(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_group_todo`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_group_todo", params)
@API("adapter.napcat.file.test_download_stream", description="测试下载流", version="1", public=True)
async def api_action_test_download_stream(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``test_download_stream`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("test_download_stream", params)

View File

@@ -0,0 +1,431 @@
"""NapCat 消息与互动 API 端点。"""
from __future__ import annotations
from typing import Any, Dict, Optional
from maibot_sdk import API
from .support import NapCatApiIdInput, NapCatApiParamsInput, NapCatApiSupportMixin
class NapCatMessageApiMixin(NapCatApiSupportMixin):
"""NapCat 消息、互动与 AI 相关 API。"""
@API("adapter.napcat.message.send_poke", description="发送戳一戳", version="1", public=True)
async def api_send_poke(
self,
user_id: Optional[NapCatApiIdInput] = None,
group_id: Optional[NapCatApiIdInput] = None,
target_id: Optional[NapCatApiIdInput] = None,
qq_id: Optional[NapCatApiIdInput] = None,
) -> Dict[str, Any]:
"""发送戳一戳。
Args:
user_id: 目标用户号。
group_id: 可选群号。
target_id: 官方 ``send_poke`` 动作支持的目标 ID。
qq_id: 兼容旧版调用方式的 ``user_id`` 别名。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
normalized_user_id_input = str(user_id).strip() if user_id is not None else ""
normalized_qq_id_input = str(qq_id).strip() if qq_id is not None else ""
if normalized_user_id_input and normalized_qq_id_input:
resolved_user_id = self._normalize_positive_int(user_id, "user_id")
resolved_qq_id = self._normalize_positive_int(qq_id, "qq_id")
if resolved_user_id != resolved_qq_id:
raise ValueError("user_id 与 qq_id 不能同时传递不同的值")
elif normalized_user_id_input:
resolved_user_id = self._normalize_positive_int(user_id, "user_id")
elif normalized_qq_id_input:
resolved_user_id = self._normalize_positive_int(qq_id, "qq_id")
else:
raise ValueError("user_id 不能为空")
normalized_group_id: Optional[int] = None
if group_id is not None and str(group_id).strip():
normalized_group_id = self._normalize_positive_int(group_id, "group_id")
normalized_target_id: Optional[int] = None
if target_id is not None and str(target_id).strip():
normalized_target_id = self._normalize_positive_int(target_id, "target_id")
return await self._require_query_service().send_poke(
user_id=resolved_user_id,
group_id=normalized_group_id,
target_id=normalized_target_id,
)
@API("adapter.napcat.message.delete_msg", description="撤回消息", version="1", public=True)
async def api_delete_msg(self, message_id: NapCatApiIdInput) -> Dict[str, Any]:
"""撤回消息。
Args:
message_id: 消息 ID。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._require_query_service().delete_message(
message_id=self._normalize_positive_int(message_id, "message_id")
)
@API("adapter.napcat.message.send_group_ai_record", description="发送群 AI 语音", version="1", public=True)
async def api_send_group_ai_record(
self,
group_id: NapCatApiIdInput,
character: object,
text: object,
) -> Dict[str, Any]:
"""发送群 AI 语音。
Args:
group_id: 群号。
character: 角色标识。
text: 语音文本。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._require_query_service().send_group_ai_record(
group_id=self._normalize_positive_int(group_id, "group_id"),
character=self._normalize_non_empty_string(character, "character"),
text=self._normalize_non_empty_string(text, "text"),
)
@API("adapter.napcat.message.set_msg_emoji_like", description="给消息贴表情", version="1", public=True)
async def api_set_msg_emoji_like(
self,
message_id: NapCatApiIdInput,
emoji_id: NapCatApiIdInput,
set: bool = True,
) -> Dict[str, Any]:
"""给消息贴表情或取消表情。
Args:
message_id: 消息 ID。
emoji_id: 表情 ID。
set: 是否设置为已贴表情。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._require_query_service().set_message_emoji_like(
message_id=self._normalize_positive_int(message_id, "message_id"),
emoji_id=self._normalize_positive_int(emoji_id, "emoji_id"),
set_like=bool(set),
)
@API("adapter.napcat.message.get_msg", description="获取消息详情", version="1", public=True)
async def api_get_msg(self, message_id: NapCatApiIdInput) -> Optional[Dict[str, Any]]:
"""获取消息详情。
Args:
message_id: 消息 ID。
Returns:
Optional[Dict[str, Any]]: 消息详情字典;失败时返回 ``None``。
"""
return await self._require_query_service().get_message_detail(
str(self._normalize_positive_int(message_id, "message_id"))
)
@API("adapter.napcat.message.get_forward_msg", description="获取合并转发消息", version="1", public=True)
async def api_get_forward_msg(
self,
message_id: object = "",
id: object = "",
) -> Optional[Dict[str, Any]]:
"""获取合并转发消息详情。
Args:
message_id: 合并转发消息 ID。
id: NapCat 官方文档中的兼容字段。
Returns:
Optional[Dict[str, Any]]: 合并转发消息详情;失败时返回 ``None``。
"""
normalized_message_id = str(message_id or "").strip()
normalized_forward_id = str(id or "").strip()
if normalized_message_id and normalized_forward_id and normalized_message_id != normalized_forward_id:
raise ValueError("message_id 与 id 不能同时传递不同的值")
if not normalized_message_id and not normalized_forward_id:
raise ValueError("message_id 或 id 至少提供一个")
return await self._require_query_service().get_forward_message(
message_id=normalized_message_id or None,
forward_id=normalized_forward_id or None,
)
@API("adapter.napcat.message.ark_share_group", description="分享群 (Ark)", version="1", public=True)
async def api_action_ark_share_group(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``ArkShareGroup`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("ArkShareGroup", params)
@API("adapter.napcat.message.ark_share_peer", description="分享用户 (Ark)", version="1", public=True)
async def api_action_ark_share_peer(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``ArkSharePeer`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("ArkSharePeer", params)
@API(
"adapter.napcat.message.click_inline_keyboard_button", description="点击内联键盘按钮", version="1", public=True
)
async def api_action_click_inline_keyboard_button(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``click_inline_keyboard_button`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("click_inline_keyboard_button", params)
@API("adapter.napcat.message.fetch_emoji_like", description="获取表情点赞详情", version="1", public=True)
async def api_action_fetch_emoji_like(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``fetch_emoji_like`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("fetch_emoji_like", params)
@API("adapter.napcat.message.forward_friend_single_msg", description="转发单条消息", version="1", public=True)
async def api_action_forward_friend_single_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``forward_friend_single_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("forward_friend_single_msg", params)
@API("adapter.napcat.message.forward_group_single_msg", description="转发单条消息", version="1", public=True)
async def api_action_forward_group_single_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``forward_group_single_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("forward_group_single_msg", params)
@API("adapter.napcat.message.friend_poke", description="发送戳一戳", version="1", public=True)
async def api_action_friend_poke(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``friend_poke`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("friend_poke", params)
@API("adapter.napcat.message.get_ai_record", description="获取 AI 语音", version="1", public=True)
async def api_action_get_ai_record(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_ai_record`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_ai_record", params)
@API("adapter.napcat.message.get_emoji_likes", description="获取消息表情点赞列表", version="1", public=True)
async def api_action_get_emoji_likes(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_emoji_likes`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_emoji_likes", params)
@API("adapter.napcat.message.get_friend_msg_history", description="获取好友历史消息", version="1", public=True)
async def api_action_get_friend_msg_history(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_friend_msg_history`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_friend_msg_history", params)
@API("adapter.napcat.message.get_group_msg_history", description="获取群历史消息", version="1", public=True)
async def api_action_get_group_msg_history(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_group_msg_history`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_group_msg_history", params)
@API("adapter.napcat.message.mark_all_as_read", description="标记所有消息已读", version="1", public=True)
async def api_action_mark_all_as_read(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``_mark_all_as_read`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("_mark_all_as_read", params)
@API("adapter.napcat.message.mark_group_msg_as_read", description="标记群聊已读", version="1", public=True)
async def api_action_mark_group_msg_as_read(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``mark_group_msg_as_read`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("mark_group_msg_as_read", params)
@API("adapter.napcat.message.mark_msg_as_read", description="标记消息已读 (Go-CQHTTP)", version="1", public=True)
async def api_action_mark_msg_as_read(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``mark_msg_as_read`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("mark_msg_as_read", params)
@API("adapter.napcat.message.mark_private_msg_as_read", description="标记私聊已读", version="1", public=True)
async def api_action_mark_private_msg_as_read(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``mark_private_msg_as_read`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("mark_private_msg_as_read", params)
@API("adapter.napcat.message.send_ark_share", description="分享用户 (Ark)", version="1", public=True)
async def api_action_send_ark_share(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_ark_share`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_ark_share", params)
@API("adapter.napcat.message.send_forward_msg", description="发送合并转发消息", version="1", public=True)
async def api_action_send_forward_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_forward_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_forward_msg", params)
@API("adapter.napcat.message.send_group_ark_share", description="分享群 (Ark)", version="1", public=True)
async def api_action_send_group_ark_share(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_group_ark_share`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_group_ark_share", params)
@API("adapter.napcat.message.send_group_forward_msg", description="发送群合并转发消息", version="1", public=True)
async def api_action_send_group_forward_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_group_forward_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_group_forward_msg", params)
@API("adapter.napcat.message.send_msg", description="发送消息", version="1", public=True)
async def api_action_send_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_msg", params)
@API(
"adapter.napcat.message.send_private_forward_msg", description="发送私聊合并转发消息", version="1", public=True
)
async def api_action_send_private_forward_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_private_forward_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_private_forward_msg", params)
@API("adapter.napcat.message.send_private_msg", description="发送私聊消息", version="1", public=True)
async def api_action_send_private_msg(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_private_msg`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_private_msg", params)

View File

@@ -0,0 +1,69 @@
"""NapCat 消息工具扩展。"""
from __future__ import annotations
from typing import Any, Dict
from maibot_sdk import Tool
from maibot_sdk.types import ToolParameterInfo, ToolParamType
from .message import NapCatMessageApiMixin
def _tool_param(name: str, param_type: ToolParamType, description: str, required: bool) -> ToolParameterInfo:
"""构造工具参数声明。"""
return ToolParameterInfo(name=name, param_type=param_type, description=description, required=required)
@Tool(
"find_user_qq_id",
description="根据指定消息的 msg_id 查询该条消息发送者的 QQ 号信息",
parameters=[
_tool_param("msg_id", ToolParamType.STRING, "要查询的消息 ID", True),
],
)
async def handle_find_user_qq_id(self: NapCatMessageApiMixin, msg_id: str = "", **kwargs: Any) -> Dict[str, Any]:
"""根据消息 ID 查询发送者的 QQ 号信息。"""
del kwargs
normalized_msg_id = str(self._normalize_positive_int(msg_id, "msg_id"))
message_detail = await self._require_query_service().get_message_detail(normalized_msg_id)
if not isinstance(message_detail, dict):
return {
"success": False,
"content": f"未找到 msg_id={normalized_msg_id} 对应的消息记录",
"msg_id": normalized_msg_id,
}
sender = message_detail.get("sender", {})
if not isinstance(sender, dict):
sender = {}
user_id = str(message_detail.get("user_id") or sender.get("user_id") or sender.get("uin") or "").strip()
if not user_id:
return {
"success": False,
"content": f"已获取消息详情,但未解析出 msg_id={normalized_msg_id} 的发送者 QQ 号",
"msg_id": normalized_msg_id,
"message_detail": message_detail,
}
nickname = str(sender.get("nickname") or sender.get("name") or "").strip()
cardname = str(sender.get("card") or "").strip()
sender_info = {
"user_id": user_id,
"nickname": nickname or None,
"cardname": cardname or None,
}
display_name = cardname or nickname or user_id
return {
"success": True,
"content": f"msg_id={normalized_msg_id} 的发送者 QQ 号是 {user_id}(显示名:{display_name}",
"msg_id": normalized_msg_id,
"sender": sender_info,
}
NapCatMessageApiMixin.handle_find_user_qq_id = handle_find_user_qq_id

View File

@@ -0,0 +1,275 @@
"""NapCat API 端点的公共辅助能力。"""
from __future__ import annotations
from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, TypeAlias
from maibot_sdk import API
from ..types import NapCatActionParamsInput, NapCatActionResponse, NapCatIdInput
if TYPE_CHECKING:
from ..services import NapCatActionService, NapCatQueryService
NapCatApiIdInput: TypeAlias = NapCatIdInput
NapCatApiParamsInput: TypeAlias = NapCatActionParamsInput
class NapCatApiSupportMixin:
"""NapCat API 端点共享辅助逻辑。"""
_action_service: Optional["NapCatActionService"]
_query_service: Optional["NapCatQueryService"]
def _ensure_runtime_components(self) -> None:
"""确保运行时组件已经初始化。"""
raise NotImplementedError
@staticmethod
def _coerce_int(value: object, field_name: str, expectation: str) -> int:
"""将受支持的输入值转换为整数。
Args:
value: 待转换的值。
field_name: 字段名,用于错误提示。
expectation: 期望的取值描述,例如“正整数”。
Returns:
int: 转换后的整数值。
Raises:
ValueError: 当值无法转换为整数时抛出。
"""
if isinstance(value, bool):
raise ValueError(f"{field_name} 必须是{expectation}")
if isinstance(value, int):
return value
if isinstance(value, float):
try:
return int(value)
except (OverflowError, ValueError) as exc:
raise ValueError(f"{field_name} 必须是{expectation}") from exc
if isinstance(value, str):
normalized_value = value.strip()
if not normalized_value:
raise ValueError(f"{field_name} 必须是{expectation}")
try:
return int(normalized_value)
except ValueError as exc:
raise ValueError(f"{field_name} 必须是{expectation}") from exc
raise ValueError(f"{field_name} 必须是{expectation}")
def _require_query_service(self) -> "NapCatQueryService":
"""返回当前可用的 NapCat 查询服务。
Returns:
NapCatQueryService: 已初始化的查询服务。
Raises:
RuntimeError: 当查询服务尚未初始化时抛出。
"""
self._ensure_runtime_components()
query_service = self._query_service
if query_service is None:
raise RuntimeError("NapCat 查询服务尚未初始化")
return query_service
def _require_action_service(self) -> "NapCatActionService":
"""返回当前可用的 NapCat 动作服务。
Returns:
NapCatActionService: 已初始化的动作服务。
Raises:
RuntimeError: 当动作服务尚未初始化时抛出。
"""
self._ensure_runtime_components()
action_service = self._action_service
if action_service is None:
raise RuntimeError("NapCat 动作服务尚未初始化")
return action_service
@staticmethod
def _normalize_positive_int(value: object, field_name: str) -> int:
"""将任意值规范化为正整数。
Args:
value: 待规范化的值。
field_name: 字段名,用于错误提示。
Returns:
int: 规范化后的正整数。
Raises:
ValueError: 当值无法转换为正整数时抛出。
"""
normalized_value = NapCatApiSupportMixin._coerce_int(value, field_name, "正整数")
if normalized_value <= 0:
raise ValueError(f"{field_name} 必须是正整数")
return normalized_value
@staticmethod
def _normalize_non_negative_int(value: object, field_name: str) -> int:
"""将任意值规范化为非负整数。
Args:
value: 待规范化的值。
field_name: 字段名,用于错误提示。
Returns:
int: 规范化后的非负整数。
Raises:
ValueError: 当值无法转换为非负整数时抛出。
"""
normalized_value = NapCatApiSupportMixin._coerce_int(value, field_name, "非负整数")
if normalized_value < 0:
raise ValueError(f"{field_name} 必须是非负整数")
return normalized_value
@staticmethod
def _normalize_bool(value: object, field_name: str) -> bool:
"""将任意值规范化为布尔值。
Args:
value: 待规范化的值。
field_name: 字段名,用于错误提示。
Returns:
bool: 规范化后的布尔值。
Raises:
ValueError: 当值不是布尔值时抛出。
"""
if not isinstance(value, bool):
raise ValueError(f"{field_name} 必须是布尔值")
return value
@staticmethod
def _normalize_non_empty_string(value: object, field_name: str) -> str:
"""将任意值规范化为非空字符串。
Args:
value: 待规范化的值。
field_name: 字段名,用于错误提示。
Returns:
str: 规范化后的字符串。
Raises:
ValueError: 当值为空时抛出。
"""
normalized_value = str(value or "").strip()
if not normalized_value:
raise ValueError(f"{field_name} 不能为空")
return normalized_value
@classmethod
def _normalize_user_id_list(cls, values: object, field_name: str) -> List[int]:
"""将任意值规范化为用户号列表。
Args:
values: 待规范化的值。
field_name: 字段名,用于错误提示。
Returns:
List[int]: 规范化后的用户号列表。
Raises:
ValueError: 当值不是非空数组时抛出。
"""
if not isinstance(values, list) or not values:
raise ValueError(f"{field_name} 必须是非空数组")
return [cls._normalize_positive_int(value, field_name) for value in values]
@staticmethod
def _normalize_params(params: NapCatApiParamsInput) -> Dict[str, Any]:
"""将动作参数规范化为可变字典。
Args:
params: 调用方提供的参数对象。
Returns:
Dict[str, Any]: 规范化后的参数字典。
Raises:
ValueError: 当 ``params`` 不是映射对象时抛出。
"""
if params is None:
return {}
if not isinstance(params, Mapping):
raise ValueError("params 必须是对象")
return {str(key): value for key, value in params.items()}
async def _call_napcat_action(
self,
action_name: str,
params: NapCatApiParamsInput = None,
) -> NapCatActionResponse:
"""调用 NapCat 动作并返回原始响应。
Args:
action_name: NapCat 动作名称。
params: 传递给 NapCat 的动作参数。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
normalized_action_name = self._normalize_non_empty_string(action_name, "action_name")
normalized_params = self._normalize_params(params)
return await self._require_action_service().call_action(normalized_action_name, normalized_params)
async def _call_napcat_action_data(
self,
action_name: str,
params: NapCatApiParamsInput = None,
) -> Any:
"""调用 NapCat 动作并返回 ``data`` 字段。
Args:
action_name: NapCat 动作名称。
params: 传递给 NapCat 的动作参数。
Returns:
Any: NapCat 响应中的 ``data`` 字段。
"""
normalized_action_name = self._normalize_non_empty_string(action_name, "action_name")
normalized_params = self._normalize_params(params)
return await self._require_action_service().call_action_data(normalized_action_name, normalized_params)
@API("adapter.napcat.action.call", description="调用任意 OneBot 动作", version="1", public=True)
async def api_call_action(
self,
action_name: str = "",
params: NapCatApiParamsInput = None,
) -> NapCatActionResponse:
"""调用任意 OneBot 动作。
Args:
action_name: OneBot 动作名称。
params: 动作参数。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action(action_name, params)
@API(
"adapter.napcat.action.call_data", description="调用任意 OneBot 动作并返回 data 字段", version="1", public=True
)
async def api_call_action_data(
self,
action_name: str = "",
params: NapCatApiParamsInput = None,
) -> Any:
"""调用任意 OneBot 动作并返回 ``data`` 字段。
Args:
action_name: OneBot 动作名称。
params: 动作参数。
Returns:
Any: NapCat 响应中的 ``data`` 字段。
"""
return await self._call_napcat_action_data(action_name, params)

View File

@@ -0,0 +1,290 @@
"""NapCat 系统与运行时 API 端点。"""
from __future__ import annotations
from typing import Any, Dict, Optional
from maibot_sdk import API
from .support import NapCatApiParamsInput, NapCatApiSupportMixin
class NapCatSystemApiMixin(NapCatApiSupportMixin):
"""NapCat 系统状态、凭证与运行控制相关 API。"""
@API("adapter.napcat.system.get_login_info", description="获取当前登录账号信息", version="1", public=True)
async def api_get_login_info(self) -> Optional[Dict[str, Any]]:
"""获取当前登录账号信息。
Returns:
Optional[Dict[str, Any]]: 登录信息字典;失败时返回 ``None``。
"""
return await self._require_query_service().get_login_info()
@API("adapter.napcat.system.bot_exit", description="退出登录", version="1", public=True)
async def api_action_bot_exit(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``bot_exit`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("bot_exit", params)
@API("adapter.napcat.system.can_send_image", description="是否可以发送图片", version="1", public=True)
async def api_action_can_send_image(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``can_send_image`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("can_send_image", params)
@API("adapter.napcat.system.can_send_record", description="是否可以发送语音", version="1", public=True)
async def api_action_can_send_record(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``can_send_record`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("can_send_record", params)
@API("adapter.napcat.system.check_url_safely", description="检查URL安全性", version="1", public=True)
async def api_action_check_url_safely(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``check_url_safely`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("check_url_safely", params)
@API("adapter.napcat.system.clean_cache", description="清理缓存", version="1", public=True)
async def api_action_clean_cache(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``clean_cache`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("clean_cache", params)
@API("adapter.napcat.system.get_credentials", description="获取登录凭证", version="1", public=True)
async def api_action_get_credentials(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_credentials`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_credentials", params)
@API("adapter.napcat.system.get_csrf_token", description="获取 CSRF Token", version="1", public=True)
async def api_action_get_csrf_token(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_csrf_token`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_csrf_token", params)
@API(
"adapter.napcat.system.get_doubt_friends_add_request", description="获取可疑好友申请", version="1", public=True
)
async def api_action_get_doubt_friends_add_request(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_doubt_friends_add_request`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_doubt_friends_add_request", params)
@API("adapter.napcat.system.get_model_show", description="获取机型显示", version="1", public=True)
async def api_action_get_model_show(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``_get_model_show`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("_get_model_show", params)
@API("adapter.napcat.system.get_online_clients", description="获取在线客户端", version="1", public=True)
async def api_action_get_online_clients(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_online_clients`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_online_clients", params)
@API("adapter.napcat.system.get_robot_uin_range", description="获取机器人 UIN 范围", version="1", public=True)
async def api_action_get_robot_uin_range(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_robot_uin_range`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_robot_uin_range", params)
@API("adapter.napcat.system.get_status", description="获取运行状态", version="1", public=True)
async def api_action_get_status(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_status`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_status", params)
@API("adapter.napcat.system.get_version_info", description="获取版本信息", version="1", public=True)
async def api_action_get_version_info(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``get_version_info`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("get_version_info", params)
@API("adapter.napcat.system.nc_get_packet_status", description="获取Packet状态", version="1", public=True)
async def api_action_nc_get_packet_status(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``nc_get_packet_status`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("nc_get_packet_status", params)
@API("adapter.napcat.system.nc_get_user_status", description="获取用户在线状态", version="1", public=True)
async def api_action_nc_get_user_status(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``nc_get_user_status`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("nc_get_user_status", params)
@API("adapter.napcat.system.send_packet", description="发送原始数据包", version="1", public=True)
async def api_action_send_packet(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``send_packet`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("send_packet", params)
@API(
"adapter.napcat.system.set_doubt_friends_add_request", description="处理可疑好友申请", version="1", public=True
)
async def api_action_set_doubt_friends_add_request(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_doubt_friends_add_request`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_doubt_friends_add_request", params)
@API("adapter.napcat.system.set_input_status", description="设置输入状态", version="1", public=True)
async def api_action_set_input_status(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_input_status`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_input_status", params)
@API("adapter.napcat.system.set_model_show", description="设置机型", version="1", public=True)
async def api_action_set_model_show(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``_set_model_show`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("_set_model_show", params)
@API("adapter.napcat.system.set_online_status", description="设置在线状态", version="1", public=True)
async def api_action_set_online_status(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_online_status`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_online_status", params)
@API("adapter.napcat.system.set_restart", description="重启服务", version="1", public=True)
async def api_action_set_restart(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``set_restart`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("set_restart", params)
@API("adapter.napcat.system.unknown_action", description="unknown", version="1", public=True)
async def api_action_unknown_action(self, params: NapCatApiParamsInput = None) -> Dict[str, Any]:
"""调用 NapCat 的 ``unknown`` 动作。
Args:
params: 传递给 NapCat 的动作参数字典;具体字段请参考 NapCat 官方文档。
Returns:
Dict[str, Any]: NapCat 返回的原始响应字典。
"""
return await self._call_napcat_action("unknown", params)