async def test_bot_polling(): def callback(data: dict): if "groups.getById" in data["url"]: return {"response": [{"id": 1}]} elif "groups.getLongPollServer" in data["url"]: return {"response": {"ts": 1, "server": "!SERVER!", "key": ""}} elif "!SERVER!" in data["url"]: return EXAMPLE_EVENT elif "messages.send" in data["url"]: return json.dumps({"response": 100}) bot = Bot("token") set_http_callback(bot.api, callback) @bot.labeler.raw_event(GroupEventType.WALL_POST_NEW, GroupTypes.WallPostNew) async def wall_post_handler(post: GroupTypes.WallPostNew): assert post.object.owner_id == -123456 assert post.ctx_api == bot.api @bot.labeler.message() async def message_handler(message: Message): assert message.id == 100 assert message.from_id == 1 assert await message.answer() == 100 async for event in bot.polling.listen(): assert event.get("updates") for update in event["updates"]: await bot.router.route(update, bot.api) break
async def test_bot_polling(): class TestApi(API): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) @property def groups(self): return GroupsCategory(self) @property def messages(self): return MessagesCategory(self) def callback(method: str, url: str, data: dict): if "groups.getById" in url: return {"response": [{"id": 1}]} elif "groups.getLongPollServer" in url: return {"response": {"ts": 1, "server": "!SERVER!", "key": ""}} elif "!SERVER!" in url: return EXAMPLE_EVENT elif "messages.send" in url: _r = {**data, **{"r": 1}} if "peer_ids" in data: return {"response": [_r]} return {"response": _r} bot = Bot(api=TestApi("token")) set_http_callback(bot.api, callback) @bot.labeler.raw_event(GroupEventType.WALL_POST_NEW, GroupTypes.WallPostNew) async def wall_post_handler(post: GroupTypes.WallPostNew): assert post.object.owner_id == -123456 assert post.ctx_api == bot.api @bot.labeler.message() async def message_handler(message: Message): assert message.id == 100 assert message.from_id == 1 assert await message.answer() == { "peer_ids": str(message.peer_id), "r": 1, "random_id": 0, } assert await message.answer(some_unsigned_param="test") == { "peer_ids": str(message.peer_id), "random_id": 0, "some_unsigned_param": "test", "r": 1, } async for event in bot.polling.listen(): assert event.get("updates") for update in event["updates"]: await bot.router.route(update, bot.api) break
import logging import os from vkbottle import Bot from .blueprints import bps # You should provide API to bot before # constructing blueprints otherwise they won't # have it, API is not needed if you are not # requested to use it outside of handlers and # cannot be passed to blueprint if you use # multibot. Read the docs at # > high-level/bot/blueprint bot = Bot(os.environ["token"]) logging.basicConfig(level=logging.INFO) for bp in bps: bp.load(bot) # Moreover, you can use: # import vkbottle import load_blueprints_from_package # for bp in load_blueprints_from_package("blueprints"): # bp.load(bot) bot.run_forever()
u.branch = branch u.context = context return await u.save() await UserState.create(uid=uid, branch=branch, context=context) async def all_users(self): """This method should return user_ids of all stated users""" return [u.uid async for u in UserState.all()] async def delete_user(self, uid: int): """This method should delete the user's bot from the database""" u = await UserState.get(uid=uid) await u.delete() bot = Bot(os.environ.get("token")) bot.branch = SqliteBranch() class StoredBranch(ClsBranch): @rule_disposal(VBMLRule("/говорить <word>")) async def say(self, ans: Message, word: str): self.context["word"] = word return f"Теперь я буду говорить слово: {word}" @rule_disposal(VBMLRule("/остановить")) async def stop(self, ans: Message): await bot.branch.exit(ans.peer_id) return "Бранч остановлен!" async def branch(self, ans: Message, *args):
from vkbottle import Bot, Message, vkscript from typing import List import os bot = Bot(os.environ["TOKEN"]) @vkscript def get_names(api, user_ids=1): names = [] for user in api.users.get(user_ids=user_ids): names.append(user.first_name) return names @bot.on.message_handler(text="/names <( )*ids>") async def fetch_names(ans: Message, ids: List[int]): return ", ".join(await bot.api.execute(get_names(user_ids=ids))) bot.run_polling()
from vkbottle import Bot from blueprints import bps from connect_info import test_token main_bot = Bot(token=test_token) for bp in bps: bp.load(main_bot) main_bot.run_forever()
from vkbottle import Bot, Message from vkbottle.ext import Middleware import os from time import time # Add variable TOKEN to your env variables bot = Bot(os.environ["TOKEN"], debug="DEBUG") @bot.middleware.middleware_handler() class UserCheck(Middleware): async def pre(self, message: Message): if not message.from_id > 0: return False @bot.on.message_handler(lev={ "hello": ["reaction to hello"], "hi": { "source": "reaction to hi" } }) async def pronounce(ans: Message, source): return f"Hello! {source}" bot.run_polling()
from vkbottle import Bot, Message, keyboard_gen, types bot = Bot(token='token', group_id=1, debug=True) """Bot functions When bot receive message «hi» in private chat it answers «hi, my lil friend« and sends a keyboard If user joins, bot will try to send a message «Welcome to the group!» If bot can't do it and VKError with codes 901 or 902 appeared, bot uses logger to send a log about it """ @bot.on.message('hi') async def wrapper(ans: Message): keyboard = [[{'text': 'fantastic button'}]] await ans('hi, my lil friend', keyboard=keyboard_gen(keyboard)) @bot.on.event.group_join() async def wrapper(event: types.GroupJoin): await bot.api.messages.send(peer_id=event.user_id, random_id=100, message='Welcome to the group!') @bot.error_handler(901, 902) async def error(error: list): print('Cant send message to this user :(, error code:', error[0]) if __name__ == '__main__': bot.run_polling()
from vkbottle import Bot, Message from vkbottle import PhotoUploader from dotenv import load_dotenv from config import Config from routes import main, mentors, news, faq, schedule from models import DBStoredBranch, UserState from utils import init_db from vkbottle.ext import Middleware import os load_dotenv() token = os.environ.get('TOKEN') bot = Bot(tokens=[token], debug=Config.DEBUG) bot.branch = DBStoredBranch() photo_uploader = PhotoUploader(bot.api, generate_attachment_strings=True) @bot.middleware.middleware_handler() class CheckUserStateMiddleware(Middleware): async def pre(self, msg: Message, *args): if not Config.USE_MIDDLEWARE: return u = await UserState.filter(uid=msg.from_id).get_or_none() if u is None: u = await UserState.create( uid=msg.from_id, branch='main', context={}
from vkbottle import Bot, Message from tracemoe import ATraceMoe from datetime import timedelta bot = Bot("Vk group token") @bot.on.message_handler( text=["откуда", "аниме", "что за аниме", "какое аниме"], lower=True, command=True) async def wrapper(ans: Message): if ans.attachments and ans.attachments[0].photo: res = await ATraceMoe().search(ans.attachments[0].photo.sizes[-1].url, is_url=True) titles = res["docs"][0]["title_english"] episode = res["docs"][0]["episode"] rtimef = round(res["docs"][0]["from"]) timefrom = datetime.timedelta(seconds=rtimef) rtimet = round(res["docs"][0]["from"]) timeto = datetime.timedelta(seconds=rtimet) similarity = round(res["docs"][0]["similarity"] * 100) await ans("""Аниме:{} Серия: {} Таймкод: с {} по {} Точность: {}%""".format( titles, episodes, timefrom, timeto,
from vkbottle import AudioUploader, Bot, DocUploader, Message, PhotoUploader import requests import PIL from PIL import Image, ImageDraw, ImageFont import dem bot = Bot('token') photo_uploader = PhotoUploader( bot.api, generate_attachment_strings=True) # Создание объекта загрузчика @bot.on.message(text="/дем <str1>//<str2>") async def wrapper(ans: Message, str1, str2): if ans.attachments and ans.attachments[0].photo: photo = ans.attachments[0].photo.sizes[-1].url p = requests.get(photo) out = open(r'img.jpg', "wb") out.write(p.content) out.close() dem.makeImage(str1=str1, str2=str2) photo = await photo_uploader.upload_message_photo('result.jpg') await ans(f'Ваш демотиватор:', attachment=photo) else: await ans(f'Прикрепите фотографию и попробуйте снова!') @bot.on.message(text="/дем <str1>") async def wrapper(ans: Message, str1): if ans.attachments and ans.attachments[0].photo: str2 = ''
# -*- coding: utf8 -*- import os, json, requests, random, re from plugins import gf from modules import pluginMg from vkbottle import Bot, Message, keyboard_gen, types from vkbottle.keyboard import Keyboard, Text #Основная группа get_data = gf.loadjson("conf.json") token = str(get_data['token']) bot = Bot(token=token) users_dir = os.path.join(r"users/") # Генерация/Обновление курсов file = open("curs.json", "w", encoding='utf-8') cursList = {"coin": '{}'.format(random.randint(5500, 9500))} json.dump(cursList, file, ensure_ascii=False) file.close() @bot.on.message() async def wrapper(ans: Message): check_profile = os.path.exists(users_dir + str(ans.from_id) + ".json") if check_profile == True: pass else: data = await bot.api.users.get(user_ids=ans.from_id) first_name = data[0]['first_name'] last_name = data[0]['last_name'] from_id = ans.from_id
from vkbottle import Bot from vkbottle.bot import Message from vkbottle.callback import BotCallback TOKEN = "<TOKEN>" callback = BotCallback(url="http://example.com/whateveryouwant", title="my server") bot = Bot(token=TOKEN, callback=callback) @bot.on.message(text="привет") async def hi_handler(message: Message): users_info = await bot.api.users.get(message.from_id) await message.answer(f"Hello, {users_info[0].first_name}")
from vkbottle import Bot, Message bot = Bot(token='token', group_id=1, debug=True) """Bot functions Described in code comments """ # STANDART HANDLERS @bot.on.message('hi') async def wrapper(ans: Message): # Works if message 'hi' in private dialog is received await ans('hi') @bot.on.chat_message('banana') async def wrapper(ans: Message): # Works if message 'banana' in chat received await ans('clean me..') @bot.on.message_both('apple') async def wrapper(ans: Message): # Works if message 'apple' in both (chat or private) dialog received await ans('steve jobs..((((') @bot.on.chat_message.startswith('/start') async def wrapper(ans: Message): # Works if message in chat starts with '/start' await ans('this message starts with /start, yes?')
from aiohttp.web import RouteTableDef, Application, Request, run_app from vkbottle import Bot app = Application() routes = RouteTableDef() bot = Bot("my-token", secret="SecretKey") @routes.get("/bot") async def executor(request: Request): return await bot.emulate(event=dict(request.query), confirmation_token="ConfirmationToken") @bot.on.message(text="test", lower=True) async def wrapper(): return "test" app.add_routes(routes) run_app(app)
from vkbottle import Bot import config bot = Bot(tokens=config.TOKEN_BOT) if __name__ == '__main__': from routes import query_timetable, call_schedule, notify, other bot.set_blueprints(call_schedule.bp, notify.bp, other.bp, query_timetable.bp) bot.run_polling()
from time import time as current from tortoise import Tortoise from vkbottle import Bot, Message from vkbottle.ext import Middleware from vkbottle.rule import AbstractMessageRule from .tortoise_models import User bot = Bot("token") """ Better works with tortoise. Choose only asynchronous libraries to integrate them with vkbottle """ class Registered(AbstractMessageRule): async def check(self, message: Message): self.context.args.append(await User.get(uid=message.from_id)) return True @bot.middleware.middleware_handler() class Register(Middleware): async def pre(self, message: Message): if not await User.get_or_none(uid=message.from_id): await User.create(uid=message.from_id, time=current()) await message("You are now registered")
from mcstatus import MinecraftServer from vkbottle import Bot, Message bot=Bot('токен группы') @bot.on.message_handler(text='чек <check>', lower = True) async def minecraft(ans: Message, check): try: server = MinecraftServer.lookup(check) status = server.status() await ans("Онлайн сервера: {0} \n Пинг: {1} ms".format(status.players.online, status.latency)) except: await ans('Ошибка') bot.run_polling()
import config import random import time as tm from sqlighter import SQLighter import logging import keyboards as kb from vkbottle.api import API from vkbottle.api.api.util.builtin import LimitedTokenGenerator from datetime import datetime, date, time, timedelta from vkbottle.exceptions import VKError import os from vkbottle.rule import AbstractMessageRule token = "053bc3be3550cb649bb2" bot = Bot(config.API_TOKEN, debug=False) # инициализируем соединение с БД db = SQLighter('db.db') #id админа admin_id = 550194476 #cсылка на донаты link = 'https://vk.com/app6471849_-187582264' link2 = f'https://api.vkdonate.ru?action=donates&count=50&sort=date&key={token}' link3 = f'https://vkdonate.ru/api?action=donates&count=50&sort=date&key={token}' # Создаем класс для правила class OnlyMe(AbstractMessageRule):
from vkbottle import Bot, Message from examples.tests.blueprints.plugins import fare_bp, greet_bp import os bot = Bot(tokens=os.environ["TOKEN"], debug="DEBUG") bot.set_blueprints(fare_bp, greet_bp) @bot.on.message_handler(text="Where are the blueprints?") async def wrapper(ans: Message): await ans("They’re on top!") bot.run_polling(skip_updates=True)
from vkbottle import Bot, Message, keyboard_gen, VKError import random import generator bot = Bot("TOKEN") @bot.on.message_handler() async def handle(_): if random.randint(0,8) == 3: var = random.randint(0,3) if var == 0: return generator.genOne() elif var == 1: return generator.genTwo() elif var == 2: return generator.genThree() elif var == 3: return generator.genFour() bot.run_polling()
from vkbottle import Bot, Message bot = Bot('token', 1, debug=True, plugin_folder='examplebot') # Answer <Тебя зовут ИМЯ> to <!меня зовут ИМЯ> @bot.on.message('!меня зовут <name>', lower=True) async def wrapper(ans: Message, name): await ans(f'Тебя зовут {name}') bot.run_polling()
import string from pydantic import ValidationError import comments import config import random import messages import aiosqlite import transactions from vkbottle import Bot, Message, User, VKError from vkbottle.api.keyboard import keyboard_gen from vkbottle.keyboard import Text, Keyboard from vkbottle.branch import ExitBranch bot = Bot(config.token) user = User(config.acces_token) qiwi = transactions.Qiwi() def getRandomId(): return random.randint(0, 10000000) async def check_or_register_user(user_id: int): """ Регистрирует пользователя, если его еще нет в базе данных. :param user_id: id пользователя, кого надо зарегистрировать """ conn = await aiosqlite.connect('Database/database.db') cursor = await conn.cursor()
async def test_bot_scopes(): bot = Bot(token="some token") assert await bot.api.token_generator.get_token() == "some token" assert bot.api == bot.polling.api assert bot.labeler.message_view is bot.router.views["message"] assert bot.labeler.raw_event_view is bot.router.views["raw"]
MAX_RANDOM_ID_INT = int(2e9) MIN_RANDOM_ID_INT = int(-2e9) START_WRITE_POSITION_X = 30 START_WRITE_POSITION_Y = 50 BLACK_COLOR = (0, 0, 0) BOT_CREATOR_ID = 500101793 CAR_COST_MULTIPLIER = 0.1 class DatabaseActions(Enum): ADD = 0 REMOVE = 1 class AccessingLevels(Enum): MODERATOR = "Модерка" ADMINISTRATOR = "Администраторка" class BuyCarUserStatuses(Enum): APPROVED = 0 NOT_ENOUGH_MONEY = 1 NOT_ENOUGH_EXP = 2 NOW_HAVE_CAR = 3 BOT = Bot(ACCESS_TOKEN, loop=asyncio.get_event_loop(), group_id=BOT_GROUP_ID) USER = vkBottleUser(USER_ACCESS_TOKEN)
import random import sqlite3 import time import vk_api import vkcoin import hashlib from vk_api.longpoll import VkLongPoll from vkbottle import Bot from vkcoinapi import * vk_session = vk_api.VkApi(token='ab4145d1b0425733b338a2082ae05c1452c98a5d38a14a1100f239b07dc2249b6278d9b1e05d2679a4222') bot = Bot("ab4145d1b0425733b338a2082ae05c1452c98a5d38a14a1100f239b07dc2249b6278d9b1e05d2679a4222") group_id = '-195266217' coin = VKCoin(key='8jrkRfHFBk76U4e8n7Cl&oJJe!BFkMnfA5&zh4#6dA88tjZQ19', merchantId=192557599) pay = VKCoin(key='8jrkRfHFBk76U4e8n7Cl&oJJe!BFkMnfA5&zh4#6dA88tjZQ19', merchantId=192557599) coin_sema = VKCoin(key='8jrkRfHFBk76U4e8n7Cl&oJJe!BFkMnfA5&zh4#6dA88tjZQ19', merchantId=192557599) merchant = vkcoin.VKCoin(user_id=192557599, key='8jrkRfHFBk76U4e8n7Cl&oJJe!BFkMnfA5&zh4#6dA88tjZQ19') vk = vk_session.get_api() longpoll_type = VkLongPoll(vk_session) conn = sqlite3.connect(r"timer.db") c = conn.cursor() sqlite3.connect(":memory:", check_same_thread=False) connt = sqlite3.connect(r"all_inf.db") t = connt.cursor() sqlite3.connect(":memory:", check_same_thread=False) def winner(id, summ): t.execute("SELECT balance FROM us WHERE id=%d" % (int(id))) bal = int(t.fetchone()[0]) t.execute("UPDATE us SET balance=%d WHERE id=%d" % (bal + int(summ), int(id)))
qiwi = {} op = {} po = {} course = config.course course_sale = config.course_sale logic = { } spisok = {} comment = {} bot = Bot( 'e87ce7d5121ce273cb4cdc11abca24e09af9c4c91a24cbc22956c7c67c56029024e99cbd942a2c87e8525', mobile = True ) vk = vk_api.VkApi( token = 'e87ce7d5121ce273cb4cdc11abca24e09af9c4c91a24cbc22956c7c67c56029024e99cbd942a2c87e8525' ).get_api() merchant = vkcoin.VKCoin( user_id = config.user_id, key = config.key ) api = QApi( token = config.token_qiwi, phone = config.phone ) main = Keyboard( ) main.add_row( ) main.add_button( Text( label = '📥Купить' ), color = 'positive' ) main.add_button( Text( label = '📤Продать' ), color = 'negative' ) main.add_row( ) main.add_button( Text( label = '📊 Информация' ), color = 'primary' ) @bot.on.message( text = '<text>', lower = True )
from io import BytesIO from gtts import gTTS from PIL import Image from vkbottle import AudioUploader, Bot, DocUploader, Message, PhotoUploader bot = Bot("token") photo_uploader = PhotoUploader(bot.api, generate_attachment_strings=True) doc_uploader = DocUploader(bot.api, generate_attachment_strings=True) audio_uploader = AudioUploader(bot.api, generate_attachment_strings=True) @bot.on.message_handler(text="photo_from_bytes", lower=True) async def photo_from_bytes(ans: Message): image = Image.new("RGB", (320, 320), (0, 0, 0)) fp = BytesIO() image.save(fp, "RGB") setattr(fp, "name", "image.png") photo = await photo_uploader.upload_message_photo(fp) await ans(attachment=photo) @bot.on.message_handler(text="doc_from_file", lower=True) async def photo_from_bytes(ans: Message): image = Image.new("RGB", (320, 320), (0, 0, 0)) image.save("image.png", "RGB") photo = await doc_uploader.upload_doc_to_message("image.png", ans.peer_id) await ans(attachment=photo)
from vkbottle import Bot, Message, keyboard_gen from vkbottle.rule import ChatActionRule bot = Bot("VK Group Token") async def check(ans: Message, id): items = (await bot.api.messages.get_conversations_by_id(peer_ids=ans.peer_id)).items if not items: return False chat_settings = items[0].chat_settings is_admin = id == chat_settings["owner_id"] or id in chat_settings["admin_ids"] return is_admin async def get_id(bot, pattern: str) -> int: if pattern.isdigit(): return int(pattern) elif ( "vk.com/" in pattern or "http://vk.com/" in pattern or "https://vk.com/" in pattern ): uid = (await bot.api.users.get(user_ids=pattern.split("/")[-1]))[0] return uid["id"] elif "[id" in pattern: uid = pattern.split("|")[0] return int(uid.replace("[id", ""))
import telebot from vkbottle import Bot, Message from vkbottle.rule import AttachmentRule from database import Users bot = Bot(tokens=[ 'a698725881e84f995088a628c7c87a841c5282293e2ea647d442e1cb8b19ec72e09264d8705dd4820275f' ]) telegram = telebot.TeleBot( token='1229780153:AAH4l5C9rVWNsLriS-sZpsEZlkQ3ek6Vfpg') @bot.on.message(text='<telegram_id:int>') async def wrapper(answer: Message, telegram_id): data = [(i.vk_id, i.telegram_id) for i in Users.select() if i.vk_id == answer.from_id] if not data: Users.create(vk_id=answer.from_id, telegram_id=telegram_id) await answer('Отправь мне аудиозаписи во вложении') else: await answer('Отправь мне аудиозаписи во вложении') @bot.on.message(AttachmentRule('audio')) async def wrapper(answer: Message): for attachment in answer.attachments: telegram_id = Users.get(Users.vk_id == str(answer.from_id)).telegram_id telegram.send_audio( chat_id=telegram_id, audio=attachment.audio.url,