def __init__( self, tokens: typing.Union[str, typing.List[str]], bot_type: BotType, router: typing.Optional[BaseRouter] = None, group_id: typing.Optional[int] = None, uvloop: bool = False, ): if uvloop: import uvloop asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) self.group_id = group_id self.bot_type = bot_type self.api_session = create_api_session_aiohttp(tokens, bot_type) self.api_context: APIOptionsRequestContext = self.api_session.api.get_context( ) if self.bot_type is BotType.USER: if not isinstance(tokens, str): raise RuntimeError("Only one str token") self.SimpleBotEvent = SimpleUserEvent self._lp = UserLongpoll(self.api_context, UserLongpollData()) self._token_storage = UserTokenStorage[UserId](tokens) self.dispatcher = Dispatcher(self.api_session.api, self._token_storage) self._lp = UserLongpollExtension(self.dispatcher, self._lp) else: self.SimpleBotEvent = SimpleBotEvent self._lp = BotLongpoll(self.api_context, BotLongpollData(group_id)) self._token_storage = TokenStorage[GroupId]() self.dispatcher = Dispatcher(self.api_session.api, self._token_storage) self._lp = BotLongpollExtension(self.dispatcher, self._lp) self.middleware_manager = self.dispatcher.middleware_manager # auf self.add_middleware = self.middleware_manager.add_middleware self.router = router or DefaultRouter() self.dispatcher.add_router(self.router) self.text_filter = TextFilter self.event_type_filter = EventTypeFilter self.payload_filter = PayloadFilter self.chat_action_filter = ChatActionFilter self.command_filter = CommandsFilter self.regex_filter = RegexFilter self.state_filter = StateFilter self.vbml_filter = VBMLFilter self.reply_filter = ReplyMessageFilter self.args_filter = MessageArgsFilter self.fwd_filter = FwdMessagesFilter self.conversation_type_filter = MessageFromConversationTypeFilter self.text_contains_filter = TextContainsFilter self.payload_contains_filter = PayloadContainsFilter self.text_startswith_filter = TextStartswithFilter if self.bot_type is BotType.USER: self.from_me_filter = FromMeFilter
async def main(): # await bb.start() # stor.asyncio_loop.stop() # return path = os.path.dirname(os.path.abspath(__file__)) full_path = f"{path}/base/config{mode}.json" with open(full_path, 'r') as file: stor.config = json.load(file) bot_tokens = Token(stor.config['TOKEN']) user_tokens = Token(stor.config['USER_TOKEN']) stor.config['BASEFILE'] = f"{path}/base/{stor.config['BASEFILE']}" stor.config['LOGFILE'] = f"{path}/base/{stor.config['LOGFILE']}" stor.config['CONFIG'] = full_path logging.basicConfig(level=stor.config['LOGLEVEL'], filename=stor.config['LOGFILE']) logging.addLevelName(11, 'OK') logging.addLevelName(12, 'DONE') logging.addLevelName(13, 'NO') logging.addLevelName(14, 'BAD') base_logger = logging.getLogger('base') command_logger = logging.getLogger('co') utils.st.logger = command_logger stor.start_time = int(time.time()) user_client = AIOHTTPClient() user_tokens = [UserSyncSingleToken(tok) for tok in user_tokens] stor.user_api = API(user_tokens, user_client) client = AIOHTTPClient() tokens = [BotSyncSingleToken(tok) for tok in bot_tokens] api_session = API(tokens, client) api = api_session.get_context() lp_data = BotLongpollData(stor.config['GROUP_ID']) longpoll = BotLongpoll(api, lp_data) token_storage = TokenStorage[GroupId]() dp = Dispatcher(api_session, token_storage) dp.add_router(await hand.initiate_router(DefaultRouter())) await dp.cache_potential_tokens() await base.initiate(stor.config['BASEFILE'], base_logger) # storage = ConfirmationStorage() # storage.add_confirmation(GroupId(stor.config['GROUP_ID']),stor.config['CONFIRMATION']) # cb_extension = AIOHTTPCallbackExtension( # dp, path="/", host="0.0.0.0", port=80, secret=stor.config['SECRET'], confirmation_storage=storage # ) lp_extension = BotLongpollExtension(dp, longpoll) # await cb_extension.start() await lp_extension.start()
from vkwave.api import API from vkwave.bots import DefaultRouter from vkwave.bots import MessageFromConversationTypeFilter from vkwave.bots import SimpleBotEvent from vkwave.bots import simple_bot_message_handler from vkwave.client import AIOHTTPClient from database import utils as db from database.models import Chat from database.models import FinancialCategory from services import filters from services import keyboard as kbs from services.finances import generate_debtors_call from services.logger.config import config finances_router = DefaultRouter() api_session = API(tokens=os.getenv("VK_TOKEN"), clients=AIOHTTPClient()) api = api_session.get_context() logger.configure(**config) @simple_bot_message_handler( finances_router, filters.PLFilter({"button": "finances"}), MessageFromConversationTypeFilter("from_pm"), ) @logger.catch() async def finances(ans: SimpleBotEvent): with logger.contextualize(user_id=ans.object.object.message.from_id): await ans.answer( "Список финансовых категорий",
import os from loguru import logger from vkwave.api import API from vkwave.bots import ChatActionFilter from vkwave.bots import CommandsFilter from vkwave.bots import DefaultRouter from vkwave.bots import MessageFromConversationTypeFilter from vkwave.bots import SimpleBotEvent from vkwave.bots import simple_bot_message_handler from vkwave.client import AIOHTTPClient from services.logger.config import config from services.media import translate_string chats_router = DefaultRouter() api_session = API(tokens=os.getenv("VK_TOKEN"), clients=AIOHTTPClient()) api = api_session.get_context() logger.configure(**config) @simple_bot_message_handler( chats_router, ChatActionFilter("chat_invite_user"), ) @logger.catch() async def greeting(ans: SimpleBotEvent): with logger.contextualize(user_id=ans.object.object.message.from_id): await ans.answer("Привет!")
DefaultRouter, SimpleBotEvent, simple_bot_message_handler, PayloadFilter, FiniteStateMachine, State, ForWhat, StateFilter, CommandsFilter, Keyboard, ) from db.models.user import User from utils.constants import MENU_KB coin_flip_router = DefaultRouter() fsm = FiniteStateMachine() class CoinState: bet = State("bet") coin = State("coin") @simple_bot_message_handler(coin_flip_router, CommandsFilter("exit")) async def games(event: SimpleBotEvent): if await fsm.get_data(event, for_what=ForWhat.FOR_USER) is not None: await fsm.finish(event=event, for_what=ForWhat.FOR_USER) return await event.answer( message=
DefaultRouter, GroupId, EventTypeFilter, PayloadFilter, 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, )
from vkwave.bots import DefaultRouter from vkwave.bots import MessageFromConversationTypeFilter from vkwave.bots import SimpleBotEvent from vkwave.bots import simple_bot_message_handler from vkwave.client import AIOHTTPClient from database import utils as db from database.models import Chat from services import call from services import filters from services import keyboard as kbs from services import media from services.exceptions import EmptyCallMessage from services.logger.config import config call_router = DefaultRouter() api_session = API(tokens=os.getenv("VK_TOKEN"), clients=AIOHTTPClient()) api = api_session.get_context() logger.configure(**config) @simple_bot_message_handler( call_router, filters.PLFilter({"button": "call"}), MessageFromConversationTypeFilter("from_pm"), ) @logger.catch() async def start_call(ans: SimpleBotEvent): with logger.contextualize(user_id=ans.object.object.message.from_id): if db.chats.get_list_of_chats_by_group( db.admin.get_active_group(
from vkwave.bots import DefaultRouter, SimpleBotEvent, simple_bot_message_handler from utils.constants import MENU_KB menu_router = DefaultRouter() @simple_bot_message_handler( menu_router, ) async def menu(event: SimpleBotEvent): return await event.answer( message= f"Выберите дальнейшее действие, {event['current_user'].first_name}", keyboard=MENU_KB.get_keyboard(), )
from vkwave.bots import ( DefaultRouter, simple_bot_message_handler, SimpleBotEvent, BaseEvent, ) from vkwave.bots.core import BaseFilter from vkwave.bots.core.dispatching.filters.base import FilterResult from vkwave.bots.storage.types import Key from helpers import get_schedule_and_days from storage import storage from utils import create_text_schedule current_day_schedule_router = DefaultRouter() class IsDayRequestMessage(BaseFilter): async def check(self, event: BaseEvent) -> FilterResult: return FilterResult(event.object.object.message.payload and json.loads( event.object.object.message.payload).get("day") is not None) @simple_bot_message_handler(current_day_schedule_router, IsDayRequestMessage()) async def day_schedule(event: SimpleBotEvent): # TODO: слать инлайн клаву снова schedule, days = await get_schedule_and_days() day_data: str = json.loads(event.object.object.message.payload)["day"]
from vkwave.bots import ( DefaultRouter, SimpleBotEvent, simple_bot_message_handler, PayloadFilter, ) from utils.constants import GAMES_KB games_router = DefaultRouter() @simple_bot_message_handler(games_router, PayloadFilter({"command": "games"})) async def games(event: SimpleBotEvent): return await event.answer(message=f"Выберите игру", keyboard=GAMES_KB.get_keyboard())
import datetime from vkwave.bots import ( DefaultRouter, simple_bot_message_handler, SimpleBotEvent, PayloadFilter, ) from helpers import create_one_day_schedule from utils import get_now, is_weekend tomorrow_schedule_router = DefaultRouter() @simple_bot_message_handler(tomorrow_schedule_router, PayloadFilter({"command": "tomorrow"})) async def tomorrow(event: SimpleBotEvent): now = get_now() tomorrow_date = now + datetime.timedelta(days=1) if is_weekend(tomorrow_date): return "завтра выходной, хд" await event.answer( await create_one_day_schedule(tomorrow_date, tomorrow=True), dont_parse_links=True, )
from vkwave.bots import ( DefaultRouter, simple_bot_message_handler, PayloadFilter, SimpleBotEvent, ) from helpers import get_current_schedule_for_which_and_next, get_current_lesson from utils import create_text_schedule_for_one_lesson current_lesson_router = DefaultRouter() @simple_bot_message_handler(current_lesson_router, PayloadFilter({"command": "which"})) async def send_schedule(event: SimpleBotEvent): current_schedule = await get_current_schedule_for_which_and_next() if current_schedule is None: return "Какие пары иди спи" current_lesson = get_current_lesson(current_schedule) if current_lesson is not None: return await event.answer( message=create_text_schedule_for_one_lesson(current_lesson), dont_parse_links=True, ) return "Сейчас пары нет"
DefaultRouter, simple_bot_message_handler, PayloadFilter, SimpleBotEvent, ) from helpers import ( get_current_schedule_for_which_and_next, get_current_lesson, get_schedule_and_days, create_next_lesson_message, correct_schedule, ) from utils import get_now, get_current_timedelta next_lesson_router = DefaultRouter() @simple_bot_message_handler(next_lesson_router, PayloadFilter({"command": "next"})) async def next_lesson(event: SimpleBotEvent): schedule, days = await get_schedule_and_days() now = get_now() current_schedule = await get_current_schedule_for_which_and_next() if current_schedule is None: return "некст пара не обнаружена))" current_timedelta = get_current_timedelta() current_lesson = get_current_lesson(current_schedule) message = create_next_lesson_message( current_schedule=current_schedule,
from vkwave.bots import MessageFromConversationTypeFilter from vkwave.bots import SimpleBotEvent from vkwave.bots import simple_bot_message_handler from vkwave.client import AIOHTTPClient from database import utils as db from database.models import Chat from database.models import Student from services import filters from services import keyboard as kbs from services.chats import get_confirm_message from services.chats import prepare_set_from_db from services.chats import prepare_set_from_vk from services.logger.config import config preferences_router = DefaultRouter() api_session = API(tokens=os.getenv("VK_TOKEN"), clients=AIOHTTPClient()) api = api_session.get_context() logger.configure(**config) @simple_bot_message_handler( preferences_router, filters.PLFilter({"button": "settings"}), MessageFromConversationTypeFilter("from_pm"), ) @logger.catch() async def open_preferences(ans: SimpleBotEvent): with logger.contextualize(user_id=ans.object.object.message.from_id): active_group = db.admin.get_active_group( db.students.get_system_id_of_student(ans.object.object.message.from_id),
from vkwave.bots import ( DefaultRouter, simple_bot_message_handler, SimpleBotEvent, PayloadFilter, ) from utils import get_now, create_percent, is_weekend attend_apparently_router = DefaultRouter() @simple_bot_message_handler(attend_apparently_router, PayloadFilter({"command": "go"})) async def send_go(event: SimpleBotEvent): now = get_now() if is_weekend(now): return "В выходные поучиться захотелось?" percent = create_percent(user_id=event.object.object.message.from_id, now=now) await event.answer(f"Идти на пары стоит с вероятностью {percent}%")
from vkwave.bots import DefaultRouter, SimpleBotEvent, simple_bot_message_handler from vkwave.types.objects import MessagesMessageAttachmentType from vkwave.bots.core.dispatching import filters from loguru import logger import random import requests vk_msg_from_chat = DefaultRouter() tg_bot = None CONFIG_OBJ = None def config_vk_hand(c=None): global CONFIG_OBJ if not c: return CONFIG_OBJ CONFIG_OBJ = c def setup_tg_bot_to_vk_handler(new_global): global tg_bot tg_bot = new_global def check_if_chat_in_config(peer_id: int) -> None: global CONFIG_OBJ if peer_id not in CONFIG_OBJ['vk']['chats']: CONFIG_OBJ['vk']['chats'].append(peer_id)
from vkwave.bots import ( DefaultRouter, simple_bot_message_handler, SimpleBotEvent, PayloadFilter, ) from helpers import create_one_day_schedule from utils import get_now, is_weekend today_schedule_router = DefaultRouter() @simple_bot_message_handler(today_schedule_router, PayloadFilter({"command": "today"})) async def today(event: SimpleBotEvent): now = get_now() if is_weekend(now): return "ниче нет" await event.answer(await create_one_day_schedule(now), dont_parse_links=True)
import time import datetime from vkwave.bots import ( DefaultRouter, simple_bot_message_handler, PayloadFilter, SimpleBotEvent, ) from db.models.user import User bonus_router = DefaultRouter() @simple_bot_message_handler(bonus_router, PayloadFilter({"command": "bonus"})) async def bonus(event: SimpleBotEvent): user: User = event["current_user"] if time.time() - user.last_bonus_time <= 86400: return await event.answer( f"Бонус доступен раз в день, следующий будет доступен -" f" {datetime.datetime.fromtimestamp(86400 + user.last_bonus_time)}" ) user.last_bonus_time = time.time() user.balance += 1000 await user.commit() return await event.answer("Получен бонус 1000!")
import hyperjson from loguru import logger from vkwave.api import API from vkwave.bots import DefaultRouter from vkwave.bots import MessageFromConversationTypeFilter from vkwave.bots import SimpleBotEvent from vkwave.bots import simple_bot_message_handler from vkwave.client import AIOHTTPClient from database import utils as db from database.models import Student from services import filters from services import keyboard as kbs from services.logger.config import config contacts_router = DefaultRouter() api_session = API(tokens=os.getenv("VK_TOKEN"), clients=AIOHTTPClient()) api = api_session.get_context() logger.configure(**config) @simple_bot_message_handler( contacts_router, filters.PLFilter({"button": "contacts"}), MessageFromConversationTypeFilter("from_pm"), ) @logger.catch() async def start_contacts(ans: SimpleBotEvent): with logger.contextualize(user_id=ans.object.object.message.from_id): db.shortcuts.update_admin_storage( db.students.get_system_id_of_student(
from github import Github from loguru import logger from vkwave.api import API from vkwave.bots import DefaultRouter from vkwave.bots import MessageFromConversationTypeFilter from vkwave.bots import SimpleBotEvent from vkwave.bots import simple_bot_message_handler from vkwave.client import AIOHTTPClient from database import utils as db from services import filters from services import keyboard as kbs from services.logger.config import config report_router = DefaultRouter() api_session = API(tokens=os.getenv("VK_TOKEN"), clients=AIOHTTPClient()) api = api_session.get_context() logger.configure(**config) @simple_bot_message_handler( report_router, filters.PLFilter({"button": "report_error"}), MessageFromConversationTypeFilter("from_pm"), ) @logger.catch() async def start_reporting(ans: SimpleBotEvent): db.shortcuts.update_admin_storage( db.students.get_system_id_of_student(ans.object.object.message.from_id), state_id=db.bot.get_id_of_state("wait_issue_title"),