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
