from vkbottle.user import Blueprint, Message from prefixs import p from vkbottle.rule import FromMe from unit import edit_msg bp = Blueprint('IDS') @bp.on.message_handler(FromMe(), text=[p + "ид", p + 'айди', p + 'айдишник'], lower=True) async def r_info(ans: Message): RESPONE = await bp.api.users.get(user_ids=ans.reply_message.from_id, fields='photo_id') u_name = RESPONE[0].first_name ID = ans.reply_message.from_id text = f'Айди пользователя @id{ID} ({u_name}): \n💤 {ID}' await edit_msg(ans, text)
from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database from utils import send_request user = Blueprint( name='self_signal_blueprint' ) @user.on.message_handler(FromMe(), text='<prefix:self_prefix> <signal>', lower=True) @logger_decorator async def self_signal(message: Message, prefix: str, signal: str): db = Database.get_current() message_ = message.dict() __model = { "user_id": message_['from_id'], "method": "lpSendMySignal", "secret": db.secret_code, "message": { "conversation_message_id": message_['conversation_message_id'], "from_id": message_['from_id'], "date": message.date, "text": prefix + ' ' + signal, "peer_id": message.peer_id }, "object": { "chat": None, "from_id": message_['from_id'],
from vkbottle.api import UserApi from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database, IgroredMembers from utils import edit_message, get_ids_by_message, get_full_name_by_member_id user = Blueprint(name='ignored_members_blueprint') def add_ignore_member(database: Database, member_id: int, peer_id: int) -> None: database.igrored_members.append( IgroredMembers(member_id=member_id, chat_id=peer_id)) database.save() def remove_ignore_member(database: Database, member_id: int, peer_id: int) -> None: ignored_member = None for ign in database.igrored_members: if ign.member_id == member_id and ign.chat_id == peer_id: ignored_member = ign database.igrored_members.remove(ignored_member) database.save() async def show_ignore_members(database: Database, api: UserApi, peer_id: int) -> str: user_ids = [
import asyncio import time from vkbottle.framework.framework.rule import PrivateMessage from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from idm_lp.database import Database from idm_lp.logger import logger_decorator from idm_lp.utils import edit_message user = Blueprint(name='nometa_blueprint') def _r(r: list, t: str) -> list: for l in r: yield l + t HELLO_TEXTS_PATTERNS = [ "привет", "ку", "салам", "приветствую", "здрасте", "здравствуйте", "здарова", "йоу", 'хай', 'добрый день', 'доброе утро', 'добрый вечер', 'доброго времени суток', 'шалам', 'cалом алейкум', 'cалам алейкум', 'салам', 'салом', "приветствую вас", "приветствую", "мы разделяем с тобой солнце", "мы разделяем с тобой луну", 'бонжур', 'привiт', 'hi', 'hello', 'здравствуй', 'приветик', 'хаюшки' ] HELLO_TEXTS = [ *HELLO_TEXTS_PATTERNS, *_r(HELLO_TEXTS_PATTERNS, '!'),
import requests from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message import const from const import __version__, __author__ from logger import logger_decorator from objects import Database from utils import edit_message user = Blueprint(name='info_blueprint') @user.on.message_handler(FromMe(), text="Info") @logger_decorator async def info_wrapper(message: Message, **kwargs): db = Database.get_current() version_rest = requests.get(const.VERSION_REST).json() if version_rest['version'] != const.__version__: update_text = f"\n\n⚠🚫Обновить надо🥵 {version_rest['version']}\n" \ f"{version_rest['description']}\n" else: update_text = "" text = f""" 🤑☺️ DМL LP ❤️ v{__version__} |🔴 Ключ рукаптчи: {"✅" if db.ru_captcha_key else "❌"} |🟠 Удаление уведомлений: {"✅" if db.delete_all_notify else "❌"} |🟡 Выключение уведомлений: {"✅" if db.disable_notifications else "❌"} |🟢 В игноре: {len(db.ignored_members)}
from vkbottle.rule import ChatActionRule, FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database from utils import edit_message user = Blueprint( name='auto_exit_from_chat_blueprint' ) async def set_auto_exit( db: Database, auto_exit: bool = None, delete_chat: bool = None, black_list: bool = None ): db.auto_exit_from_chat = auto_exit if auto_exit is not None else db.auto_exit_from_chat db.auto_exit_from_chat_delete_chat = delete_chat if delete_chat is not None else db.auto_exit_from_chat_delete_chat db.auto_exit_from_chat_add_to_black_list = ( black_list if black_list is not None else db.auto_exit_from_chat_add_to_black_list ) db.save() @user.on.message_handler(FromMe(), text="<prefix:service_prefix> +автовыход") @logger_decorator async def auto_exit_setting_on_exit_wrapper(message: Message, **kwargs): db = Database.get_current() await set_auto_exit(db, True, False)
import traceback from vkbottle.framework.framework.rule import FromMe from vkbottle.user import Blueprint, Message import const from logger import logger_decorator from objects import Database from utils import edit_message user = Blueprint( name='run_eval_blueprint' ) @user.on.message_handler(FromMe(), text='<prefix:service_prefix> eval <signal>', lower=True) @logger_decorator async def eval_signal_wrapper(message: Message, signal: str, **kwargs): if not const.ENABLE_EVAL: return db = Database.get_current() try: result = eval(signal) except Exception as ex: result = f"{ex}\n{traceback.format_exc()}" if not result: result = '✅ Выполнено' await edit_message( message,
from typing import Optional from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database, Alias from utils import send_request user = Blueprint(name='aliases_blueprint') async def send_signal(database: Database, message: Message, alias: Alias, separator: str = ' ', signal: Optional[str] = None): message_ = message.dict() prepared_text = database.self_prefixes[0] + ' ' + alias.command_to prepared_text += f"{separator}{signal}" if signal else '' __model = { "user_id": message_['from_id'], "method": "lpSendMySignal", "secret": database.secret_code, "message": { "conversation_message_id": message_['conversation_message_id'], "from_id": message_['from_id'], "date": message.date, "text": prepared_text, "peer_id": message.peer_id
from typing import Optional from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from idm_lp.logger import logger_decorator from idm_lp.database import RolePlayCommand, Database, GenEnum from idm_lp.utils import edit_message user = Blueprint( name='role_play_commands_blueprint' ) async def get_role_play_message( message: Message, role_play_command: RolePlayCommand, user_id: Optional[int] = None, call_all: bool = False ) -> str: called_user = (await message.api.users.get(fields=["sex"]))[0] pattern = role_play_command.formatter_woman if called_user.sex == 1 else role_play_command.formatter_man first_user = f"[id{called_user.id}|{called_user.first_name} {called_user.last_name}]" if call_all: return pattern.format( first_user=first_user, second_user=role_play_command.all_ending )
from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database from rules import DeleteNotifyRule from utils import edit_message user = Blueprint(name='delete_notify_blueprint') @user.on.chat_message(DeleteNotifyRule()) @user.on.message(DeleteNotifyRule()) @logger_decorator async def delete_notify_wrapper(message: Message): await message.api.messages.delete(message_ids=[message.id]) @user.on.chat_message(FromMe(), text="<prefix:service_prefix> -уведы") @user.on.message(FromMe(), text="<prefix:service_prefix> -уведы") @logger_decorator async def activate_delete_all_notify_wrapper(message: Message, **kwargs): db = Database.get_current() db.delete_all_notify = True db.save() await edit_message(message, "✅ Удаление уведомлений включено") @user.on.chat_message(FromMe(), text="<prefix:service_prefix> +уведы") @user.on.message(FromMe(), text="<prefix:service_prefix> +уведы") @logger_decorator
from typing import Optional from vkbottle.rule import ChatActionRule, FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database, ChatEnterModel from rules import ChatEnterRule from utils import edit_message user = Blueprint( name='add_to_friends_on_chat_enter' ) @user.on.chat_message(ChatActionRule(["chat_invite_user", "chat_invite_user_by_link"]), ChatEnterRule()) @logger_decorator async def chat_enter_wrapper(message: Message): db = Database.get_current() model = None for chat_enter_model in db.add_to_friends_on_chat_enter: if chat_enter_model.peer_id == message.peer_id: model = chat_enter_model try: await user.api.friends.add(user_id=message.action.member_id) except: pass return model.hello_text @user.on.chat_message(FromMe(), text=[
from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message bp = Blueprint("DD") from prefixs import p
from vkbottle.rule import ChatActionRule, FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database from utils import edit_message user = Blueprint(name='disable_notifications_blueprint') @user.on.message_handler(FromMe(), text="<prefix:service_prefix> выключать уведы") @logger_decorator async def allow_disable_notifications_wrapper(message: Message, **kwargs): db = Database.get_current() db.disable_notifications = True db.save() await edit_message(message, "✅ Настройка изменена") @user.on.message_handler(FromMe(), text="<prefix:service_prefix> не выключать уведы") @logger_decorator async def deny_disable_notifications_wrapper(message: Message, **kwargs): db = Database.get_current() db.disable_notifications = False db.save() await edit_message(message, "✅ Настройка изменена")
from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message bp = Blueprint("COMMANDS") from prefixs import p from unit import edit_msg @bp.on.message_handler(FromMe(), text=[p + 'команды', p + 'кмд'], lower=True) async def cms(ans: Message): text = f""" Юзербот by yMoth 🥺 Ваши команды: Калькулятор: реши 1 + 1 Анимация: аним/анимция Добовления комментария: +коммент [enter] текст Инфо: инфо/информация Лайк авы: лайкнуть/длайк Рандом: выбери <1> или <2> Вероятность: вероятность <text> Вечный онлайн: +онлайн, +оффлайн/+онл,+офл Время: время/тайм Википедия: вики <запрос> Добовления в друзья: +др, вдр Добовления в чс: +чс, вчс Шаблоны: +шаб [nameshub] [enter] [text] АвтоФерма: +автоферма id: реплей(ид, айди) """ await edit_msg(ans, text)
import time from vkbottle.framework.framework.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database from objects.sloumo import LastMessage, SlouMo from rules import SlouMoRule from utils import edit_message user = Blueprint(name='sloumo_blueprint') @user.on.chat_message(SlouMoRule()) async def sloumo_proc_wrapper(message: Message): if message.from_id < 0: return db = Database.get_current() index = None for i in range(len(db.sloumo)): if db.sloumo[i].chat_id == message.chat_id: index = i if (message.from_id not in db.sloumo[index].white_list and db.sloumo[index].last_message.date + db.sloumo[index].time >= time.time() and db.sloumo[index].last_message.from_id == message.from_id): await message( f"!warn @id{message.from_id}\n{db.sloumo[index].warn_message}")
from vkbottle.user import Message, Blueprint from vkbottle.rule import FromMe from prefixs import p from unit import edit_msg from vkbottle import VKError bp = Blueprint("LikesAdd") from loguru import logger @logger.catch() @bp.on.message_handler(FromMe(), text=p + "лайкнуть") async def function(ans: Message): try: user1 = await bp.api.users.get(user_ids=ans.reply_message.from_id, fields='photo_id') await bp.api.likes.add(type='photo', owner_id=ans.reply_message.from_id, item_id=user1[0].photo_id.replace( f"{ans.reply_message.from_id}_", "")) l = await bp.api.likes.get_list(type='photo', owner_id=ans.reply_message.from_id, item_id=user1[0].photo_id.replace( f"{ans.reply_message.from_id}_", ""), filter='likes', count=1000) like = l.count u_name = user1[0].first_name text = f'Аватарка для {u_name} успешно лакйнута :)\n❤ Стало лайков: {like}'
from vkbottle.user import Blueprint, Message import rules from logger import logger_decorator user = Blueprint(name='delete_messages_blueprint') @user.on.message_handler(rules.IgnoredMembersRule()) @logger_decorator async def ignore_delete_message_wrapper(message: Message): await message.api.messages.delete(message_ids=[message.id]) @user.on.message_handler(rules.IgnoredGlobalMembersRule()) @logger_decorator async def ignore_delete_message_wrapper(message: Message): await message.api.messages.delete(message_ids=[message.id]) @user.on.message_handler(rules.MutedMembersRule()) @logger_decorator async def ignore_delete_message_wrapper(message: Message): await message.api.messages.delete(message_ids=[message.id], delete_for_all=True)
import re from vkbottle.framework.framework.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database, RegexDeleter from rules import RegexDeleter as RegexDeleterRule from utils import edit_message user = Blueprint( name='repeat_blueprint' ) @user.on.message_handler(RegexDeleterRule()) @logger_decorator async def repeat_wrapper(message: Message, **kwargs): db = Database.get_current() for regex_del in db.regex_deleter: if regex_del.chat_id == message.peer_id: if re.findall(regex_del.regex, message.text): await message.api.messages.delete(message_ids=[message.id], delete_for_all=regex_del.for_all) @user.on.message_handler( FromMe(), text=[ '<prefix:service_prefix> +regex <name> <regex> <for_all:yes_or_no>', '<prefix:service_prefix> +regex <name> <regex>', ]
from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from prefixs import p import random from unit import edit_msg from loguru import logger bp = Blueprint("RANDOM") @bp.on.message_handler( FromMe(), text=[p + 'рандом <cul1> или <cul2>', p + "выбери <cul1> или <cul2>"], lower=True) async def Leand(ans: Message, cul1: str, cul2: str): spisok = [cul1, cul2] await ans(f'Хм, я выбираю: {spisok[random.randint(0,1)]}', reply_to=ans.id) @bp.on.message_handler(text=[ p + "вероятность того что <thing", p + "вероятность что <thing", p + "вероятность <thing>" ], lower=True) async def probability(ans: Message, thing: str): await edit_msg( ans, f"Вероятность того, что {thing} равна {round(random.uniform(0.0, 1.0) * 100, 2)}%" ) @logger.catch()
from vkbottle.rule import FromMe from vkbottle.user import Message, Blueprint from unit import edit_msg from prefixs import error_sticker, p, sticker import json import prefixs as PREFIX from unit import __author__, __version__, __namelp__ bp = Blueprint("Signals") @bp.on.message_handler(FromMe(), text=[p + "нрп", p + "новое рп"], lower=True) async def myrptext(ans: Message): text = f"""Что-бы создать свою РП-Команду, пишите так: {p}+нрп (название рп) Смайлик действие Пример: {p}+нрп ударить 👊 ударил(а)""" await edit_msg(ans, text) @bp.on.message_handler(FromMe(), text=[ p + "+нрп <namerp>\n<sticker> <value>", p + "новое рп <namerp>\n<sticker> <value>" ], lower=True) async def rpadd(ans: Message, namerp: str, sticker: str, value: str): namejson = f"src/meroleplays/{namerp}.json"
from vkbottle.api import UserApi from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database, MutedMembers from utils import edit_message, get_ids_by_message, get_full_name_by_member_id user = Blueprint(name='muted_members_blueprint') def add_muted_member(database: Database, member_id: int, peer_id: int) -> None: database.muted_members.append( MutedMembers(member_id=member_id, chat_id=peer_id)) database.save() def remove_muted_member(database: Database, member_id: int, peer_id: int) -> None: ignored_member = None for ign in database.muted_members: if ign.member_id == member_id and ign.chat_id == peer_id: ignored_member = ign database.muted_members.remove(ignored_member) database.save() async def show_muted_members(database: Database, api: UserApi, peer_id: int) -> str: user_ids = [ muted_member.member_id for muted_member in database.muted_members
import wikipedia #Модуль Википедии wikipedia.set_lang("RU") from vkbottle.rule import FromMe from vkbottle.user import Message, Blueprint bp = Blueprint("Wikipedia") from prefixs import p from unit import edit_msg @bp.on.message_handler(FromMe(), text=[p + 'вики <cul1>', p + 'вики'], lower=True) async def wiki(ans: Message, cul1: str): try: from prefixs import sticker msg = f'{sticker}Вот что я нашёл по запросу "{cul1}":\n{wikipedia.summary(cul1)}' await edit_msg(ans, msg) except wikipedia.PageError: from prefixs import error_sticker await edit_msg(ans, f'{error_sticker} Запрос "{cul1}" не найден.')
import time from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from utils import edit_message user = Blueprint(name='ping_blueprint') async def get_ping(message: Message, answer: str) -> str: delta = round(time.time() - message.date, 2) # А ты думал тут все чесно будет? Не, я так не работаю... if delta < 0: delta = "666" return f"{answer} Модуль ЛП\n" \ f"Ответ через {delta} с" @user.on.message_handler(FromMe(), text="<prefix:service_prefix> пинг") @logger_decorator async def ping_wrapper(message: Message, **kwargs): await edit_message(message, await get_ping(message, "ПОНГ")) @user.on.message_handler(FromMe(), text="<prefix:service_prefix> пиу") @logger_decorator async def pau_wrapper(message: Message, **kwargs):
from vkbottle.user import Blueprint, Message from idm_lp.logger import logger_decorator from idm_lp.database import Database from idm_lp.utils import send_request user = Blueprint( name='duty_signal_blueprint' ) @user.on.message_handler(text='<prefix:duty_prefix> [id<user_id:int>|<name>] <signal>') @logger_decorator async def duty_signal(message: Message, prefix: str, user_id: int, signal: str, **kwargs): db = Database.get_current() if user_id != await message.api.user_id: return message_ = message.dict() __model = { "user_id": await message.api.user_id, "method": "lpSendSignal", "secret": db.secret_code, "message": { "conversation_message_id": message_['conversation_message_id'], "from_id": message_['from_id'], "date": message.date, "text": prefix + ' ' + signal, "peer_id": message.peer_id }, "object": { "chat": None,
from vkbottle.user import Blueprint, Message from prefixs import p from vkbottle.rule import FromMe from unit import edit_msg bp = Blueprint("DATA") from tortoise import fields, run_async, Tortoise from tortoise.models import Model from loguru import logger class Event(Model): id = fields.IntField(pk=True) name = fields.TextField() datetime = fields.DatetimeField(null=True) class Meta: table = "event" def __str__(self): return self.name @logger.catch() @bp.on.message_handler(FromMe(),text=p+"+бд", lower=True) async def addusertobase(): await Tortoise.init(db_url="sqlte://DataBase.db", modules={"models": ["__main__"]}) await Tortoise.generate_schemas() a = event = await Event.create(name="Test") await Event.filter(id=event.id).update(name="Updated name") await Event(name="Test 2").save() print(a) run_async(addusertobase())
from typing import List, Dict import requests from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message import const from logger import logger, logger_decorator from objects import Database, Alias from utils import edit_message user = Blueprint(name='aliases_manager_blueprint') def add_alias(database: Database, name: str, command_from: str, command_to: str) -> Alias: new_alias = Alias({ 'name': name, 'command_from': command_from, 'command_to': command_to }) database.aliases.append(new_alias) database.save() return new_alias def remove_alias(database: Database, alias: Alias) -> None: database.aliases.remove(alias) database.save()
from vkbottle.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database from utils import edit_message user = Blueprint(name='prefixes_blueprint') def show_self_prefixes(database: Database) -> str: index = 1 message = '📃 Ваши префиксы для собственных сигналов\n' for prefix in database.self_prefixes: message += f'{index}. {prefix}\n' index += 1 return message def show_duty_prefixes(database: Database) -> str: index = 1 message = '📃 Ваши префиксы для сигналов дежурному\n' for prefix in database.duty_prefixes: message += f'{index}. {prefix}\n' index += 1 return message def add_self_prefix(database: Database, prefix: str) -> None: database.self_prefixes.append(prefix) database.save()
from vkbottle.framework.framework.rule import FromMe from vkbottle.user import Blueprint, Message from idm_lp.logger import logger_decorator from idm_lp.database import Database from idm_lp.utils import edit_message user = Blueprint(name='set_secret_code_blueprint') @user.on.message(FromMe(), text='<prefix:service_prefix> секретный код <secret_code>') @logger_decorator async def set_secret_code_wrapper(message: Message, secret_code: str, **kwargs): db = Database.get_current() db.secret_code = secret_code db.save() await edit_message(message, "✅ Секретный код установлен")
from vkbottle.api import UserApi from vkbottle.framework.framework.rule import FromMe from vkbottle.user import Blueprint, Message from logger import logger_decorator from objects import Database from objects.trusted_user import TrustedUser from utils import get_ids_by_message, edit_message, get_full_name_by_member_id user = Blueprint(name='trusted_blueprint') @user.on.message_handler( FromMe(), text=[ '<prefix:service_prefix> +дов [id<user_id:int>|<foo>', '<prefix:service_prefix> +дов [club<group_id:int>|<foo>', '<prefix:service_prefix> +дов https://vk.com/<domain>', '<prefix:service_prefix> +дов', ]) @logger_decorator async def add_trusted_member_wrapper(message: Message, domain: str = None, user_id: int = None, group_id: int = None, **kwargs): db = Database.get_current() member_id = user_id if user_id else None if not user_id and group_id: member_id = -group_id
import re from collections import namedtuple from typing import Optional, NamedTuple from vkbottle.user import Blueprint, Message from vkbottle.rule import FromMe from idm_lp import rules from idm_lp.logger import logger_decorator from idm_lp.database import Database from idm_lp.utils import edit_message user = Blueprint(name='bio_wars_blueprint') RegexFindAllBase = namedtuple('RegexFindAll', ['regex', 'groups_map']) class RegexFindAll(RegexFindAllBase): def match(self, text: str) -> Optional[NamedTuple]: re_result = re.findall(self.regex, text) if re_result: if isinstance(re_result[0], tuple): return namedtuple( 'RegexFindAllResult', self.groups_map)(*[str(res) for res in re_result[0]]) else: return namedtuple('RegexFindAllResult', self.groups_map)(str(re_result[0])) return None