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}