async def initiate_router(router):
# router.registrar.register(
# router.registrar.new()
# .handle(test)
# .ready()
# )
router.registrar.register(router.registrar.new().with_filters(
EventTypeFilter('message_new')
& (ChatActionFilter(MessagesMessageActionStatus.CHAT_INVITE_USER)
| ChatActionFilter(
MessagesMessageActionStatus.CHAT_INVITE_USER_BY_LINK))).handle(
new_user).ready())
router.registrar.register(router.registrar.new().with_filters(
EventTypeFilter('message_new') & # without callback button support!
PayloadFilter(None)).handle(keyboard_msg).ready())
router.registrar.register(router.registrar.new().with_filters(
EventTypeFilter('message_new')
& CommandFilter()).handle(command).ready())
router.registrar.register(router.registrar.new().with_filters(
EventTypeFilter('message_new')).handle(simple_msg).ready())
return router
def decorator(func: typing.Callable[..., typing.Any]):
record = self.router.registrar.new()
record.with_filters(*filters)
if self.bot_type is BotType.BOT:
record.filters.append(EventTypeFilter(BotEventType.MESSAGE_NEW))
else:
record.filters.append(EventTypeFilter(EventId.MESSAGE_EVENT.value))
record.handle(SimpleBotCallback(func, self.bot_type))
self.router.registrar.register(record.ready())
return func
def decorator(func: typing.Callable[..., typing.Any]):
record = router.registrar.new()
record.with_filters(*filters)
record.filters.append(EventTypeFilter(EventId.MESSAGE_EVENT.value))
record.handle(SimpleBotCallback(func, BotType.USER))
router.registrar.register(record.ready())
return func
from vkwave.bots import Dispatcher, EventTypeFilter, TextFilter
from vkwave.bots.core.dispatching.events.base import BotEvent
from vkwave.bots.core.dispatching.extensions.longpoll_bot import BotLongpollExtension
from vkwave.bots.core.dispatching.router.router import DefaultRouter
from vkwave.bots.core.tokens.storage import TokenStorage
from vkwave.bots.core.tokens.types import GroupId
from vkwave.client.default import AIOHTTPClient
from vkwave.longpoll.bot import BotLongpoll, BotLongpollData
basicConfig(level="DEBUG")
logger = getLogger(__name__)
text = lambda text: TextFilter(text)
text_startswith = lambda text: lambda event: event.object.object.message.text.startswith(
text)
new_message = EventTypeFilter("message_new")
router = DefaultRouter()
wd = router.registrar.with_decorator
api = API(BotSyncSingleToken(getenv("TOKEN")), AIOHTTPClient())
token_storage = TokenStorage[GroupId]()
dp = Dispatcher(api, token_storage)
ext = BotLongpollExtension(
dp, BotLongpoll(api.get_context(), BotLongpollData(getenv("GROUP_ID"))))
client = AsyncUrbanClient()
def make_result(defs: List[UrbanDefinition]) -> str:
result = ""
CommandsFilter,
Keyboard,
)
from vkwave.client import AIOHTTPClient
from vkwave.api import BotSyncSingleToken, Token, API
from vkwave.longpoll.bot import BotLongpoll, BotLongpollData
from vkwave.types.bot_events import BotEventType
logging.basicConfig(level=logging.DEBUG)
bot_token = Token("123")
gid = 123
router = DefaultRouter()
@router.registrar.with_decorator(CommandsFilter(["hello"]),
EventTypeFilter(BotEventType.MESSAGE_NEW))
async def kb_handler(event: BaseEvent):
kb = Keyboard(one_time=True)
kb.add_text_button(text="123456", payload={"hello": "world"})
await event.api_ctx.messages.send(
peer_id=event.object.object.message.peer_id,
message="123",
keyboard=kb.get_keyboard(),
random_id=0,
)
@router.registrar.with_decorator(PayloadFilter({"hello": "world"}),
EventTypeFilter(BotEventType.MESSAGE_NEW))
async def handler(event: BaseEvent):
from vkwave.bots import EventTypeFilter, BotEvent, SimpleLongPollBot
from vkwave.bots.fsm import FiniteStateMachine, StateFilter, ForWhat, State, ANY_STATE
from vkwave.types.bot_events import BotEventType
bot = SimpleLongPollBot("123", group_id=123)
fsm = FiniteStateMachine()
bot.router.registrar.add_default_filter(StateFilter(fsm, ..., ..., always_false=True))
bot.router.registrar.add_default_filter(
EventTypeFilter(BotEventType.MESSAGE_NEW.value)
) # we don't want to write it in all handlers.
class MyState:
name = State("name")
age = State("age")
# starting interview (has default filter that will reject messages if state exists)
@bot.message_handler(bot.text_filter("start"))
async def simple_handler(event: BotEvent):
await fsm.set_state(event=event, state=MyState.name, for_what=ForWhat.FOR_USER)
return "Input your name"
# exiting interview (work with any state because of `state=ANY_STATE`)
@bot.message_handler(
bot.text_filter("exit"), StateFilter(fsm=fsm, state=ANY_STATE, for_what=ForWhat.FOR_USER)
)
TextFilter,
UserId,
)
from vkwave.client import AIOHTTPClient
from vkwave.api import API, BotSyncSingleToken, Token
from vkwave.longpoll import UserLongpollData, UserLongpoll
from vkwave.types.user_events import EventId
logging.basicConfig(level=logging.DEBUG)
bot_token = Token("token")
router = DefaultRouter()
# EventTypeFilter((3, 4, 5, 18)) == EventTypeFilter(EventId.MESSAGE_EVENT.value)
@router.registrar.with_decorator(EventTypeFilter(EventId.MESSAGE_EVENT.value),
FromMeFilter(from_me=True))
async def from_me(event: UserEvent):
print("from me:", event.object.object.text)
# FromMeFilter(from_me=False) -> message from other user
# FromMeFilter(from_me=True) -> message from me
@router.registrar.with_decorator(EventTypeFilter((3, 4, 5, 18)),
FromMeFilter(from_me=False),
TextFilter("hello"))
async def answer_hello(event: UserEvent):
await event.api_ctx.messages.send(user_id=event.object.object.peer_id,
message="hello!",
random_id=0)
def _install_handler(bot: SimpleLongPollBot, handler: Callable,
event_type: BotEventType) -> None:
record = bot.router.registrar.new()
record.filters.append(EventTypeFilter(event_type))
record.handle(bot.SimpleBotCallback(handler, bot.bot_type))
bot.router.registrar.register(record.ready())