def wrapper(gm: GroupMessage):
cp = CommandParser(gm, settings.commandSymbol)
gp = groupPermissions(cp.sender_id)
if gp.isBlocked():
raise ExecutionStop()
if not re.match(pattern, cp.plain_message):
raise ExecutionStop()
async def limit(event: GroupMessage) -> NoReturn:
if await Permission.get(event.sender.group,
event.sender) >= override_level:
return
member = event.sender.id
group = event.sender.group.id
if not await group_setting.get_setting(group,
Setting.frequency_limit):
return
frequency_limit_instance = await FrequencyLimit.get_frequency_limit_dict(
)
await frequency_limit_instance.add_record(group, member, weight)
if frequency_limit_instance.blacklist_judge(group, member):
if not frequency_limit_instance.announce_judge(group, member):
await frequency_limit_instance.blacklist_announced(
group, member)
await ariadne_ctx.get().sendGroupMessage(
group,
MessageChain("检测到大量请求，加入黑名单一小时！"),
quote=event.messageChain.getFirst(Source))
raise ExecutionStop()
if frequency_limit_instance.get(
group, member, func_name) + weight >= total_weight:
await ariadne_ctx.get().sendGroupMessage(
group,
MessageChain("超过频率调用限制！"),
quote=event.messageChain.getFirst(Source))
raise ExecutionStop()
else:
await frequency_limit_instance.update(group, weight)
return
def wrapper(gm: GroupMessage):
cp = CommandParser(gm, settings.commandSymbol)
gp = groupPermissions(cp.sender_id)
if gp.isBlocked():
raise ExecutionStop()
if cp.Command.cmd != command_name:
raise ExecutionStop()
async def catch(self, interface: DispatcherInterface):
# 因为 Dispatcher 的特性, 要用 yield (自动清理 self.parsed_items)
token = None
if self.parsed_items.get(None) is None:
message_chain = (await interface.lookup_param(
"__kanata_messagechain__",
MessageChain, None
)).exclude(Source, Quote, Xml, Json, App, Poke)
mapping_result = self.detect_and_mapping(
self.signature_list, message_chain
)
if mapping_result is not None:
token = self.parsed_items.set(self.allocation(mapping_result))
else:
if self.stop_exec_if_fail:
raise ExecutionStop()
random_id = random.random()
current_item = self.parsed_items.get()
if current_item is not None:
result = current_item.get(interface.name, random_id)
yield Force(result) if result is not random_id else None
else:
if self.stop_exec_if_fail:
raise ExecutionStop()
if token is not None:
self.parsed_items.reset(token)
def wrapper(gm: GroupMessage):
M = MessagePro(gm, settings.commandSymbol)
if M.permission.isBlocked():
raise ExecutionStop()
if not M.plain_message:
raise ExecutionStop()
if not re.match(pattern, M.plain_message):
raise ExecutionStop()
def wrapper(gm: GroupMessage):
M = MessagePro(gm, settings.commandSymbol)
if M.permission.isBlocked():
raise ExecutionStop()
if not M.plain_message:
raise ExecutionStop()
if M.Command.cmd != command_name:
raise ExecutionStop()
def func(messageChain: MessageChain) -> NoReturn:
plains = messageChain.get(Plain)
haved = False
for p in plains:
if p.text.strip() == param:
haved = True
elif p.text.strip():
raise ExecutionStop()
if not haved:
raise ExecutionStop()
async def beforeDispatch(self, interface: DispatcherInterface):
message_chain: MessageChain = (await interface.lookup_param(
"__literature_messagechain__", MessageChain, None)).exclude(Source)
if set([i.__class__ for i in message_chain.__root__
]).intersection(BLOCKING_ELEMENTS):
raise ExecutionStop()
noprefix = self.prefix_match(message_chain)
if noprefix is None:
raise ExecutionStop()
interface.execution_contexts[
-1].literature_detect_result = self.parse_message(noprefix)
def wrapper(gm: GroupMessage):
cp = CommandParser(gm, settings.commandSymbol)
gp = groupPermissions(cp.sender_id)
if gp.isBlocked():
raise ExecutionStop()
inList = False
for word in words_list:
if word in cp.plain_message:
inList = True
break
if not inList:
raise ExecutionStop()
def wrapper(gm: GroupMessage):
M = MessagePro(gm, settings.commandSymbol)
if M.permission.isBlocked():
raise ExecutionStop()
if not M.plain_message:
raise ExecutionStop()
matched: bool = False
for p in pattern_list:
if re.match(p, M.plain_message):
matched = True
break
if not matched:
raise ExecutionStop()
def wrapper(gm: GroupMessage):
M = MessagePro(gm, settings.commandSymbol)
if M.permission.isBlocked():
raise ExecutionStop()
inList = False
if not M.plain_message:
raise ExecutionStop()
for word in words_list:
if word in M.plain_message:
inList = True
break
if not inList:
raise ExecutionStop()
async def catch(self, interface: DispatcherInterface):
# 因为 Dispatcher 的特性, 要用 yield (自动清理 self.parsed_items)
if self.parsed_items is None:
message_chain = (await interface.execute_with(
"__kanata_messagechain_origin__", MessageChain,
None)).exclude(Source, Quote, Xml, Json, App, Poke)
self.parsed_items = self.allocation(
self.detect_and_mapping(self.signature_list, message_chain)
or {})
if self.stop_exec_if_fail and self.parsed_items is None:
self.parsed_items = None
self.will_clean = False
raise ExecutionStop()
if self.parsed_items:
result = self.parsed_items.get(interface.name)
if result is None:
if interface.default: # 不是 None, 生成 None.
yield Force(None)
else: # 无默认值 None, 也无结果, 应转交控制权予下级(实际上这里必定触发 RequirementCrashed, 只不过我不想写 raise 了.)
return
else:
yield Force(result)
self.parsed_items = None
async def cd_check(event: GroupMessage) -> NoReturn:
if await Permission.get(event.sender.group,
event.sender) >= override_level:
return
current = time.time()
async with (await cls.get_lock()):
last = cls.last_exec[event.sender.id]
if current - cls.last_exec[event.sender.id][1] >= suspend_time:
cls.last_exec[event.sender.id] = (1, current)
if event.sender.id in cls.sent_alert:
cls.sent_alert.remove(event.sender.id)
return
elif last[0] < max_exec:
cls.last_exec[event.sender.id] = (last[0] + 1, current)
if event.sender.id in cls.sent_alert:
cls.sent_alert.remove(event.sender.id)
return
if event.sender.id not in cls.sent_alert:
if not silent:
await ariadne_ctx.get().sendGroupMessage(
event.sender.group,
MessageChain.create([
Plain(
f"冷却还有{last[1] + suspend_time - current:.2f}秒结束，"
f"之后可再执行{max_exec}次")
]),
quote=event.messageChain.getFirst(Source).id,
)
cls.sent_alert.add(event.sender.id)
raise ExecutionStop()
def func(messageChain: MessageChain) -> NoReturn:
p = messageChain.get(Plain)
if not p or not reduce(
lambda a, b: bool(a or b),
map(lambda plain: plain.text.strip().startswith(param), p),
):
raise ExecutionStop()
async def perm_check(event: GroupMessage) -> NoReturn:
if not Permission.DEFAULT <= level <= Permission.MASTER:
raise ValueError(f"invalid level: {level}")
member_level = await cls.get(event.sender.group, event.sender)
if member_level == cls.MASTER:
pass
elif member_level < level:
raise ExecutionStop()
async def switch(event: GroupMessage) -> NoReturn:
member = event.sender.id
group = event.sender.group.id
if not await group_setting.get_setting(group, Setting.switch):
if response_administrator and await user_permission_require(
group, member, 2):
return
raise ExecutionStop()
return
def target(self, interface: DecoratorInterface):
last_time = interface.local_storage.get(self.cool_down_id)
time = datetime.datetime.today()
if last_time and time - last_time <= self.cool_down_time:
if interface.name:
return False
raise ExecutionStop()
interface.local_storage[self.cool_down_id] = time
return True
async def beforeDispatch(self, interface: DispatcherInterface):
message_chain: MessageChain = (await interface.lookup_param(
"__literature_messagechain__", MessageChain, None)).exclude(Source)
if set([i.__class__ for i in message_chain.__root__
]).intersection(BLOCKING_ELEMENTS):
raise ExecutionStop()
if self.allow_quote and message_chain.has(Quote):
# 自动忽略自 Quote 后第一个 At
message_chain = message_chain[(1, None):]
if self.skip_one_at_in_quote and message_chain.__root__:
if message_chain.__root__[0].__class__ is At:
message_chain = message_chain[(1, 1):]
noprefix = self.prefix_match(message_chain)
if noprefix is None:
raise ExecutionStop()
interface.execution_contexts[
-1].literature_detect_result = self.parse_message(noprefix)
def func(messageChain: MessageChain):
p = messageChain.get(Plain)
for i in p:
if not i.text.strip():
continue
t = re.fullmatch(param, i.text.strip())
if t:
return t
else:
raise ExecutionStop()
async def manage_group_events(app: Ariadne, group: Group):
if name not in saya_data.switch:
saya_data.add_saya(name)
if group.id not in saya_data.switch[name]:
saya_data.add_group(group)
if not saya_data.is_turned_on(name, group):
if saya_data.is_notice_on(name, group):
await app.sendMessage(
group,
MessageChain.create([Plain(text=f"{name}插件已关闭，请联系管理员")]))
raise ExecutionStop()
async def judge(event: GroupMessage) -> NoReturn:
member = event.sender
group = member.group
if name not in saya_data.switch:
saya_data.add_saya(name)
if group.id not in saya_data.switch[name]:
saya_data.add_group(group)
if log:
print(name, saya_data.is_turned_on(name, group))
if not saya_data.is_turned_on(name, group):
if saya_data.is_notice_on(name, group) or notice:
await ariadne_ctx.get().sendMessage(
group, MessageChain(f"{name}插件已关闭，请联系管理员"))
raise ExecutionStop()
if not await group_setting.get_setting(group, Setting.switch):
if response_administrator and await user_permission_require(
group, member, 2):
return
raise ExecutionStop()
return
async def catch(self, interface: DispatcherInterface):
if not self.content_token:
return
random_id = random.random()
current_item = self.parsed_items.get()
if current_item is not None:
result = current_item.get(interface.name, random_id)
return Force(result) if result is not random_id else None
else:
if self.stop_exec_if_fail:
raise ExecutionStop()
def FriendMessageInterruptWaiter(event: FriendMessage):
if special_friend:
if event.sender.id != (special_friend.id if isinstance(
special_friend, Friend) else special_friend):
raise ExecutionStop()
if quote_access:
quotes = event.messageChain.get(Quote)
if not quotes:
raise ExecutionStop()
quote: Quote = quotes[0]
if isinstance(quote_access, BotMessage):
if quote.id != quote_access.messageId:
raise ExecutionStop()
elif isinstance(quote_access, Source):
if quote.id != quote_access.id:
raise ExecutionStop()
if custom_judgement:
if not custom_judgement(event):
raise ExecutionStop()
return event
async def blacklist(event: GroupMessage) -> NoReturn:
member = event.sender.id
group = event.sender.group.id
if await orm.fetchone(
select(BlackList.member_id).where(
BlackList.member_id == member, BlackList.group_id
== group)) or await orm.fetchone(
select(BlackList.member_id).where(
BlackList.member_id == member,
BlackList.is_global is True)):
raise ExecutionStop()
return
async def target(self, interface: DecoratorInterface):
if self.need_load_from_database:
self.need_load_from_database = False
await self.__load_permission_from_dataBase()
self.permission = PermissionCache.permissions.get(self.permission_id)
async with aiosqlite.connect(DATEBASE_PATH) as db:
if await check_permission(db, self.permission,
self.__make_permittee(interface.event)):
return True
if interface.name:
return False
raise ExecutionStop()
async def beforeDispatch(self, interface: DispatcherInterface):
message_chain: MessageChain = (await interface.lookup_param(
"__kanata_messagechain__", MessageChain, None)).exclude(Source)
if set([i.__class__ for i in message_chain.__root__
]).intersection(BLOCKING_ELEMENTS):
raise ExecutionStop()
if self.allow_quote and message_chain.has(Quote):
# 自动忽略自 Quote 后第一个 At
# 0: Quote, 1: At, 2: Plain(一个空格, 可能会在以后的 mirai 版本后被其处理, 这里先自动处理这个了.)
message_chain = message_chain[(3, None):]
if self.skip_one_at_in_quote and message_chain.__root__:
if message_chain.__root__[0].__class__ is At:
message_chain = message_chain[(
1, 1):] # 利用 MessageIndex 可以非常快捷的实现特性.
mapping_result = self.detect_and_mapping(self.signature_list,
message_chain)
if mapping_result is not None:
self.content_token = self.parsed_items.set(
self.allocation(mapping_result))
else:
if self.stop_exec_if_fail:
raise ExecutionStop()
def parse_message(self, message_chain: MessageChain):
string_result, id_elem_map = self.trans_to_map(message_chain)
parsed_args, variables = getopt.getopt(
shlex.split(string_result),
"".join([
arg.short if isinstance(arg, SwitchParameter) else
(arg.short + ":") for arg in self.arguments.values()
if arg.short
]),
[
long if isinstance(arg, SwitchParameter) else long + "="
for arg in self.arguments.values() for long in arg.longs
],
)
map_with_bar = {
**self.gen_long_map_with_bar(),
**self.gen_short_map_with_bar()
}
parsed_args = {
map_with_bar[k]: (
MessageChain.create([
Plain(i)
if not re.match("^\$\d+$", i) else id_elem_map[int(i[1:])]
for i in printer(re.split(r"((?<!\\)\$[0-9]+)", v)) if i
]).asMerged() if isinstance(self.arguments[map_with_bar[k]],
BoxParameter) else
(self.arguments[map_with_bar[k]].auto_reverse
and not self.arguments[map_with_bar[k]].default or True),
self.arguments[map_with_bar[k]],
)
for k, v in parsed_args
}
variables = [
MessageChain.create([
Plain(i)
if not re.match("^\$\d+$", i) else id_elem_map[int(i[1:])]
for i in re.split(r"((?<!\\)\$[0-9]+)", v) if i
]).asMerged() for v in variables
]
for param_name, argument_setting in self.arguments.items():
if param_name not in parsed_args:
if argument_setting.default is not None:
parsed_args[param_name] = (
argument_setting.default,
argument_setting,
)
else:
raise ExecutionStop()
return (parsed_args, variables)
async def catch(self, interface: DispatcherInterface):
# 因为 Dispatcher 的特性, 要用 yield (自动清理 self.parsed_items)
token = None
if self.parsed_items.get(None) is None:
message_chain: MessageChain = (await interface.lookup_param(
"__kanata_messagechain__",
MessageChain, None
)).exclude(Source)
if set([i.__class__ for i in message_chain.__root__]).intersection(BLOCKING_ELEMENTS):
raise ExecutionStop()
if self.allow_quote and message_chain.has(Quote):
# 自动忽略自 Quote 后第一个 At
# 0: Quote, 1: At, 2: Plain(一个空格, 可能会在以后的 mirai 版本后被其处理, 这里先自动处理这个了.)
message_chain = message_chain[(3, None):]
if self.skip_one_at_in_quote and message_chain.__root__:
if message_chain.__root__[0].__class__ is At:
message_chain = message_chain[(1, 1):] # 利用 MessageIndex 可以非常快捷的实现特性.
mapping_result = self.detect_and_mapping(
self.signature_list, message_chain
)
if mapping_result is not None:
token = self.parsed_items.set(self.allocation(mapping_result))
else:
if self.stop_exec_if_fail:
raise ExecutionStop()
random_id = random.random()
current_item = self.parsed_items.get()
if current_item is not None:
result = current_item.get(interface.name, random_id)
yield Force(result) if result is not random_id else None
else:
if self.stop_exec_if_fail:
raise ExecutionStop()
if token is not None:
self.parsed_items.reset(token)
async def generator_factory(self):
interface: DispatcherInterface = (yield)
current_status: StatusCodeEnum = StatusCodeEnum.DISPATCHING # init stat
message_chain: MessageChain = (await interface.lookup_param(
"__kanata_messagechain__", MessageChain, None)).exclude(Source)
if set([i.__class__ for i in message_chain.__root__
]).intersection(BLOCKING_ELEMENTS):
raise ExecutionStop()
if self.allow_quote and message_chain.has(Quote):
# 自动忽略自 Quote 后第一个 At
# 0: Quote, 1: At, 2: Plain(一个空格, 可能会在以后的 mirai 版本后被其处理, 这里先自动处理这个了.)
message_chain = message_chain[(3, None):]
if self.skip_one_at_in_quote and message_chain.__root__:
if message_chain.__root__[0].__class__ is At:
message_chain = message_chain[(1, 1):]
mapping_result = self.detect_and_mapping(self.signature_list,
message_chain)
if mapping_result is not None:
parsed_items = self.allocation(mapping_result)
else:
if self.stop_exec_if_fail:
raise ExecutionStop()
yield
while current_status is StatusCodeEnum.DISPATCHING:
result = None
if interface.name != "__kanata_messagechain__":
random_id = random.random()
if parsed_items is not None:
item = parsed_items.get(interface.name, random_id)
result = Force(item) if item is not random_id else None
else:
if self.stop_exec_if_fail:
raise ExecutionStop()
current_status, external = yield (ResponseCodeEnum.VALUE, result)
async def manage_mirai_events(app: Ariadne, event: MiraiEvent):
group = event.group_id if hasattr(event, "group_id") else '0'
if name not in saya_data.switch:
saya_data.add_saya(name)
if group not in saya_data.switch[name]:
saya_data.add_group(group)
if not saya_data.is_turned_on(name, group):
if saya_data.is_notice_on(name, group):
if group != '0':
await app.sendGroupMessage(
int(group),
MessageChain.create(
[Plain(text=f"{name}插件已关闭，请联系管理员")]))
raise ExecutionStop()
