def assign_message_handler(bot: bots.SimpleLongPollBot, handler: Callable[[bots.SimpleBotEvent], None], filter: bots.core.BaseFilter = None): if filter: bot.message_handler(filter)(handler) return bot.message_handler()(handler)
def __init__(self, token: str, group_id: int, mode: Union[Frameworks, str] = Frameworks.AIOGRAM) -> None: super().__init__(mode) self.container = AppContainer() self.mode = mode self._events: Dict[str, Optional[Callable[..., Any]]] = { "on_startup": None, "on_shutdown": None } if mode == Frameworks.AIOGRAM: from aiogram import Bot, Dispatcher bot = Bot(token=token) self.dp = Dispatcher(bot) self.inject_values = {Bot: bot, Dispatcher: self.dp} elif mode == Frameworks.VKWAVE: from vkwave.bots import TaskManager, SimpleLongPollBot self._task_manager = TaskManager() # group_id = httpx.get( # 'https://api.vk.com/method/groups.getById', params={"access_token": token, "v": "5.92"} # ).json()["response"][0]['id'] self.bot = SimpleLongPollBot(tokens=token, group_id=group_id) self.inject_values = {SimpleLongPollBot: self.bot}
from vkwave.bots import SimpleLongPollBot bot = SimpleLongPollBot(tokens="1234", group_id=456) @bot.message_handler(bot.conversation_type_filter(from_what="from_chat")) async def handle(event: bot.SimpleBotEvent): await event.answer(f"hello to chat!") @bot.message_handler(bot.fwd_filter(fwd_count=3)) # bot.fwd_filter() for any count async def handle(event: bot.SimpleBotEvent): await event.answer("3 fwd...") @bot.message_handler(bot.args_filter(args_count=2)) async def handle(event: bot.SimpleBotEvent): args = event["args"] await event.answer(f"Your args - {args}") @bot.message_handler(bot.text_contains_filter("wow")) async def handle(event: bot.SimpleBotEvent): await event.answer(f"Your text contains 'wow', wow!") bot.run_forever()
from config import Config import threading import schedule import asyncio import string import vk_api import pyowm import json import time conf = Config() config_dict = get_default_config() config_dict['language'] = 'ru' owm = pyowm.OWM(conf.weather, config_dict) mgr = owm.weather_manager() db = DataBase bot = SimpleLongPollBot(tokens=[conf.vk_api], group_id=200632750) def jobe(): vk_session = vk_api.VkApi(token=conf.vk_api) vk = vk_session.get_api() print("-отдельный процесс-" + str(datetime.now().time())) from db import DataBase dba = DataBase while True: data = str(datetime.now().date()) datear = dba.load(dba, data, 'alarmt') timer = datetime.now().time().hour for nam in datear: if int(timer) >= int(nam[3]): vk.messages.send(random_id=0,
from vkwave.bots import SimpleLongPollBot bot = SimpleLongPollBot(tokens=["Token"], group_id=123) @bot.message_handler( bot.vbml_filter("+<country_code:int>(<state_code:int>)<number:int>")) async def vbml_test(event): vmbl_data = event["vmbl_data"] country_code = vmbl_data["country_code"] state_code = vmbl_data["state_code"] number = vmbl_data["number"] print(country_code, state_code, number) bot.run_forever()
from vkwave.bots import SimpleLongPollBot bot = SimpleLongPollBot(tokens="MyToken", group_id=123456789) @bot.message_handler() def handle(_) -> str: """ Функция может быть как синхронной, так и асинхронной """ return "Hello world!" bot.run_forever()
attend_apparently_router, current_day_schedule_router, current_lesson_router, default_router, next_lesson_router, schedule_router, today_schedule_router, tomorrow_schedule_router, ) load_dotenv() # logging.basicConfig(filename="schedule_parser.log", level=logging.ERROR) bot = SimpleLongPollBot( os.getenv("TOKEN"), group_id=int(os.getenv("GROUP_ID")), ) bot.dispatcher.add_router(attend_apparently_router) bot.dispatcher.add_router(current_day_schedule_router) bot.dispatcher.add_router(current_lesson_router) bot.dispatcher.add_router(next_lesson_router) bot.dispatcher.add_router(schedule_router) bot.dispatcher.add_router(today_schedule_router) bot.dispatcher.add_router(tomorrow_schedule_router) bot.dispatcher.add_router(default_router) def run(): loop = asyncio.get_event_loop() loop.create_task(update_all_forever())
from vkwave.bots import SimpleLongPollBot, Keyboard, CallbackAnswer from vkwave.types.bot_events import BotEventType bot = SimpleLongPollBot(tokens=["Token"], group_id=123) @bot.message_handler(bot.text_filter("123")) async def simple(event: bot.SimpleBotEvent): kb = Keyboard() kb.add_callback_button(payload={"21321": 123}, text="123") await event.answer("HELLO", keyboard=kb.get_keyboard()) @bot.handler(bot.event_type_filter(BotEventType.MESSAGE_EVENT)) async def all(event: bot.SimpleBotEvent): await event.callback_answer(event_data=CallbackAnswer.open_link( link="https://google.com")) bot.run_forever()
from vkwave.bots import BaseEvent, PayloadFilter, Keyboard from vkwave.bots import SimpleLongPollBot from bs4 import BeautifulSoup as BS import requests, os, datetime, json gId = 189021062 token = os.environ.get('BOT_TOKEN') bot = SimpleLongPollBot(tokens=token, group_id=gId) @bot.message_handler(bot.text_contains_filter('start')) async def kb_handler(event: BaseEvent): kb = Keyboard(one_time=False) kb.add_text_button(text='анекдот', payload={"anec": "default"}) kb.add_text_button(text='анекдот про замая', payload={"anec": "zamai"}) kb.add_row() kb.add_text_button(text='дней до школы', payload={"date": "school"}) kb.add_text_button(text='дата регистрации', payload={"date": "reg"}) await event.answer(message="[d34th1sn34r|боты дёшево куда угодно]", keyboard=kb.get_keyboard()) @bot.message_handler(PayloadFilter({"anec": "default"})) async def anec(event: BaseEvent): rawcontent = requests.get( 'http://rzhunemogu.ru/RandJSON.aspx?CType=1').text await event.answer(json.loads(rawcontent, strict=False)['content'])
import time from gtts import gTTS import logging from vkwave.types.objects import MessagesMessageAttachmentType, BaseBoolInt from vkwave.bots.utils.keyboards import Keyboard from vkwave.bots.utils.keyboards.keyboard import ButtonColor from constants import commands, sberkot_stickers from db import connection import db import generate from properties import TOKEN, GROUP_ID TALKING = False bot = SimpleLongPollBot(tokens=TOKEN, group_id=GROUP_ID) client = AIOHTTPClient() api = API(clients=client, tokens=BotSyncSingleToken(Token(TOKEN)), ) router = DefaultRouter() logging.basicConfig(level=logging.INFO) db.execute_query(connection, """ CREATE TABLE IF NOT EXISTS messages( id INTEGER PRIMARY KEY AUTOINCREMENT, peer_id INTEGER, text TEXT NOT NULL, from_id INTEGER, name TEXT NOT NULL default unknown, date TEXT NOT NULL default unknown); """)
from blueprints import preferences from blueprints import report from blueprints import schedule from blueprints import web from database import utils as db from services import keyboard as kbs from services.exceptions import StudentNotFound from services.filters import PLFilter from services.logger.config import config __version__ = "2.15.3" from services.logger.handlers import InterceptHandler bot = SimpleLongPollBot( tokens=os.getenv("VK_TOKEN"), group_id=os.getenv("GROUP_ID"), ) bot.dispatcher.add_router(call.call_router) bot.dispatcher.add_router(preferences.preferences_router) bot.dispatcher.add_router(chats.chats_router) bot.dispatcher.add_router(finances.finances_router) bot.dispatcher.add_router(schedule.schedule_router) bot.dispatcher.add_router(web.web_router) bot.dispatcher.add_router(report.report_router) bot.dispatcher.add_router(contacts.contacts_router) logger.configure(**config) logging.basicConfig(level=logging.DEBUG, handlers=[InterceptHandler()]) @bot.message_handler(
from utils.markups import DEFAULT_MARKUP, CANCEL_MARKUP, MEMS_MARKUP logging.basicConfig( level=logging.ERROR, format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', ) client = AIOHTTPClient() api = API( clients=client, tokens=BotSyncSingleToken(Token(config.BOT_TOKEN)), ) uploader = VoiceUploader(api.get_context()) bot = SimpleLongPollBot(tokens=config.BOT_TOKEN, group_id=config.GROUP_ID) fsm = FiniteStateMachine() bot.router.registrar.add_default_filter( StateFilter(fsm, ..., ..., always_false=True)) bot.router.registrar.add_default_filter( EventTypeFilter(BotEventType.MESSAGE_NEW.value)) async def get_user_data(message: bot.SimpleBotEvent) -> dict: user_data = (await bot.api_context.users.get( user_ids=message.object.object.message.peer_id)).response[0] user_id = user_data.id user_full_name = f'{user_data.first_name} {user_data.last_name}' user_first_name = user_data.first_name
# not the greatest implementation, but you can make any method = error["error"]["request_params"]["method"] request_params = {} for param in error["error"]["request_params"]: if param["key"] in ("oauth", "v", "method"): continue request_params[param["key"]] = param["value"] key = await solve_captcha(error["error"]["captcha_img"]) request_params.update({"captcha_sid": error["error"]["captcha_sid"], "captcha_key": key}) return await api_ctx.api_request(method, params=request_params) # Easy way bot = SimpleLongPollBot(tokens="MyToken", group_id=123456789) bot.api_session.api.default_api_options.error_dispatcher.add_handler(14, captcha_handler) # Not easy way api_session = API(BotSyncSingleToken(Token("MyToken")), AIOHTTPClient()) api = api_session.get_context() dp = Dispatcher(api_session, TokenStorage[GroupId]()) lp_extension = BotLongpollExtension(dp, BotLongpoll(api, BotLongpollData(123456789))) api_session.default_api_options.error_dispatcher.add_handler(14, captcha_handler)
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) )
""" create many bots with the same functionality """ import asyncio from vkwave.bots import SimpleLongPollBot, TaskManager, ClonesBot bot = SimpleLongPollBot( tokens=["Bot0TOKEN"], group_id=444, ) @bot.message_handler(bot.text_filter("123")) async def simple(event: bot.SimpleBotEvent): await event.answer("HELLO") clones = ClonesBot(bot, SimpleLongPollBot("Bot1TOKEN", 192868628), SimpleLongPollBot("Bot2TOKEN", 172702125)) async def clone_request(): # clones.clones - тупл с клонами (SimpleLongPollUserBot или SimpleLongPollBot) # Запрос с первого клона print(clones.clones[0].api_context.users.get()) asyncio.get_event_loop().run_until_complete(clone_request()) clones.run_all_bots()
from vkwave.api import APIOptionsRequestContext from vkwave.bots import SimpleLongPollBot, TaskManager from vkwave.vkscript import execute from vkwave.types.extension_responses import ExecuteResponse bot = SimpleLongPollBot(tokens=["123"], group_id=456,) @execute def get_subs_names(api: APIOptionsRequestContext, group_id: int): subs_names = [] subscribers = api.groups.getMembers(group_id=group_id) subscribers = subscribers.items for sub_id in subscribers: subscriber_data = api.users.get(user_ids=sub_id) subs_names.append(subscriber_data[0].first_name) return subs_names @bot.message_handler(bot.text_filter("follow")) async def simple(event: bot.SimpleBotEvent): """ Get name of each subscriber """ check_group = 191949777 print(get_subs_names.build(api=event.api_ctx, group_id=check_group))
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())
""" Answer on all messages besides "dog" """ from vkwave.bots import BaseMiddleware, BotEvent, MiddlewareResult, SimpleLongPollBot bot = SimpleLongPollBot( tokens="123", group_id=456, ) # raw middleware: # class Middleware(BaseMiddleware): # async def pre_process_event(self, event: BotEvent) -> MiddlewareResult: # if event.object.object.message.text == "dog": # return MiddlewareResult(False) # return MiddlewareResult(True) # bot.middleware_manager.add_middleware(Middleware()) # или # bot.add_middleware(Middleware()) # Мидлварь имеет два основных асинхронных(!) метода: # 1) pre_process_event(event: BaseEvent) -> MiddlewareResult # обязательный, исполняется перед роутингом; # 2) post_process_event(event: BaseEvent): # необязательный, выполняется после роутинга # (и после обработки хендлером, если таковой имеется).
from vkwave.bots import SimpleLongPollBot, TaskManager bot = SimpleLongPollBot(tokens="MyToken", group_id=123456789) # or if you want do a lot of requests without 'to many requests' errors # bot = SimpleLongPollBot(tokens=["MyToken1", "MyToken2", "MyToken3"], group_id=123456789) @bot.message_handler(bot.text_filter("hello")) async def simple(event: bot.SimpleBotEvent): await event.answer("hello from vkwave!") @bot.message_handler(bot.command_filter(commands=["start"])) async def start(event: bot.SimpleBotEvent): user_data = (await bot.api_context.users.get( user_ids=event.object.object.message.peer_id)).response[0] user_name = user_data.first_name await event.answer(f"You just started, {user_name}") bot.run_forever() # or # task_manager = TaskManager() # task_manager.add_task(bot.run) # task_manager.run()
import logging from vkwave.bots import SimpleLongPollBot from config import TOKEN, GROUP_ID from middlewares import UserMiddleware from blueprints import ( menu_router, profile_router, games_router, coin_flip_router, bonus_router, ) logging.basicConfig(level="DEBUG") bot = SimpleLongPollBot(TOKEN, group_id=GROUP_ID) bot.middleware_manager.add_middleware(UserMiddleware()) bot.dispatcher.add_router(profile_router) bot.dispatcher.add_router(games_router) bot.dispatcher.add_router(coin_flip_router) bot.dispatcher.add_router(bonus_router) # регаем последним чтобы сначала проверялись все остальные команды bot.dispatcher.add_router(menu_router) bot.run_forever()
new_passw = input('Введите новый пароль для конфига: ') new_vk_token = input('Введите вк токен: ') new_group_id = input('Введите вк айди группы: ') new_tg_token = input('Введите тг-бот токен: ') c.new_cfg(new_passw,new_vk_token,new_group_id,new_tg_token) else: passw = input('Введите пароль от конфига:') # passw = 123 c.unlock_file(passw) logger.info('Started') bot = Bot(token=c.data['tg']['token']) dp = Dispatcher(bot) logger.debug('Telegram: got api') vk_bot = SimpleLongPollBot(tokens=c.data['vk']['public_token'], group_id=c.data['vk']['public_id']) logger.debug('VKAPI: registered bot') import handlers # Telegram handlers.setup_tg_handlers(dp) handlers.config_tg_hand(c.data) handlers.setup_tg_api(bot) handlers.setup_vk_bot_to_tg_handler(vk_bot) logger.debug('Telegram: ready') # Vkontakte handlers.setup_tg_bot_to_vk_handler(bot) handlers.config_vk_hand(c.data) vk_bot.dispatcher.add_router(handlers.vk_msg_from_chat)
from vkwave.bots import SimpleLongPollBot import logging from state_manager import MemoryStorage from state_manager.models.state_managers.vkwave import VkWaveStateManager from state_manager.routes.vkwave.state import VkWaveMainStateRouter from state_manager.storages.base import BaseStorage logging.basicConfig(level=logging.INFO) bot = SimpleLongPollBot( tokens="your token", group_id=123123, ) main_state = VkWaveMainStateRouter(bot) async def test(state_manager: VkWaveStateManager): return await state_manager.data @main_state.message_handler() async def home(event: bot.SimpleBotEvent, state_manager: VkWaveStateManager): await event.answer("go to home2") await state_manager.set_next_state("home2") @main_state.message_handler() async def home2(event: bot.SimpleBotEvent, state_manager: VkWaveStateManager, storage: BaseStorage):
def __init__(self, token: str, group_id: int): super().__init__(token=token) self.group_id = group_id self._task_manager = TaskManager() self.bot = SimpleLongPollBot(tokens=token, group_id=group_id) self.inject_values = {SimpleLongPollBot: self.bot}