def on_raw_keyword(keyword: str, rule: Rule = None, **kwargs) -> Matcher:
"""Ensure the raw message contains the target keyword."""
def raw_keyword(keyword: str) -> Rule:
"""Ensure the raw message contains the target keyword."""
async def _raw_keyword(bot: Bot, event: Event, state: dict) -> bool:
"""Rule wrapper for raw_keyword."""
return keyword in str(event.message)
return Rule(_raw_keyword)
return on_message(raw_keyword(keyword) & rule, **kwargs)
def decorator(func: Callable):
matcher = on_message(rule=Rule(fullmatch_checker), **kwargs)
@wraps(func)
@self._pre_check(only_to_me=only_to_me)
async def wrapper(bot: Bot, event: Event, state: T_State):
await func(bot, event)
logger.info(
f'消息{event.get_session_id()}已被on_fullmatch处理器{func.__name__}处理。'
)
matcher.handle()(wrapper)
def decorator(func: Callable):
matcher = on_message(permission=msg_type, priority=9, **kwargs)
@wraps(func)
@self._pre_check(only_to_me=only_to_me)
async def wrapper(bot: Bot, event: Event, state: T_State):
await func(bot, event)
logger.info(
f'消息{event.get_session_id()}已被on_message处理器{func.__name__}处理。'
)
await matcher.finish()
return matcher.handle()(wrapper)
def on_simple_command(cmd: str,
aliases: set = None,
rule: Rule = None,
**kwargs) -> Matcher:
"""Recognize a command that does not contain any parameters."""
def simple_command(cmd: str, aliases: set = None) -> Rule:
"""Recognize a command that does not contain any parameters."""
commands = set([cmd]) | (aliases or set()) # generate the commands
async def _simple_command(bot: Bot, event: Event, state: dict) -> bool:
"""Rule wrapper for simple_command."""
return str(event.message).strip() in commands
return Rule(_simple_command)
return on_message(simple_command(cmd, aliases) & rule, **kwargs)
import re
from nonebot import on_message
from nonebot.typing import T_State
from nonebot.adapters.cqhttp.bot import Bot
from nonebot.adapters.cqhttp.event import GroupMessageEvent
from nonebot.adapters.cqhttp.permission import GROUP
from omega_miya.utils.Omega_plugin_utils import has_notice_permission
from .utils import sp_event_check
last_msg = {}
last_repeat_msg = {}
repeat_count = {}
repeater = on_message(rule=has_notice_permission(),
permission=GROUP,
priority=100,
block=False)
@repeater.handle()
async def handle_repeater(bot: Bot, event: GroupMessageEvent, state: T_State):
group_id = event.group_id
global last_msg, last_repeat_msg, repeat_count
try:
last_msg[group_id]
except KeyError:
last_msg[group_id] = ''
try:
last_repeat_msg[group_id]
import re
from nonebot import on_message
from nonebot.exception import StopPropagation
from nonebot.adapters.cqhttp import Bot, MessageEvent
echo = on_message(priority=20, block=False)
REPEAT = 'repeat'
echo_maps = [{
'reply':
'确实。',
'rules': ['不会真', '应该', '我是', '我就是', '这就是',
re.compile('.是.[^?？][?？]$')]
}, {
'reply':
REPEAT,
'rules': [
re.compile('.*XM.*', re.IGNORECASE),
re.compile('.*羡慕.*'),
re.compile('.*YYDS.*', re.IGNORECASE),
]
}, {
'reply': '我信了',
'rules': [
re.compile('flag', re.IGNORECASE),
]
}]
@echo.handle()
from typing import Union
import nonebot
from loguru import logger
from nonebot import on_regex, on_command, on_message
from nonebot.adapters import Message, Event
from nonebot.adapters.onebot.v11 import Bot, MessageSegment, ActionFailed, GroupMessageEvent, PrivateMessageEvent
from .data_source import Pixiv, pixivlist, Q, pixiv_config, pixivhistory
from nonebot.matcher import Matcher
from nonebot.params import CommandArg
from nonebot.typing import T_State
pixiv = on_command("pixiv", aliases={"p"}, priority=2)
uixiv = on_command("u", aliases={"uid"}, priority=2)
pixiv_reply = on_message(priority=2)
pixiv_api = Pixiv()
cmd = list(nonebot.get_driver().config.command_start)[0]
@pixiv.handle()
async def pixiv_look(bot: Bot,
event: Union[GroupMessageEvent, PrivateMessageEvent],
args: Message = CommandArg()):
args = args.__str__().split()
if len(args) == 2:
if args[0] in ["p", "pid", "id", "i", "P", "Pid", "PID"]:
if pixiv_config.on_temp:
info = pixivlist.search(Q["pid"] == int(args[1]))
if info:
resp = info[0]["data"]
from dataclasses import dataclass
from nonebot import on_message
from nonebot.params import Depends
test_depends = on_message()
runned = []
def dependency():
runned.append(1)
return 1
def parameterless():
assert len(runned) == 0
runned.append(1)
def gen_sync():
yield 1
async def gen_async():
yield 2
@dataclass
class ClassDependency:
x: int = Depends(gen_sync)
r"^[\.。/#\:].*",
r"^[\S+]$",
r"^[\S+]$",
r"此处消息的转义尚未被插件支持",
r"请使用最新版手机QQ体验新功能",
]
def filter_msg(msg: str = EventPlainText()):
for p in filter_patterns:
if re.search(p, msg):
return False
return True
chat = on_message(rule=to_me(), block=True, priority=100)
@chat.handle()
async def first_receive(
matcher: Matcher, event: MessageEvent, msg: str = EventPlainText()
):
if event.reply:
await chat.finish()
if not filter_msg(msg):
await chat.finish()
if msg:
reply = await get_reply(msg, event)
else:
reply = random.choice(null_reply)
from random import choice
from nonebot import on_notice, on_message
from nonebot.adapters.onebot.v11.bot import Bot
from nonebot.adapters.onebot.v11.message import Message
from nonebot.adapters.onebot.v11.event import GroupMessageEvent, FriendRecallNoticeEvent, PokeNotifyEvent, GroupRecallNoticeEvent
from nonebot.rule import to_me
import src.plugins as cfg
poke = on_notice(rule=to_me())
recall = on_notice(priority=10)
flashimg = on_message(priority=10)
# 群聊撤回
@recall.handle()
async def _(bot: Bot, event: GroupRecallNoticeEvent):
switch_map = cfg.check_switcher(event.group_id, '防撤回')
if len(switch_map) == 0:
return
mid = event.message_id
msg = await bot.get_msg(message_id=mid)
if event.user_id != event.self_id and ',type=flash' not in msg['message']:
re = '刚刚说了:\n' + msg['message']
await recall.finish(message=Message(re), at_sender=True)
# 私聊撤回
@recall.handle()
async def _(bot: Bot, event: FriendRecallNoticeEvent):
from nonebot import on_notice, on_message
from nonebot.adapters.cqhttp import GroupRecallNoticeEvent, Bot, Message, FriendRecallNoticeEvent, PokeNotifyEvent, \
MessageEvent
from nonebot.rule import to_me
from random import choice
poke = on_notice(rule=to_me())
recall = on_notice()
flashimg = on_message()
# 群聊
@recall.handle()
async def _(bot: Bot, event: GroupRecallNoticeEvent):
mid = event.message_id
meg = await bot.get_msg(message_id=mid)
if event.user_id != event.self_id and 'type=flash,' not in meg['message']:
re = '刚刚说了:' + meg['message'] + '\n不要以为派蒙没看见！'
await recall.finish(message=Message(re), at_sender=True)
# 私聊
@recall.handle()
async def _(bot: Bot, event: FriendRecallNoticeEvent):
mid = event.message_id
meg = await bot.get_msg(message_id=mid)
if event.user_id != event.self_id and 'type=flash,' not in meg['message']:
re = '刚刚说了:' + meg['message'] + '\n不要以为派蒙没看见！'
await recall.finish(message=Message(re))
from nonebot import (
on_message, )
from nonebot.adapters.cqhttp import GroupMessageEvent, Message
from nonebot.adapters import Bot
from .model import (predict)
chat = on_message(priority=5, block=False)
@chat.handle()
async def _(bot: Bot, event: GroupMessageEvent):
if str(event.group_id) in [
"1098933683", "913211173", "993211173", "1124718762"
]:
msg: Message = event.get_message()
await chat.finish(predict(str(msg)))
recorder_obj.save_data()
@scheduler.scheduled_job("cron", day=1, hour=0, minute=0, second=0, id="clear_recorder")
async def clear_recorder():
"""每个月最后一天 24 点（下月 0 点）保存记录于历史记录文件夹，并重置记录"""
recorder_obj.save_data_to_history()
recorder_obj.init_data()
logger.info("记录清除完成")
# endregion
# region 复读
repeat_message = on_message(
rule=need_repeat,
permission=GROUP,
priority=5,
block=True,
)
@repeat_message.handle()
async def repeat_message_handle(event: GroupMessageEvent):
await repeat_message.finish(event.message)
repeat_cmd = repeat.command("basic", aliases={"repeat", "复读"}, permission=GROUP)
repeat_cmd.__doc__ = """
复读
查看当前群是否启用复读功能
/repeat
from nonebot.adapters import Message, Event
from nonebot.adapters.onebot.v11 import Event, Bot, MessageSegment, ActionFailed, GroupMessageEvent, PrivateMessageEvent
import re
from nonebot.matcher import Matcher
from nonebot.params import Received, EventMessage, CommandArg, State, RegexGroup
from nonebot.typing import T_State
from .data_source import Ncm, music, ncm_config, playlist, setting, Q, cmd
set = on_command("ncm", priority=1, block=False) # 功能设置
music_regex = on_regex("(song|url)\?id=([0-9]+)(|&)", priority=2,
block=False) # 歌曲id识别 (新增json识别)
playlist_regex = on_regex("playlist\?id=([0-9]+)&", priority=2,
block=False) # 歌单识别
music_reply = on_message(priority=2, block=False) # 回复下载
search = on_regex("搜(歌|歌单|用户)", priority=2, block=False) # 搜东西
@music_regex.handle()
async def music_receive(bot: Bot,
event: Event,
regroup: Tuple[Any, ...] = RegexGroup()):
if event.dict()["message_type"] == "private":
return await bot.send(event=event,
message=Message(
MessageSegment.text("私聊无法启用解析功能")))
info = setting.search(Q["group_id"] == event.dict()["group_id"])
# logger.info(info)
nid = regroup[1]
from nonebot import on_message
from nonebot.typing import T_State
from nonebot.adapters.cqhttp import Bot, Event, Message, MessageSegment
from src.extensions.mongodb import MongoChat
from .config import Config
cfg = Config()
db = MongoChat()
record = on_message(priority=100, block=False)
@record.handle()
async def log2database(bot: Bot, event: Event, state: T_State):
message_id = event.get_event_description().split()[1]
session_id = event.get_session_id().split("_")
if session_id[0] == 'group':
group_id = session_id[1]
user_id = session_id[2]
self_id = None
msg: Message[MessageSegment] = event.get_message()
else:
group_id = None
user_id = session_id[0]
self_id = bot.self_id
msg: Message[MessageSegment] = event.get_message()
await db.log_chat(msg, user_id, message_id, group_id, self_id)
import re
import json
from nonebot import on_message
from nonebot.adapters.cqhttp import Bot, Event, Message, exception
from nonebot.log import logger
from nonebot.exception import StopPropagation
# from asyncstdlib.builtins import map as amap, list as alist
import aiohttp
from src.plugins.kit48.config import API_ROOT
bili_cover = on_message(priority=10, block=False)
reg = re.compile(r'https://www.bilibili.com/video/[0-9a-zA-Z]+')
short_reg = re.compile(r'https://b23.tv/[0-9a-zA-Z]+')
@bili_cover.handle()
async def handle_image(bot: Bot, event: Event, state: dict):
message = str(event.get_message())
short_result = short_reg.findall(message)
short_links = list(set(short_result))
# # https://stackoverflow.com/questions/62846735/how-to-use-await-inside-map-function
# makeup_links = await alist(amap(get_target_link, short_links))
result = reg.findall(message)
links = list(filter(lambda link: type(link) == str, list(
set(result)))) + short_links
for link in links:
info = await get_data(link)
from epicteller.bot.controller import base
from epicteller.core.controller import message as message_ctl
from epicteller.core.controller import episode as episode_ctl
from epicteller.core.controller import room as room_ctl
from epicteller.core.model.character import Character
from epicteller.core.model.episode import Episode
from epicteller.core.model.message import TextMessageContent, ImageMessageContent, MessageContent
from epicteller.core.util import imghosting
from epicteller.core.util.enum import MessageType, ExternalType
VALID_MESSAGE_REGEX_PATTERN = r'^[^()（）]'
VALID_MESSAGE_REGEX = re.compile(VALID_MESSAGE_REGEX_PATTERN)
say = on_message(rule=regex(VALID_MESSAGE_REGEX_PATTERN),
permission=permission.GROUP,
priority=99999)
@say.handle()
async def _(bot: Bot, event: MessageEvent, state: dict):
await prepare(bot, event, state)
episode: Episode = state.get('episode')
character: Character = state.get('character')
message_type: MessageType = state.get('message_type')
content: MessageContent = state.get('content')
is_gm: bool = state.get('is_gm')
message = await message_ctl.create_message(episode, character,
message_type, content, is_gm)
internal_message_id = event.message_id
except error.combat.CombatOrderEmptyError:
await combat_cmd.finish('❌ 先攻列表为空，无法进入下一行动轮。')
return
async def combat_end(bot: Bot, event: MessageEvent, state: dict):
combat: Combat = state['combat']
try:
await combat_ctl.end_combat(combat)
except error.combat.CombatEndedError:
await combat_cmd.finish('❌ 当前战斗已结束。')
return
next_token = on_message(rule=regex(r'^\s*(回合结束|行动结束)\s*$'),
permission=permission.GROUP,
priority=99998,
block=True)
@next_token.handle()
async def _(bot: Bot, event: MessageEvent, state: dict):
await prepare_combat_context(next_token, bot, event, state)
combat: Combat = state['combat']
if not combat or combat.state != CombatState.RUNNING:
return
is_gm: bool = state['is_gm']
character: Optional[Character] = state['character']
if not is_gm:
if not character:
return
token = combat.tokens[combat.order.current_token_name]
from nonebot import (
on_message,
)
from nonebot.adapters.cqhttp import GroupMessageEvent, MessageSegment, Message
from nonebot.adapters import Bot
from aredis import StrictRedis
redis_client = StrictRedis(host='localhost', port=6379, decode_responses=True, db=1)
save_chat_data = on_message(priority=5, block=False)
@save_chat_data.handle()
async def _(bot: Bot, event: GroupMessageEvent):
msg: Message = event.get_message()
for item in msg:
if item.type == 'text':
group_id = str(event.group_id)
with open(f'/var/www/chat_data/{group_id}_chat.log', 'a+') as file:
if not await redis_client.exists(group_id):
await redis_client.set(group_id, True)
file.write("\n")
file.write(f"{item.data.get('text')}\n")
await redis_client.expire(group_id, 60)
trigger = {} #重复触发词判定
data = {} #语料数据
ptalk = {} #群回复率
focus_id = [] #特别对象
gpath = os.path.dirname(__file__)
path = gpath + '/data.json'
with open(path) as f:
data = json.load(f)
def union(gid, uid):
return (gid << 32) | uid
chat = on_message(priority=99)
@chat.handle()
async def _(bot: Bot, event: GroupMessageEvent):
message = str(event.raw_message)
print(message)
group_id = event.group_id
user_id = event.user_id
global ptalk
ptalk.setdefault(group_id, 1)
trigger.setdefault(group_id, ' ')
for i in data:
if i in message:
from nonebot import on_message
from nonebot.adapters.cqhttp import Bot, MessageEvent
from nonebot.log import logger
# 展示所有接收到的信息，比如方便测试 QQ 表情等特殊消息的数据结构
print_plugin = on_message(priority=1, block=False)
@print_plugin.handle()
async def handle_print(bot: Bot, event: MessageEvent, state: dict):
message = str(event.get_message())
logger.info(f'receive message: {message}')
import asyncio
from nonebot import on_message
from nonebot.permission import USER
from nonebot.typing import Bot, Event
a = on_message(priority=0, permission=USER(123123123), temp=True)
@a.handle()
async def test_a(bot: Bot, event: Event, state: dict):
print("======== A Received ========")
print("======== A Running Completed ========")
b = on_message(priority=0, permission=USER(123456789), temp=True)
@b.handle()
async def test_b(bot: Bot, event: Event, state: dict):
print("======== B Received ========")
await asyncio.sleep(10)
print("======== B Running Completed ========")
c = on_message(priority=0, permission=USER(1111111111))
@c.handle()
async def test_c(bot: Bot, event: Event, state: dict):
print("======== C Received ========")
from nonebot import on_message
from math import exp
from random import random
from nonebot.adapters.cqhttp import Bot, Event
repeat = on_message(priority=5)
tjmp = {}
def sigmoid(num):
num //= 2
if num < 1:
return -1
num -= 3
print(1 / (1 + exp(-num)))
return 1 / (1 + exp(-num))
@repeat.handle()
async def firsthandle(bot: Bot, event: Event, state: dict):
msg = str(event.message).strip()
global tjmp
if event.detail_type != "group":
return
if event.group_id not in tjmp:
tjmp[event.group_id] = [0, "", "", 0]
now = tjmp[event.group_id]
try:
if msg == now[2]:
now[0] += 1
import asyncio
from nonebot import on_message
from nonebot.typing import T_State
from nonebot.permission import USER
from nonebot.adapters import Bot, Event
a = on_message(priority=0, permission=USER("123123123"), temp=True)
@a.handle()
async def test_a(bot: Bot, event: Event, state: T_State):
print("======== A Received ========")
print("======== A Running Completed ========")
b = on_message(priority=0, permission=USER("123456789"), temp=True)
@b.handle()
async def test_b(bot: Bot, event: Event, state: T_State):
print("======== B Received ========")
await asyncio.sleep(10)
print("======== B Running Completed ========")
c = on_message(priority=0, permission=USER("1111111111"))
@c.handle()
async def test_c(bot: Bot, event: Event, state: T_State):
if status_config.server_status_cpu:
data.append(f"CPU: {int(cpu_status()):02d}%")
if status_config.server_status_memory:
data.append(f"Memory: {int(memory_status()):02d}%")
if status_config.server_status_disk:
data.append(f"Disk:\n" + "\n".join(
f" {k}: {int(v.percent):02d}%" for k, v in disk_usage().items()))
await matcher.send(message="\n".join(data))
async def _group_poke(bot: Bot, event: Event, state: T_State) -> bool:
return isinstance(event, PokeNotifyEvent) and str(
event.user_id) in global_config.superusers
group_poke = on_notice(_group_poke, priority=10, block=True)
group_poke.handle()(server_status)
async def _poke(bot: Bot, event: Event, state: T_State) -> bool:
return (isinstance(event, PrivateMessageEvent) and
event.sub_type == "friend" and event.message[0].type == "poke")
poke = on_message(_poke, permission=SUPERUSER, priority=10)
poke.handle()(server_status)
import time
import os
from nonebot import on_message
from nonebot.adapters import Event, Bot
from nonebot.adapters.cqhttp import PrivateMessageEvent
from .sqlite import is_logging, start_logging, stop_logging
from .s3 import upload_file
TRPGLogger = on_message(priority=1, block=False)
@TRPGLogger.handle()
async def _(bot: Bot, event: Event):
message = str(event.get_message()).strip()
if isinstance(event, PrivateMessageEvent):
return
if message[:4] == '.log':
if isinstance(event, PrivateMessageEvent):
await bot.send(event, "暂不支持")
return
if message[4:].strip() == 'on' or message[4:].strip() == '':
if is_logging(event.group_id):
await bot.send(event, "正在进行日志记录, 无法再次开始!")
else:
await bot.send(event, "开始日志记录")
start_logging(event.group_id, event.time)
elif message[4:].strip() == 'off':
file_path = os.path.join(
'data', 'trpglogger',
import httpx
import io
from nonebot import (
on_message, )
from nonebot.adapters import Bot
from nonebot.adapters.cqhttp import MessageEvent, GroupMessageEvent
from nonebot.adapters.cqhttp.message import MessageSegment
from PIL import Image
from .data_source import predict
from typing import Dict, List
recognition = on_message(priority=5)
@recognition.handle()
async def _(bot: Bot, event: GroupMessageEvent):
msg: MessageSegment = event.get_message().pop()
if msg.type == "image":
async with httpx.AsyncClient() as client:
image = await client.get(msg.data['url'])
im = Image.open(io.BytesIO(image.content))
pre: List[Dict[str, float]] = predict(im)
if not pre:
return
elif pre[0]["score"] > 0.9:
await recognition.finish(f" 一定是 {pre[0]['name']} 拉")
return
elif pre[0]["score"] > 0.7:
await recognition.finish(f"我猜是 {pre[0]['name']} ")
from loguru import logger
from nonebot import on_command, on_message
from nonebot import on_regex
from nonebot.adapters.cqhttp import Bot, Event, Message, MessageSegment
from .data_source import Setu, hso_config
from .model import Power
# -----------
# 事件响应
# -----------
# -----------------------------------------------------------------
setu = on_regex(pattern="来(.*?)[点丶份张幅](.*?)的?(|r18)[色瑟涩🐍][图圖🤮]", priority=1)
db = on_command("hso", priority=2)
reply = on_message(priority=3)
pic = on_command("查看")
asyncio.run(Power().update_all())
@setu.receive()
async def message_receive(bot: Bot, event: Event, state: dict): # 涩图调用
# logger.info(bot.__dict__)
# logger.info(event.dict())
# logger.info(state)
await Setu(bot, event, state).main()
# -----------------------------------------------------------------
await del_event.finish("我可不想忘记[CQ:face,id=14]")
list_event = on_command("list", rule=startswith("list"), priority=5)
@list_event.handle()
async def _(bot: Bot, event: MessageEvent):
stripped_arg = event.raw_message.split()[1:]
logger.debug(f"{stripped_arg}, {len(stripped_arg)}")
if stripped_arg and len(stripped_arg) == 1:
res = await redis_client.smembers(stripped_arg[0])
await list_event.finish(f"{res}")
group = on_message(block=False, priority=5)
@group.handle()
async def _(bot: Bot, event: MessageEvent):
msg: Message = event.get_message()
for i in msg:
if i.type == "image":
return
sentence = event.raw_message.strip()
if sentence.split()[0] in [
'add', 'list', 'del', 'help', 'info', 'jita', '签到', '兑换', '积分',
'抽奖', '柏青哥', '积分池'
from nonebot import on_message
from nonebot.matcher import Matcher
from nonebot.adapters import Event, Message
from nonebot.params import ArgStr, Received, EventMessage, LastReceived
test_handle = on_message()
@test_handle.handle()
async def handle():
await test_handle.finish("send", at_sender=True)
test_got = on_message()
@test_got.got("key1", "prompt key1")
@test_got.got("key2", "prompt key2")
async def got(key1: str = ArgStr(), key2: str = ArgStr()):
if key2 == "text":
await test_got.reject("reject", at_sender=True)
assert key1 == "text"
assert key2 == "text_next"
test_receive = on_message()
@test_receive.receive()
@test_receive.receive("receive")
