def get_annotations_mapping(self):
return {
Mirai: lambda k: self,
GroupMessage: lambda k: k.body \
if self.getEventCurrentName(k.body) == "GroupMessage" else \
raiser(ValueError("you cannot setting a unbind argument.")),
FriendMessage: lambda k: k.body \
if self.getEventCurrentName(k.body) == "FriendMessage" else \
raiser(ValueError("you cannot setting a unbind argument.")),
TempMessage: lambda k: k.body \
if self.getEventCurrentName(k.body) == "TempMessage" else \
raiser(ValueError("you cannot setting a unbind argument.")),
MessageChain: lambda k: k.body.messageChain \
if self.getEventCurrentName(k.body) in MessageTypes else \
raiser(ValueError("MessageChain is not enable in this type of event.")),
components.Source: lambda k: k.body.messageChain.getSource() \
if self.getEventCurrentName(k.body) in MessageTypes else \
raiser(TypeError("Source is not enable in this type of event.")),
Group: lambda k: k.body.sender.group \
if self.getEventCurrentName(k.body) in ["GroupMessage", "TempMessage"] else \
raiser(ValueError("Group is not enable in this type of event.")),
Friend: lambda k: k.body.sender \
if self.getEventCurrentName(k.body) == "FriendMessage" else \
raiser(ValueError("Friend is not enable in this type of event.")),
Member: lambda k: k.body.sender \
if self.getEventCurrentName(k.body) in ["GroupMessage", "TempMessage"] else \
raiser(ValueError("Group is not enable in this type of event.")),
"Sender": lambda k: k.body.sender \
if self.getEventCurrentName(k.body) in MessageTypes else \
raiser(ValueError("Sender is not enable in this type of event.")),
"Type": lambda k: self.getEventCurrentName(k.body),
**self.gen_event_anno()
}
def get_annotations_mapping(self):
from .event.message import MessageChain
return {
Session: lambda k: self,
GroupMessage: lambda k: k.body \
if k.name == "GroupMessage" else\
raiser(ValueError("you cannot setting a unbind argument.")),
FriendMessage: lambda k: k.body \
if k.name == "FriendMessage" else\
raiser(ValueError("you cannot setting a unbind argument.")),
MessageChain: lambda k: k.body.messageChain\
if k.name in MessageTypes else\
raiser(ValueError("MessageChain is not enable in this type of event.")),
components.Source: lambda k: k.body.messageChain.getSource()\
if k.name in MessageTypes else\
raiser(TypeError("Source is not enable in this type of event.")),
Group: lambda k: k.body.sender.group\
if k.name == "GroupMessage" else\
raiser(ValueError("Group is not enable in this type of event.")),
Friend: lambda k: k.body.sender\
if k.name == "FriendMessage" else\
raiser(ValueError("Friend is not enable in this type of event.")),
Member: lambda k: k.body.sender\
if k.name == "GroupMessage" else\
raiser(ValueError("Group is not enable in this type of event.")),
"Sender": lambda k: k.body.sender\
if k.name in MessageTypes else\
raiser(ValueError("Sender is not enable in this type of event.")),
"Type": lambda k: k.name,
**self.gen_event_anno()
}
async def handleMessageForTempMessage(
self,
message: T.Union[
MessageChain,
BaseMessageComponent,
T.List[BaseMessageComponent],
str
]):
if isinstance(message, MessageChain):
return json.loads(message.json())
elif isinstance(message, BaseMessageComponent):
return [json.loads(message.json())]
elif isinstance(message, (tuple, list)):
result = []
for i in message:
if isinstance(i, InternalImage):
result.append({
"type": "Image" if not i.flash else "FlashImage",
"imageId": (await self.handleInternalImageForTempMessage(i)).asFriendImage()
})
elif isinstance(i, components.Image):
result.append({
"type": "Image" if not i.flash else "FlashImage",
"imageId": i.asFriendImage()
})
else:
result.append(json.loads(i.json()))
return result
elif isinstance(message, str):
return [json.loads(components.Plain(text=message).json())]
else:
raise raiser(ValueError("invaild message."))
async def revokeMessage(self, source: T.Union[components.Source, BotMessage, int]):
return assertOperatorSuccess(await fetch.http_post(f"{self.baseurl}/recall", {
"sessionKey": self.session_key,
"target": source if isinstance(source, int) else source.id \
if isinstance(source, components.Source) else source.messageId\
if isinstance(source, BotMessage) else\
raiser(TypeError("invaild message source"))
}), raise_exception=True)
async def mute(self, group: T.Union[Group, int],
member: T.Union[Member, int], time: T.Union[timedelta,
int]):
return assertOperatorSuccess(
await fetch.http_post(f"{self.baseurl}/mute", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group),
"memberId": self.handleTargetAsMember(member),
"time": time if isinstance(time, int) else \
int(time.total_seconds()) \
if timedelta(days=30) >= time >= timedelta(minutes=1) \
else \
int(timedelta(days=30).total_seconds()) \
if timedelta(days=30) >= time else \
int(timedelta(minutes=1).total_seconds()) \
if time <= timedelta(minutes=1) else \
raiser(ValueError("invaild time."))
if isinstance(time, timedelta) else raiser(ValueError("invaild time."))
}
), raise_exception=True)
async def handleMessageAsFriend(
self, message: T.Union[MessageChain, BaseMessageComponent,
T.List[BaseMessageComponent], str]):
return json.loads(message.json()) \
if isinstance(message, MessageChain) else \
[json.loads(message.json())] \
if isinstance(message, BaseMessageComponent) else \
[
json.loads(i.json()) \
# 对Image特殊处理
if type(i) != InternalImage else \
{
"type": "Image",
"imageId": (await self.handleInternalImageAsFriend(i)).asFriendImage()
} \
for i in message if i
] \
if isinstance(message, (tuple, list)) else \
[json.loads(components.Plain(text=message).json())] \
if isinstance(message, str) else \
raiser(ValueError("invaild message(s)."))
def handleMessageAsGroup(
self,
message: T.Union[
MessageChain,
BaseMessageComponent,
T.List[BaseMessageComponent],
str
]):
return json.loads(message.json()) \
if isinstance(message, MessageChain) else \
[json.loads(message.json())] \
if isinstance(message, BaseMessageComponent) else \
[
json.loads(i.json()) \
# 对Image特殊处理
if type(i) != components.Image else \
{"type": "Image", "imageId": i.asGroupImage()} \
for i in message
] \
if isinstance(message, (tuple, list)) else \
[json.loads(components.Plain(text=message).json())] \
if isinstance(message, str) else \
raiser(ValueError("invaild message(s)."))
def handleTargetAsMember(self, target: T.Union[Member, int]):
return target if isinstance(target, int) else \
target.id if isinstance(target, Member) else \
raiser(ValueError("invaild target as a member obj."))
def handleTargetAsFriend(self, target: T.Union[Friend, int]):
return target if isinstance(target, int) else \
target.id if isinstance(target, Friend) else \
raiser(ValueError("invaild target as a friend obj."))
def handleTargetAsGroup(self, target: T.Union[Group, int]):
return target if isinstance(target, int) else \
target.id if isinstance(target, Group) else \
raiser(ValueError("invaild target as group."))
async def main_entrance(self, run_body, event_context, queue):
if isinstance(run_body, dict):
callable_target = run_body['func']
for depend in run_body['dependencies']:
await self.main_entrance(
{
"func": depend.func if not inspect.isclass(depend.func) else\
depend.func.__call__ if hasattr(depend.func, "__call__") else\
raiser(TypeError("must be callable.")),
"middlewares": depend.middlewares
},
event_context, queue
)
else:
callable_target = run_body if not inspect.isclass(run_body) else\
run_body.__call__ if hasattr(run_body, "__call__") else\
raiser(TypeError("must be callable."))
translated_mapping = {
**(await self.argument_compiler(
callable_target,
event_context
)),
**(await self.signature_checkout(
callable_target,
event_context,
queue
))
}
try:
if isinstance(run_body, dict):
middlewares = run_body.get("middlewares")
if middlewares:
async_middlewares = []
normal_middlewares = []
for middleware in middlewares:
if all([
hasattr(middleware, "__aenter__"),
hasattr(middleware, "__aexit__")
]):
async_middlewares.append(middleware)
elif all([
hasattr(middleware, "__enter__"),
hasattr(middleware, "__exit__")
]):
normal_middlewares.append(middleware)
else:
SessionLogger.error(f"threw a exception by {event_context.name}, no currect context error.")
raise AttributeError("no a currect context object.")
async with contextlib.AsyncExitStack() as async_stack:
for async_middleware in async_middlewares:
SessionLogger.debug(f"a event called {event_context.name}, enter a currect async context.")
await async_stack.enter_async_context(async_middleware)
with contextlib.ExitStack() as normal_stack:
for normal_middleware in normal_middlewares:
SessionLogger.debug(f"a event called {event_context.name}, enter a currect context.")
normal_stack.enter_context(normal_middleware)
if inspect.iscoroutinefunction(callable_target):
return await callable_target(**translated_mapping)
else:
return callable_target(**translated_mapping)
if inspect.iscoroutinefunction(callable_target):
return await callable_target(**translated_mapping)
else:
return callable_target(**translated_mapping)
except (NameError, TypeError) as e:
EventLogger.error(f"threw a exception by {event_context.name}, it's about Annotations Checker, please report to developer.")
traceback.print_exc()
except Exception as e:
EventLogger.error(f"threw a exception by {event_context.name}, and it's {e}")
await self.throw_exception_event(event_context, queue, e)
from .entities import (Normal, Require, Optional)
from collections import Counter
from functools import lru_cache
from typing import List
from mirai.misc import raiser, printer
from .logger import CommandLogger
# 这些规则都是互斥的, 并且是由转译层完成, 属于高级设定
default_unique_handlers = {
"int": lambda x: int(x),
"float": lambda x: float(x),
"LongParams": lambda x: x.split(" "),
"bool": lambda x: \
True if x == "true" else \
False if x == "false" else \
raiser(ValueError(f"cannot parse this string as a vaild bool: {x}"))
}
def string_as_string(string):
return f"\\{string}"
def signature_spliter(signature_string: str):
result = re.split(r"((?!\\)[<>\[\]\:\,])", signature_string)
if result:
if result[-1] == "":
result.pop() # 直接去掉最后有可能丢数据, 这里还是判断一下吧
return result
