class VBMLRule(MessageRule):
""" """
_patcher = vbml.Patcher()
_patterns: List[vbml.Pattern]
def __init__(self,
pattern: Union[str, List[str]],
patcher: Optional[vbml.Patcher] = None,
flags: Optional[re.RegexFlag] = None) -> None:
if isinstance(pattern, str):
_patterns = [pattern]
elif isinstance(pattern, list):
_patterns = pattern
else:
_patterns = list(pattern)
self._patterns = [vbml.Pattern(i, flags=flags) for i in _patterns]
if patcher is not None:
self._patcher = patcher
def check(self, msg: Message) -> Optional[RuleResult]:
for i in self._patterns:
result = self._patcher.check(i, msg.text)
if result is True:
return self.ok()
if isinstance(result, dict):
return self.ok(*result.values())
def __init__(
self,
pattern: Union[str, "vbml.Pattern", Iterable[Union[str,
"vbml.Pattern"]]],
patcher: Optional["vbml.Patcher"] = None,
flags: Optional[re.RegexFlag] = None,
):
flags = flags or self.config.get("vbml_flags") or (re.MULTILINE
| re.DOTALL)
if isinstance(pattern, str):
pattern = [
vbml.Pattern(pattern,
flags=flags or self.config.get("vbml_flags"))
]
elif isinstance(pattern, vbml.Pattern):
pattern = [pattern]
elif isinstance(pattern, Iterable):
pattern = [
p if isinstance(p, vbml.Pattern) else vbml.Pattern(p,
flags=flags)
for p in pattern
]
self.patterns = pattern
self.patcher = patcher or self.config.get(
"vbml_patcher") or vbml.Patcher()
def __init__(self, **kwargs):
self.message_view = MessageView()
self.raw_update_view = RawUpdateView()
self.custom_rules = kwargs.get("custom_rules") or DEFAULT_CUSTOM_RULES
self.auto_rules: List["ABCRule"] = []
self.rule_config: Dict[str, Any] = {
"vbml_flags": re.MULTILINE, # Flags for VBMLRule
"vbml_patcher": vbml.Patcher(), # Patcher for VBMLRule
}
def __init__(self, pattern: typing.Union["vbml.Pattern", str], patcher: typing.Optional["vbml.Patcher"] = None):
if vbml is None:
raise RuntimeError("you have to install vbml - pip install vbml")
if patcher is None:
self.patcher = vbml.Patcher()
if isinstance(pattern, str):
self.pattern = vbml.Patcher.get_current(no_error=False).pattern(pattern)
elif isinstance(pattern, vbml.Pattern):
self.pattern = pattern
self._patcher = vbml.Patcher.get_current(no_error=False)
def __init__(
self,
pattern: typing.Union["vbml.Pattern", str],
patcher: typing.Optional["vbml.Patcher"] = None,
):
if vbml is None:
raise RuntimeError("you have to install vbml - pip install vbml")
self.patcher: vbml.Patcher = patcher or vbml.Patcher()
if isinstance(pattern, str):
self.pattern = vbml.Pattern(pattern)
elif isinstance(pattern, vbml.Pattern):
self.pattern = pattern
def __init__(self, **kwargs):
# Default views are fixed in BotLabeler,
# if you need to create your own implement
# custom labeler
self.message_view = MessageView()
self.raw_event_view = RawEventView()
self.custom_rules = kwargs.get("custom_rules") or DEFAULT_CUSTOM_RULES
self.auto_rules: List["ABCRule"] = []
# Rule config is accessible from every single custom rule
self.rule_config: Dict[str, Any] = {
"vbml_flags": re.MULTILINE, # Flags for VBMLRule
"vbml_patcher": vbml.Patcher(), # Patcher for VBMLRule
}
def __init__(
self,
message_view: "ABCMessageView",
raw_event_view: "ABCRawEventView",
custom_rules: Optional[Dict[str, Type["ABCRule"]]] = None,
auto_rules: Optional[List["ABCRule"]] = None,
):
self.message_view = message_view
self.raw_event_view = raw_event_view
self.custom_rules = custom_rules or DEFAULT_CUSTOM_RULES
self.auto_rules = auto_rules or []
# Rule config is accessible from every single custom rule
self.rule_config: Dict[str, Any] = {
"vbml_flags": re.MULTILINE | re.DOTALL, # Flags for VBMLRule
"vbml_patcher": vbml.Patcher(), # Patcher for VBMLRule
}
async def test_rules(api: API):
assert await base.FromPeerRule(123).check(fake_message(api, peer_id=123))
assert not await base.FromUserRule().check(fake_message(api, from_id=-1))
assert await base.VBMLRule("i am in love with <whom>", vbml.Patcher()).check(
fake_message(api, text="i am in love with you")
) == {"whom": "you"}
assert await base.FuncRule(lambda m: m.text.endswith("!")).check(
fake_message(api, text="yes!")
)
assert not await base.PeerRule().check(fake_message(api, peer_id=1, from_id=1))
assert await base.PayloadMapRule([("a", int), ("b", str)]).check(
fake_message(api, payload=json.dumps({"a": 1, "b": ""}))
)
assert await base.PayloadMapRule([("a", int), ("b", [("c", str), ("d", dict)])]).check(
fake_message(api, payload=json.dumps({"a": 1, "b": {"c": "", "d": {}}}))
)
assert await base.PayloadMapRule({"a": int, "b": {"c": str, "d": dict}}).check(
fake_message(api, payload=json.dumps({"a": 1, "b": {"c": "", "d": {}}}))
)
assert await base.StickerRule(sticker_ids=[1, 2]).check(
fake_message(api, attachments=[{"type": "sticker", "sticker": {"sticker_id": 2}}])
)
assert (
await AndRule(base.FromPeerRule(123), base.FromPeerRule([1, 123])).check(
fake_message(api, peer_id=123)
)
is not False
)
assert (
await OrRule(base.FromPeerRule(123), base.FromPeerRule([1, 123])).check(
fake_message(api, peer_id=1)
)
is not False
)
assert await NotRule(base.FromPeerRule(123)).check(fake_message(api, peer_id=1)) is not False
assert await base.RegexRule(r"Hi .*?").check(fake_message(api, text="Hi bro")) == {"match": ()}
assert await base.RegexRule("Hi (.*?)$").check(fake_message(api, text="Hi bro")) == {
"match": ("bro",)
}
assert await base.RegexRule(r"Hi .*?").check(fake_message(api, text="Hi")) != {"match": ()}
assert base.PayloadMapRule.transform_to_map({"a": int, "b": {"c": str, "d": dict}}) == [
("a", int),
("b", [("c", str), ("d", dict)]),
]
assert await base.CommandRule("cmd", ["!", "."], 2).check(
fake_message(api, text="!cmd test bar")
) == {"args": ("test", "bar")}
assert (
await base.CommandRule("cmd", ["!", "."], 2).check(fake_message(api, text="cmd test bar"))
is False
)
# todo: if args are more than args_count do join excess args with last
assert (
await base.CommandRule("cmd", ["!", "."], 1).check(fake_message(api, text="cmd test bar"))
is False
)
assert (
await base.CommandRule("cmd", ["!", "."], 3).check(fake_message(api, text="cmd test bar"))
is False
)
labeler = BotLabeler()
labeler.vbml_ignore_case = True
assert (
await labeler.get_custom_rules({"text": "privet"})[0].check(
fake_message(api, text="Privet")
)
== {}
)
labeler.vbml_ignore_case = False
assert not await labeler.get_custom_rules({"text": "privet"})[0].check(
fake_message(api, text="Private")
)
assert await base.PayloadRule({"cmd": "text"}).check(
fake_message(api, payload='{"cmd":"text"}')
)
assert await base.PayloadRule([{"cmd": "text"}, {"cmd": "ne text"}]).check(
fake_message(api, payload='{"cmd":"text"}')
)
s_mock_message = fake_message(api)
s_mock_message.state_peer = StatePeer(peer_id=1, state=FirstMockState.MOCK)
assert await base.StateRule(state=FirstMockState.MOCK).check(s_mock_message)
assert not await base.StateRule(state=SecondMockState.MOCK).check(s_mock_message)
assert await base.StateRule(state=None).check(fake_message(api))
assert await base.StateGroupRule(state_group=None).check(fake_message(api))
sg_mock_message = fake_message(api)
sg_mock_message.state_peer = StatePeer(peer_id=1, state=FirstMockState.MOCK, payload={})
assert await base.StateGroupRule(state_group=FirstMockState).check(sg_mock_message)
assert not await base.StateGroupRule(state_group=SecondMockState).check(sg_mock_message)
def __init__(
self,
tokens: Token = None,
*,
login: str = None,
password: str = None,
user_id: int = None,
debug: typing.Union[str, bool] = True,
loop: asyncio.AbstractEventLoop = None,
expand_models: bool = True,
mobile: bool = False,
log_to_path: typing.Union[str, bool] = None,
vbml_patcher: vbml.Patcher = None,
mode: int = 234,
only_asyncio_loop: bool = False,
**context,
):
self.__tokens = [tokens] if isinstance(tokens, str) else tokens
self.context: dict = context
if uvloop is not None:
if not only_asyncio_loop:
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
if login and password:
self.__tokens = self.get_tokens(login, password)
self.loop = loop or asyncio.get_event_loop()
self.__debug: bool = debug
self._api: UserApi = UserApi(self.__tokens)
self.mode = mode
self._expand_models: bool = expand_models
self._patcher: vbml.Patcher = vbml_patcher or vbml.Patcher(
pattern="^{}$")
self.user_id: typing.Optional[int] = user_id or self.get_id_by_token(
self.__tokens[0])
self._api.user_id = user_id
self.error_handler: VKErrorHandler = DefaultErrorHandler()
UserApi.set_current(self._api)
VKErrorHandler.set_current(self.error_handler)
self.on: UserHandler = UserHandler()
self.branch: ABCBranchGenerator = DictBranch()
self.middleware: MiddlewareExecutor = MiddlewareExecutor()
self.error_handler: VKErrorHandler = DefaultErrorHandler()
self.deconstructed_handle: UserProcessor = UserProcessor(
self.user_id, expand_models=expand_models)
self._stop: bool = False
self.status = UserStatus()
if isinstance(debug, bool):
debug = "INFO" if debug else "ERROR"
self.logger = LoggerLevel(debug)
logger.remove()
logger.add(
sys.stderr,
colorize=True,
format="<level>[<blue>VKBottle</blue>] {message}</level>",
filter=self.logger,
level=0,
enqueue=mobile is False,
)
if log_to_path:
logger.add(
"log_user_{time}.log" if log_to_path is True else log_to_path,
rotation="20 MB",
)
logger.info("Using JSON_MODULE - {}".format(USAGE))
logger.info("Using asyncio loop - {}".format(
asyncio.get_event_loop_policy().__class__.__module__))
async def test_rules(api: API):
assert await rules.FromPeerRule(123).check(fake_message(api, peer_id=123))
assert not await rules.FromUserRule().check(fake_message(api, from_id=-1))
assert await rules.VBMLRule(
"i am in love with <whom>",
vbml.Patcher()).check(fake_message(api,
text="i am in love with you")) == {
"whom": "you"
}
assert await rules.FuncRule(lambda m: m.text.endswith("!")).check(
fake_message(api, text="yes!"))
assert not await rules.PeerRule(from_chat=True).check(
fake_message(api, peer_id=1, from_id=1))
assert await rules.PayloadMapRule([
("a", int), ("b", str)
]).check(fake_message(api, payload=json.dumps({
"a": 1,
"b": ""
})))
assert await rules.PayloadMapRule([("a", int),
("b", [("c", str), ("d", dict)])]
).check(
fake_message(api,
payload=json.dumps({
"a": 1,
"b": {
"c": "",
"d": {}
}
})))
assert await rules.PayloadMapRule({
"a": int,
"b": {
"c": str,
"d": dict
}
}).check(
fake_message(api,
payload=json.dumps({
"a": 1,
"b": {
"c": "",
"d": {}
}
})))
assert await rules.StickerRule(sticker_ids=[1, 2]).check(
fake_message(api,
attachments=[{
"type": "sticker",
"sticker": {
"sticker_id": 2
}
}]))
assert (await AndFilter(rules.FromPeerRule(123),
rules.FromPeerRule([1, 123])).check(
fake_message(api, peer_id=123)) is not False)
assert (await
OrFilter(rules.FromPeerRule(123),
rules.FromPeerRule([1, 123
])).check(fake_message(api,
peer_id=1))
is not False)
assert await rules.RegexRule(r"Hi .*?").check(
fake_message(api, text="Hi bro")) == {
"match": ()
}
assert await rules.RegexRule("Hi (.*?)$").check(
fake_message(api, text="Hi bro")) == {
"match": ("bro", )
}
assert not await rules.RegexRule(r"Hi .*?").check(
fake_message(api, text="Hi")) == {
"match": ()
}
assert rules.PayloadMapRule.transform_to_map({
"a": int,
"b": {
"c": str,
"d": dict
}
}) == [
("a", int),
("b", [("c", str), ("d", dict)]),
]
labeler = BotLabeler()
labeler.vbml_ignore_case = True
assert (await labeler.get_custom_rules({"text": "privet"})
[0].check(fake_message(api, text="Privet")) == {})
labeler.vbml_ignore_case = False
assert not await labeler.get_custom_rules({"text": "privet"})[0].check(
fake_message(api, text="Private"))
assert await rules.PayloadRule({
"cmd": "text"
}).check(fake_message(api, payload='{"cmd":"text"}'))
assert await rules.PayloadRule([{
"cmd": "text"
}, {
"cmd": "ne text"
}]).check(fake_message(api, payload='{"cmd":"text"}'))
assert await rules.StateRule(state=None).check(fake_message(api))
assert not await rules.StateRule(state=MockIntEnum.MOCK).check(
fake_message(api))
assert await rules.StateGroupRule(state_group=None).check(fake_message(api)
)
sg_mock_message = fake_message(api)
sg_mock_message.state_peer = StatePeer(peer_id=1,
state=MockIntEnum.MOCK,
payload={})
assert await rules.StateGroupRule(state_group=MockIntEnum
).check(sg_mock_message)
import re
from abc import abstractmethod
from typing import Union, List
import vbml
from tottle.types.mini import MessageMini
from tottle.dispatch.rules import ABCRule
from tottle.utils.enums import ChatType
VBML_PATCHER = vbml.Patcher()
class ABCMessageRule(ABCRule):
@abstractmethod
async def check(self, message: MessageMini) -> bool:
pass
class FromChatRule(ABCMessageRule):
async def check(self, message: MessageMini) -> bool:
return message.chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
class PrivateMessageRule(ABCMessageRule):
async def check(self, message: MessageMini) -> bool:
return message.chat.type == ChatType.PRIVATE
class TextRule(ABCMessageRule):
def __init__(
