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,
