Updated modules.json after parse 2026-01-11 01:19:41

archquise/H.Modules/BirthdayTime.py

@@ -168,10 +168,10 @@ class DaysToMyBirthday(loader.Module):
                 await asyncio.sleep(60)
 
     @loader.command(
-        ru_doc="Выставить таймер дней в ник (нестабильно)",
-        en_doc="Set the timer of days in the nickname (unstable)",
+        ru_doc="Включить таймер дней в ник (нестабильно)",
+        en_doc="Enable timer of days in nickname (unstable)",
     )
-    async def btname(self, message):
+    async def btnameon(self, message):
         try:
             user = await self.client(GetFullUserRequest(self.client.hikka_me.id))
             name = user.users[0].last_name or ""
@@ -181,25 +181,32 @@ class DaysToMyBirthday(loader.Module):
             return
 
         self.db.set(__name__, "last_name", name)
+        self.db.set(__name__, "change_name", True)
+        await utils.answer(message, self.strings("btname_yes"))
+
+    @loader.command(
+        ru_doc="Выключить таймер дней в ник",
+        en_doc="Disable timer of days in nickname",
+    )
+    async def btnameoff(self, message):
         change_name = self.db.get(__name__, "change_name", False)
 
-        if change_name:
-            self.db.set(__name__, "change_name", False)
+        if not change_name:
             await utils.answer(message, self.strings("btname_no"))
-            try:
-                await self.client(
-                    UpdateProfileRequest(last_name=self.db.get(__name__, "last_name"))
-                )
-                await utils.answer(message, self.strings("name_not_changed"))
-            except UserPrivacyRestrictedError:
-                await utils.answer(message, self.strings("name_privacy_error"))
-            except Exception as e:
-                logger.error(f"Error removing name: {e}")
-                await utils.answer(message, self.strings("error"))
+            return
 
-        else:
-            self.db.set(__name__, "change_name", True)
-            await utils.answer(message, self.strings("btname_yes"))
+        self.db.set(__name__, "change_name", False)
+        await utils.answer(message, self.strings("btname_no"))
+        try:
+            await self.client(
+                UpdateProfileRequest(last_name=self.db.get(__name__, "last_name"))
+            )
+            await utils.answer(message, self.strings("name_not_changed"))
+        except UserPrivacyRestrictedError:
+            await utils.answer(message, self.strings("name_privacy_error"))
+        except Exception as e:
+            logger.error(f"Error removing name: {e}")
+            await utils.answer(message, self.strings("error"))
 
     @loader.command(
         ru_doc="Вывести таймер",

archquise/H.Modules/CodeShare.py

@@ -35,6 +35,7 @@ from telethon.types import MessageMediaDocument
 
 logger = logging.getLogger(__name__)
 
+
 @loader.tds
 class CodeShareMod(loader.Module):
     """Uploads your code at the kmi.aeza.net (Pastebin and GitHub Gist alternative)"""
@@ -55,16 +56,16 @@ class CodeShareMod(loader.Module):
     async def upload_to_kmi(self, content: str) -> str:
         url = "https://kmi.aeza.net"
         data = aiohttp.FormData()
-        data.add_field('kmi', content)
+        data.add_field("kmi", content)
 
         async with aiohttp.ClientSession() as session:
-                async with session.post(url, data=data) as response:
-                    if response.status == 200:
-                        link = await response.text()
-                        return link
-                    else:
-                       logger.error(f"Error occurred! Status code: {response.status}")
-                       return
+            async with session.post(url, data=data) as response:
+                if response.status == 200:
+                    link = await response.text()
+                    return link
+                else:
+                    logger.error(f"Error occurred! Status code: {response.status}")
+                    return
 
     @loader.command(
         ru_doc="Загрузка кода на сайт",
@@ -75,20 +76,14 @@ class CodeShareMod(loader.Module):
         reply = await message.get_reply_message()
         if args:
             link = await self.upload_to_kmi(args)
-            await utils.answer(message, self.strings['link_ready'].format(link))
+            await utils.answer(message, self.strings["link_ready"].format(link))
             return
         if reply and isinstance(reply.media, MessageMediaDocument):
             file_name = await reply.download_media()
-            async with aiofiles.open(file_name, mode='r') as f:
+            async with aiofiles.open(file_name, mode="r") as f:
                 content = await f.read()
             link = await self.upload_to_kmi(content)
-            os.remove(file_name)
-            await utils.answer(message, self.strings['link_ready'].format(link))
+            await os.remove(file_name)
+            await utils.answer(message, self.strings["link_ready"].format(link))
             return
-        await utils.answer(message, self.strings['invalid_args'])
-            
-
-
-
-
-
+        await utils.answer(message, self.strings["invalid_args"])

archquise/H.Modules/EmojiStickerBlocker.py

@@ -31,7 +31,6 @@ import re
 from typing import Optional, Set
 
 from telethon.errors import FloodWaitError, MessageDeleteForbiddenError
-from telethon.tl.functions.messages import DeleteMessagesRequest
 from telethon.tl.types import Message, MessageMediaDocument
 
 from .. import loader, utils
@@ -82,17 +81,20 @@ class EmojiStickerBlocker(loader.Module):
         self.blocked_packs: Set[str] = set()
         self.blocked_stickers: Set[str] = set()
         self.blocked_emojis: Set[str] = set()
+        self._client = None
+        self._db = None
 
+    async def client_ready(self, client, db):
+        self._client = client
+        self._db = db
         self._load_blocklists()
 
     def _load_blocklists(self):
-        """Load blocklists from database"""
         self.blocked_packs = set(self._db.get(__name__, "blocked_packs", []))
         self.blocked_stickers = set(self._db.get(__name__, "blocked_stickers", []))
         self.blocked_emojis = set(self._db.get(__name__, "blocked_emojis", []))
 
     def _save_blocklists(self):
-        """Save blocklists to database"""
         self._db.set(__name__, "blocked_packs", list(self.blocked_packs))
         self._db.set(__name__, "blocked_stickers", list(self.blocked_stickers))
         self._db.set(__name__, "blocked_emojis", list(self.blocked_emojis))
@@ -107,9 +109,15 @@ class EmojiStickerBlocker(loader.Module):
                 return message.sticker.set_name.lower()
 
         if isinstance(message.media, MessageMediaDocument):
-            if hasattr(message.media.document, "attributes"):
+            if hasattr(message.media, "document") and hasattr(
+                message.media.document, "attributes"
+            ):
                 for attr in message.media.document.attributes:
-                    if hasattr(attr, "stickerset") and attr.stickerset:
+                    if (
+                        hasattr(attr, "stickerset")
+                        and hasattr(attr.stickerset, "title")
+                        and attr.stickerset.title
+                    ):
                         return attr.stickerset.title.lower()
 
         return None
@@ -126,19 +134,18 @@ class EmojiStickerBlocker(loader.Module):
 
         if emojis:
             return emojis[0]
-        else:
-            return None
+        return None
 
     async def _delete_message(self, message: Message) -> bool:
         """Delete message with error handling"""
         try:
-            await self._client(DeleteMessagesRequest([message.id]))
+            await self._client.delete_messages(message.to_id, [message.id])
             return True
         except MessageDeleteForbiddenError:
-            await utils.answer(message, self.strings["no_permission"])
+            logger.warning("No permission to delete message")
             return False
         except FloodWaitError as e:
-            logger.warning(f"Flood wait when deleting message: {e}")
+            logger.warning(f"Flood wait when deleting message: {e.seconds}s")
             return False
         except Exception as e:
             logger.error(f"Error deleting message: {e}")
@@ -146,19 +153,23 @@ class EmojiStickerBlocker(loader.Module):
 
     async def _should_block_message(self, message: Message) -> tuple[bool, str]:
         """Check if message should be blocked and return reason"""
-        pack_name = self._extract_pack_name(message)
-        emoji_text = self._extract_emoji_text(message)
+        try:
+            pack_name = self._extract_pack_name(message)
+            emoji_text = self._extract_emoji_text(message)
 
-        if pack_name and pack_name in self.blocked_packs:
-            return True, f"pack: {pack_name}"
+            if pack_name and pack_name in self.blocked_packs:
+                return True, f"pack: {pack_name}"
 
-        if message.sticker:
-            sticker_id = str(message.sticker.id)
-            if sticker_id in self.blocked_stickers:
-                return True, f"sticker: {sticker_id}"
+            if message.sticker:
+                sticker_id = str(message.sticker.id)
+                if sticker_id in self.blocked_stickers:
+                    return True, f"sticker: {sticker_id}"
 
-        if emoji_text and emoji_text in self.blocked_emojis:
-            return True, f"emoji: {emoji_text}"
+            if emoji_text and emoji_text in self.blocked_emojis:
+                return True, f"emoji: {emoji_text}"
+
+        except Exception as e:
+            logger.error(f"Error checking message: {e}")
 
         return False, ""
 
@@ -174,7 +185,9 @@ class EmojiStickerBlocker(loader.Module):
 
         pack_name = args.lower().strip()
 
-        # Add to blocked packs
+        if pack_name in self.blocked_packs:
+            return await utils.answer(message, self.strings["not_found"])
+
         self.blocked_packs.add(pack_name)
         self._save_blocklists()
 
@@ -194,6 +207,10 @@ class EmojiStickerBlocker(loader.Module):
             return await utils.answer(message, self.strings["no_reply"])
 
         sticker_id = str(reply_msg.sticker.id)
+
+        if sticker_id in self.blocked_stickers:
+            return await utils.answer(message, self.strings["not_found"])
+
         self.blocked_stickers.add(sticker_id)
         self._save_blocklists()
 
@@ -206,6 +223,7 @@ class EmojiStickerBlocker(loader.Module):
     async def emojiblock(self, message: Message):
         """Block emoji from reply or input"""
         args = utils.get_args_raw(message)
+        emoji_text = None
 
         if args:
             emoji_text = args.strip()
@@ -223,6 +241,9 @@ class EmojiStickerBlocker(loader.Module):
             if not emoji_text:
                 return await utils.answer(message, self.strings["no_reply"])
 
+        if emoji_text in self.blocked_emojis:
+            return await utils.answer(message, self.strings["not_found"])
+
         self.blocked_emojis.add(emoji_text)
         self._save_blocklists()
 
@@ -326,6 +347,8 @@ class EmojiStickerBlocker(loader.Module):
 
     async def watcher(self, message: Message):
         """Monitor messages and block unwanted content"""
+        if not self._client or not self._db:
+            return
 
         if message.is_group or message.is_channel:
             return

archquise/H.Modules/README.md

@@ -1,91 +1,184 @@
 <div align="center">
-  <img src="https://github.com/Codwizer/ReModules/blob/main/assets/Vector.png" alt="hikka_mods" width="600">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/Codwizer/ReModules/blob/main/assets/Vector.png">
+    <img src="https://github.com/Codwizer/ReModules/blob/main/assets/Vector.png" alt="H:Mods Logo" width="400">
+  </picture>
 </div>
 
-<h1 align="center">H:Mods - Hikka Modules</h1>
+<h1 align="center">
+  <a href="https://github.com/archquise/H.Modules">
+    <img src="https://readme-typing-svg.herokuapp.com/?lines=H:Mods;Hikka+Modules+Collection&center=true&vCenter=true&width=500&height=80&color=00D9FF&center=true&vCenter=true">
+  </a>
+</h1>
 
 <p align="center">
-  Enhance your <a href="https://github.com/hikariatama/Hikka">Hikka</a>/<a href="https://github.com/coddrago/Heroku">Heroku</a> experience with a curated collection of community modules.
+  <a href="https://github.com/hikariatama/Hikka">
+    <img src="https://img.shields.io/badge/Hikka-Userbot-blue?style=for-the-badge&logo=python" alt="Hikka">
+  </a>
+  <a href="https://github.com/coddrago/Heroku">
+    <img src="https://img.shields.io/badge/Heroku-Userbot-purple?style=for-the-badge&logo=heroku" alt="Heroku">
+  </a>
 </p>
 
 <p align="center">
   <a href="https://t.me/hikka_mods">
-    <img src="https://img.shields.io/badge/Join%20the-Telegram%20Channel-blue?style=flat-square&logo=telegram" alt="Telegram Channel">
+    <img src="https://img.shields.io/badge/Telegram%20Channel-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram Channel">
+  </a>
+  <a href="https://github.com/archquise/H.Modules">
+    <img src="https://img.shields.io/badge/GitHub-Repository-181717?style=for-the-badge&logo=github" alt="GitHub">
+  </a>
+  <a href="https://github.com/archquise/H.Modules/stargazers">
+    <img src="https://img.shields.io/github/stars/archquise/H.Modules?style=for-the-badge&logo=github&color=yellow" alt="Stars">
   </a>
 </p>
 
 ---
 
-## ✨ Installation Guide
+## 🚀 Quick Start
 
-### 1. Direct Installation
-
-To install a module directly from the repository, use the following command:
-
-
-```bash
-.dlm https://raw.githubusercontent.com/archquise/H.Modules/main/<module_name>.py
-```
-**Example:** To install example_module.py, use:
-
-
-```bash
-.dlm https://raw.githubusercontent.com/archquise/H.Modules/main/example_module.py
-```
-### 2. Repository Installation (Recommended)
-
-For easier module management and updates, install the entire repository.
-
-**Step 1: Add the Repository**
+### 📦 Repository Installation (Recommended)
 
+The easiest way to install and manage all modules:
 
 ```bash
 .addrepo https://github.com/archquise/H.Modules/raw/main
 ```
 
-**Step 2: Install Modules from the Repository**
+After adding the repository, install any module:
 
 ```bash
 .dlm <module_name>
 ```
-**Example:** After adding the repository, to install example_module, use:
+
+### 🎯 Direct Installation
+
+Install a specific module directly:
 
 ```bash
-.dlm example_module
+.dlm https://raw.githubusercontent.com/archquise/H.Modules/main/<module_name>.py
 ```
+
 ---
 
-## 📜 License
+## 🛠️ Installation Guide
 
-This project is licensed under a **Proprietary License**. By using this software, you agree to the terms and conditions outlined below.
+### Step 1: Add Repository
 
-> **You are granted permission to use the Software for personal and non-commercial purposes, subject to the following conditions:**
+```bash
+.addrepo https://github.com/archquise/H.Modules/raw/main
+```
 
-1.  Modification or alteration of the Software is strictly prohibited without explicit written permission from the author.
-2.  Redistribution of the Software, in original or modified form, is strictly prohibited without explicit written permission from the author.
-3.  The Software is provided "as is", without any warranty, express or implied.
-4.  The copyright notice and this permission notice must be included in all copies or substantial portions of the Software.
-5.  By using the Software, you agree to be bound by the terms and conditions of this license.
+### Step 2: Install Modules
 
-**Contact:** For any inquiries or requests for permissions, please contact archquise@gmail.com.
+```bash
+# Install specific module
+.dlm TelegraphComic
+
+
+# Install from direct URL
+.dlm https://raw.githubusercontent.com/archquise/H.Modules/main/TelegraphComic.py
+```
+
+### Step 4: Configure Modules
+
+Most modules have configurable settings:
+
+```bash
+# View module configuration
+.config TelegraphComic
+
+# Update configuration
+.config TelegraphComic upload_service catbox
+```
+
+## 🐛 Troubleshooting
+
+### Common Issues
 
 <details>
-  <summary>Show Full License Details</summary>
-  > <i>All files of this repository are under <b>Proprietary License.</b></i><br>
-  > <b>Permission is hereby granted to any person obtaining a copy of this software and associated documentation files (the "Software"), to use the Software for personal and non-commercial purposes, subject to the following conditions:</b>
+  <summary>❌ Module Installation Failed</summary>
 
-  1. The Software may not be modified, altered, or otherwise changed in any way without the explicit written permission of the author.
-  2. Redistribution of the Software, in original or modified form, is strictly prohibited without the explicit written permission of the author.
-  3. The Software is provided "as is", without warranty of any kind, express or implied.
-  4. The copyright notice and this permission notice must be included in all copies or substantial portions of the Software.
-  5. By using the Software, you agree to be bound by the terms and conditions of this license.
+**Solution:**
+
+1. Check repository URL is correct
+2. Ensure you have internet connection
+3. Try restarting Hikka/Heroku
+4. Use direct installation method
+
+```bash
+.dlm https://raw.githubusercontent.com/archquise/H.Modules/main/<module_name>.py
+```
+
+</details>
+
+<details>
+  <summary>⚠️ Module Not Working</summary>
+
+**Solution:**
+2. Check configuration: `.cfg <module_name>`
+3. Check dependencies are installed
+4. Update the module: `.dlm <module_name>`
+
+</details>
+
+<details>
+  <summary>🔧 Configuration Issues</summary>
+
+**Solution:**
+
+1. Reset to defaults: `.cfg <module_name> reset`
+2. Check syntax: `.cfg <module_name>`
+3. View help: `.help <module_name>`
 
-  For any inquiries or requests for permissions, please contact archquise@gmail.com.
 </details>
 
 ---
 
-<p align="center">
-    <img src="https://raw.githubusercontent.com/trinib/trinib/82213791fa9ff58d3ca768ddd6de2489ec23ffca/images/footer.svg" width="100%">
-</p>
+## 📜 License
 
+<div align="center">
+
+**🔒 Proprietary License**
+
+This project is licensed under a proprietary license. By using this software, you agree to the following terms:
+
+</div>
+
+### 📋 License Terms
+
+> **✅ What You CAN Do:**
+
+> - Use the software for personal and non-commercial purposes
+> - Install and use modules in Hikka/Heroku
+> - Modify configuration settings
+> - Report issues and suggest improvements
+
+> **❌ What You CANNOT Do:**
+
+> - Modify, alter, or change the software without explicit permission
+> - Redistribute the software in original or modified form
+> - Use for commercial purposes without permission
+> - Remove copyright notices or attribution
+
+### 📧 Contact
+
+For inquiries or permission requests:
+
+- **Email:** `archquise@gmail.com`
+- **Telegram:** [@hikka_mods](https://t.me/hikka_mods)
+
+---
+
+<div align="center">
+  <picture>
+    <img src="https://raw.githubusercontent.com/trinib/trinib/82213791fa9ff58d3ca768ddd6de2489ec23ffca/images/footer.svg" alt="Footer" width="100%">
+  </picture>
+  
+  <p>
+    <sub>Built with ❤️ for the Hikka/Heroku community</sub>
+  </p>
+  
+  <p>
+    <a href="#top">⬆️ Back to Top</a>
+  </p>
+</div>

archquise/H.Modules/TelegraphComic.py

@@ -0,0 +1,536 @@
+# Proprietary License Agreement
+
+# Copyright (c) 2026-2029 CodWiz
+
+# Permission is hereby granted to any person obtaining a copy of this software and associated documentation files (the "Software"), to use the Software for personal and non-commercial purposes, subject to the following conditions:
+
+# 1. The Software may not be modified, altered, or otherwise changed in any way without the explicit written permission of the author.
+
+# 2. Redistribution of the Software, in original or modified form, is strictly prohibited without the explicit written permission of the author.
+
+# 3. 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 non-infringement. In no event shall the author or copyright holder 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.
+
+# 4. Any use of the Software must include the above copyright notice and this permission notice in all copies or substantial portions of the Software.
+
+# 5. By using the Software, you agree to be bound by the terms and conditions of this license.
+
+# For any inquiries or requests for permissions, please contact codwiz@yandex.ru.
+
+# ---------------------------------------------------------------------------------
+# Name: TelegraphComics
+# Description: Create comics on Telegraph from ZIP/RAR archives
+# Author: @hikka_mods
+# ---------------------------------------------------------------------------------
+# meta developer: @hikka_mods
+# requires: aiohttp, zipfile, telegraph
+# ---------------------------------------------------------------------------------
+
+import asyncio
+import logging
+import os
+import tempfile
+from typing import List, Optional
+import zipfile
+
+import aiohttp
+from telethon.types import MessageMediaDocument, Message
+
+from telegraph import Telegraph
+
+from .. import loader, utils
+
+logger = logging.getLogger(__name__)
+
+
+@loader.tds
+class TelegraphComicMod(loader.Module):
+    """Create comics on Telegraph from ZIP/CBZ/RAR archives"""
+
+    strings = {
+        "name": "TelegraphComic",
+        "invalid_args": "<emoji document_id=5388785832956016892>❌</emoji> Invalid arguments. Usage: .telegraphcomics <title> | <cover_url> (optional)",
+        "no_reply": "<emoji document_id=5388785832956016892>❌</emoji> Reply to a message with ZIP/CBZ/RAR file",
+        "unsupported_format": "<emoji document_id=5388785832956016892>❌</emoji> Unsupported file format. Only ZIP/CBZ/RAR files are supported",
+        "processing": "<emoji document_id=5256094480498436162>⏳</emoji> Processing archive...",
+        "uploading": "<emoji document_id=5854762571659218443>⏳</emoji> Uploading images...",
+        "creating_article": "<emoji document_id=5854762571659218443>⏳</emoji> Creating Telegraph article...",
+        "archive_extracted": "<emoji document_id=5854762571659218443>📦</emoji> Archive successfully extracted: <emoji document_id=5208422125924275090>✅</emoji>",
+        "upload_files": "<emoji document_id=5854762571659218443>📦</emoji> Upload image files:",
+        "creating_telegraph": "<emoji document_id=5854762571659218443>📝</emoji> Creating Telegraph article:",
+        "success": '<emoji document_id=5208422125924275090>✅</emoji> <b>Telegraph article created!</b>\n\n<emoji document_id=5256094480498436162>📦</emoji> Archive successfully extracted: <emoji document_id=5208422125924275090>✅</emoji>\n\n<emoji document_id=5256094480498436162>📦</emoji> Upload image files:\n{upload_status}\n\n<emoji document_id=5256230583717079814>📝</emoji> Creating Telegraph article:\n{article_status}\n\n<emoji document_id=5271604874419647061>🔗</emoji> <a href="{url}">{url}</a>',
+        "error": "<emoji document_id=5854929766146118183>❌</emoji> <b>Error:</b> {}",
+        "_cls_doc": "Create comics on Telegraph from ZIP/CBZ/RAR archives",
+    }
+
+    strings_ru = {
+        "_cls_doc": "Создание комиксов на Telegraph из ZIP/CBZ/RAR архивов",
+        "invalid_args": "<emoji document_id=5388785832956016892>❌</emoji> Неверные аргументы. Использование: .telegraphcomics <название> | <ссылка_на_обложку>(необязательно)",
+        "no_reply": "<emoji document_id=5388785832956016892>❌</emoji> Ответьте на сообщение с ZIP/CBZ/RAR файлом",
+        "unsupported_format": "<emoji document_id=5388785832956016892>❌</emoji> Неподдерживаемый формат. Только ZIP/CBZ/RAR файлы",
+        "processing": "<emoji document_id=5256094480498436162>⏳</emoji> Обработка архива...",
+        "uploading": "<emoji document_id=5256094480498436162>⏳</emoji> Загрузка изображений...",
+        "creating_article": "<emoji document_id=5854762571659218443>⏳</emoji> Создание Telegraph статьи...",
+        "archive_extracted": "<emoji document_id=5256094480498436162>📦</emoji> Архив успешно распакован: <emoji document_id=5208422125924275090>✅</emoji>",
+        "upload_files": "<emoji document_id=5256094480498436162>📦</emoji> Загрузка файлов изображений:",
+        "creating_telegraph": "<emoji document_id=5854762571659218443>📝</emoji> Создание Telegraph статьи:",
+        "success": '<emoji document_id=5208422125924275090>✅</emoji> <b>Telegraph статья создана!</b>\n\n<emoji document_id=5256094480498436162>📦</emoji> Архив успешно распакован: <emoji document_id=5208422125924275090>✅</emoji>\n\n<emoji document_id=5256094480498436162>📦</emoji> Загрузка файлов изображений:\n{upload_status}\n\n<emoji document_id=5256230583717079814>📝</emoji> Создание Telegraph статьи:\n{article_status}\n\n<emoji document_id=5271604874419647061>🔗</emoji> <a href="{url}">{url}</a>',
+        "error": "<emoji document_id=5388785832956016892>❌</emoji> <b>Ошибка:</b> {}",
+        "available_services": "Доступные сервисы: catbox, bashupload, kappa, x0, tmpfiles, pomf",
+        "current_service": "Текущий сервис: {}",
+        "invalid_service": "❌ Неизвестный сервис: {}\n\n{}",
+    }
+
+    def __init__(self):
+        self.config = loader.ModuleConfig(
+            loader.ConfigValue(
+                "upload_service",
+                "catbox",
+                "Upload service to use",
+                validator=loader.validators.Choice(
+                    ["catbox", "bashupload", "kappa", "x0", "tmpfiles", "pomf"]
+                ),
+            ),
+            loader.ConfigValue(
+                "short_name",
+                "HikkaMods",
+                "short name for the article",
+                validator=loader.validators.String(),
+            ),
+            loader.ConfigValue(
+                "author_name",
+                "HikkaMods",
+                "nickname of the author of the article",
+                validator=loader.validators.String(),
+            ),
+            loader.ConfigValue(
+                "author_url",
+                "https://t.me/hikka_mods",
+                "link to author",
+                validator=loader.validators.String(),
+            ),
+        )
+
+    async def client_ready(self, client, db):
+        self.client = client
+        self.db = db
+        self.telegraph = Telegraph()
+        self.telegraph.create_account(
+            short_name=self.config["short_name"],
+            author_name=self.config["author_name"],
+            author_url=self.config["author_url"],
+        )
+
+    async def _upload_file_to_service(
+        self,
+        session: aiohttp.ClientSession,
+        url: str,
+        file_path: str,
+        field_name: str,
+        **extra_fields,
+    ) -> Optional[str]:
+        """Generic file upload method"""
+        try:
+            with open(file_path, "rb") as f:
+                data = aiohttp.FormData()
+                data.add_field(field_name, f, filename=os.path.basename(file_path))
+
+                for key, value in extra_fields.items():
+                    data.add_field(key, value)
+
+                async with session.post(url, data=data) as response:
+                    if response.status == 200:
+                        result = await response.text()
+                        return result.strip() if result else None
+                    else:
+                        logger.info(
+                            f"Upload failed with status {response.status}: {await response.text()}"
+                        )
+        except Exception as e:
+            logger.info(f"Error uploading to {url}: {e}")
+        return None
+
+    async def upload_to_catbox(self, file_path: str) -> Optional[str]:
+        """Upload file to catbox.moe"""
+        async with aiohttp.ClientSession() as session:
+            result = await self._upload_file_to_service(
+                session,
+                "https://catbox.moe/user/api.php",
+                file_path,
+                "fileToUpload",
+                reqtype="fileupload",
+            )
+            return (
+                result
+                if result and result.startswith("https://files.catbox.moe/")
+                else None
+            )
+
+    async def upload_to_bashupload(self, file_path: str) -> Optional[str]:
+        """Upload file to bashupload.com"""
+        async with aiohttp.ClientSession() as session:
+            try:
+                with open(file_path, "rb") as f:
+                    data = aiohttp.FormData()
+                    data.add_field("file", f, filename=os.path.basename(file_path))
+
+                    async with session.post(
+                        "https://bashupload.com", data=data
+                    ) as response:
+                        if response.status == 200:
+                            result = await response.text()
+
+                            lines = result.strip().split("\n")
+                            for line in lines:
+                                if line.startswith("https://"):
+                                    return line
+
+                            if "wget" in result:
+                                urls = [
+                                    line
+                                    for line in result.split("\n")
+                                    if "wget" in line
+                                ]
+                                if urls:
+                                    parts = urls[0].split()
+                                    for part in parts:
+                                        if part.startswith("https://"):
+                                            return part
+            except Exception as e:
+                logger.info(f"Error uploading to bashupload: {e}")
+        return None
+
+    async def upload_to_kappa(self, file_path: str) -> Optional[str]:
+        """Upload file to kappa.lol"""
+        async with aiohttp.ClientSession() as session:
+            try:
+                with open(file_path, "rb") as f:
+                    data = aiohttp.FormData()
+                    data.add_field("file", f, filename=os.path.basename(file_path))
+
+                    async with session.post(
+                        "https://kappa.lol/api/upload", data=data
+                    ) as response:
+                        if response.status == 200:
+                            result = await response.json()
+                            if result and "id" in result:
+                                return f"https://kappa.lol/{result['id']}"
+            except Exception as e:
+                logger.info(f"Error uploading to kappa: {e}")
+        return None
+
+    async def upload_to_x0(self, file_path: str) -> Optional[str]:
+        """Upload file to x0.at"""
+        async with aiohttp.ClientSession() as session:
+            try:
+                with open(file_path, "rb") as f:
+                    data = aiohttp.FormData()
+                    data.add_field("file", f, filename=os.path.basename(file_path))
+
+                    async with session.post("https://x0.at", data=data) as response:
+                        if response.status == 200:
+                            result = await response.text()
+                            return (
+                                result.strip()
+                                if result and "https://" in result
+                                else None
+                            )
+            except Exception as e:
+                logger.info(f"Error uploading to x0: {e}")
+        return None
+
+    async def upload_to_tmpfiles(self, file_path: str) -> Optional[str]:
+        """Upload file to tmpfiles.org"""
+        async with aiohttp.ClientSession() as session:
+            try:
+                with open(file_path, "rb") as f:
+                    data = aiohttp.FormData()
+                    data.add_field("file", f, filename=os.path.basename(file_path))
+
+                    async with session.post(
+                        "https://tmpfiles.org/api/v1/upload", data=data
+                    ) as response:
+                        if response.status == 200:
+                            result = await response.json()
+                            if result and "data" in result and "url" in result["data"]:
+                                return result["data"]["url"]
+            except Exception as e:
+                logger.info(f"Error uploading to tmpfiles: {e}")
+        return None
+
+    async def upload_to_pomf(self, file_path: str) -> Optional[str]:
+        """Upload file to pomf.lain.la"""
+        async with aiohttp.ClientSession() as session:
+            try:
+                with open(file_path, "rb") as f:
+                    data = aiohttp.FormData()
+                    data.add_field("files[]", f, filename=os.path.basename(file_path))
+
+                    async with session.post(
+                        "https://pomf.lain.la/upload.php", data=data
+                    ) as response:
+                        if response.status == 200:
+                            result = await response.json()
+                            if result and "files" in result and result["files"]:
+                                return result["files"][0].get("url")
+            except Exception as e:
+                logger.info(f"Error uploading to pomf: {e}")
+        return None
+
+    async def upload_file(self, file_path: str) -> Optional[str]:
+        """Upload file to selected service"""
+        service_name = self.config["upload_service"]
+
+        service_map = {
+            "catbox": self.upload_to_catbox,
+            "bashupload": self.upload_to_bashupload,
+            "kappa": self.upload_to_kappa,
+            "x0": self.upload_to_x0,
+            "tmpfiles": self.upload_to_tmpfiles,
+            "pomf": self.upload_to_pomf,
+        }
+
+        service_func = service_map.get(service_name)
+        if not service_func:
+            return await self.upload_to_catbox(file_path)
+
+        try:
+            result = await service_func(file_path)
+            return result
+        except Exception as e:
+            logger.error(f"Upload to {service_name} failed: {e}")
+            return None
+
+    async def extract_zip_archive(self, zip_path: str, extract_dir: str) -> List[str]:
+        """Extract ZIP archive and return sorted list of image files"""
+        image_extensions = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".avif"}
+        image_files = []
+
+        try:
+            with zipfile.ZipFile(zip_path, "r") as zip_ref:
+                zip_ref.extractall(extract_dir)
+
+                for root, _, files in os.walk(extract_dir):
+                    for file in files:
+                        if os.path.splitext(file)[1].lower() in image_extensions:
+                            image_files.append(os.path.join(root, file))
+
+                image_files.sort(key=lambda x: os.path.basename(x).lower())
+
+        except Exception as e:
+            logger.info(f"Error extracting ZIP archive: {e}")
+
+        return image_files
+
+    async def create_telegraph_article(
+        self, title: str, image_urls: List[str], cover_url: Optional[str] = None
+    ) -> Optional[str]:
+        """Create Telegraph article with images"""
+        try:
+            if cover_url:
+                content = f'<img src="{cover_url}"/><br>'
+                content += "<br>".join(f'<img src="{url}"/>' for url in image_urls)
+            else:
+                content = "<br>".join(f'<img src="{url}"/>' for url in image_urls)
+
+            response = await asyncio.to_thread(
+                lambda: self.telegraph.create_page(
+                    title=title,
+                    html_content=content,
+                    author_name=self.config["author_name"],
+                    author_url=self.config["author_url"],
+                )
+            )
+
+            return response["url"]
+
+        except Exception as e:
+            logger.info(f"Error creating Telegraph article: {e}")
+            return None
+
+    async def _process_cover_url(self, cover_url: str) -> Optional[str]:
+        """Process cover URL - handle Telegram message links and direct URLs"""
+        if not cover_url:
+            return None
+
+        cover_url = cover_url.strip()
+
+        if "t.me/" in cover_url and "/" in cover_url.split("t.me/")[1]:
+            try:
+                parts = cover_url.split("/")
+                if len(parts) >= 4:
+                    chat_username = parts[-3]
+                    message_id = int(parts[-1])
+
+                    message = await self.client.get_messages(
+                        chat_username, ids=message_id
+                    )
+                    if message and message.media:
+                        media_path = await message.download_media()
+                        if media_path:
+                            uploaded_url = await self.upload_file(media_path)
+                            os.remove(media_path)
+                            return uploaded_url
+            except Exception as e:
+                logger.info(f"Error processing Telegram cover link: {e}")
+                return cover_url
+
+        return cover_url
+
+    async def _process_comics_request(self, message, create_func) -> None:
+        """Common logic for processing comics requests"""
+        args = utils.get_args_raw(message)
+        reply = await message.get_reply_message()
+
+        if not args or not reply:
+            await utils.answer(message, self.strings["invalid_args"])
+            return
+
+        if not isinstance(reply.media, MessageMediaDocument):
+            await utils.answer(message, self.strings["no_reply"])
+            return
+
+        if "|" in args:
+            title, cover_url = args.split("|", 1)
+        else:
+            title = args
+            cover_url = None
+
+        title = title.strip()
+        cover_url = (
+            await self._process_cover_url(cover_url.strip()) if cover_url else None
+        )
+
+        await utils.answer(message, self.strings["processing"])
+
+        file_path = await reply.download_media()
+        if not file_path:
+            await utils.answer(
+                message, self.strings["error"].format("Failed to download file")
+            )
+            return
+
+        try:
+            if not (file_path.lower().endswith((".zip", ".cbz"))):
+                await utils.answer(message, self.strings["unsupported_format"])
+                return
+
+            with tempfile.TemporaryDirectory() as temp_dir:
+                archive_path = file_path
+                if file_path.lower().endswith(".cbz"):
+                    import shutil
+
+                    zip_path = file_path[:-4] + ".zip"
+                    shutil.copy2(file_path, zip_path)
+                    archive_path = zip_path
+
+                image_files = await self.extract_zip_archive(archive_path, temp_dir)
+
+                if archive_path != file_path and os.path.exists(archive_path):
+                    os.remove(archive_path)
+                if not image_files:
+                    await utils.answer(
+                        message,
+                        self.strings["error"].format("No images found in archive"),
+                    )
+                    return
+
+                await utils.answer(message, self.strings["archive_extracted"])
+
+                await utils.answer(message, self.strings["uploading"])
+
+                upload_tasks = [self.upload_file(img_file) for img_file in image_files]
+                upload_results = await asyncio.gather(
+                    *upload_tasks, return_exceptions=True
+                )
+                image_urls = []
+                failed_uploads = 0
+                upload_errors = []
+                upload_status_lines = []
+
+                for i, (img_file, result) in enumerate(
+                    zip(image_files, upload_results)
+                ):
+                    filename = os.path.basename(img_file)
+                    if isinstance(result, Exception):
+                        error_str = str(result)
+                        logger.info(f"Upload failed: {error_str}")
+                        failed_uploads += 1
+                        upload_errors.append(error_str)
+                        upload_status_lines.append(
+                            f"{filename} - <emoji document_id=5388785832956016892>❌</emoji>"
+                        )
+                    elif result and "https://" in result:
+                        image_urls.append(result)
+                        upload_status_lines.append(
+                            f"{filename} - <emoji document_id=5208422125924275090>✅</emoji>"
+                        )
+                    else:
+                        failed_uploads += 1
+                        upload_errors.append("Invalid response from upload service")
+                        upload_status_lines.append(
+                            f"{filename} - <emoji document_id=5388785832956016892>❌</emoji>"
+                        )
+
+                if not image_urls:
+                    error_details = []
+                    error_details.append(f"Failed uploads: {failed_uploads}")
+
+                    if upload_errors:
+                        unique_errors = list(set(upload_errors))[:3]
+                        error_details.append("Errors: " + "; ".join(unique_errors))
+
+                    error_msg = " | ".join(error_details)
+                    await utils.answer(
+                        message,
+                        self.strings["error"].format(error_msg),
+                    )
+                    return
+
+                upload_status = (
+                    self.strings["upload_files"] + "\n" + "\n".join(upload_status_lines)
+                )
+                await utils.answer(message, upload_status)
+
+                await utils.answer(message, self.strings["creating_article"])
+
+                article_url = await create_func(title, image_urls, cover_url)
+                if article_url:
+                    article_status_lines = []
+                    for i, (img_file, url) in enumerate(zip(image_files, image_urls)):
+                        filename = os.path.basename(img_file)
+                        article_status_lines.append(
+                            f"{filename} - <emoji document_id=5208422125924275090>✅</emoji>"
+                        )
+
+                    upload_status = "\n".join(upload_status_lines)
+                    article_status = "\n".join(article_status_lines)
+
+                    await utils.answer(
+                        message,
+                        self.strings["success"].format(
+                            upload_status=upload_status,
+                            article_status=article_status,
+                            url=article_url,
+                        ),
+                    )
+
+                else:
+                    await utils.answer(
+                        message,
+                        self.strings["error"].format("Failed to create article"),
+                    )
+        except Exception as e:
+            await utils.answer(
+                message,
+                self.strings["error"].format(f"Processing error: {e}"),
+            )
+        finally:
+            if os.path.exists(file_path):
+                os.remove(file_path)
+
+    @loader.command(
+        ru_doc="Создать комикс на Telegraph из ZIP/CBZ/RAR архива\nАргументы: <название> | <ссылка_на_обложку>(необязательно)\nИспользование: .telegraphcomics <title> | <cover_url>(optional)",
+        en_doc="Create Telegraph comic from ZIP/CBZ/RAR archive\nArguments: <title> | <cover_url>(optional)\nUsage: .telegraphcomics <title> | <cover_url>(optional)",
+    )
+    async def telegraphcomicscmd(self, message):
+        await self._process_comics_request(message, self.create_telegraph_article)

archquise/H.Modules/TimedEmojiStatus.py

@@ -185,20 +185,25 @@ class TimedEmojiStatusMod(loader.Module):
             return "❌"
 
         if document_id:
-            return f"<emoji document_id={document_id}>📋</emoji>"
+            return f"[Custom Emoji ID: {document_id}]"
 
         if emoji_str.isdigit():
-            return f"<emoji document_id={emoji_str}>📋</emoji>"
+            return f"[Custom Emoji ID: {emoji_str}]"
 
         if "<emoji document_id=" in emoji_str:
-            return emoji_str
+         
+            import re
+            match = re.search(r'document_id=(\d+)', emoji_str)
+            if match:
+                return f"[Custom Emoji ID: {match.group(1)}]"
+            return "[Custom Emoji]"
 
         if len(emoji_str) == 1 or (
             len(emoji_str) <= 4 and all(ord(c) >= 0x1F000 for c in emoji_str)
         ):
             return emoji_str
 
-        return emoji_str
+        return emoji_str[:10] + "..." if len(emoji_str) > 10 else emoji_str
 
     async def _set_emoji_status(
         self, emoji_input: str, until: datetime | None = None, message: Message = None

archquise/H.Modules/VirusTotal.py

@@ -38,6 +38,7 @@ from .. import loader, utils
 
 logger = logging.getLogger(__name__)
 
+
 @loader.tds
 class VirusTotalMod(loader.Module):
     """Professional file scanning with VirusTotal"""

archquise/H.Modules/caliases.py

@@ -0,0 +1,223 @@
+# Proprietary License Agreement
+
+# Copyright (c) 2024-29 CodWiz
+
+# Permission is hereby granted to any person obtaining a copy of this software and associated documentation files (the "Software"), to use the Software for personal and non-commercial purposes, subject to the following conditions:
+
+# 1. The Software may not be modified, altered, or otherwise changed in any way without the explicit written permission of the author.
+
+# 2. Redistribution of the Software, in original or modified form, is strictly prohibited without the explicit written permission of the author.
+
+# 3. 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 non-infringement. In no event shall the author or copyright holder 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.
+
+# 4. Any use of the Software must include the above copyright notice and this permission notice in all copies or substantial portions of the Software.
+
+# 5. By using the Software, you agree to be bound by the terms and conditions of this license.
+
+# For any inquiries or requests for permissions, please contact codwiz@yandex.ru.
+
+# ---------------------------------------------------------------------------------
+# Name: CAliases
+# Description: Module for custom aliases
+# Author: @hikka_mods
+# ---------------------------------------------------------------------------------
+# meta developer: @hikka_mods
+# scope: CAliases
+# scope: CAliases 0.0.1
+# ---------------------------------------------------------------------------------
+
+import logging
+from typing import Dict, Optional
+
+from telethon import types
+
+from .. import loader, utils
+
+logger = logging.getLogger(__name__)
+
+
+@loader.tds
+class CustomAliasesMod(loader.Module):
+    """Module for custom aliases"""
+
+    strings = {
+        "name": "CAliases",
+        "c404": "<emoji document_id=5312526098750252863>❌</emoji> <b>Command <code>{}</code> not found!</b>",
+        "a404": "<emoji document_id=5312526098750252863>❌</emoji> <b>Custom alias <code>{}</code> not found!</b>",
+        "no_args": "<emoji document_id=5312526098750252863>❌</emoji> <b>You must specify two args: alias name and command</b>",
+        "added": (
+            "<emoji document_id=5314250708508220914>✅</emoji> <b>Custom alias <i>{alias}</i> for command "
+            "<code>{prefix}{cmd}</code> successfully added!</b>\n<b>Use it like:</b> <code>{prefix}{alias}{args}</code>"
+        ),
+        "argsopt": " [args (optional)]",
+        "deleted": "<emoji document_id=5314250708508220914>✅</emoji> <b>Custom alias <code>{}</code> successfully deleted</b>",
+        "list": "<emoji document_id=5974492756494519709>🔗</emoji> <b>Custom aliases ({len}):</b>\n",
+        "no_aliases": "<emoji document_id=5312526098750252863>❌</emoji> <b>You have no custom aliases!</b>",
+    }
+
+    strings_ru = {
+        "c404": "<emoji document_id=5312526098750252863>❌</emoji> <b>Команда <code>{}</code> не найдена!</b>",
+        "a404": "<emoji document_id=5312526098750252863>❌</emoji> <b>Кастомный алиас <code>{}</code> не найден!</b>",
+        "no_args": "<emoji document_id=5312526098750252863>❌</emoji> <b>Вы должны указать как минимум два аргумента: имя алиаса и команду</b>",
+        "added": (
+            "<emoji document_id=5314250708508220914>✅</emoji> <b>Успешно добавил алиас с названием <i>{alias}</i> "
+            "для команды <code>{prefix}{cmd}</code></b>\n<b>Используй его так:</b> <code>{prefix}{alias}{args}</code>"
+        ),
+        "argsopt": " [аргументы (необязательно)]",
+        "deleted": "<emoji document_id=5314250708508220914>✅</emoji> <b>Кастомный алиас <code>{}</code> успешно удалён</b>",
+        "list": "<emoji document_id=5974492756494519709>🔗</emoji> <b>Кастомные алиасы (всего {len}):</b>\n",
+        "no_aliases": "<emoji document_id=5312526098750252863>❌</emoji> <b>У вас нет кастомных алиасов!</b>",
+    }
+
+    def __init__(self):
+        self._aliases_cache: Optional[Dict[str, Dict[str, str]]] = None
+        self._prefix_cache: Optional[str] = None
+
+    def _get_aliases(self) -> Dict[str, Dict[str, str]]:
+        if self._aliases_cache is None:
+            self._aliases_cache = self.get("aliases", {})
+        return self._aliases_cache
+
+    def _save_aliases(self, aliases: Dict[str, Dict[str, str]]) -> None:
+        self.set("aliases", aliases)
+        self._aliases_cache = aliases
+
+    def _get_prefix(self) -> str:
+        if self._prefix_cache is None:
+            self._prefix_cache = self.get_prefix()
+        return self._prefix_cache
+
+    def _format_alias_list(self) -> str:
+        """Format aliases list for display"""
+        aliases = self._get_aliases()
+        if not aliases:
+            return self.strings["no_aliases"]
+
+        lines = [self.strings["list"].format(len=len(aliases))]
+
+        for alias_name, alias_data in aliases.items():
+            cmd = alias_data["command"]
+            if alias_data.get("args"):
+                cmd += f" {alias_data['args']}"
+
+            lines.append(
+                f"  <emoji document_id=5280726938279749656>▪️</emoji> <code>{alias_name}</code> "
+                f"<emoji document_id=5960671702059848143>👈</emoji> <code>{cmd}</code>"
+            )
+
+        return "\n".join(lines)
+
+    def _validate_command(self, cmd: str) -> bool:
+        """Check if command exists"""
+        return cmd in self.allmodules.commands
+
+    def _parse_alias_args(self, message: types.Message) -> tuple:
+        """Parse alias command arguments"""
+        raw_args = utils.get_args_raw(message)
+        if not raw_args:
+            return None, None, None
+
+        parts = raw_args.split(" ", 2)
+        if len(parts) < 2:
+            return None, None, None
+
+        alias_name = parts[0]
+        command = parts[1]
+        cmd_args = parts[2] if len(parts) > 2 else ""
+
+        return alias_name, command, cmd_args
+
+    @loader.command(
+        ru_doc="Получить список всех алиасов",
+        en_doc=" Get list of all aliases"
+    )
+    async def caliasescmd(self, message: types.Message):
+        """Get all aliases"""
+        await utils.answer(message, self._format_alias_list())
+
+    @loader.command(
+        ru_doc="<имя> Удалить алиас",
+        en_doc="<name> Remove alias"
+    )
+    async def rmcaliascmd(self, message: types.Message):
+        """Remove alias"""
+        args = utils.get_args(message)
+        if not args:
+            return await utils.answer(message, self.strings["no_args"])
+
+        alias_name = args[0]
+        aliases = self._get_aliases()
+
+        if alias_name not in aliases:
+            return await utils.answer(message, self.strings["a404"].format(alias_name))
+
+        del aliases[alias_name]
+        self._save_aliases(aliases)
+        await utils.answer(message, self.strings["deleted"].format(alias_name))
+
+    @loader.command(
+        ru_doc="<имя> <команда> [аргументы] Добавить новый алиас (может содержать ключевое слово {args})",
+        en_doc="<name> <command> [arguments] Add new alias (may contain {args} keyword)",
+    )
+    async def caliascmd(self, message: types.Message):
+        """Add new alias (may contain {args} keyword)"""
+        alias_name, command, cmd_args = self._parse_alias_args(message)
+
+        if not alias_name or not command:
+            return await utils.answer(message, self.strings["no_args"])
+
+        if not self._validate_command(command):
+            return await utils.answer(message, self.strings["c404"].format(command))
+
+        aliases = self._get_aliases()
+        aliases[alias_name] = {"command": command, "args": cmd_args}
+        self._save_aliases(aliases)
+
+        prefix = self._get_prefix()
+        full_cmd = f"{command} {cmd_args}" if cmd_args else command
+        args_display = self.strings["argsopt"] if "{args}" in cmd_args else ""
+
+        await utils.answer(
+            message,
+            self.strings["added"].format(
+                alias=alias_name,
+                prefix=prefix,
+                cmd=full_cmd,
+                args=args_display,
+            ),
+        )
+
+    @loader.tag(only_messages=True, no_media=True, no_inline=True, out=True)
+    async def watcher(self, message: types.Message):
+        """Handle alias execution"""
+        if not message.raw_text:
+            return
+
+        aliases = self._get_aliases()
+        prefix = self._get_prefix()
+        text = message.raw_text
+        first_word = text.split()[0].lower()
+
+        if not first_word.startswith(prefix):
+            return
+
+        alias_name = first_word[len(prefix) :]
+        if alias_name not in aliases:
+            return
+
+        alias_data = aliases[alias_name]
+        command = alias_data["command"]
+        template_args = alias_data.get("args", "")
+
+        user_args = utils.get_args_raw(message)
+        if user_args and template_args:
+            final_command = f"{command} {template_args}".format(args=user_args)
+        else:
+            final_command = f"{command} {template_args}" if template_args else command
+
+        try:
+            await self.allmodules.commands[command](
+                await utils.answer(message, f"{prefix}{final_command}")
+            )
+        except Exception as e:
+            logger.error(f"Error executing alias '{alias_name}': {e}")

archquise/H.Modules/coddrago/DelMessTools.py

@@ -1,7 +1,7 @@
 # ---------------------------------------------------------------------------------
-#░█▀▄░▄▀▀▄░█▀▄░█▀▀▄░█▀▀▄░█▀▀▀░▄▀▀▄░░░█▀▄▀█
-#░█░░░█░░█░█░█░█▄▄▀░█▄▄█░█░▀▄░█░░█░░░█░▀░█
-#░▀▀▀░░▀▀░░▀▀░░▀░▀▀░▀░░▀░▀▀▀▀░░▀▀░░░░▀░░▒▀
+# ░█▀▄░▄▀▀▄░█▀▄░█▀▀▄░█▀▀▄░█▀▀▀░▄▀▀▄░░░█▀▄▀█
+# ░█░░░█░░█░█░█░█▄▄▀░█▄▄█░█░▀▄░█░░█░░░█░▀░█
+# ░▀▀▀░░▀▀░░▀▀░░▀░▀▀░▀░░▀░▀▀▀▀░░▀▀░░░░▀░░▒▀
 # Name: DelMessTools
 # Description: Module to manage and delete your messages in the current chat
 # Author: @codrago_m
@@ -19,10 +19,11 @@
 
 __version__ = (1, 1, 0)
 
-from hikkatl.tl.types import Message, DocumentAttributeFilename
+from telethon.tl.types import Message, DocumentAttributeFilename
 
 from .. import loader, utils
 
+
 class DelMessTools(loader.Module):
     """Module to manage and delete your messages in the current chat"""
 
@@ -38,7 +39,12 @@ class DelMessTools(loader.Module):
         "enabled": "It's not operational now anyway.",
         "disabled": "Operation status changed to disabled.",
         "interrupted": "The deletion was interrupted because you changed your mind.",
-        "none": "You didn't even intend to delete anything here, but anyway it's disabled now."
+        "none": "You didn't even intend to delete anything here, but anyway it's disabled now.",
+        "no_args": "Please specify arguments for the command.",
+        "no_keyword": "Please specify a keyword to delete messages.",
+        "no_length": "Please specify a valid length.",
+        "invalid_time": "Invalid time format. Please use the format: YYYY-MM-DD HH:MM:SS",
+        "invalid_length": "Please specify a valid number for length.",
     }
 
     strings_ru = {
@@ -52,30 +58,58 @@ class DelMessTools(loader.Module):
         "enabled": "Оно итак сейчас не работает.",
         "disabled": "Режим работы изменен на выключено.",
         "interrupted": "Удаление было прервано т.к вы передумали.",
-        "none": "Вы даже не пытались ничего здесь удалить, в любом случае сейчас оно выключено."
+        "none": "Вы даже не пытались ничего здесь удалить, в любом случае сейчас оно выключено.",
+        "no_args": "Пожалуйста, укажите аргументы для команды.",
+        "no_keyword": "Пожалуйста, укажите ключевое слово для удаления сообщений.",
+        "no_length": "Пожалуйста, укажите корректную длину.",
+        "invalid_time": "Неверный формат времени. Используйте формат: YYYY-MM-DD HH:MM:SS",
+        "invalid_length": "Пожалуйста, укажите корректное число для длины.",
     }
 
+    def __init__(self):
+        self.client = None
+        self.db = None
+        self.tg_id = None
+
+    async def client_ready(self, client, db):
+        self.client = client
+        self.db = db
+        self.tg_id = (await client.get_me()).id
+
+    @loader.command(
+        ru_doc="[reply] [-img] [-voice] [-file] [-all] - удалить все ваши сообщения в текущем чате или только до сообщения, на которое ответили\n        -all - удалять сообщения в каждой теме, если это форум, иначе флаг игнорируется",
+        en_doc="[reply] [-img] [-voice] [-file] [-all] - delete all your messages in current chat or only ones up to the message you replied to\n        -all - to delete messages in each topic if this is a forum otherwise the flag'll just be ignored",
+    )
+    async def purge(self, message: Message):
+        if not self.client or not self.db or not self.tg_id:
+            return
 
-    async def purgecmd(self, message: Message):
-        """ [reply] [-img] [-voice] [-file] [-all] - delete all your messages in current chat or only ones up to the message you replied to
-        -all - to delete messages in each topic if this is a forum otherwise the flag'll just be ingored
-        """
         reply = await message.get_reply_message()
         is_last = False
         args, types_filter, is_each = self.get_types_filter(message)
-        is_forum = (await self.client.get_entity(message.chat.id)).forum
+
+        try:
+            entity = await self.client.get_entity(message.chat.id)
+            is_forum = getattr(entity, "forum", False)
+        except Exception:
+            is_forum = False
 
         status = self.db.get(__name__, "status", {})
         status[message.chat.id] = True
         self.db.set(__name__, "status", status)
 
+        deleted_count = 0
         async for i in self.client.iter_messages(message.peer_id):
             status = self.db.get(__name__, "status", {})
             if status.get(message.chat.id, None) is not True:
                 return await utils.answer(message, self.strings["interrupted"])
 
-            if is_forum and not is_each and utils.get_topic(message) != utils.get_topic(i):
-                continue
+            if is_forum and not is_each:
+                try:
+                    if utils.get_topic(message) != utils.get_topic(i):
+                        continue
+                except Exception:
+                    pass
 
             if i.from_id == self.tg_id and self.is_valid_type(i, types_filter):
                 if reply:
@@ -83,58 +117,86 @@ class DelMessTools(loader.Module):
                         break
                     if i.id == reply.id:
                         is_last = True
-                await message.client.delete_messages(message.peer_id, [i.id])
+                try:
+                    await self.client.delete_messages(message.peer_id, [i.id])
+                    deleted_count += 1
+                except Exception:
+                    pass
 
         if reply:
             await utils.answer(message, self.strings["purge_reply_complete"])
         else:
             await utils.answer(message, self.strings["purge_complete"])
 
-    async def purgekeywordcmd(self, message: Message):
-        """ <keyword> [-img] [-voice] [-file] [-all] - delete all your messages containing the specified keyword in the current chat
-        -all - to delete messages in each topic if this is a forum otherwise the flag'll just be ingored
-        """
+    @loader.command(
+        ru_doc="<ключевое слово> [-img] [-voice] [-file] [-all] - удалить все ваши сообщения с указанным ключевым словом в текущем чате\n        -all - удалять сообщения в каждой теме, если это форум, иначе флаг игнорируется",
+        en_doc="<keyword> [-img] [-voice] [-file] [-all] - delete all your messages containing the specified keyword in the current chat\n        -all - to delete messages in each topic if this is a forum otherwise the flag'll just be ignored",
+    )
+    async def purgekeyword(self, message: Message):
+        if not self.client or not self.db or not self.tg_id:
+            return
+
         args = utils.get_args_raw(message)
         if not args:
-            return await utils.answer(message, "Please specify anything because you didn't.")
+            return await utils.answer(message, self.strings["no_args"])
 
         args, types_filter, is_each = self.get_types_filter(message)
         if not args:
-            return await utils.answer(message, "Please specify a keyword to delete messages.")
+            return await utils.answer(message, self.strings["no_keyword"])
 
-        is_forum = (await self.client.get_entity(message.chat.id)).forum
+        try:
+            entity = await self.client.get_entity(message.chat.id)
+            is_forum = getattr(entity, "forum", False)
+        except Exception:
+            is_forum = False
 
         status = self.db.get(__name__, "status", {})
         status[message.chat.id] = True
         self.db.set(__name__, "status", status)
 
+        deleted_count = 0
         async for i in self.client.iter_messages(message.peer_id):
             status = self.db.get(__name__, "status", {})
             if status.get(message.chat.id, None) is not True:
                 return await utils.answer(message, self.strings["interrupted"])
 
-            if is_forum and not is_each and utils.get_topic(message) != utils.get_topic(i):
-                continue
+            if is_forum and not is_each:
+                try:
+                    if utils.get_topic(message) != utils.get_topic(i):
+                        continue
+                except Exception:
+                    pass
 
-            if i.from_id == self.tg_id and args.lower() in (i.text or '').lower() and self.is_valid_type(i, types_filter):
-                await message.client.delete_messages(message.chat.id, [i.id])
+            if (
+                i.from_id == self.tg_id
+                and args.lower() in (i.text or "").lower()
+                and self.is_valid_type(i, types_filter)
+            ):
+                try:
+                    await self.client.delete_messages(message.chat.id, [i.id])
+                    deleted_count += 1
+                except Exception:
+                    pass
 
         await utils.answer(message, self.strings["purge_keyword_complete"])
 
-    async def purgetimecmd(self, message: Message):
-        """ <start_time> <end_time> [-img] [-voice] [-file] [-all] - delete all your messages within the specified time range in the current chat
-        -all - to delete messages in each topic if this is a forum otherwise the flag'll just be ingored
-        Time format: YYYY-MM-DD HH:MM:SS
-        """
+    @loader.command(
+        ru_doc="<начальное время> <конечное время> [-img] [-voice] [-file] [-all] - удалить все ваши сообщения в указанном временном диапазоне в текущем чате\n        -all - удалять сообщения в каждой теме, если это форум, иначе флаг игнорируется\n        Формат времени: YYYY-MM-DD HH:MM:SS",
+        en_doc="<start_time> <end_time> [-img] [-voice] [-file] [-all] - delete all your messages within the specified time range in the current chat\n        -all - to delete messages in each topic if this is a forum otherwise the flag'll just be ignored\n        Time format: YYYY-MM-DD HH:MM:SS",
+    )
+    async def purgetime(self, message: Message):
+        if not self.client or not self.db or not self.tg_id:
+            return
+
         args = utils.get_args_raw(message)
         if not args:
-            return await utils.answer(message, "Please specify anything because you didn't.")
+            return await utils.answer(message, self.strings["no_args"])
 
         args, types_filter, is_each = self.get_types_filter(message)
         args = args.split()
 
         if not args or len(args) < 2:
-            return await utils.answer(message, "Please specify the start and end time in the format: YYYY-MM-DD HH:MM:SS")
+            return await utils.answer(message, self.strings["no_args"])
 
         from datetime import datetime
 
@@ -142,66 +204,111 @@ class DelMessTools(loader.Module):
             start_time = datetime.strptime(args[0], "%Y-%m-%d %H:%M:%S")
             end_time = datetime.strptime(args[1], "%Y-%m-%d %H:%M:%S")
         except ValueError:
-            return await utils.answer(message, "Invalid time format. Please use the format: YYYY-MM-DD HH:MM:SS")
+            return await utils.answer(message, self.strings["invalid_time"])
 
-        is_forum = (await self.client.get_entity(message.chat.id)).forum
+        try:
+            entity = await self.client.get_entity(message.chat.id)
+            is_forum = getattr(entity, "forum", False)
+        except Exception:
+            is_forum = False
 
         status = self.db.get(__name__, "status", {})
         status[message.chat.id] = True
         self.db.set(__name__, "status", status)
 
+        deleted_count = 0
         async for i in self.client.iter_messages(message.peer_id):
             status = self.db.get(__name__, "status", {})
             if status.get(message.chat.id, None) is not True:
                 return await utils.answer(message, self.strings["interrupted"])
 
-            if is_forum and not is_each and utils.get_topic(message) != utils.get_topic(i):
-                continue
+            if is_forum and not is_each:
+                try:
+                    if utils.get_topic(message) != utils.get_topic(i):
+                        continue
+                except Exception:
+                    pass
 
-            if i.from_id == self.tg_id and start_time <= i.date <= end_time and self.is_valid_type(i, types_filter):
-                await message.client.delete_messages(message.peer_id, [i.id])
+            if (
+                i.from_id == self.tg_id
+                and start_time <= i.date <= end_time
+                and self.is_valid_type(i, types_filter)
+            ):
+                try:
+                    await self.client.delete_messages(message.peer_id, [i.id])
+                    deleted_count += 1
+                except Exception:
+                    pass
 
         await utils.answer(message, self.strings["purge_time_complete"])
 
-    async def purgelengthcmd(self, message: Message):
-        """ <length> [-img] [-voice] [-file] [-all] - delete all your messages with the specified length in the current chat
-        -all - to delete messages in each topic if this is a forum otherwise the flag'll just be ingored
-        """
+    @loader.command(
+        ru_doc="<длина> [-img] [-voice] [-file] [-all] - удалить все ваши сообщения указанной длины в текущем чате\n        -all - удалять сообщения в каждой теме, если это форум, иначе флаг игнорируется",
+        en_doc="<length> [-img] [-voice] [-file] [-all] - delete all your messages with the specified length in the current chat\n        -all - to delete messages in each topic if this is a forum otherwise the flag'll just be ignored",
+    )
+    async def purgelength(self, message: Message):
+        if not self.client or not self.db or not self.tg_id:
+            return
+
         args = utils.get_args_raw(message)
         if not args:
-            return await utils.answer(message, "Please specify anything because you didn't.")
+            return await utils.answer(message, self.strings["no_args"])
 
         args, types_filter, is_each = self.get_types_filter(message)
         if not args:
-            return await utils.answer(message, "Please specify a valid length.")
+            return await utils.answer(message, self.strings["no_length"])
 
-        length = int(args)
-        is_forum = (await self.client.get_entity(message.chat.id)).forum
+        try:
+            length = int(args)
+        except ValueError:
+            return await utils.answer(message, self.strings["invalid_length"])
+
+        try:
+            entity = await self.client.get_entity(message.chat.id)
+            is_forum = getattr(entity, "forum", False)
+        except Exception:
+            is_forum = False
 
         status = self.db.get(__name__, "status", {})
         status[message.chat.id] = True
         self.db.set(__name__, "status", status)
 
+        deleted_count = 0
         async for i in self.client.iter_messages(message.peer_id):
             status = self.db.get(__name__, "status", {})
             if status.get(message.chat.id, None) is not True:
                 return await utils.answer(message, self.strings["interrupted"])
 
-            if is_forum and not is_each and utils.get_topic(message) != utils.get_topic(i):
-                continue
+            if is_forum and not is_each:
+                try:
+                    if utils.get_topic(message) != utils.get_topic(i):
+                        continue
+                except Exception:
+                    pass
 
-            if i.from_id == self.tg_id and len(i.text or '') == length and self.is_valid_type(i, types_filter):
-                await message.client.delete_messages(message.peer_id, [i.id])
+            if (
+                i.from_id == self.tg_id
+                and len(i.text or "") == length
+                and self.is_valid_type(i, types_filter)
+            ):
+                try:
+                    await self.client.delete_messages(message.peer_id, [i.id])
+                    deleted_count += 1
+                except Exception:
+                    pass
 
         await utils.answer(message, self.strings["purge_length_complete"])
 
-    async def nopurgecmd(self, message: Message):
-        """
-        Interrupt the deletion process
-        Use in the chat where you've previously started deletion
-        """
+    @loader.command(
+        ru_doc="Прервать процесс удаления\nИспользуйте в чате, где вы ранее начали удаление",
+        en_doc="Interrupt the deletion process\nUse in the chat where you've previously started deletion",
+    )
+    async def nopurge(self, message: Message):
+        if not self.db:
+            return
+
         chat_id = utils.get_chat_id(message)
-        
+
         status = self.db.get(__name__, "status", {})
         _status = status.get(chat_id, None)
         status[chat_id] = False
@@ -214,20 +321,26 @@ class DelMessTools(loader.Module):
         else:
             await utils.answer(message, self.strings["none"])
 
-
     def get_types_filter(self, message: Message):
-        """ Get the types filter from the command arguments."""
-        args = utils.get_args_raw(message).split()
+        """Get the types filter from the command arguments."""
+        args_raw = utils.get_args_raw(message)
+        if not args_raw:
+            return "", [], False
+
+        args = args_raw.split()
         types_filter = []
         valid_types = ["-img", "-voice", "-file", "-all"]
         is_each = "-all" in args
 
+        _args = args_raw
+        args_ = ""
+
         for i, arg in enumerate(args):
             if arg in valid_types:
                 _args = " ".join(args[:i])
                 args_ = " ".join(args[i:])
                 break
-                    
+
         if "-img" in args_:
             types_filter.append("img")
         if "-voice" in args_:
@@ -240,15 +353,17 @@ class DelMessTools(loader.Module):
         return _args, types_filter, is_each
 
     def is_valid_type(self, message: Message, types_filter):
-        """ Check if the message matches the specified types filter. """
+        """Check if the message matches the specified types filter."""
         if not types_filter:
             return True  # No filtering means all types are valid
 
-        if "img" in types_filter and message.photo:
+        if "img" in types_filter and hasattr(message, "photo") and message.photo:
             return True
-        if "voice" in types_filter and message.voice:
-            return True
-        if "file" in types_filter and isinstance(message.document, DocumentAttributeFilename):
+        if "voice" in types_filter and hasattr(message, "voice") and message.voice:
             return True
+        if "file" in types_filter and hasattr(message, "document") and message.document:
+            for attr in getattr(message.document, "attributes", []):
+                if isinstance(attr, DocumentAttributeFilename):
+                    return True
 
         return False

archquise/H.Modules/privacy.py

@@ -0,0 +1,350 @@
+# Proprietary License Agreement
+
+# Copyright (c) 2024-29 CodWiz
+
+# Permission is hereby granted to any person obtaining a copy of this software and associated documentation files (the "Software"), to use the Software for personal and non-commercial purposes, subject to the following conditions:
+
+# 1. The Software may not be modified, altered, or otherwise changed in any way without the explicit written permission of the author.
+
+# 2. Redistribution of the Software, in original or modified form, is strictly prohibited without the explicit written permission of the author.
+
+# 3. 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 non-infringement. In no event shall the author or copyright holder 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.
+
+# 4. Any use of the Software must include the above copyright notice and this permission notice in all copies or substantial portions of the Software.
+
+# 5. By using the Software, you agree to be bound by the terms and conditions of this license.
+
+# For any inquiries or requests for permissions, please contact codwiz@yandex.ru.
+
+# ---------------------------------------------------------------------------------
+# Name: Privacy
+# Description: Module for fast privacy settings management
+# Author: @hikka_mods
+# ---------------------------------------------------------------------------------
+# meta developer: @hikka_mods
+# scope: Privacy
+# scope: Privacy 0.0.1
+# ---------------------------------------------------------------------------------
+
+import logging
+import re
+from typing import Dict, List, Optional
+
+import telethon
+from telethon import types
+
+from .. import inline, loader, utils
+
+logger = logging.getLogger(__name__)
+
+
+@loader.tds
+class PrivacyMod(loader.Module):
+    """Module for fast privacy settings management"""
+
+    _PRIVACY_TYPES = {
+        "phone": types.InputPrivacyKeyPhoneNumber,
+        "add_by_phone": types.InputPrivacyKeyAddedByPhone,
+        "online": types.InputPrivacyKeyStatusTimestamp,
+        "photos": types.InputPrivacyKeyProfilePhoto,
+        "forwards": types.InputPrivacyKeyForwards,
+        "calls": types.InputPrivacyKeyPhoneCall,
+        "p2p": types.InputPrivacyKeyPhoneP2P,
+        "voices": types.InputPrivacyKeyVoiceMessages,
+        "bio": getattr(types, "InputPrivacyKeyAbout", None),
+        "invites": types.InputPrivacyKeyChatInvite,
+    }
+
+    _PRIVACY_RULES = {
+        types.PrivacyValueAllowAll: types.InputPrivacyValueAllowAll,
+        types.PrivacyValueAllowChatParticipants: types.InputPrivacyValueAllowChatParticipants,
+        types.PrivacyValueAllowContacts: types.InputPrivacyValueAllowContacts,
+        types.PrivacyValueAllowUsers: types.InputPrivacyValueAllowUsers,
+        types.PrivacyValueDisallowAll: types.InputPrivacyValueDisallowAll,
+        types.PrivacyValueDisallowChatParticipants: types.InputPrivacyValueDisallowChatParticipants,
+        types.PrivacyValueDisallowContacts: types.InputPrivacyValueDisallowContacts,
+        types.PrivacyValueDisallowUsers: types.InputPrivacyValueDisallowUsers,
+    }
+
+    strings = {
+        "name": "Privacy",
+        "privacy_types": (
+            "<emoji document_id=5974492756494519709>🔗</emoji> <b>Available privacy types:</b>\n"
+        ),
+        "no_user": "<emoji document_id=5312383351217201533>⚠️</emoji> <b>User not specified</b>",
+        "u_silly": (
+            "<emoji document_id=5449682572223194186>🥺</emoji> <b>You can't set privacy exceptions for yourself</b>"
+        ),
+        "choose_type": "🔑 <b>Select privacy type to manage</b>",
+        "not_supported_type": (
+            "<emoji document_id=5312383351217201533>⚠️</emoji> <b>Privacy type '{}' not supported</b>"
+        ),
+        "allowed": (
+            "<emoji document_id=5298609004551887592>💕</emoji> <b>{user} added to allowed users for [{type}]</b>"
+        ),
+        "disallowed": (
+            "<emoji document_id=5224379368242965520>💔</emoji> <b>{user} added to disallowed users for [{type}]</b>"
+        ),
+        "privacy": {
+            "phone": "Phone Number",
+            "add_by_phone": "Find by Phone",
+            "p2p": "P2P Calls",
+            "online": "Last Seen",
+            "photos": "Profile Photos",
+            "forwards": "Message Forwards",
+            "calls": "Phone Calls",
+            "voices": "Voice Messages",
+            "bio": "Bio",
+            "invites": "Chat Invites",
+        },
+    }
+
+    strings_ru = {
+        "_cls_doc": "Модуль для быстрого управления настройками приватности",
+        "privacy_types": (
+            "<emoji document_id=5974492756494519709>🔗</emoji> <b>Доступные типы приватности:</b>\n"
+        ),
+        "no_user": "<emoji document_id=5312383351217201533>⚠️</emoji> <b>Пользователь не указан</b>",
+        "u_silly": (
+            "<emoji document_id=5449682572223194186>🥺</emoji> <b>Нельзя установить исключения приватности для самого себя</b>"
+        ),
+        "choose_type": "🔑 <b>Выберите тип настроек приватности</b>",
+        "not_supported_type": (
+            "<emoji document_id=5312383351217201533>⚠️</emoji> <b>Тип приватности '{}' не поддерживается</b>"
+        ),
+        "allowed": (
+            "<emoji document_id=5298609004551887592>💕</emoji> <b>{user} добавлен в разрешённые для [{type}]</b>"
+        ),
+        "disallowed": (
+            "<emoji document_id=5224379368242965520>💔</emoji> <b>{user} добавлен в запрещённые для [{type}]</b>"
+        ),
+        "privacy": {
+            "phone": "Номер телефона",
+            "add_by_phone": "Поиск по номеру",
+            "p2p": "P2P звонки",
+            "online": "Последний вход",
+            "photos": "Фотографии профиля",
+            "forwards": "Пересылка сообщений",
+            "calls": "Звонки",
+            "voices": "Голосовые сообщения",
+            "bio": "О себе",
+            "invites": "Приглашения в чаты",
+        },
+    }
+
+    def __init__(self):
+        self._client: Optional[telethon.TelegramClient] = None
+        self._me: Optional[types.User] = None
+
+    async def client_ready(self, client: telethon.TelegramClient, db) -> None:
+        """Initialize client and get current user"""
+        self._client = client
+        self._me = await client.get_me()
+
+    async def _get_user_id(self, message: types.Message) -> Optional[int]:
+        """Extract user ID from reply or username"""
+        reply = await message.get_reply_message()
+        if reply:
+            return reply.sender_id
+
+        args = utils.get_args(message)
+        if not args:
+            return None
+
+        username = args[0]
+        match = re.search(r"(?:t\.me/|@|^(\w+)\.t\.me$)([a-zA-Z0-9_.]+)", username)
+        if not match:
+            return None
+
+        username = match.group(1) or match.group(2)
+        try:
+            entity = await self._client.get_entity(username)
+            return getattr(entity, "user_id", getattr(entity, "id", None))
+        except Exception:
+            return None
+
+    def _format_privacy_list(self) -> str:
+        """Format privacy types list"""
+        lines = [self.strings["privacy_types"]]
+
+        for key, name in self.strings["privacy"].items():
+            if key in self._PRIVACY_TYPES:
+                lines.append(f"  <code>{key}</code> — {name}")
+
+        return "\n".join(lines)
+
+    def _create_privacy_keyboard(
+        self, user: types.User, action: str
+    ) -> List[List[Dict]]:
+        """Create inline keyboard for privacy type selection"""
+        buttons = []
+
+        for key, name in self.strings["privacy"].items():
+            if key not in self._PRIVACY_TYPES:
+                continue
+
+            buttons.append(
+                [
+                    {
+                        "text": name,
+                        "callback": self._privacy_callback_handler,
+                        "args": (user, key, action),
+                    }
+                ]
+            )
+
+        return [buttons[i : i + 2] for i in range(0, len(buttons), 2)]
+
+    async def _privacy_callback_handler(self, call: inline.types.InlineCall) -> None:
+        """Handle privacy type selection callback"""
+        user, privacy_key, action = call.data
+
+        if privacy_key not in self._PRIVACY_TYPES:
+            await call.answer(self.strings["not_supported_type"].format(privacy_key))
+            return
+
+        privacy_type = self._PRIVACY_TYPES[privacy_key]
+        await self._update_privacy_settings(user, privacy_type, action)
+
+        action_text = "allowed" if action == "allow" else "disallowed"
+        await call.edit(
+            self.strings[action_text].format(
+                user=telethon.utils.get_display_name(user),
+                type=self.strings["privacy"][privacy_key],
+            )
+        )
+
+    async def _update_privacy_settings(
+        self, user: types.User, privacy_key: types.TypeInputPrivacyKey, action: str
+    ) -> None:
+        """Update privacy settings for specified user"""
+        try:
+            current_rules = await self._client(
+                telethon.functions.account.GetPrivacyRequest(key=privacy_key)
+            )
+        except Exception as e:
+            logger.error(f"Error getting privacy rules: {e}")
+            return
+
+        new_rules = []
+        existing_user_ids = set()
+
+        for rule in current_rules.rules:
+            rule_type = type(rule)
+
+            if rule_type == types.PrivacyValueAllowUsers:
+                for user_id in rule.users:
+                    existing_user_ids.add(user_id)
+                    if user_id != user.id:
+                        new_rules.append(rule)
+            elif rule_type == types.PrivacyValueDisallowUsers:
+                for user_id in rule.users:
+                    existing_user_ids.add(user_id)
+                    if user_id != user.id:
+                        new_rules.append(rule)
+
+        if action == "allow" and user.id not in existing_user_ids:
+            new_rules.append(
+                types.InputPrivacyValueAllowUsers(
+                    [types.InputUser(user.id, user.access_hash)]
+                )
+            )
+        elif action == "disallow" and user.id in existing_user_ids:
+            for rule in new_rules[:]:
+                if type(rule) in [
+                    types.PrivacyValueAllowUsers,
+                    types.PrivacyValueDisallowUsers,
+                ]:
+                    user_list = getattr(rule, "users", [])
+                    if user.id in user_list:
+                        user_list.remove(user.id)
+                        if not user_list:
+                            new_rules.remove(rule)
+                            break
+
+        try:
+            await self._client(
+                telethon.functions.account.SetPrivacyRequest(
+                    key=privacy_key, rules=new_rules
+                )
+            )
+        except Exception as e:
+            logger.error(f"Error updating privacy settings: {e}")
+
+    @loader.command(
+        ru_doc="Список типов настроек приватности",
+        en_doc="List of privacy types"
+    )
+    async def privacytypescmd(self, message: types.Message) -> None:
+        """Show available privacy types"""
+        await utils.answer(message, self._format_privacy_list())
+
+    @loader.command(
+        ru_doc="<user> Добавить в разрешённые",
+        en_doc="<user> Add to allowed list",
+    )
+    async def allowusercmd(self, message: types.Message) -> None:
+        """Add user to privacy exceptions"""
+        user_id = await self._get_user_id(message)
+        if not user_id:
+            return await utils.answer(message, self.strings["no_user"])
+
+        if user_id == self._me.id:
+            return await utils.answer(message, self.strings["u_silly"])
+
+        try:
+            user_entity = await self._client.get_entity(user_id)
+        except Exception:
+            return await utils.answer(message, self.strings["no_user"])
+
+        await self.inline.form(
+            message=message,
+            text=self.strings["choose_type"],
+            reply_markup=self._create_privacy_keyboard(user_entity, "allow"),
+        )
+
+    @loader.command(
+        ru_doc="<user> Добавить в запрещённые",
+        en_doc="<user> Add to forbidden list",
+    )
+    async def disallowuser(self, message: types.Message) -> None:
+        """Add user to privacy restrictions"""
+        user_id = await self._get_user_id(message)
+        if not user_id:
+            return await utils.answer(message, self.strings["no_user"])
+
+        if user_id == self._me.id:
+            return await utils.answer(message, self.strings["u_silly"])
+
+        try:
+            user_entity = await self._client.get_entity(user_id)
+        except Exception:
+            return await utils.answer(message, self.strings["no_user"])
+
+        await self.inline.form(
+            message=message,
+            text=self.strings["choose_type"],
+            reply_markup=self._create_privacy_keyboard(user_entity, "disallow"),
+        )
+
+    async def _create_privacy_keyboard(
+        self, user: types.User, action: str
+    ) -> List[List[Dict]]:
+        """Create inline keyboard for privacy type selection"""
+        buttons = []
+
+        for key, name in self.strings["privacy"].items():
+            if key not in self._PRIVACY_TYPES:
+                continue
+
+            buttons.append(
+                [
+                    {
+                        "text": name,
+                        "callback": self._privacy_callback_handler,
+                        "args": (user, key, action),
+                    }
+                ]
+            )
+
+        return [buttons[i : i + 2] for i in range(0, len(buttons), 2)]

archquise/H.Modules/sdsaver.py

@@ -1,30 +1,32 @@
-__version__ = (1, 0, 0)
-#          █▄▀ ▄▀█ █▀▄▀█ █▀▀ █▄▀ █  █ █▀█ █▀█
-#          █ █ █▀█ █ ▀ █ ██▄ █ █ ▀▄▄▀ █▀▄ █▄█ ▄
-#                © Copyright 2025
-#            ✈ https://t.me/kamekuro
+# Proprietary License Agreement
 
-# 🔒 Licensed under CC-BY-NC-ND 4.0 unless otherwise specified.
-# 🌐 https://creativecommons.org/licenses/by-nc-nd/4.0
-# + attribution
-# + non-commercial
-# + no-derivatives
+# Copyright (c) 2024-29 CodWiz
 
-# You CANNOT edit, distribute or redistribute this file without direct permission from the author.
+# Permission is hereby granted to any person obtaining a copy of this software and associated documentation files (the "Software"), to use the Software for personal and non-commercial purposes, subject to the following conditions:
 
-# meta banner: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/sdsaver.png
-# meta pic: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/sdsaver.png
-# meta developer: @kamekuro_hmods
-# scope: hikka_min 1.7.0
+# 1. The Software may not be modified, altered, or otherwise changed in any way without the explicit written permission of the author.
+
+# 2. Redistribution of the Software, in original or modified form, is strictly prohibited without the explicit written permission of the author.
+
+# 3. 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 non-infringement. In no event shall the author or copyright holder 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.
+
+# 4. Any use of the Software must include the above copyright notice and this permission notice in all copies or substantial portions of the Software.
+
+# 5. By using the Software, you agree to be bound by the terms and conditions of this license.
+
+# For any inquiries or requests for permissions, please contact codwiz@yandex.ru.
+
+# ---------------------------------------------------------------------------------
+# Name: SDSaver
+# Description: The module for automatically saving self-destructing mediat
+# Author: @hikka_mods
+# ---------------------------------------------------------------------------------
+# meta developer: @hikka_mods
+# scope: SDSaver
+# scope: SDSaver 0.0.1
+# ---------------------------------------------------------------------------------
 
-import aiohttp
-import asyncio
-import io
-import json
 import logging
-import random
-import requests
-import string
 
 import aiogram
 import telethon
@@ -43,17 +45,16 @@ class SDSaverMod(loader.Module):
         "name": "SDSaver",
         "sdmode_on": "<emoji document_id=5769230088960741619>🔥</emoji> <b>Automatic saving self-destructing media is enabled</b>",
         "sdmode_off": "<emoji document_id=5769230088960741619>🔥</emoji> <b>Automatic saving self-destructing media is disabled</b>",
-        "sd": "🔥 <b><a href=\"{link}\">{name}</a> sent self-destructing media:</b>\n{caption}"
+        "sd": '🔥 <b><a href="{link}">{name}</a> sent self-destructing media:</b>\n{caption}',
     }
 
     strings_ru = {
         "_cls_doc": "Модуль для автоматического сохранения самоуничтожающихся медиа",
         "sdmode_on": "<emoji document_id=5769230088960741619>🔥</emoji> <b>Автоматическое сохранение самоуничтожающихся медиа включено</b>",
         "sdmode_off": "<emoji document_id=5769230088960741619>🔥</emoji> <b>Автоматическое сохранение самоуничтожающихся медиа выключено</b>",
-        "sd": "🔥 <b><a href=\"{link}\">{name}</a> отправил(а) самоуничтожающееся медиа:</b>\n{caption}"
+        "sd": '🔥 <b><a href="{link}">{name}</a> отправил(а) самоуничтожающееся медиа:</b>\n{caption}',
     }
 
-
     async def client_ready(self, client, db):
         self._client = client
         self._db = db
@@ -68,28 +69,23 @@ class SDSaverMod(loader.Module):
         )
         self._channel = int(f"-100{channel.id}")
 
-
     @loader.command(
-        ru_doc="👉 Включить/Выключить автоматическое сохранение самоуничтожающихся медиа"
+        ru_doc="Включить/Выключить автоматическое сохранение самоуничтожающихся медиа",
+        en_doc="Enable/Disable automatic saving self-destructing media",
     )
     async def sdmodecmd(self, message: telethon.types.Message):
-        """👉 Enable/Disable automatic saving self-destructing media"""
-
         need_mode = not self.get("save_sd", True)
         self.set("save_sd", need_mode)
         await utils.answer(
             message, self.strings(f"sdmode_{'on' if need_mode else 'off'}")
         )
 
-
     @loader.watcher("in", only_messages=True)
     async def watcher(self, message: telethon.types.Message):
         if (
-            not self.get("save_sd", True)
-        ) or (
-            not message.media
-        ) or (
-            not getattr(message.media, "ttl_seconds", None)
+            (not self.get("save_sd", True))
+            or (not message.media)
+            or (not getattr(message.media, "ttl_seconds", None))
         ):
             return
 
@@ -104,17 +100,17 @@ class SDSaverMod(loader.Module):
             "caption": self.strings("sd").format(
                 link=utils.get_entity_url(sender),
                 name=utils.escape_html(telethon.utils.get_display_name(sender)),
-                caption=message.text if message.text else ''
-            )
+                caption=message.text if message.text else "",
+            ),
         }
         if message.photo:
-            args['photo'] = aiogram.types.BufferedInputFile(media, "sd.png")
+            args["photo"] = aiogram.types.BufferedInputFile(media, "sd.png")
             method = self.inline.bot.send_photo
         if message.video or message.video_note:
-            args['video'] = aiogram.types.BufferedInputFile(media, "sd.mp4")
+            args["video"] = aiogram.types.BufferedInputFile(media, "sd.mp4")
             method = self.inline.bot.send_video
         if message.voice:
-            args['voice'] = aiogram.types.BufferedInputFile(media, "sd.ogg")
+            args["voice"] = aiogram.types.BufferedInputFile(media, "sd.ogg")
             method = self.inline.bot.send_voice
 
-        await method(**args)
+        await method(**args)

archquise/H.Modules/silenttr.py

@@ -27,6 +27,7 @@
 # ---------------------------------------------------------------------------------
 
 from telethon.types import Message
+from telethon import events
 
 from .. import loader, utils
 
@@ -79,6 +80,7 @@ class SilentTRMod(loader.Module):
     async def client_ready(self, client, db):
         self._client = client
         self._db = db
+        self._me = await client.get_me()
 
         self._global_settings = self._db.get(
             __name__, "global_settings", {"reactions": False, "tags": False}
@@ -87,27 +89,22 @@ class SilentTRMod(loader.Module):
         self._global_ignore = self._db.get(__name__, "global_ignore", [])
         self._chat_ignore = self._db.get(__name__, "chat_ignore", {})
 
-        client.add_event_handler(self._on_message_reaction_updated)
-        client.add_event_handler(self._on_new_message)
+        client.add_event_handler(
+            self._on_message_reaction_updated, events.MessageReactionsUpdated
+        )
+        client.add_event_handler(self._on_new_message, events.NewMessage)
 
     async def on_unload(self):
         self._client.remove_event_handler(self._on_message_reaction_updated)
         self._client.remove_event_handler(self._on_new_message)
 
-    def _save_global_settings(self):
+    def _save_settings(self):
         self._db.set(__name__, "global_settings", self._global_settings)
-
-    def _save_chat_settings(self):
         self._db.set(__name__, "chat_settings", self._chat_settings)
-
-    def _save_global_ignore(self):
         self._db.set(__name__, "global_ignore", self._global_ignore)
-
-    def _save_chat_ignore(self):
         self._db.set(__name__, "chat_ignore", self._chat_ignore)
 
     async def _on_message_reaction_updated(self, event):
-        """Обработчик обновления реакций"""
         try:
             message = await self._client.get_messages(
                 event.chat_id, ids=event.message_id
@@ -115,226 +112,180 @@ class SilentTRMod(loader.Module):
         except Exception:
             return
 
-        if message.sender_id != (await self._client.get_me()).id:
+        if message.sender_id != self._me.id:
             return
 
         chat_id = str(event.chat_id)
         user_id = event.user_id
 
-        if user_id in self._global_ignore:
-            return
-
-        if chat_id in self._chat_ignore and user_id in self._chat_ignore[chat_id]:
+        if user_id in self._global_ignore or (
+            chat_id in self._chat_ignore and user_id in self._chat_ignore[chat_id]
+        ):
             return
 
         chat_settings = self._chat_settings.get(
             chat_id, {"reactions": None, "tags": None}
         )
-        if chat_settings["reactions"] is None:
-            if not self._global_settings["reactions"]:
-                return
-        else:
-            if not chat_settings["reactions"]:
-                return
+        reactions_enabled = (
+            chat_settings["reactions"]
+            if chat_settings["reactions"] is not None
+            else self._global_settings["reactions"]
+        )
 
-        await self._client.read_messages(event.chat_id, event.message_id)
+        if reactions_enabled:
+            await self._client.read_messages(event.chat_id, event.message_id)
 
     async def _on_new_message(self, event):
-        """Обработчик новых сообщений для упоминаний"""
-
-        if event.out:
-            return
-
-        me = await self._client.get_me()
-        mentioned = False
-        if event.mentioned:
-            mentioned = True
-        else:
-            if event.entities:
-                for entity in event.entities:
-                    if entity.type == "mentionName" and entity.user_id == me.id:
-                        mentioned = True
-                        break
-                    elif entity.type == "textMention" and entity.user_id == me.id:
-                        mentioned = True
-                        break
-
-        if not mentioned:
+        if event.out or not event.mentioned:
             return
 
         chat_id = str(event.chat_id)
         user_id = event.sender_id
 
-        if user_id in self._global_ignore:
-            return
-
-        if chat_id in self._chat_ignore and user_id in self._chat_ignore[chat_id]:
+        if user_id in self._global_ignore or (
+            chat_id in self._chat_ignore and user_id in self._chat_ignore[chat_id]
+        ):
             return
 
         chat_settings = self._chat_settings.get(
             chat_id, {"reactions": None, "tags": None}
         )
-        if chat_settings["tags"] is None:
-            if not self._global_settings["tags"]:
+        tags_enabled = (
+            chat_settings["tags"]
+            if chat_settings["tags"] is not None
+            else self._global_settings["tags"]
+        )
+
+        if tags_enabled:
+            await event.mark_read()
+
+    @loader.command(
+        ru_doc="[on/off] - тихие реакции во всех чатах",
+        en_doc="[on/off] - silent reactions in all chats",
+    )
+    async def _toggle_setting(
+        self, message: Message, setting_type: str, scope: str = "global"
+    ):
+        args = utils.get_args_raw(message).lower()
+        chat_id = str(message.chat_id) if scope == "chat" else None
+
+        if args not in ["on", "off", ""]:
+            await utils.answer(
+                message,
+                self.strings["args_error"]
+                if scope == "global"
+                else self.strings["chat_args_error"],
+            )
+            return
+
+        if scope == "global":
+            if args == "on":
+                self._global_settings[setting_type] = True
+            elif args == "off":
+                self._global_settings[setting_type] = False
+            else:
+                status = "on" if self._global_settings[setting_type] else "off"
+                await utils.answer(message, f"Global silent {setting_type}: {status}")
                 return
         else:
-            if not chat_settings["tags"]:
+            chat_settings = self._chat_settings.get(
+                chat_id, {"reactions": None, "tags": None}
+            )
+            if args == "on":
+                chat_settings[setting_type] = True
+            elif args == "off":
+                chat_settings[setting_type] = False
+            else:
+                status = chat_settings[setting_type]
+                if status is None:
+                    status = f"global ({'on' if self._global_settings[setting_type] else 'off'})"
+                else:
+                    status = "on" if status else "off"
+                await utils.answer(
+                    message, f"Silent {setting_type} in this chat: {status}"
+                )
                 return
+            self._chat_settings[chat_id] = chat_settings
 
-        await event.mark_read()
+        self._save_settings()
+        status_key = "on" if args == "on" else "off"
+        if scope == "global":
+            key = f"global_{setting_type}_{status_key}"
+        else:
+            key = f"chat_{setting_type}_{status_key}"
+
+        await utils.answer(
+            message,
+            self.strings.get(
+                key,
+                f"✅ {scope.title()} silent {setting_type} {'enabled' if args == 'on' else 'disabled'}",
+            ),
+        )
 
     @loader.command(
         ru_doc="[on/off] - тихие реакции во всех чатах",
         en_doc="[on/off] - silent reactions in all chats",
     )
     async def sreacts(self, message: Message):
-        """Toggle global silent reactions"""
-        args = utils.get_args_raw(message).lower()
-        if args == "on":
-            self._global_settings["reactions"] = True
-            self._save_global_settings()
-            await utils.answer(message, self.strings["global_reactions_on"])
-        elif args == "off":
-            self._global_settings["reactions"] = False
-            self._save_global_settings()
-            await utils.answer(message, self.strings["global_reactions_off"])
-        elif args == "":
-            status = "on" if self._global_settings["reactions"] else "off"
-            await utils.answer(message, f"Global silent reactions: {status}")
-        else:
-            await utils.answer(message, self.strings["args_error"])
+        await self._toggle_setting(message, "reactions", "global")
 
     @loader.command(
         ru_doc="[on/off] - тихие упоминания во всех чатах",
         en_doc="[on/off] - silent tags in all chats",
     )
     async def stags(self, message: Message):
-        """Toggle global silent tags"""
-        args = utils.get_args_raw(message).lower()
-        if args == "on":
-            self._global_settings["tags"] = True
-            self._save_global_settings()
-            await utils.answer(message, self.strings["global_tags_on"])
-        elif args == "off":
-            self._global_settings["tags"] = False
-            self._save_global_settings()
-            await utils.answer(message, self.strings["global_tags_off"])
-        elif args == "":
-            status = "on" if self._global_settings["tags"] else "off"
-            await utils.answer(message, f"Global silent tags: {status}")
-        else:
-            await utils.answer(message, self.strings["args_error"])
+        await self._toggle_setting(message, "tags", "global")
 
     @loader.command(
         ru_doc="[on/off] - тихие реакции и упоминания во всех чатах",
         en_doc="[on/off] - silent reactions and tags in all chats",
     )
     async def sall(self, message: Message):
-        """Toggle global silent reactions and tags"""
         args = utils.get_args_raw(message).lower()
         if args == "on":
             self._global_settings["reactions"] = True
             self._global_settings["tags"] = True
-            self._save_global_settings()
-            await utils.answer(message, "✅ Global silent reactions and tags enabled")
         elif args == "off":
             self._global_settings["reactions"] = False
             self._global_settings["tags"] = False
-            self._save_global_settings()
-            await utils.answer(message, "❌ Global silent reactions and tags disabled")
         elif args == "":
             status_r = "on" if self._global_settings["reactions"] else "off"
             status_t = "on" if self._global_settings["tags"] else "off"
             await utils.answer(
                 message, f"Global silent reactions: {status_r}, tags: {status_t}"
             )
+            return
         else:
             await utils.answer(message, self.strings["args_error"])
+            return
+
+        self._save_settings()
+        await utils.answer(
+            message,
+            f"{'✅' if args == 'on' else '❌'} Global silent reactions and tags {'enabled' if args == 'on' else 'disabled'}",
+        )
 
     @loader.command(
         ru_doc="[on/off] - тихие реакции в этом чате",
         en_doc="[on/off] - silent reactions in this chat",
     )
     async def hsreacts(self, message: Message):
-        """Toggle silent reactions in this chat"""
-        args = utils.get_args_raw(message).lower()
-        chat_id = str(message.chat_id)
-
-        # Получаем настройки чата или создаем новые
-        chat_settings = self._chat_settings.get(
-            chat_id, {"reactions": None, "tags": None}
-        )
-
-        if args == "on":
-            chat_settings["reactions"] = True
-            self._chat_settings[chat_id] = chat_settings
-            self._save_chat_settings()
-            await utils.answer(message, self.strings["chat_reactions_on"])
-        elif args == "off":
-            chat_settings["reactions"] = False
-            self._chat_settings[chat_id] = chat_settings
-            self._save_chat_settings()
-            await utils.answer(message, self.strings["chat_reactions_off"])
-        elif args == "":
-            status = chat_settings["reactions"]
-            if status is None:
-                status = (
-                    "global ("
-                    + ("on" if self._global_settings["reactions"] else "off")
-                    + ")"
-                )
-            else:
-                status = "on" if status else "off"
-            await utils.answer(message, f"Silent reactions in this chat: {status}")
-        else:
-            await utils.answer(message, self.strings["chat_args_error"])
+        await self._toggle_setting(message, "reactions", "chat")
 
     @loader.command(
         ru_doc="[on/off] - тихие упоминания в этом чате",
         en_doc="[on/off] - silent tags in this chat",
     )
     async def hstags(self, message: Message):
-        """Toggle silent tags in this chat"""
-        args = utils.get_args_raw(message).lower()
-        chat_id = str(message.chat_id)
-
-        chat_settings = self._chat_settings.get(
-            chat_id, {"reactions": None, "tags": None}
-        )
-
-        if args == "on":
-            chat_settings["tags"] = True
-            self._chat_settings[chat_id] = chat_settings
-            self._save_chat_settings()
-            await utils.answer(message, self.strings["chat_tags_on"])
-        elif args == "off":
-            chat_settings["tags"] = False
-            self._chat_settings[chat_id] = chat_settings
-            self._save_chat_settings()
-            await utils.answer(message, self.strings["chat_tags_off"])
-        elif args == "":
-            status = chat_settings["tags"]
-            if status is None:
-                status = (
-                    "global ("
-                    + ("on" if self._global_settings["tags"] else "off")
-                    + ")"
-                )
-            else:
-                status = "on" if status else "off"
-            await utils.answer(message, f"Silent tags in this chat: {status}")
-        else:
-            await utils.answer(message, self.strings["chat_args_error"])
+        await self._toggle_setting(message, "tags", "chat")
 
     @loader.command(
         ru_doc="[on/off] - тихие реакции и упоминания в этом чате",
         en_doc="[on/off] - silent reactions and tags in this chat",
     )
     async def hsall(self, message: Message):
-        """Toggle silent reactions and tags in this chat"""
         args = utils.get_args_raw(message).lower()
         chat_id = str(message.chat_id)
-
         chat_settings = self._chat_settings.get(
             chat_id, {"reactions": None, "tags": None}
         )
@@ -342,66 +293,58 @@ class SilentTRMod(loader.Module):
         if args == "on":
             chat_settings["reactions"] = True
             chat_settings["tags"] = True
-            self._chat_settings[chat_id] = chat_settings
-            self._save_chat_settings()
-            await utils.answer(
-                message, "✅ Silent reactions and tags enabled in this chat"
-            )
         elif args == "off":
             chat_settings["reactions"] = False
             chat_settings["tags"] = False
-            self._chat_settings[chat_id] = chat_settings
-            self._save_chat_settings()
-            await utils.answer(
-                message, "❌ Silent reactions and tags disabled in this chat"
-            )
         elif args == "":
             status_r = chat_settings["reactions"]
-            if status_r is None:
-                status_r = (
-                    "global ("
-                    + ("on" if self._global_settings["reactions"] else "off")
-                    + ")"
-                )
-            else:
-                status_r = "on" if status_r else "off"
             status_t = chat_settings["tags"]
-            if status_t is None:
-                status_t = (
-                    "global ("
-                    + ("on" if self._global_settings["tags"] else "off")
-                    + ")"
-                )
-            else:
-                status_t = "on" if status_t else "off"
+
+            def format_status(status, setting_type):
+                if status is None:
+                    return f"global ({'on' if self._global_settings[setting_type] else 'off'})"
+                return "on" if status else "off"
+
+            status_r = format_status(status_r, "reactions")
+            status_t = format_status(status_t, "tags")
             await utils.answer(
                 message, f"Silent reactions: {status_r}, tags: {status_t} in this chat"
             )
+            return
         else:
             await utils.answer(message, self.strings["chat_args_error"])
+            return
 
-    async def _get_user_id(self, message: Message):
-        """Получить ID пользователя из аргументов или ответа"""
-        reply = await message.get_reply_message()
-        args = utils.get_args_raw(message)
-
-        if reply:
-            return reply.sender_id
-        elif args:
-            try:
-                user = await self._client.get_entity(args)
-                return user.id
-            except Exception:
-                return None
-        else:
-            return None
+        self._chat_settings[chat_id] = chat_settings
+        self._save_settings()
+        await utils.answer(
+            message,
+            f"{'✅' if args == 'on' else '❌'} Silent reactions and tags {'enabled' if args == 'on' else 'disabled'} in this chat",
+        )
 
     @loader.command(
         ru_doc="[ответ/username] - игнорировать пользователя глобально",
         en_doc="[reply/username] - ignore user globally",
     )
+    async def _get_user_id(self, message: Message):
+        reply = await message.get_reply_message()
+        args = utils.get_args_raw(message)
+
+        if reply:
+            return reply.sender_id
+        if args:
+            try:
+                user = await self._client.get_entity(args)
+                return user.id
+            except Exception:
+                return None
+        return None
+
+    @loader.command(
+        ru_doc="[ответ/username] - игнорировать пользователя в этом чате",
+        en_doc="[reply/username] - ignore user in this chat",
+    )
     async def ignore(self, message: Message):
-        """Toggle ignore user globally"""
         user_id = await self._get_user_id(message)
         if not user_id:
             await utils.answer(message, self.strings["no_reply"])
@@ -414,21 +357,18 @@ class SilentTRMod(loader.Module):
             self._global_ignore.append(user_id)
             await utils.answer(message, self.strings["ignore_added"])
 
-        self._save_global_ignore()
+        self._save_settings()
 
     @loader.command(
-        ru_doc="[ответ/username] - игнорировать пользователя в этом чате",
-        en_doc="[reply/username] - ignore user in this chat",
+        ru_doc="Показать статус Silent T&R", en_doc="Show Silent T&R status"
     )
     async def hignore(self, message: Message):
-        """Toggle ignore user in this chat"""
         user_id = await self._get_user_id(message)
         if not user_id:
             await utils.answer(message, self.strings["no_reply"])
             return
 
         chat_id = str(message.chat_id)
-
         if chat_id not in self._chat_ignore:
             self._chat_ignore[chat_id] = []
 
@@ -439,13 +379,12 @@ class SilentTRMod(loader.Module):
             self._chat_ignore[chat_id].append(user_id)
             await utils.answer(message, self.strings["hignore_added"])
 
-        self._save_chat_ignore()
+        self._save_settings()
 
     @loader.command(
         ru_doc="Показать статус Silent T&R", en_doc="Show Silent T&R status"
     )
     async def strstatus(self, message: Message):
-        """Show status"""
         global_reactions = "on" if self._global_settings["reactions"] else "off"
         global_tags = "on" if self._global_settings["tags"] else "off"
 

archquise/H.Modules/timezone.py

@@ -34,6 +34,7 @@ from .. import loader, utils
 
 logger = logging.getLogger(__name__)
 
+
 @loader.tds
 class TimeZoneMod(loader.Module):
     """Prints current time in selected timezone (UTC+n and tzdata formats supported)"""
@@ -43,7 +44,7 @@ class TimeZoneMod(loader.Module):
         "invalid_args": "<emoji document_id=5854929766146118183>❌</emoji> There is no arguments or they are invalid",
         "_cls_doc": "Prints current time in selected timezone (UTC+n and tzdata formats supported)",
         "time_utc": "<emoji document_id=5276412364458059956>🕓</emoji> Current time by UTC+{}: {}",
-        "time_tzdata": "<emoji document_id=5276412364458059956>🕓</emoji> Current time in {}: {}"
+        "time_tzdata": "<emoji document_id=5276412364458059956>🕓</emoji> Current time in {}: {}",
     }
 
     strings_ru = {
@@ -51,7 +52,7 @@ class TimeZoneMod(loader.Module):
         "invalid_args": "<emoji document_id=5854929766146118183>❌</emoji> Нет аргументов или они неверны",
         "tzdata_error": "<emoji document_id=5854929766146118183>❌</emoji> Произошла ошибка при получении времени по tzdata: {}\n\nУбедитесь, что часовой пояс указан верно",
         "time_utc": "<emoji document_id=5276412364458059956>🕓</emoji> Текущее время по UTC+{}: {}",
-        "time_tzdata": "<emoji document_id=5276412364458059956>🕓</emoji> Текущее время в {}: {}"
+        "time_tzdata": "<emoji document_id=5276412364458059956>🕓</emoji> Текущее время в {}: {}",
     }
 
     @loader.command(
@@ -61,12 +62,14 @@ class TimeZoneMod(loader.Module):
     async def utccmd(self, message):
         args = utils.get_args(message)
         if not args or not args[0].isdigit() or len(args) > 1:
-            await utils.answer(message, self.strings['invalid_args'])
-            return 
+            await utils.answer(message, self.strings["invalid_args"])
+            return
         offset = timedelta(hours=int(args[0]))
         tz = timezone(offset)
         time = datetime.now(tz)
-        await utils.answer(message, self.strings['time_utc'].format(args[0], time.strftime('%H:%M:%S')))
+        await utils.answer(
+            message, self.strings["time_utc"].format(args[0], time.strftime("%H:%M:%S"))
+        )
 
     @loader.command(
         ru_doc="Выводит время по часовому поясу tzdata | Использование: .tzdata Europe/Moscow",
@@ -75,12 +78,15 @@ class TimeZoneMod(loader.Module):
     async def tzdatacmd(self, message):
         args = utils.get_args(message)
         if args[0].isdigit() or not args or len(args) > 1:
-            await utils.answer(message, self.strings['invalid_args'])
-            return 
-        try: 
+            await utils.answer(message, self.strings["invalid_args"])
+            return
+        try:
             time = datetime.now(ZoneInfo(args[0]))
         except Exception as e:
-            await utils.answer(message, self.strings['tzdata_error'].format(e))
-            logger.error(self.strings['tzdata_error'].format(e))
+            await utils.answer(message, self.strings["tzdata_error"].format(e))
+            logger.error(self.strings["tzdata_error"].format(e))
             return
-        await utils.answer(message, self.strings['time_tzdata'].format(args[0], time.strftime('%H:%M:%S')))
+        await utils.answer(
+            message,
+            self.strings["time_tzdata"].format(args[0], time.strftime("%H:%M:%S")),
+        )

archquise/H.Modules/ytdl.py

@@ -42,6 +42,7 @@ from .. import loader, utils
 
 logger = logging.getLogger(__name__)
 
+
 @loader.tds
 class YTDLMod(loader.Module):
     """Downloads and sends audio/video from YouTube"""
@@ -50,46 +51,47 @@ class YTDLMod(loader.Module):
         "name": "YTDL",
         "_cls_doc": "Downloads and sends audio/video from YouTube",
         "invalid_args": "<emoji document_id=5854929766146118183>❌</emoji> There is no arguments or they are invalid",
-        "downloading_video": "<emoji document_id=5215484787325676090>🕐</emoji> Video is downloading...",
-        "downloaded_video": "<emoji document_id=5854762571659218443>✅</emoji> Video is downloaded!",
-        "downloading_audio": "<emoji document_id=5215484787325676090>🕐</emoji> Audio is downloading...",
-        "downloaded_audio": "<emoji document_id=5854762571659218443>✅</emoji> Audio is downloaded!",
+        "downloading": "<emoji document_id=5215484787325676090>🕐</emoji> Downloading...",
+        "done": "<emoji document_id=5854762571659218443>✅</emoji> Done!",
     }
 
     strings_ru = {
         "_cls_doc": "Скачивает и отправляет аудио/видео с Ютуба",
         "invalid_args": "<emoji document_id=5854929766146118183>❌</emoji> Нет аргументов или они неверны",
-        "downloading_video": "<emoji document_id=5215484787325676090>🕐</emoji> Видео скачивается...",
-        "downloaded_video": "<emoji document_id=5854762571659218443>✅</emoji> Видео загружено!",
-        "downloading_audio": "<emoji document_id=5215484787325676090>🕐</emoji> Аудио скачивается...",
-        "downloaded_audio": "<emoji document_id=5854762571659218443>✅</emoji> Аудио загружено!",
+        "downloading": "<emoji document_id=5215484787325676090>🕐</emoji> Скачиваю...",
+        "done": "<emoji document_id=5854762571659218443>✅</emoji> Готово!",
     }
 
-
     def _validate_url(self, url: str) -> bool:
         """Validate URL format"""
         if not url:
             return False
 
         url_pattern = re.compile(
-            r'^(?:https?://)?(?:www\.|m\.)?(?:youtube\.com|youtu\.be|music\.youtube\.com)/(?:watch\?v=|playlist\?list=|channel/|@|live/|shorts/)?[\w-]+',
-            re.IGNORECASE
+            r"^(?:https?://)?(?:www\.|m\.)?(?:youtube\.com|youtu\.be|music\.youtube\.com)/(?:watch\?v=|playlist\?list=|channel/|@|live/|shorts/)?[\w-]+",
+            re.IGNORECASE,
         )
 
         return url_pattern.match(url) is not None
 
     async def get_target(self):
         system = platform.system()
-        machine = platform.machine().lower() 
+        machine = platform.machine().lower()
 
         if system == "Windows":
             return "Windows"
-    
+
         if system == "Darwin":
-            return "aarch64-apple-darwin" if machine == "arm64" else "x86_64-apple-darwin"
-    
+            return (
+                "aarch64-apple-darwin" if machine == "arm64" else "x86_64-apple-darwin"
+            )
+
         if system == "Linux":
-            return "aarch64-unknown-linux-gnu" if machine in ("aarch64", "arm64") else "x86_64-unknown-linux-gnu"
+            return (
+                "aarch64-unknown-linux-gnu"
+                if machine in ("aarch64", "arm64")
+                else "x86_64-unknown-linux-gnu"
+            )
 
         return "x86_64-unknown-linux-gnu"
 
@@ -106,138 +108,131 @@ class YTDLMod(loader.Module):
     async def client_ready(self, client, db):
         deno_path = Path("deno")
         deno_which = shutil.which("deno")
+
+        # Trying to fix previous shitcode...
+        if self.get("deno_source") == "file":
+            self.set("deno_source", str(deno_path.resolve())) 
+            
         if not deno_which and not deno_path.is_file():
             logger.warning("Deno is not installed, attempting installation...")
             target = await self.get_target()
             if target == "Windows":
-                logger.critical("Windows platform is unsupported by this module. All future commands will fail. Please, unload the module.")
-                return 
+                logger.critical(
+                    "Windows platform is unsupported by this module. All future commands will fail. Please, unload the module."
+                )
+                return
             async with aiohttp.ClientSession() as session:
                 download_link = f"https://github.com/denoland/deno/releases/latest/download/deno-{target}.zip"
                 async with session.get(download_link) as resp:
                     if resp.status == 200:
-                        async with aiofiles.open("deno.zip", mode='wb') as f:
-                                async for chunk in resp.content.iter_chunked(8192):
-                                    await f.write(chunk)
+                        async with aiofiles.open("deno.zip", mode="wb") as f:
+                            async for chunk in resp.content.iter_chunked(8192):
+                                await f.write(chunk)
                     else:
                         logger.critical(f"Failed to download Deno: HTTP {resp.status}")
                         self.set("deno_source", "install_failed")
                         return
             if Path("deno.zip").is_file():
-                with zipfile.ZipFile("deno.zip","r") as zip_ref:
+                with zipfile.ZipFile("deno.zip", "r") as zip_ref:
                     zip_ref.extractall()
                 os.remove("deno.zip")
                 os.chmod(deno_path, 0o755)
-                self.set("deno_source", "file")
+                self.set("deno_source", str(deno_path.resolve()))
         elif deno_which:
             self.set("deno_source", deno_which)
-    
-    @loader.command(
-        en_doc="Download video",
-        ru_doc="Скачать видео"
-    )
+
+    @loader.command(en_doc="Download video", ru_doc="Скачать видео")
     async def ytdlvcmd(self, message):
         args = utils.get_args(message)
         if not args or not self._validate_url(args[0]) or len(args) > 1:
-            await utils.answer(message, self.strings['invalid_args'])
+            await utils.answer(message, self.strings["invalid_args"])
             return
 
-
-        source = self.get('deno_source')
-        deno_path = Path('deno').resolve() if source == 'file' else source if source != 'install_failed' else None
-        if not deno_path:
-            logger.critical("Deno wasn't installed in auto-mode. Please, install it manually or resolve the issue and reboot userbot.")
+        source = self.get("deno_source")
+        if source == "install_failed" or not Path(source).is_file():
+            logger.critical(
+                "Deno wasn't installed in auto-mode. Please, install it manually or resolve the issue and reboot userbot."
+            )
             return
-        
-        await utils.answer(message, self.strings['downloading_video'])
-        
+
+        await utils.answer(message, self.strings["downloading"])
+
         filename_prefix = f"video_{message.id}"
         ydl_opts = {
-            'quiet': True,
-            'outtmpl': f'{filename_prefix}.%(ext)s',
-            'js_runtimes': {'deno': {'path': str(deno_path)}},
-            
-            'extractor_args': {
-                'youtube': {
-                    'player_client': ['mweb', 'android'],
+            "quiet": True,
+            "outtmpl": f"{filename_prefix}.%(ext)s",
+            "js_runtimes": {"deno": {"path": source}},
+            "postprocessors": [
+                {
+                    "key": "FFmpegVideoConvertor",
+                    "preferedformat": "mp4",
                 }
-            },
-
-            'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
-            
-            'postprocessors': [{
-                'key': 'FFmpegVideoConvertor',
-                'preferedformat': 'mp4',
-            }],
-            'postprocessor_args': {
-                'video_convertor': [
-                    '-c:v', 'libx264',
-                    '-pix_fmt', 'yuv420p',
-                    '-preset', 'veryfast',
-                    '-crf', '23',
-                    '-c:a', 'aac'
+            ],
+            "postprocessor_args": {
+                "video_convertor": [
+                    "-c:v",
+                    "libx264",
+                    "-pix_fmt",
+                    "yuv420p",
+                    "-preset",
+                    "veryfast",
+                    "-crf",
+                    "23",
+                    "-c:a",
+                    "aac",
                 ],
-                'merger': [
-                    '-movflags', 'faststart'
-                ]
+                "merger": ["-movflags", "faststart"],
             },
         }
-        if self.get('youtube_cookie'):
-            ydl_opts['cookiefile'] = self.get('youtube_cookie')
+        if self.get("youtube_cookie"):
+            ydl_opts["cookiefile"] = self.get("youtube_cookie")
         with YoutubeDL(ydl_opts) as ydl:
             info = ydl.extract_info(args[0], download=True)
-            filename = ydl.prepare_filename(info)
-            await self.client.send_file(message.chat_id, filename, caption=self.strings['downloaded_video'])
-            await message.delete()
+            filename = ydl.prepare_filename(info).split(".")[0] + ".mp4"
+            await utils.answer(message, self.strings['done'], file=filename, invert_media=True)
+            os.remove(filename)
 
-    @loader.command(
-        en_doc="Download audio",
-        ru_doc="Скачать аудио"
-    )
+    @loader.command(en_doc="Download audio", ru_doc="Скачать аудио")
     async def ytdlacmd(self, message):
         args = utils.get_args(message)
         if not args or not self._validate_url(args[0]) or len(args) > 1:
-            await utils.answer(message, self.strings['invalid_args'])
+            await utils.answer(message, self.strings["invalid_args"])
             return
 
-
-        source = self.get('deno_source')
-        deno_path = Path('deno').resolve() if source == 'file' else source if source != 'install_failed' else None
-        if not deno_path:
-            logger.critical("Deno wasn't installed in auto-mode. Please, install it manually or resolve the issue and reboot userbot.")
+        source = self.get("deno_source")
+        if source == "install_failed" or not Path(source).is_file():
+            logger.critical(
+                "Deno wasn't installed in auto-mode. Please, install it manually or resolve the issue and reboot userbot."
+            )
             return
-        
-        await utils.answer(message, self.strings['downloading_audio'])
-        
+
+        await utils.answer(message, self.strings["downloading"])
+
         filename_prefix = f"audio_{message.id}"
         ydl_opts = {
-            'quiet': True,
-            'outtmpl': f'{filename_prefix}.%(ext)s',
-            'js_runtimes': {'deno': {'path': str(deno_path)}},
-            
-           'postprocessors': [
-        {
-            'key': 'FFmpegExtractAudio',
-            'preferredcodec': 'mp3',
-            'preferredquality': '0',
-        },
-        {
-            'key': 'FFmpegMetadata',
-            'add_metadata': True,
-        },
-        {
-            'key': 'EmbedThumbnail',
-        },
-    ],
-            'writethumbnail': True,
+            "quiet": True,
+            "outtmpl": f"{filename_prefix}.%(ext)s",
+            "js_runtimes": {"deno": {"path": source}},
+            "postprocessors": [
+                {
+                    "key": "FFmpegExtractAudio",
+                    "preferredcodec": "mp3",
+                    "preferredquality": "0",
+                },
+                {
+                    "key": "FFmpegMetadata",
+                    "add_metadata": True,
+                },
+                {
+                    "key": "EmbedThumbnail",
+                },
+            ],
+            "writethumbnail": True,
         }
-        if self.get('youtube_cookie'):
-            ydl_opts['cookiefile'] = self.get('youtube_cookie')
+        if self.get("youtube_cookie"):
+            ydl_opts["cookiefile"] = self.get("youtube_cookie")
         with YoutubeDL(ydl_opts) as ydl:
             info = ydl.extract_info(args[0], download=True)
             filename = ydl.prepare_filename(info).split(".")[0] + ".mp3"
-            await self.client.send_file(message.chat_id, filename, caption=self.strings['downloaded_audio'])
-            await message.delete()
-        
-
-
+            await utils.answer(message, self.strings['done'], file=filename)
+            os.remove(filename)

modules.json

@@ -29726,355 +29726,6 @@
       "Chat"
     ]
   },
-  "unneyon/hikka-mods/warpigs.py": {
-    "name": "WarPigsMod",
-    "description": "Some auto-functions for your pig in @warpigs_bot",
-    "meta": {
-      "pic": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/warpigs.png",
-      "banner": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/warpigs.png",
-      "developer": "@kamekuro_hmods"
-    },
-    "commands": [
-      {
-        "afightcmd": "👉 Enable/disable autofight 👉 Включить/отключить автобой"
-      },
-      {
-        "agrowcmd": "👉 Enable/disable autogrow 👉 Включить/отключить автокормёжку"
-      },
-      {
-        "setnamecmd": "<name> 👉 Changes your pig's name <имя> 👉 Меняет имя вашего хряка"
-      }
-    ],
-    "new_commands": [
-      {
-        "afight": {
-          "ru_doc": "👉 Включить/отключить автобой",
-          "en_doc": null,
-          "doc": "👉 Enable/disable autofight"
-        }
-      },
-      {
-        "agrow": {
-          "ru_doc": "👉 Включить/отключить автокормёжку",
-          "en_doc": null,
-          "doc": "👉 Enable/disable autogrow"
-        }
-      },
-      {
-        "setname": {
-          "ru_doc": "<имя> 👉 Меняет имя вашего хряка",
-          "en_doc": null,
-          "doc": "<name> 👉 Changes your pig's name"
-        }
-      }
-    ],
-    "category": [
-      "Chat",
-      "Tools"
-    ]
-  },
-  "unneyon/hikka-mods/tidal.py": {
-    "name": "TidalMod",
-    "description": "API wrapper over TIDAL Hi-Fi music streaming service\nThanks @hikarimods for original module: t.me/hikarimods/764",
-    "meta": {
-      "pic": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/tidal.png",
-      "banner": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/tidal.png",
-      "developer": "@kamekuro_hmods"
-    },
-    "commands": [
-      {
-        "tlogincmd": "👉 Open OAuth window to login into TIDAL 👉 Авторизация в TIDAL"
-      },
-      {
-        "tidalcmd": "<query> 👉 Search track in TIDAL <запрос> 👉 Поиск трека в TIDAL"
-      },
-      {
-        "turlcmd": "<ID/url> 👉 Search track in TIDAL by ID or url <ID/ссылка> 👉 Поиск трека в TIDAL по ID или ссылке"
-      }
-    ],
-    "new_commands": [
-      {
-        "tlogin": {
-          "ru_doc": "👉 Авторизация в TIDAL",
-          "en_doc": null,
-          "doc": "👉 Open OAuth window to login into TIDAL"
-        }
-      },
-      {
-        "tidal": {
-          "ru_doc": "<запрос> 👉 Поиск трека в TIDAL",
-          "en_doc": null,
-          "doc": "<query> 👉 Search track in TIDAL"
-        }
-      },
-      {
-        "turl": {
-          "ru_doc": "<ID/ссылка> 👉 Поиск трека в TIDAL по ID или ссылке",
-          "en_doc": null,
-          "doc": "<ID/url> 👉 Search track in TIDAL by ID or url"
-        }
-      }
-    ],
-    "category": [
-      "Tools",
-      "Games"
-    ]
-  },
-  "unneyon/hikka-mods/sdsaver.py": {
-    "name": "SDSaverMod",
-    "description": "The module for automatically saving self-destructing media",
-    "meta": {
-      "pic": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/sdsaver.png",
-      "banner": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/sdsaver.png",
-      "developer": "@kamekuro_hmods"
-    },
-    "commands": [
-      {
-        "sdmodecmd": "👉 Enable/Disable automatic saving self-destructing media 👉 Включить/Выключить автоматическое сохранение самоуничтожающихся медиа"
-      }
-    ],
-    "new_commands": [
-      {
-        "sdmode": {
-          "ru_doc": "👉 Включить/Выключить автоматическое сохранение самоуничтожающихся медиа",
-          "en_doc": null,
-          "doc": "👉 Enable/Disable automatic saving self-destructing media"
-        }
-      }
-    ],
-    "category": [
-      "Chat",
-      "Tools"
-    ]
-  },
-  "unneyon/hikka-mods/yamusic.py": {
-    "name": "YaMusicMod",
-    "description": "The module for Yandex.Music streaming service",
-    "meta": {
-      "pic": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/yamusic.png",
-      "banner": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/yamusic.png",
-      "developer": "@kamekuro_hmods"
-    },
-    "commands": [
-      {
-        "yguidecmd": "👉 Guide for obtaining a Yandex.Music token 👉 Гайд по получению токена Яндекс.Музыки"
-      },
-      {
-        "ybiocmd": "👉 Enable/disable autobio 👉 Включить/выключить автобио"
-      },
-      {
-        "ysearchcmd": "👉 Searching tracks in Yandex.Music 👉 Поиск треков в Яндекс.Музыке"
-      },
-      {
-        "ynowcmd": "👉 Get the banner of the track playing right now 👉 Получить баннер трека, который играет сейчас"
-      },
-      {
-        "ynowtcmd": "👉 Get the track playing right now 👉 Получить трек, который играет сейчас"
-      },
-      {
-        "ylikecmd": "👉 Like the track playing right now 👉 Лайкнуть играющий сейчас трек"
-      },
-      {
-        "yunlikecmd": "👉 Unlike the track playing right now 👉 Снять лайк с играющего сейчас трека"
-      },
-      {
-        "ydislikecmd": "👉 Dislike the track playing right now 👉 Дизлайкнуть играющий сейчас трек"
-      },
-      {
-        "ylyricscmd": "👉 Get the lyrics of the track playing right now 👉 Получить текст играющего сейчас трека"
-      }
-    ],
-    "new_commands": [
-      {
-        "yguide": {
-          "ru_doc": "👉 Гайд по получению токена Яндекс.Музыки",
-          "en_doc": null,
-          "doc": "👉 Guide for obtaining a Yandex.Music token"
-        }
-      },
-      {
-        "ybio": {
-          "ru_doc": "👉 Включить/выключить автобио",
-          "en_doc": null,
-          "doc": "👉 Enable/disable autobio"
-        }
-      },
-      {
-        "ysearch": {
-          "ru_doc": "👉 Поиск треков в Яндекс.Музыке",
-          "en_doc": null,
-          "doc": "👉 Searching tracks in Yandex.Music"
-        }
-      },
-      {
-        "ynow": {
-          "ru_doc": "👉 Получить баннер трека, который играет сейчас",
-          "en_doc": null,
-          "doc": "👉 Get the banner of the track playing right now"
-        }
-      },
-      {
-        "ynowt": {
-          "ru_doc": "👉 Получить трек, который играет сейчас",
-          "en_doc": null,
-          "doc": "👉 Get the track playing right now"
-        }
-      },
-      {
-        "ylike": {
-          "ru_doc": "👉 Лайкнуть играющий сейчас трек",
-          "en_doc": null,
-          "doc": "👉 Like the track playing right now"
-        }
-      },
-      {
-        "yunlike": {
-          "ru_doc": "👉 Снять лайк с играющего сейчас трека",
-          "en_doc": null,
-          "doc": "👉 Unlike the track playing right now"
-        }
-      },
-      {
-        "ydislike": {
-          "ru_doc": "👉 Дизлайкнуть играющий сейчас трек",
-          "en_doc": null,
-          "doc": "👉 Dislike the track playing right now"
-        }
-      },
-      {
-        "ylyrics": {
-          "ru_doc": "👉 Получить текст играющего сейчас трека",
-          "en_doc": null,
-          "doc": "👉 Get the lyrics of the track playing right now"
-        }
-      }
-    ],
-    "category": [
-      "Tools",
-      "Fun"
-    ]
-  },
-  "unneyon/hikka-mods/privacy.py": {
-    "name": "PrivacyMod",
-    "description": "Module for fastly changing privacy settings",
-    "meta": {
-      "pic": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/privacy.png",
-      "banner": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/privacy.png",
-      "developer": "@kamekuro_hmods"
-    },
-    "commands": [
-      {
-        "privacytypescmd": "👉 List of setting types to pass it in commands 👉 Список типов настроек для указания их в командах"
-      },
-      {
-        "allowusercmd": "<user> [setting (optional)] 👉 Add user to includes for some setting <пользователь> [настройка (необязательно)] 👉 Добавить пользователя в разрешённых для какой-либо настройки"
-      },
-      {
-        "disallowusercmd": "<user> [setting (optional)] 👉 Add user to excludes for some setting <пользователь> [настройка (необязательно)] 👉 Добавить пользователя в запрещённых для какой-либо настройки"
-      }
-    ],
-    "new_commands": [
-      {
-        "privacytypes": {
-          "ru_doc": "👉 Список типов настроек для указания их в командах",
-          "en_doc": null,
-          "doc": "👉 List of setting types to pass it in commands"
-        }
-      },
-      {
-        "allowuser": {
-          "ru_doc": "<пользователь> [настройка (необязательно)] 👉 Добавить пользователя в разрешённых для какой-либо настройки",
-          "en_doc": null,
-          "doc": "<user> [setting (optional)] 👉 Add user to includes for some setting"
-        }
-      },
-      {
-        "disallowuser": {
-          "ru_doc": "<пользователь> [настройка (необязательно)] 👉 Добавить пользователя в запрещённых для какой-либо настройки",
-          "en_doc": null,
-          "doc": "<user> [setting (optional)] 👉 Add user to excludes for some setting"
-        }
-      }
-    ],
-    "category": [
-      "Chat",
-      "Tools"
-    ]
-  },
-  "unneyon/hikka-mods/caliases.py": {
-    "name": "CustomAliasesMod",
-    "description": "Module for custom aliases",
-    "meta": {
-      "pic": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/caliases.png",
-      "banner": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/caliases.png",
-      "developer": "@kamekuro_hmods"
-    },
-    "commands": [
-      {
-        "caliasescmd": "👉 Get all aliases 👉 Получить список всех алиасов"
-      },
-      {
-        "rmcaliascmd": "<name> 👉 Remove alias <имя> 👉 Удалить алиас"
-      },
-      {
-        "caliascmd": "<name> <command> [args] 👉 Add new alias (may contain {args} keyword) <имя> <команда> [аргументы] 👉 Добавить новый алиас (может содержать ключевое слово {args})"
-      }
-    ],
-    "new_commands": [
-      {
-        "caliases": {
-          "ru_doc": "👉 Получить список всех алиасов",
-          "en_doc": null,
-          "doc": "👉 Get all aliases"
-        }
-      },
-      {
-        "rmcalias": {
-          "ru_doc": "<имя> 👉 Удалить алиас",
-          "en_doc": null,
-          "doc": "<name> 👉 Remove alias"
-        }
-      },
-      {
-        "calias": {
-          "ru_doc": "<имя> <команда> [аргументы] 👉 Добавить новый алиас (может содержать ключевое слово {args})",
-          "en_doc": null,
-          "doc": "<name> <command> [args] 👉 Add new alias (may contain {args} keyword)"
-        }
-      }
-    ],
-    "category": [
-      "Chat",
-      "Info"
-    ]
-  },
-  "unneyon/hikka-mods/deleter.py": {
-    "name": "DeleterMod",
-    "description": "Module for delete your messages",
-    "meta": {
-      "pic": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/deleter.png",
-      "banner": "https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/deleter.png",
-      "developer": "@kamekuro_hmods"
-    },
-    "commands": [
-      {
-        "delmsgcmd": "[count] 👉 Delete messages (you can use your trigger from config: «{value}{count}» and write them only together!) [число] 👉 Удалить сообщения (можно использовать значение из конфига: «{значение}{число}», без пробела!)"
-      }
-    ],
-    "new_commands": [
-      {
-        "delmsg": {
-          "ru_doc": "[число] 👉 Удалить сообщения (можно использовать значение из конфига: «{значение}{число}», без пробела!)",
-          "en_doc": null,
-          "doc": "[count] 👉 Delete messages (you can use your trigger from config: «{value}{count}» and write them only together!)"
-        }
-      }
-    ],
-    "category": [
-      "Tools",
-      "Chat"
-    ]
-  },
   "N3rcy/modules/whisper.py": {
     "name": "WhisperMod",
     "description": "Module for speech recognition",
@@ -31133,95 +30784,115 @@
     },
     "commands": [
       {
-        "sreacts": "Toggle global silent reactions [on/off] - тихие реакции во всех чатах [on/off] - silent reactions in all chats"
+        "_toggle_setting": "[on/off] - тихие реакции во всех чатах [on/off] - silent reactions in all chats"
       },
       {
-        "stags": "Toggle global silent tags [on/off] - тихие упоминания во всех чатах [on/off] - silent tags in all chats"
+        "sreacts": "[on/off] - тихие реакции во всех чатах [on/off] - silent reactions in all chats"
       },
       {
-        "sall": "Toggle global silent reactions and tags [on/off] - тихие реакции и упоминания во всех чатах [on/off] - silent reactions and tags in all chats"
+        "stags": "[on/off] - тихие упоминания во всех чатах [on/off] - silent tags in all chats"
       },
       {
-        "hsreacts": "Toggle silent reactions in this chat [on/off] - тихие реакции в этом чате [on/off] - silent reactions in this chat"
+        "sall": "[on/off] - тихие реакции и упоминания во всех чатах [on/off] - silent reactions and tags in all chats"
       },
       {
-        "hstags": "Toggle silent tags in this chat [on/off] - тихие упоминания в этом чате [on/off] - silent tags in this chat"
+        "hsreacts": "[on/off] - тихие реакции в этом чате [on/off] - silent reactions in this chat"
       },
       {
-        "hsall": "Toggle silent reactions and tags in this chat [on/off] - тихие реакции и упоминания в этом чате [on/off] - silent reactions and tags in this chat"
+        "hstags": "[on/off] - тихие упоминания в этом чате [on/off] - silent tags in this chat"
       },
       {
-        "ignore": "Toggle ignore user globally [ответ/username] - игнорировать пользователя глобально [reply/username] - ignore user globally"
+        "hsall": "[on/off] - тихие реакции и упоминания в этом чате [on/off] - silent reactions and tags in this chat"
       },
       {
-        "hignore": "Toggle ignore user in this chat [ответ/username] - игнорировать пользователя в этом чате [reply/username] - ignore user in this chat"
+        "_get_user_id": "[ответ/username] - игнорировать пользователя глобально [reply/username] - ignore user globally"
       },
       {
-        "strstatus": "Show status Показать статус Silent T&R Show Silent T&R status"
+        "ignore": "[ответ/username] - игнорировать пользователя в этом чате [reply/username] - ignore user in this chat"
+      },
+      {
+        "hignore": "Показать статус Silent T&R Show Silent T&R status"
+      },
+      {
+        "strstatus": "Показать статус Silent T&R Show Silent T&R status"
       }
     ],
     "new_commands": [
+      {
+        "_toggle_setting": {
+          "ru_doc": "[on/off] - тихие реакции во всех чатах",
+          "en_doc": "[on/off] - silent reactions in all chats",
+          "doc": null
+        }
+      },
       {
         "sreacts": {
           "ru_doc": "[on/off] - тихие реакции во всех чатах",
           "en_doc": "[on/off] - silent reactions in all chats",
-          "doc": "Toggle global silent reactions"
+          "doc": null
         }
       },
       {
         "stags": {
           "ru_doc": "[on/off] - тихие упоминания во всех чатах",
           "en_doc": "[on/off] - silent tags in all chats",
-          "doc": "Toggle global silent tags"
+          "doc": null
         }
       },
       {
         "sall": {
           "ru_doc": "[on/off] - тихие реакции и упоминания во всех чатах",
           "en_doc": "[on/off] - silent reactions and tags in all chats",
-          "doc": "Toggle global silent reactions and tags"
+          "doc": null
         }
       },
       {
         "hsreacts": {
           "ru_doc": "[on/off] - тихие реакции в этом чате",
           "en_doc": "[on/off] - silent reactions in this chat",
-          "doc": "Toggle silent reactions in this chat"
+          "doc": null
         }
       },
       {
         "hstags": {
           "ru_doc": "[on/off] - тихие упоминания в этом чате",
           "en_doc": "[on/off] - silent tags in this chat",
-          "doc": "Toggle silent tags in this chat"
+          "doc": null
         }
       },
       {
         "hsall": {
           "ru_doc": "[on/off] - тихие реакции и упоминания в этом чате",
           "en_doc": "[on/off] - silent reactions and tags in this chat",
-          "doc": "Toggle silent reactions and tags in this chat"
+          "doc": null
+        }
+      },
+      {
+        "_get_user_id": {
+          "ru_doc": "[ответ/username] - игнорировать пользователя глобально",
+          "en_doc": "[reply/username] - ignore user globally",
+          "doc": null
         }
       },
       {
         "ignore": {
-          "ru_doc": "[ответ/username] - игнорировать пользователя глобально",
-          "en_doc": "[reply/username] - ignore user globally",
-          "doc": "Toggle ignore user globally"
+          "ru_doc": "[ответ/username] - игнорировать пользователя в этом чате",
+          "en_doc": "[reply/username] - ignore user in this chat",
+          "doc": null
         }
       },
       {
         "hignore": {
-          "ru_doc": "[ответ/username] - игнорировать пользователя в этом чате",
-          "en_doc": "[reply/username] - ignore user in this chat",
-          "doc": "Toggle ignore user in this chat"
+          "ru_doc": "Показать статус Silent T&R",
+          "en_doc": "Show Silent T&R status",
+          "doc": null
         }
       },
       {
         "strstatus": {
           "ru_doc": "Показать статус Silent T&R",
           "en_doc": "Show Silent T&R status",
-          "doc": "Show status"
+          "doc": null
         }
       }
     ],
@@ -31498,7 +31169,10 @@
     },
     "commands": [
       {
-        "btname": "Выставить таймер дней в ник (нестабильно) Set the timer of days in the nickname (unstable)"
+        "btnameon": "Включить таймер дней в ник (нестабильно) Enable timer of days in nickname (unstable)"
+      },
+      {
+        "btnameoff": "Выключить таймер дней в ник Disable timer of days in nickname"
       },
       {
         "bt": "Вывести таймер Display the timer"
@@ -31506,9 +31180,16 @@
     ],
     "new_commands": [
       {
-        "btname": {
-          "ru_doc": "Выставить таймер дней в ник (нестабильно)",
-          "en_doc": "Set the timer of days in the nickname (unstable)",
+        "btnameon": {
+          "ru_doc": "Включить таймер дней в ник (нестабильно)",
+          "en_doc": "Enable timer of days in nickname (unstable)",
+          "doc": null
+        }
+      },
+      {
+        "btnameoff": {
+          "ru_doc": "Выключить таймер дней в ник",
+          "en_doc": "Disable timer of days in nickname",
           "doc": null
         }
       },
@@ -31693,6 +31374,33 @@
       "Tools"
     ]
   },
+  "archquise/H.Modules/TelegraphComic.py": {
+    "name": "TelegraphComicMod",
+    "description": "Create comics on Telegraph from ZIP/CBZ/RAR archives",
+    "meta": {
+      "pic": null,
+      "banner": null,
+      "developer": "@hikka_mods"
+    },
+    "commands": [
+      {
+        "telegraphcomicscmd": "Создать комикс на Telegraph из ZIP/CBZ/RAR архива\nАргументы: <название> | <ссылка_на_обложку>(необязательно)\nИспользование: .telegraphcomics <title> | <cover_url>(optional) Create Telegraph comic from ZIP/CBZ/RAR archive\nArguments: <title> | <cover_url>(optional)\nUsage: .telegraphcomics <title> | <cover_url>(optional)"
+      }
+    ],
+    "new_commands": [
+      {
+        "telegraphcomics": {
+          "ru_doc": "Создать комикс на Telegraph из ZIP/CBZ/RAR архива\nАргументы: <название> | <ссылка_на_обложку>(необязательно)\nИспользование: .telegraphcomics <title> | <cover_url>(optional)",
+          "en_doc": "Create Telegraph comic from ZIP/CBZ/RAR archive\nArguments: <title> | <cover_url>(optional)\nUsage: .telegraphcomics <title> | <cover_url>(optional)",
+          "doc": null
+        }
+      }
+    ],
+    "category": [
+      "Chat",
+      "Tools"
+    ]
+  },
   "archquise/H.Modules/TelegramStatusCodes.py": {
     "name": "TelegramStatusCodes",
     "description": "Dictionary of telegram status codes",
@@ -32045,6 +31753,33 @@
       "Tools"
     ]
   },
+  "archquise/H.Modules/sdsaver.py": {
+    "name": "SDSaverMod",
+    "description": "The module for automatically saving self-destructing media",
+    "meta": {
+      "pic": null,
+      "banner": null,
+      "developer": "@hikka_mods"
+    },
+    "commands": [
+      {
+        "sdmodecmd": "Включить/Выключить автоматическое сохранение самоуничтожающихся медиа Enable/Disable automatic saving self-destructing media"
+      }
+    ],
+    "new_commands": [
+      {
+        "sdmode": {
+          "ru_doc": "Включить/Выключить автоматическое сохранение самоуничтожающихся медиа",
+          "en_doc": "Enable/Disable automatic saving self-destructing media",
+          "doc": null
+        }
+      }
+    ],
+    "category": [
+      "Chat",
+      "Tools"
+    ]
+  },
   "archquise/H.Modules/Weather.py": {
     "name": "Weather",
     "description": "Advanced weather module with detailed information",
@@ -32353,6 +32088,100 @@
       "Chat"
     ]
   },
+  "archquise/H.Modules/privacy.py": {
+    "name": "PrivacyMod",
+    "description": "Module for fast privacy settings management",
+    "meta": {
+      "pic": null,
+      "banner": null,
+      "developer": "@hikka_mods"
+    },
+    "commands": [
+      {
+        "privacytypescmd": "Show available privacy types Список типов настроек приватности List of privacy types"
+      },
+      {
+        "allowusercmd": "Add user to privacy exceptions <user> Добавить в разрешённые <user> Add to allowed list"
+      },
+      {
+        "disallowuser": "Add user to privacy restrictions <user> Добавить в запрещённые <user> Add to forbidden list"
+      }
+    ],
+    "new_commands": [
+      {
+        "privacytypes": {
+          "ru_doc": "Список типов настроек приватности",
+          "en_doc": "List of privacy types",
+          "doc": "Show available privacy types"
+        }
+      },
+      {
+        "allowuser": {
+          "ru_doc": "<user> Добавить в разрешённые",
+          "en_doc": "<user> Add to allowed list",
+          "doc": "Add user to privacy exceptions"
+        }
+      },
+      {
+        "disallowuser": {
+          "ru_doc": "<user> Добавить в запрещённые",
+          "en_doc": "<user> Add to forbidden list",
+          "doc": "Add user to privacy restrictions"
+        }
+      }
+    ],
+    "category": [
+      "Chat",
+      "Tools"
+    ]
+  },
+  "archquise/H.Modules/caliases.py": {
+    "name": "CustomAliasesMod",
+    "description": "Module for custom aliases",
+    "meta": {
+      "pic": null,
+      "banner": null,
+      "developer": "@hikka_mods"
+    },
+    "commands": [
+      {
+        "caliasescmd": "Get all aliases Получить список всех алиасов  Get list of all aliases"
+      },
+      {
+        "rmcaliascmd": "Remove alias <имя> Удалить алиас <name> Remove alias"
+      },
+      {
+        "caliascmd": "Add new alias (may contain {args} keyword) <имя> <команда> [аргументы] Добавить новый алиас (может содержать ключевое слово {args}) <name> <command> [arguments] Add new alias (may contain {args} keyword)"
+      }
+    ],
+    "new_commands": [
+      {
+        "caliases": {
+          "ru_doc": "Получить список всех алиасов",
+          "en_doc": " Get list of all aliases",
+          "doc": "Get all aliases"
+        }
+      },
+      {
+        "rmcalias": {
+          "ru_doc": "<имя> Удалить алиас",
+          "en_doc": "<name> Remove alias",
+          "doc": "Remove alias"
+        }
+      },
+      {
+        "calias": {
+          "ru_doc": "<имя> <команда> [аргументы] Добавить новый алиас (может содержать ключевое слово {args})",
+          "en_doc": "<name> <command> [arguments] Add new alias (may contain {args} keyword)",
+          "doc": "Add new alias (may contain {args} keyword)"
+        }
+      }
+    ],
+    "category": [
+      "Chat",
+      "Info"
+    ]
+  },
   "archquise/H.Modules/VirusTotal.py": {
     "name": "VirusTotalMod",
     "description": "Professional file scanning with VirusTotal",

unneyon/hikka-mods/LICENSE

@@ -1,402 +0,0 @@
-Attribution-NonCommercial-NoDerivatives 4.0 International
-
-=======================================================================
-
-Creative Commons Corporation ("Creative Commons") is not a law firm and
-does not provide legal services or legal advice. Distribution of
-Creative Commons public licenses does not create a lawyer-client or
-other relationship. Creative Commons makes its licenses and related
-information available on an "as-is" basis. Creative Commons gives no
-warranties regarding its licenses, any material licensed under their
-terms and conditions, or any related information. Creative Commons
-disclaims all liability for damages resulting from their use to the
-fullest extent possible.
-
-Using Creative Commons Public Licenses
-
-Creative Commons public licenses provide a standard set of terms and
-conditions that creators and other rights holders may use to share
-original works of authorship and other material subject to copyright
-and certain other rights specified in the public license below. The
-following considerations are for informational purposes only, are not
-exhaustive, and do not form part of our licenses.
-
-     Considerations for licensors: Our public licenses are
-     intended for use by those authorized to give the public
-     permission to use material in ways otherwise restricted by
-     copyright and certain other rights. Our licenses are
-     irrevocable. Licensors should read and understand the terms
-     and conditions of the license they choose before applying it.
-     Licensors should also secure all rights necessary before
-     applying our licenses so that the public can reuse the
-     material as expected. Licensors should clearly mark any
-     material not subject to the license. This includes other CC-
-     licensed material, or material used under an exception or
-     limitation to copyright. More considerations for licensors:
-    wiki.creativecommons.org/Considerations_for_licensors
-
-     Considerations for the public: By using one of our public
-     licenses, a licensor grants the public permission to use the
-     licensed material under specified terms and conditions. If
-     the licensor's permission is not necessary for any reason--for
-     example, because of any applicable exception or limitation to
-     copyright--then that use is not regulated by the license. Our
-     licenses grant only permissions under copyright and certain
-     other rights that a licensor has authority to grant. Use of
-     the licensed material may still be restricted for other
-     reasons, including because others have copyright or other
-     rights in the material. A licensor may make special requests,
-     such as asking that all changes be marked or described.
-     Although not required by our licenses, you are encouraged to
-     respect those requests where reasonable. More considerations
-     for the public:
-    wiki.creativecommons.org/Considerations_for_licensees
-
-=======================================================================
-
-Creative Commons Attribution-NonCommercial-NoDerivatives 4.0
-International Public License
-
-By exercising the Licensed Rights (defined below), You accept and agree
-to be bound by the terms and conditions of this Creative Commons
-Attribution-NonCommercial-NoDerivatives 4.0 International Public
-License ("Public License"). To the extent this Public License may be
-interpreted as a contract, You are granted the Licensed Rights in
-consideration of Your acceptance of these terms and conditions, and the
-Licensor grants You such rights in consideration of benefits the
-Licensor receives from making the Licensed Material available under
-these terms and conditions.
-
-
-Section 1 -- Definitions.
-
-  a. Adapted Material means material subject to Copyright and Similar
-     Rights that is derived from or based upon the Licensed Material
-     and in which the Licensed Material is translated, altered,
-     arranged, transformed, or otherwise modified in a manner requiring
-     permission under the Copyright and Similar Rights held by the
-     Licensor. For purposes of this Public License, where the Licensed
-     Material is a musical work, performance, or sound recording,
-     Adapted Material is always produced where the Licensed Material is
-     synched in timed relation with a moving image.
-
-  b. Copyright and Similar Rights means copyright and/or similar rights
-     closely related to copyright including, without limitation,
-     performance, broadcast, sound recording, and Sui Generis Database
-     Rights, without regard to how the rights are labeled or
-     categorized. For purposes of this Public License, the rights
-     specified in Section 2(b)(1)-(2) are not Copyright and Similar
-     Rights.
-
-  c. Effective Technological Measures means those measures that, in the
-     absence of proper authority, may not be circumvented under laws
-     fulfilling obligations under Article 11 of the WIPO Copyright
-     Treaty adopted on December 20, 1996, and/or similar international
-     agreements.
-
-  d. Exceptions and Limitations means fair use, fair dealing, and/or
-     any other exception or limitation to Copyright and Similar Rights
-     that applies to Your use of the Licensed Material.
-
-  e. Licensed Material means the artistic or literary work, database,
-     or other material to which the Licensor applied this Public
-     License.
-
-  f. Licensed Rights means the rights granted to You subject to the
-     terms and conditions of this Public License, which are limited to
-     all Copyright and Similar Rights that apply to Your use of the
-     Licensed Material and that the Licensor has authority to license.
-
-  g. Licensor means the individual(s) or entity(ies) granting rights
-     under this Public License.
-
-  h. NonCommercial means not primarily intended for or directed towards
-     commercial advantage or monetary compensation. For purposes of
-     this Public License, the exchange of the Licensed Material for
-     other material subject to Copyright and Similar Rights by digital
-     file-sharing or similar means is NonCommercial provided there is
-     no payment of monetary compensation in connection with the
-     exchange.
-
-  i. Share means to provide material to the public by any means or
-     process that requires permission under the Licensed Rights, such
-     as reproduction, public display, public performance, distribution,
-     dissemination, communication, or importation, and to make material
-     available to the public including in ways that members of the
-     public may access the material from a place and at a time
-     individually chosen by them.
-
-  j. Sui Generis Database Rights means rights other than copyright
-     resulting from Directive 96/9/EC of the European Parliament and of
-     the Council of 11 March 1996 on the legal protection of databases,
-     as amended and/or succeeded, as well as other essentially
-     equivalent rights anywhere in the world.
-
-  k. You means the individual or entity exercising the Licensed Rights
-     under this Public License. Your has a corresponding meaning.
-
-
-Section 2 -- Scope.
-
-  a. License grant.
-
-       1. Subject to the terms and conditions of this Public License,
-          the Licensor hereby grants You a worldwide, royalty-free,
-          non-sublicensable, non-exclusive, irrevocable license to
-          exercise the Licensed Rights in the Licensed Material to:
-
-            a. reproduce and Share the Licensed Material, in whole or
-               in part, for NonCommercial purposes only; and
-
-            b. produce and reproduce, but not Share, Adapted Material
-               for NonCommercial purposes only.
-
-       2. Exceptions and Limitations. For the avoidance of doubt, where
-          Exceptions and Limitations apply to Your use, this Public
-          License does not apply, and You do not need to comply with
-          its terms and conditions.
-
-       3. Term. The term of this Public License is specified in Section
-          6(a).
-
-       4. Media and formats; technical modifications allowed. The
-          Licensor authorizes You to exercise the Licensed Rights in
-          all media and formats whether now known or hereafter created,
-          and to make technical modifications necessary to do so. The
-          Licensor waives and/or agrees not to assert any right or
-          authority to forbid You from making technical modifications
-          necessary to exercise the Licensed Rights, including
-          technical modifications necessary to circumvent Effective
-          Technological Measures. For purposes of this Public License,
-          simply making modifications authorized by this Section 2(a)
-          (4) never produces Adapted Material.
-
-       5. Downstream recipients.
-
-            a. Offer from the Licensor -- Licensed Material. Every
-               recipient of the Licensed Material automatically
-               receives an offer from the Licensor to exercise the
-               Licensed Rights under the terms and conditions of this
-               Public License.
-
-            b. No downstream restrictions. You may not offer or impose
-               any additional or different terms or conditions on, or
-               apply any Effective Technological Measures to, the
-               Licensed Material if doing so restricts exercise of the
-               Licensed Rights by any recipient of the Licensed
-               Material.
-
-       6. No endorsement. Nothing in this Public License constitutes or
-          may be construed as permission to assert or imply that You
-          are, or that Your use of the Licensed Material is, connected
-          with, or sponsored, endorsed, or granted official status by,
-          the Licensor or others designated to receive attribution as
-          provided in Section 3(a)(1)(A)(i).
-
-  b. Other rights.
-
-       1. Moral rights, such as the right of integrity, are not
-          licensed under this Public License, nor are publicity,
-          privacy, and/or other similar personality rights; however, to
-          the extent possible, the Licensor waives and/or agrees not to
-          assert any such rights held by the Licensor to the limited
-          extent necessary to allow You to exercise the Licensed
-          Rights, but not otherwise.
-
-       2. Patent and trademark rights are not licensed under this
-          Public License.
-
-       3. To the extent possible, the Licensor waives any right to
-          collect royalties from You for the exercise of the Licensed
-          Rights, whether directly or through a collecting society
-          under any voluntary or waivable statutory or compulsory
-          licensing scheme. In all other cases the Licensor expressly
-          reserves any right to collect such royalties, including when
-          the Licensed Material is used other than for NonCommercial
-          purposes.
-
-
-Section 3 -- License Conditions.
-
-Your exercise of the Licensed Rights is expressly made subject to the
-following conditions.
-
-  a. Attribution.
-
-       1. If You Share the Licensed Material, You must:
-
-            a. retain the following if it is supplied by the Licensor
-               with the Licensed Material:
-
-                 i. identification of the creator(s) of the Licensed
-                    Material and any others designated to receive
-                    attribution, in any reasonable manner requested by
-                    the Licensor (including by pseudonym if
-                    designated);
-
-                ii. a copyright notice;
-
-               iii. a notice that refers to this Public License;
-
-                iv. a notice that refers to the disclaimer of
-                    warranties;
-
-                 v. a URI or hyperlink to the Licensed Material to the
-                    extent reasonably practicable;
-
-            b. indicate if You modified the Licensed Material and
-               retain an indication of any previous modifications; and
-
-            c. indicate the Licensed Material is licensed under this
-               Public License, and include the text of, or the URI or
-               hyperlink to, this Public License.
-
-          For the avoidance of doubt, You do not have permission under
-          this Public License to Share Adapted Material.
-
-       2. You may satisfy the conditions in Section 3(a)(1) in any
-          reasonable manner based on the medium, means, and context in
-          which You Share the Licensed Material. For example, it may be
-          reasonable to satisfy the conditions by providing a URI or
-          hyperlink to a resource that includes the required
-          information.
-
-       3. If requested by the Licensor, You must remove any of the
-          information required by Section 3(a)(1)(A) to the extent
-          reasonably practicable.
-
-
-Section 4 -- Sui Generis Database Rights.
-
-Where the Licensed Rights include Sui Generis Database Rights that
-apply to Your use of the Licensed Material:
-
-  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
-     to extract, reuse, reproduce, and Share all or a substantial
-     portion of the contents of the database for NonCommercial purposes
-     only and provided You do not Share Adapted Material;
-
-  b. if You include all or a substantial portion of the database
-     contents in a database in which You have Sui Generis Database
-     Rights, then the database in which You have Sui Generis Database
-     Rights (but not its individual contents) is Adapted Material; and
-
-  c. You must comply with the conditions in Section 3(a) if You Share
-     all or a substantial portion of the contents of the database.
-
-For the avoidance of doubt, this Section 4 supplements and does not
-replace Your obligations under this Public License where the Licensed
-Rights include other Copyright and Similar Rights.
-
-
-Section 5 -- Disclaimer of Warranties and Limitation of Liability.
-
-  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
-     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
-     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
-     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
-     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
-     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
-     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
-     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
-     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
-     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
-
-  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
-     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
-     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
-     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
-     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
-     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
-     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
-     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
-     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
-
-  c. The disclaimer of warranties and limitation of liability provided
-     above shall be interpreted in a manner that, to the extent
-     possible, most closely approximates an absolute disclaimer and
-     waiver of all liability.
-
-
-Section 6 -- Term and Termination.
-
-  a. This Public License applies for the term of the Copyright and
-     Similar Rights licensed here. However, if You fail to comply with
-     this Public License, then Your rights under this Public License
-     terminate automatically.
-
-  b. Where Your right to use the Licensed Material has terminated under
-     Section 6(a), it reinstates:
-
-       1. automatically as of the date the violation is cured, provided
-          it is cured within 30 days of Your discovery of the
-          violation; or
-
-       2. upon express reinstatement by the Licensor.
-
-     For the avoidance of doubt, this Section 6(b) does not affect any
-     right the Licensor may have to seek remedies for Your violations
-     of this Public License.
-
-  c. For the avoidance of doubt, the Licensor may also offer the
-     Licensed Material under separate terms or conditions or stop
-     distributing the Licensed Material at any time; however, doing so
-     will not terminate this Public License.
-
-  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
-     License.
-
-
-Section 7 -- Other Terms and Conditions.
-
-  a. The Licensor shall not be bound by any additional or different
-     terms or conditions communicated by You unless expressly agreed.
-
-  b. Any arrangements, understandings, or agreements regarding the
-     Licensed Material not stated herein are separate from and
-     independent of the terms and conditions of this Public License.
-
-
-Section 8 -- Interpretation.
-
-  a. For the avoidance of doubt, this Public License does not, and
-     shall not be interpreted to, reduce, limit, restrict, or impose
-     conditions on any use of the Licensed Material that could lawfully
-     be made without permission under this Public License.
-
-  b. To the extent possible, if any provision of this Public License is
-     deemed unenforceable, it shall be automatically reformed to the
-     minimum extent necessary to make it enforceable. If the provision
-     cannot be reformed, it shall be severed from this Public License
-     without affecting the enforceability of the remaining terms and
-     conditions.
-
-  c. No term or condition of this Public License will be waived and no
-     failure to comply consented to unless expressly agreed to by the
-     Licensor.
-
-  d. Nothing in this Public License constitutes or may be interpreted
-     as a limitation upon, or waiver of, any privileges and immunities
-     that apply to the Licensor or You, including from the legal
-     processes of any jurisdiction or authority.
-
-=======================================================================
-
-Creative Commons is not a party to its public
-licenses. Notwithstanding, Creative Commons may elect to apply one of
-its public licenses to material it publishes and in those instances
-will be considered the “Licensor.” The text of the Creative Commons
-public licenses is dedicated to the public domain under the CC0 Public
-Domain Dedication. Except for the limited purpose of indicating that
-material is shared under a Creative Commons public license or as
-otherwise permitted by the Creative Commons policies published at
-creativecommons.org/policies, Creative Commons does not authorize the
-use of the trademark "Creative Commons" or any other trademark or logo
-of Creative Commons without its prior written consent including,
-without limitation, in connection with any unauthorized modifications
-to any of its public licenses or any other arrangements,
-understandings, or agreements concerning use of licensed material. For
-the avoidance of doubt, this paragraph does not form part of the
-public licenses.
-
-Creative Commons may be contacted at creativecommons.org.

unneyon/hikka-mods/README.md

@@ -1,28 +0,0 @@
-# 🌘 Hikka Userbot Mods by @unneyon
-This repository contains a some list of modules for the Hikka Userbot. To install a module, simply copy the raw file link.
-
-## 😼 About Me
-You can contact me on Telegram: [@unneyon](https://t.me/unneyon). Feel free to reach out with any questions or inquiries. ❤<br>
-My Telegram channel with modules: [@unneyon_hmods](https://t.me/unneyon_hmods).<br>
-My modules also have comfortable web interface: [mods.unneyon.ru](https://mods.unneyon.ru).
-
-## 📥 How install
-
-You can install my modules using raw links. For example:
-```
-.dlm https://raw.githubusercontent.com/unneyon/hikka-mods/main/<module_name>
-```
-
-And you can use my repository, just add my repo:
-```
-.addrepo https://raw.githubusercontent.com/unneyon/hikka-mods/main/
-```
-Or, you can add my web repo:
-```
-.addrepo https://mods.unneyon.ru/
-```
-
-After this you will can install mod simple:
-```
-.dlm <module_name>
-```

unneyon/hikka-mods/caliases.py

@@ -1,147 +0,0 @@
-__version__ = (1, 0, 0)
-#          █▄▀ ▄▀█ █▀▄▀█ █▀▀ █▄▀ █  █ █▀█ █▀█
-#          █ █ █▀█ █ ▀ █ ██▄ █ █ ▀▄▄▀ █▀▄ █▄█ ▄
-#                © Copyright 2025
-#            ✈ https://t.me/kamekuro
-
-# 🔒 Licensed under CC-BY-NC-ND 4.0 unless otherwise specified.
-# 🌐 https://creativecommons.org/licenses/by-nc-nd/4.0
-# + attribution
-# + non-commercial
-# + no-derivatives
-
-# You CANNOT edit, distribute or redistribute this file without direct permission from the author.
-
-# meta banner: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/caliases.png
-# meta pic: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/caliases.png
-# meta developer: @kamekuro_hmods
-# scope: hikka_only
-# scope: hikka_min 1.6.3
-
-import logging
-
-from telethon import types
-
-from .. import loader, utils
-
-
-logger = logging.getLogger(__name__)
-
-
-@loader.tds
-class CustomAliasesMod(loader.Module):
-    """Module for custom aliases"""
-
-    strings = {
-        "name": "CAliases",
-        "c404": "<emoji document_id=5312526098750252863>❌</emoji> <b>Command <code>{}</code> not found!</b>",
-        "a404": "<emoji document_id=5312526098750252863>❌</emoji> <b>Custom alias <code>{}</code> not found!</b>",
-        "no_args": "<emoji document_id=5312526098750252863>❌</emoji> <b>You must specify two args: alias name and command</b>",
-        "added": (
-            "<emoji document_id=5314250708508220914>✅</emoji> <b>Custom alias <i>{alias}</i> for command "
-            "<code>{prefix}{cmd}</code> successfully added!</b>\n<b>Use it like:</b> <code>{prefix}{alias}{args}</code>"
-        ),
-        "argsopt": " [args (optional)]",
-        "deleted": "<emoji document_id=5314250708508220914>✅</emoji> <b>Custom alias <code>{}</code> successfully deleted</b>",
-        "list": "<emoji document_id=5974492756494519709>🔗</emoji> <b>Custom aliases ({len}):</b>\n",
-        "no_aliases": "<emoji document_id=5312526098750252863>❌</emoji> <b>You have no custom aliases!</b>"
-    }
-
-    strings_ru = {
-        "c404": "<emoji document_id=5312526098750252863>❌</emoji> <b>Команда <code>{}</code> не найдена!</b>",
-        "a404": "<emoji document_id=5312526098750252863>❌</emoji> <b>Кастомный алиас <code>{}</code> не найден!</b>",
-        "no_args": "<emoji document_id=5312526098750252863>❌</emoji> <b>Вы должны указать как минимум два аргумента: имя алиаса и команду</b>",
-        "added": (
-            "<emoji document_id=5314250708508220914>✅</emoji> <b>Успешно добавил алиас с названием <i>{alias}</i> "
-            "для команды <code>{prefix}{cmd}</code></b>\n<b>Используй его так:</b> <code>{prefix}{alias}{args}</code>"
-        ),
-        "argsopt": " [аргументы (необязательно)]",
-        "deleted": "<emoji document_id=5314250708508220914>✅</emoji> <b>Кастомный алиас <code>{}</code> успешно удалён</b>",
-        "list": "<emoji document_id=5974492756494519709>🔗</emoji> <b>Кастомные алиасы (всего {len}):</b>\n",
-        "no_aliases": "<emoji document_id=5312526098750252863>❌</emoji> <b>У вас нет кастомных алиасов!</b>"
-    }
-
-
-    @loader.command(
-        ru_doc="👉 Получить список всех алиасов",
-        alias="calist"
-    )
-    async def caliasescmd(self, message: types.Message):
-        """👉 Get all aliases"""
-
-        aliases = self.get("aliases", {})
-        if not aliases:
-            return await utils.answer(message, self.strings['no_aliases'])
-
-        out = self.strings['list'].format(len=len(aliases.keys()))
-        for alias in aliases.keys():
-            cmd = aliases[alias]['command']
-            if aliases[alias]['args']:
-                cmd += f" {aliases[alias]['args']}"
-            out += f"  <emoji document_id=5280726938279749656>▪️</emoji> <code>{alias}</code> " \
-                   f"<emoji document_id=5960671702059848143>👈</emoji> <code>{cmd}</code>\n"
-
-        await utils.answer(message, out)
-
-
-    @loader.command(
-        ru_doc="<имя> 👉 Удалить алиас"
-    )
-    async def rmcaliascmd(self, message: types.Message):
-        """<name> 👉 Remove alias"""
-
-        args = utils.get_args(message)
-        aliases = self.get("aliases", {})
-        if args[0] not in aliases:
-            return await utils.answer(message, self.strings['a404'])
-
-        del aliases[args[0]]
-        self.set("aliases", aliases)
-        await utils.answer(message, self.strings['deleted'].format(args[0]))
-
-
-    @loader.command(
-        ru_doc="<имя> <команда> [аргументы] 👉 Добавить новый алиас (может содержать ключевое слово {args})"
-    )
-    async def caliascmd(self, message: types.Message):
-        """<name> <command> [args] 👉 Add new alias (may contain {args} keyword)"""
-
-        rargs = " ".join(utils.get_args_raw(message).split(' ')[2:])
-        args = utils.get_args(message)
-        if len(args) < 2:
-            return await utils.answer(message, self.strings['no_args'])
-        name = args[0]
-        cmd = args[1]
-        cmdargs = rargs
-        if cmd not in self.allmodules.commands.keys():
-            return await utils.answer(message, self.strings['c404'].format(cmd))
-
-        aliases = self.get("aliases", {})
-        aliases[str(args[0])] = {"command": cmd, "args": cmdargs}
-        self.set("aliases", aliases)
-        await utils.answer(message, self.strings['added'].format(
-            alias=name,
-            prefix=self.get_prefix(),
-            cmd=cmd+' '+cmdargs if cmdargs else cmd,
-            args=self.strings["argsopt"] if "{args}" in cmdargs else ""
-        ))
-
-
-    @loader.tag(
-        only_messages=True, no_media=True, no_inline=True,
-        out=True
-    )
-    async def watcher(self, message):
-        aliases = self.get("aliases", {})
-        command = message.raw_text.lower().split()[0]
-        if (command[0] == self.get_prefix()) and (command[1:] in aliases.keys()):
-            text = message.raw_text.lower()
-            args = utils.get_args_raw(message)
-            ass = aliases[command[1:]]
-
-            await self.allmodules.commands[ass['command']](
-                await utils.answer(
-                    message,
-                    (self.get_prefix() + ass['command'] + '@me ' + ass['args']).format(args=args)
-                )
-            )

unneyon/hikka-mods/deleter.py

@@ -1,141 +0,0 @@
-__version__ = (1, 0, 0)
-#          █▄▀ ▄▀█ █▀▄▀█ █▀▀ █▄▀ █  █ █▀█ █▀█
-#          █ █ █▀█ █ ▀ █ ██▄ █ █ ▀▄▄▀ █▀▄ █▄█ ▄
-#                © Copyright 2025
-#            ✈ https://t.me/kamekuro
-
-# 🔒 Licensed under CC-BY-NC-ND 4.0 unless otherwise specified.
-# 🌐 https://creativecommons.org/licenses/by-nc-nd/4.0
-# + attribution
-# + non-commercial
-# + no-derivatives
-
-# You CANNOT edit, distribute or redistribute this file without direct permission from the author.
-
-# meta banner: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/deleter.png
-# meta pic: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/deleter.png
-# meta developer: @kamekuro_hmods
-# scope: hikka_only
-# scope: hikka_min 1.6.3
-
-import logging
-
-from telethon import types
-
-from .. import loader, utils
-
-
-logger = logging.getLogger(__name__)
-
-
-@loader.tds
-class DeleterMod(loader.Module):
-	"""Module for delete your messages"""
-
-	strings = {
-		"name": "Deleter",
-		"_cfg_trigger": "Trigger for delete messages",
-		"_cfg_edit_msgs": "Is need to edit messages before delete them?",
-		"_cfg_edit_text": "Text for edit messages"
-	} 
-
-	strings_ru = {
-		"_cfg_trigger": "Триггер-команда для удаления сообщений",
-		"_cfg_edit_msgs": "Нужно ли редактировать сообщения перед удалением?",
-		"_cfg_edit_text": "Текст для редактирования сообщений",
-		"_cls_doc": "Модуль для удаления своих сообщений"
-	}
-
-	def __init__(self):
-		self.config = loader.ModuleConfig(
-			loader.ConfigValue(
-				"trigger",
-				"дд",
-				lambda: self.strings["_cfg_trigger"]
-			),
-			loader.ConfigValue(
-				"edit_msgs",
-				True,
-				lambda: self.strings["_cfg_edit_msgs"],
-				validator=loader.validators.Boolean()
-			),
-			loader.ConfigValue(
-				"edit_text",
-				"\xad",
-				lambda: self.strings["_cfg_edit_text"]
-			)
-		)
-
-
-	@loader.command(
-		ru_doc="[число] 👉 Удалить сообщения (можно использовать значение из конфига: «{значение}{число}», без пробела!)"
-	)
-	async def delmsgcmd(self, message: types.Message):
-		"""[count] 👉 Delete messages (you can use your trigger from config: «{value}{count}» and write them only together!)"""
-
-		args = utils.get_args(message)
-		count = 1
-		if args:
-			count = int(args[0]) if args[0].isnumeric() else 1
-
-		dmsgs = []
-		msgs = await self._client.get_messages(
-			message.chat_id, limit=50+count
-		)
-		for i in msgs:
-			if i.id == message.id:
-				continue
-			if i.sender_id == self._client.tg_id:
-				dmsgs.append(i)
-
-		if self.config["edit_msgs"]:
-			await message.edit(self.config["edit_text"])
-		await message.delete()
-
-		for i in dmsgs:
-			if count == 0:
-				break
-			if self.config["edit_msgs"]:
-				try:
-					await i.edit(self.config["edit_text"])
-				except:
-					pass
-			await i.delete()
-			count -= 1
-
-
-	@loader.tag(
-		only_messages=True, no_media=True, no_inline=True,
-		out=True
-	)
-	async def watcher(self, message: types.Message):
-		if not message.raw_text.startswith(self.config['trigger']):
-			return
-
-		p = message.raw_text.partition(self.config['trigger'])[2]
-		count = int(p) if p.isdigit() else 1
-
-		dmsgs = []
-		msgs = await self._client.get_messages(
-			message.chat_id, limit=50+count
-		)
-		for i in msgs:
-			if i.id == message.id:
-				continue
-			if i.sender_id == self._client.tg_id:
-				dmsgs.append(i)
-
-		if self.config["edit_msgs"]:
-			await message.edit(self.config["edit_text"])
-		await message.delete()
-
-		for i in dmsgs:
-			if count == 0:
-				break
-			if self.config["edit_msgs"]:
-				try:
-					await i.edit(self.config["edit_text"])
-				except:
-					pass
-			await i.delete()
-			count -= 1

unneyon/hikka-mods/full.txt

@@ -1,7 +0,0 @@
-caliases
-deleter
-privacy
-sdsaver
-tidal
-warpigs
-yamusic

unneyon/hikka-mods/langpacks/yamusic.yml

@@ -1,63 +0,0 @@
-en:
-    guide: "<emoji document_id=5956561916573782596>📜</emoji> <b><a href=\"https://yandex-music.rtfd.io/en/main/token.html\">Guide for obtaining access token for Yandex.Music</a></b>"
-    search: "<emoji document_id=5474304919651491706>🎧</emoji> <b>{performer} — {title}</b>\n<emoji document_id=5242574232688298747>🎵</emoji> <b><a href=\"https://music.yandex.ru/track/{track_id}\">Yandex.Music</a> | <a href=\"https://song.link/ya/{track_id}\">song.link</a></b>"
-    downloading_track: "\n\n<emoji document_id=5841359499146825803>🕔</emoji> <i>Downloading audio…</i>"
-    uploading_banner: "\n\n<emoji document_id=5841359499146825803>🕔</emoji> <i>Uploading banner…</i>"
-    lyrics: "<emoji document_id=5956561916573782596>📜</emoji> <b>Lyrics of the <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a> track:</b>\n<blockquote expandable>{text}</blockquote>\n\n<emoji document_id=5776287149724798198>©️</emoji> <b>Writers:</b> {writers}"
-    no_lyrics: "<emoji document_id=5872829476143894491>🚫</emoji> <b>Track <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a> has no lyrics!</b>"
-    errors:
-        no_query: "<emoji document_id=5872829476143894491>🚫</emoji> <b>Specify the search query first!</b>"
-        no_token_or_invalid: "<emoji document_id=5872829476143894491>🚫</emoji> <b>You specified an invalid access token or didn't specified it at all!</b>"
-        not_found: "<emoji document_id=5872829476143894491>🚫</emoji> <b>No results found.</b>"
-        no_playing: "<emoji document_id=5872829476143894491>🚫</emoji> <b>You don't listening to anything right now.</b>"
-    autobio:
-        enabled: "<emoji document_id=5242574232688298747>🎧</emoji> <b>Autobio was enabled.</b>"
-        disabled: "<emoji document_id=5242574232688298747>🎧</emoji> <b>Autobio was disabled.</b>"
-    likes:
-        liked: "<emoji document_id=5899833370052923106>❤️</emoji> <b>Track <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a> was liked.</b>"
-        unliked: "<emoji document_id=5992453811510186287>🖤</emoji> <b>Track <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a> was unliked.</b>"
-        disliked: "<emoji document_id=5952055319059239589>💔</emoji> <b>Track <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a> was disliked.</b>"
-    _entity_types:
-        VARIOUS: "Your queue"
-        RADIO: "«My Vibe»"
-        PLAYLIST: "Playlist «{}»"
-        ALBUM: "«{}»"
-        ARTIST: "Popular tracks by {}"
-    _cfg:
-        token: "The access token for Yandex.Music."
-        now_playing_text: "The caption for .ynow and .ynowt commands. May contain {performer}, {title}, {device}, {volume}, {playing_from}, {link}, {track_id}, {album_id} keywords."
-        autobio_text: "The text for automatically changing «Bio». May contains {performer} and {title}."
-        no_playing_bio_text: "The text for changing «Bio» when there is no playing tracks."
-        banner_version: "Banner version (old / new with lyrics / new without lyrics)."
-
-ru:
-    guide: "<emoji document_id=5956561916573782596>📜</emoji> <b><a href=\"https://yandex-music.rtfd.io/en/main/token.html\">Гайд по получению токена Яндекс.Музыки</a></b>"
-    search: "<emoji document_id=5474304919651491706>🎧</emoji> <b>{performer} — {title}</b>\n<emoji document_id=5242574232688298747>🎵</emoji> <b><a href=\"https://music.yandex.ru/track/{track_id}\">Яндекс.Музыка</a> | <a href=\"https://song.link/ya/{track_id}\">song.link</a></b>"
-    downloading_track: "\n\n<emoji document_id=5841359499146825803>🕔</emoji> <i>Загрузка трека…</i>"
-    uploading_banner: "\n\n<emoji document_id=5841359499146825803>🕔</emoji> <i>Загрузка баннера…</i>"
-    lyrics: "<emoji document_id=5956561916573782596>📜</emoji> <b>Текст трека <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a>:</b>\n<blockquote expandable>{text}</blockquote>\n\n<emoji document_id=5776287149724798198>©️</emoji> <b>Авторы:</b> {writers}"
-    no_lyrics: "<emoji document_id=5872829476143894491>🚫</emoji> <b>У трека <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a> нет текста!</b>"
-    errors:
-        no_query: "<emoji document_id=5872829476143894491>🚫</emoji> <b>Укажите поисковый запрос!</b>"
-        no_token_or_invalid: "<emoji document_id=5872829476143894491>🚫</emoji> <b>Вы указали невалидный токен или не указали его вообще!</b>"
-        not_found: "<emoji document_id=5872829476143894491>🚫</emoji> <b>Результаты не найдены.</b>"
-        no_playing: "<emoji document_id=5872829476143894491>🚫</emoji> <b>Вы ничего не слушаете сейчас.</b>"
-    autobio:
-        enabled: "<emoji document_id=5242574232688298747>🎧</emoji> <b>Автобио теперь включено.</b>"
-        disabled: "<emoji document_id=5242574232688298747>🎧</emoji> <b>Автобио теперь выключено.</b>"
-    likes:
-        liked: "<emoji document_id=5899833370052923106>❤️</emoji> <b>Трек <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a> был лайкнут.</b>"
-        unliked: "<emoji document_id=5992453811510186287>🖤</emoji> <b>С трека <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a> был снят лайк.</b>"
-        disliked: "<emoji document_id=5952055319059239589>💔</emoji> <b>Трек <a href=\"https://music.yandex.ru/track/{track_id}\">{track}</a> был дизлайкнут.</b>"
-    _entity_types:
-        VARIOUS: "Ваша очередь"
-        RADIO: "«Моя волна»"
-        PLAYLIST: "Плейлист «{}»"
-        ALBUM: "«{}»"
-        ARTIST: "Популярные треки {}"
-    _cfg:
-        token: "Токен для Яндекс.Музыки."
-        now_playing_text: "Текст, использующийся в подписи к файлу в командах .ynow и .ynowt. Может содержать {performer}, {title}, {device}, {volume}, {playing_from}, {link}, {track_id} и {album_id}"
-        autobio_text: "Текст, использующийся при автоматическом изменении «О себе». Может содержать {performer} и {title}."
-        no_playing_bio_text: "Текст, использующийся при изменении «О себе», когда ничего не играет."
-        banner_version: "Версия баннера (старый / новый с текстом трека / новый без текста трека)."

unneyon/hikka-mods/privacy.py

@@ -1,397 +0,0 @@
-__version__ = (1, 0, 0)
-#          █▄▀ ▄▀█ █▀▄▀█ █▀▀ █▄▀ █  █ █▀█ █▀█
-#          █ █ █▀█ █ ▀ █ ██▄ █ █ ▀▄▄▀ █▀▄ █▄█ ▄
-#                © Copyright 2025
-#            ✈ https://t.me/kamekuro
-
-# 🔒 Licensed under CC-BY-NC-ND 4.0 unless otherwise specified.
-# 🌐 https://creativecommons.org/licenses/by-nc-nd/4.0
-# + attribution
-# + non-commercial
-# + no-derivatives
-
-# You CANNOT edit, distribute or redistribute this file without direct permission from the author.
-
-# meta banner: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/privacy.png
-# meta pic: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/privacy.png
-# meta developer: @kamekuro_hmods
-# scope: heroku_only
-# scope: hikka_min 1.6.3
-
-import logging
-import re
-import typing
-
-import telethon
-from telethon import types
-
-from .. import loader, utils, inline
-
-
-logger = logging.getLogger(__name__)
-
-
-@loader.tds
-class PrivacyMod(loader.Module):
-    """Module for fastly changing privacy settings"""
-
-    _privacy_types = {
-        "phone": types.InputPrivacyKeyPhoneNumber,
-        "add_by_phone": types.InputPrivacyKeyAddedByPhone,
-        "online": types.InputPrivacyKeyStatusTimestamp,
-        "photos": types.InputPrivacyKeyProfilePhoto,
-        "forwards": types.InputPrivacyKeyForwards,
-        "calls": types.InputPrivacyKeyPhoneCall,
-        "p2p": types.InputPrivacyKeyPhoneP2P,
-        "voices": types.InputPrivacyKeyVoiceMessages,
-        # "messages": None,
-        "birthdate": getattr(types, "InputPrivacyKeyBirthday", None),
-        "gifts": getattr(types, "InputPrivacyKeyStarGiftsAutoSave", None),
-        "bio": getattr(types, "InputPrivacyKeyAbout", None),
-        "invites": types.InputPrivacyKeyChatInvite
-    }
-    _privacy_rules = {
-        types.PrivacyValueAllowAll: types.InputPrivacyValueAllowAll,
-        getattr(types, "PrivacyValueAllowBots", None): getattr(types, "InputPrivacyValueAllowBots", None),
-        types.PrivacyValueAllowChatParticipants: types.InputPrivacyValueAllowChatParticipants,
-        getattr(types, "PrivacyValueAllowCloseFriends", None): getattr(types, "InputPrivacyValueAllowCloseFriends", None),
-        types.PrivacyValueAllowContacts: types.InputPrivacyValueAllowContacts,
-        getattr(types, "PrivacyValueAllowPremium", None): getattr(types, "InputPrivacyValueAllowPremium", None),
-        types.PrivacyValueAllowUsers: types.InputPrivacyValueAllowUsers,
-        types.PrivacyValueDisallowAll: types.InputPrivacyValueDisallowAll,
-        getattr(types, "PrivacyValueDisallowBots", None): getattr(types, "InputPrivacyValueDisallowBots", None),
-        types.PrivacyValueDisallowChatParticipants: types.InputPrivacyValueDisallowChatParticipants,
-        types.PrivacyValueDisallowContacts: types.InputPrivacyValueDisallowContacts,
-        types.PrivacyValueDisallowUsers: types.InputPrivacyValueDisallowUsers
-    }
-
-
-    strings = {
-        "name": "Privacy",
-        "privacy_types": (
-            "<emoji document_id=5974492756494519709>🔗</emoji> <b>Types of privacy settings:</b>\n"
-        ),
-        "no_user": "<emoji document_id=5312383351217201533>⚠️</emoji> <b>You haven't specified user</b>",
-        "u_silly": (
-            "<emoji document_id=5449682572223194186>🥺</emoji> <b>You can't set privacy settings "
-            "exceptions for yourself, silly.</b>"
-        ),
-        "choose_type": "🔑 <b>Select the type of settings to set exceptions</b>",
-        "not_supported_type": (
-            "<emoji document_id=5312383351217201533>⚠️</emoji> <b>It is not possible to set exceptions "
-            "for the [{}] type of settings</b>"
-        ),
-        "allowed": (
-            "<emoji document_id=5298609004551887592>💕</emoji> <b>{user} was added to the allowed "
-            "users for the [{pr}] type of settings</b>"
-        ),
-        "disallowed": (
-            "<emoji document_id=5224379368242965520>💔</emoji> <b>{user} was added to the disallowed "
-            "users for the [{pr}] type of settings</b>"
-        ),
-        "privacy": {
-            "phone": "Phone Number",
-            "add_by_phone": "Who can find you by your number",
-            "p2p": "Using Peer-to-Peer in calls",
-            "online": "Last Seen & Online",
-            "photos": "Profile Photos",
-            "forwards": "Forwarded Messages",
-            "calls": "Calls",
-            "voices": "Voice Messages",
-            # "messages": "Messages" if _privacy_types.get("messages") else None,
-            "birthdate": "Date of Birth" if _privacy_types.get("birthdate") else None,
-            "gifts": "Gifts" if _privacy_types.get("gifts") else None,
-            "bio": "Bio" if _privacy_types.get("bio") else None,
-            "invites": "Invites"
-        }
-    }
-
-    strings_ru = {
-        "_cls_doc": "Модуль для быстрого изменения настроек конфиденциальности",
-        "privacy_types": (
-            "<emoji document_id=5974492756494519709>🔗</emoji> <b>Типы настроек приватности:</b>\n"
-        ),
-        "no_user": "<emoji document_id=5312383351217201533>⚠️</emoji> <b>Вы не указали пользователя</b>",
-        "u_silly": (
-            "<emoji document_id=5449682572223194186>🥺</emoji> <b>Ты не можешь выставить исключения "
-            "настроек приватности для самого себя, глупенький</b>"
-        ),
-        "choose_type": "🔑 <b>Выберите тип настроек для выставления исключений</b>",
-        "not_supported_type": (
-            "<emoji document_id=5312383351217201533>⚠️</emoji> <b>Для типа настроек [{}] "
-            "невозможно выставить исключения</b>"
-        ),
-        "allowed": (
-            "<emoji document_id=5298609004551887592>💕</emoji> <b>{user} добавлен в разрешённых "
-            "пользователей для настройки [{pr}]</b>"
-        ),
-        "disallowed": (
-            "<emoji document_id=5224379368242965520>💔</emoji> <b>{user} добавлен в запрещённых "
-            "пользователей для настройки [{pr}]</b>"
-        ),
-        "privacy": {
-            "phone": "Номер телефона",
-            "add_by_phone": "Кто может найти Вас по номеру",
-            "p2p": "Использование peer-to-peer в звонках",
-            "online": "Время захода",
-            "photos": "Фотографии профиля",
-            "forwards": "Пересылка сообщений",
-            "calls": "Звонки",
-            "voices": "Голосовые сообщения",
-            # "messages": "Сообщения" if _privacy_types.get("messages") else None,
-            "birthdate": "Дата рождения" if _privacy_types.get("birthdate") else None,
-            "gifts": "Подарки" if _privacy_types.get("gifts") else None,
-            "bio": "О себе" if _privacy_types.get("bio") else None,
-            "invites": "Приглашения"
-        }
-    }
-
-
-    async def client_ready(self, client, db):
-        self._client: telethon.TelegramClient = client
-        self._db = db
-
-
-    @loader.command(
-        ru_doc="👉 Список типов настроек для указания их в командах",
-        alias="ptypes"
-    )
-    async def privacytypescmd(self, message: types.Message):
-        """👉 List of setting types to pass it in commands"""
-
-        out = self.strings("privacy_types")
-        for key, item in self.strings("privacy").items():
-            if not item: continue
-            out += f"  <code>{key}</code> — {item}\n"
-        await utils.answer(
-            message, out
-        )
-
-
-    @loader.command(
-        ru_doc="<пользователь> [настройка (необязательно)] 👉 Добавить пользователя в разрешённых для какой-либо настройки"
-    )
-    async def allowusercmd(self, message: types.Message):
-        """<user> [setting (optional)] 👉 Add user to includes for some setting"""
-
-        uid = await self.getID(message)
-        if (not uid) or (uid < 0):
-            return await utils.answer(message, self.strings("no_user"))
-        elif uid == (await self._client.get_me()).id:
-            return await utils.answer(message, self.strings("u_silly"))
-        args = utils.get_args(message)[(0 if message.is_reply else 1):]
-        new_allow_user: types.User = await self._client.get_entity(uid)
-
-        if (len(args) < 1) or (not self._privacy_types.get(args[0])):
-            return await self.inline.form(
-                message=message,
-                text=self.strings("choose_type"),
-                reply_markup=self.gen_kb_action(new_allow_user, "allow")
-            )
-
-        pr = self.strings('privacy').get(args[0])
-        if args[0] == "add_by_phone":
-            return await utils.answer(
-                message, self.strings("not_supported_type").format(pr)
-            )
-        key: types.TypeInputPrivacyKey = self._privacy_types.get(args[0])
-        rules = (await self._client(telethon.functions.account.GetPrivacyRequest(
-            key=key()
-        ))).rules
-
-        await self.allow_user(new_allow_user, key, rules, "allow")
-        await utils.answer(
-            message, self.strings("allowed").format(
-                user=telethon.utils.get_display_name(new_allow_user), pr=pr
-            )
-        )
-
-
-    @loader.command(
-        ru_doc="<пользователь> [настройка (необязательно)] 👉 Добавить пользователя в запрещённых для какой-либо настройки"
-    )
-    async def disallowusercmd(self, message: types.Message):
-        """<user> [setting (optional)] 👉 Add user to excludes for some setting"""
-
-        uid = await self.getID(message)
-        if (not uid) or (uid < 0):
-            return await utils.answer(message, self.strings("no_user"))
-        elif uid == (await self._client.get_me()).id:
-            return await utils.answer(message, self.strings("u_silly"))
-        args = utils.get_args(message)[(0 if message.is_reply else 1):]
-        new_allow_user: types.User = await self._client.get_entity(uid)
-
-        if (len(args) < 1) or (not self._privacy_types.get(args[0])):
-            return await self.inline.form(
-                message=message,
-                text=self.strings("choose_type"),
-                reply_markup=self.gen_kb_action(new_allow_user, "disallow")
-            )
-
-        pr = self.strings('privacy').get(args[0])
-        if args[0] == "add_by_phone":
-            return await utils.answer(
-                message, self.strings("not_supported_type").format(pr)
-            )
-        key: types.TypeInputPrivacyKey = self._privacy_types.get(args[0])
-        rules = (await self._client(telethon.functions.account.GetPrivacyRequest(
-            key=key()
-        ))).rules
-
-        await self.allow_user(new_allow_user, key, rules, "disallow")
-        await utils.answer(
-            message, self.strings("disallowed").format(
-                user=telethon.utils.get_display_name(new_allow_user), pr=pr
-            )
-        )
-
-
-    async def allow_by_kb(
-        self,
-        call: inline.types.InlineCall,
-        new_user: types.User,
-        key: types.TypeInputPrivacyKey
-    ):
-        pr = "[Unknown]"
-        for i in self._privacy_types.keys():
-            if self._privacy_types[i] == key:
-                pr = self.strings('privacy').get(i); break
-        rules = (await self._client(telethon.functions.account.GetPrivacyRequest(
-            key=key()
-        ))).rules
-
-        await self.allow_user(new_user, key, rules, "allow")
-        await call.edit(
-            text=self.strings("allowed").format(
-                user=telethon.utils.get_display_name(new_user), pr=pr
-            )
-        )
-
-
-    async def disallow_by_kb(
-        self,
-        call: inline.types.InlineCall,
-        new_user: types.User,
-        key: types.TypeInputPrivacyKey
-    ):
-        pr = "[Unknown]"
-        for i in self._privacy_types.keys():
-            if self._privacy_types[i] == key:
-                pr = self.strings('privacy').get(i); break
-        rules = (await self._client(telethon.functions.account.GetPrivacyRequest(
-            key=key()
-        ))).rules
-
-        await self.allow_user(new_user, key, rules, "disallow")
-        await call.edit(
-            text=self.strings("disallowed").format(
-                user=telethon.utils.get_display_name(new_user), pr=pr
-            )
-        )
-
-
-    async def allow_user(
-        self,
-        new_allow_user: types.User,
-        key: types.TypeInputPrivacyKey,
-        rules: list,
-        action: str = "allow" # allow/disallow
-    ):
-        new_rules = []
-        f_all = [x for x in rules if type(x) in [types.PrivacyValueAllowAll, types.PrivacyValueDisallowAll]]
-        f_all = f_all[0] if f_all else None
-        allow_users, disallow_users = [], []
-        allow_chats, disallow_chats = [], []
-        if (action == "allow") and (type(f_all) != types.PrivacyValueAllowAll):
-            allow_users.append(types.InputUser(new_allow_user.id, new_allow_user.access_hash))
-        elif (action == "disallow") and (type(f_all) != types.PrivacyValueDisallowAll):
-            disallow_users.append(types.InputUser(new_allow_user.id, new_allow_user.access_hash))
-        need_to_set = True
-
-        for rule in rules:
-            rule_type = type(rule)
-            if rule_type == types.PrivacyValueAllowUsers:
-                for user in rule.users:
-                    if (user == new_allow_user.id) and (action == "allow"):
-                        need_to_set = False; break
-                    if (user == new_allow_user.id) and (action == "disallow"):
-                        continue
-                    us: types.User = await self._client.get_entity(user)
-                    allow_users.append(types.InputUser(us.id, us.access_hash))
-            elif rule_type == types.PrivacyValueDisallowUsers:
-                for user in rule.users:
-                    if (user == new_allow_user.id) and (action == "disallow"):
-                        need_to_set = False; break
-                    if (user == new_allow_user.id) and (action == "allow"): continue
-                    us: types.User = await self._client.get_entity(user)
-                    disallow_users.append(types.InputUser(us.id, us.access_hash))
-            elif rule_type == types.PrivacyValueAllowChatParticipants:
-                for chat in rule.chats:
-                    allow_chats.append(chat)
-            elif rule_type == types.PrivacyValueDisallowChatParticipants:
-                for chat in rule.chats:
-                    disallow_chats.append(chat)
-            else:
-                new_rules.append(self._privacy_rules[rule_type]())
-
-        if allow_users:
-            new_rules.append(types.InputPrivacyValueAllowUsers(allow_users))
-        if disallow_users:
-            new_rules.append(types.InputPrivacyValueDisallowUsers(disallow_users))
-        if allow_chats:
-            new_rules.append(types.InputPrivacyValueAllowChatParticipants(allow_chats))
-        if disallow_chats:
-            new_rules.append(types.InputPrivacyValueDisallowChatParticipants(disallow_chats))
-
-        if need_to_set:
-            await self._client(telethon.functions.account.SetPrivacyRequest(
-                key=key(), rules=new_rules
-            ))
-
-
-    def gen_kb_action(
-        self,
-        new_user: types.User,
-        action: str # allow/disallow
-    ):
-        return self.split_list([
-            {
-                "text": self.strings("privacy").get(key),
-                "callback": self.allow_by_kb if action == "allow" else self.disallow_by_kb,
-                "args": (new_user, item)
-            } for key, item in self._privacy_types.items() if item
-        ], 2)
-
-
-    async def getID(self, message: types.Message):
-        reply: types.Message = await message.get_reply_message()
-        if reply:
-            return reply.sender_id
-
-        args: list = utils.get_args(message)
-        if not args: return None
-        username = args[0] if args else ""
-
-        match = re.search(r"(?:t\.me/|@|^(\w+)\.t\.me$)([a-zA-Z0-9_\.]+)", username)
-        if match:
-            username = match.group(1) or match.group(2)
-
-        try:
-            response = await self._client(telethon.functions.contacts.ResolveUsernameRequest(username))
-        except telethon.errors.rpcbaseerrors.RPCError:
-            response = None
-
-        try:
-            user_entity = await self._client.get_entity(username)
-        except Exception:
-            user_entity = None
-
-        if response and response.users:
-            return response.users[0].id
-        if user_entity:
-            return getattr(user_entity, "user_id", None)
-
-        return None
-    
-    def split_list(self, input_list: typing.List, chunk_size: int):
-        return [input_list[i:i+chunk_size] for i in range(0, len(input_list), chunk_size)]

unneyon/hikka-mods/tidal.py

@@ -1,370 +0,0 @@
-__version__ = (1, 0, 2)
-#             █ █ ▀ █▄▀ ▄▀█ █▀█ ▀
-#             █▀█ █ █ █ █▀█ █▀▄ █
-#              © Copyright 2022
-#
-#          https://t.me/hikariatama
-#
-# 🔒 Licensed under the GNU AGPLv3
-# 🌐 https://www.gnu.org/licenses/agpl-3.0.html
-
-#          █▄▀ ▄▀█ █▀▄▀█ █▀▀ █▄▀ █  █ █▀█ █▀█
-#          █ █ █▀█ █ ▀ █ ██▄ █ █ ▀▄▄▀ █▀▄ █▄█ ▄
-#                © Copyright 2025
-#            ✈ https://t.me/kamekuro
-#
-# 🔒 Licensed under CC-BY-NC-ND 4.0 unless otherwise specified.
-# 🌐 https://creativecommons.org/licenses/by-nc-nd/4.0
-# + attribution
-# + non-commercial
-# + no-derivatives
-#
-# You CANNOT edit, distribute or redistribute this file without direct permission from the author.
-
-# ORIGINAL MODULE: https://raw.githubusercontent.com/hikariatama/ftg/master/tidal.py
-
-# meta banner: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/tidal.png
-# meta pic: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/tidal.png
-# meta developer: @kamekuro_hmods
-# scope: hikka_only
-# scope: hikka_min 1.6.3
-# requires: git+https://github.com/tamland/python-tidal
-
-import asyncio
-import base64
-import io
-import json
-import logging
-import re
-import requests
-import tidalapi
-
-from telethon import types
-
-from .. import loader, utils
-
-
-logger = logging.getLogger(__name__)
-
-
-@loader.tds
-class TidalMod(loader.Module):
-    """API wrapper over TIDAL Hi-Fi music streaming service
-    Thanks @hikarimods for original module: t.me/hikarimods/764"""
-
-    strings = {
-        "name": "Tidal",
-        "_cfg_quality": "Select the desired quality for the tracks",
-        "args": "<emoji document_id=5312526098750252863>❌</emoji> <b>Specify search query</b>",
-        "404": "<emoji document_id=5312526098750252863>❌</emoji> <b>No results found</b>",
-        "oauth": (
-            "<emoji document_id=5773798959206108871>🔑</emoji> <b>Login to TIDAL</b>\n\n<i>This link will expire in 5 minutes</i>"
-        ),
-        "oauth_btn": "🔑 Login",
-        "success": "<emoji document_id=5314250708508220914>✅</emoji> <b>Successfully logged in!</b>",
-        "error": "<emoji document_id=5312526098750252863>❌</emoji> <b>Error logging in</b>",
-        "search": "<emoji document_id=5438616889632761336>🎧</emoji> <b>{artist} — {title}</b>\n<emoji document_id=5359582743992737342>🎵</emoji> <b><a href=\"https://tidal.com/track/{track_id}\">TIDAL</a> | <a href=\"https://song.link/t/{track_id}\">song.link</a></b>",
-        "downloading_file": "\n\n<emoji document_id=5325617665874600234>🕔</emoji> <i>Downloading audio…</i>",
-        "searching": "<emoji document_id=5309965701241379366>🔍</emoji> <b>Searching…</b>",
-        "auth_first": "<emoji document_id=5312526098750252863>❌</emoji> <b>You need to login first</b>",
-    }
-
-    strings_ru = {
-        "_cfg_quality": "Выберите желаемое качество для треков",
-        "args": "<emoji document_id=5312526098750252863>❌</emoji> <b>Укажите поисковый запрос</b>",
-        "404": "<emoji document_id=5312526098750252863>❌</emoji> <b>Ничего не найдено</b>",
-        "oauth": (
-            "<emoji document_id=5773798959206108871>🔑</emoji> <b>Авторизуйтесь в TIDAL</b>\n\n<i>Эта ссылка будет действительна в"
-            " течение 5 минут</i>"
-        ),
-        "oauth_btn": "🔑 Авторизоваться",
-        "success": "<emoji document_id=5314250708508220914>✅</emoji> <b>Успешно авторизованы!</b>",
-        "error": "<emoji document_id=5312526098750252863>❌</emoji> <b>Ошибка авторизации</b>",
-        "search": "<emoji document_id=5438616889632761336>🎧</emoji> <b>{artist} — {title}</b>\n<emoji document_id=5359582743992737342>🎵</emoji> <b><a href=\"https://tidal.com/track/{track_id}\">TIDAL</a> | <a href=\"https://song.link/t/{track_id}\">song.link</a></b>",
-        "downloading_file": "\n\n<emoji document_id=5325617665874600234>🕔</emoji> <i>Загрузка аудио…</i>",
-        "searching": "<emoji document_id=5309965701241379366>🔍</emoji> <b>Ищем…</b>",
-        "auth_first": "<emoji document_id=5312526098750252863>❌</emoji> <b>Сначала нужно авторизоваться</b>",
-        "_cls_doc": (
-            """Модуль для музыкального сервиса TIDAL Hi-Fi
-            Спасибо @hikarimods за оригинальный модуль: t.me/hikarimods/764"""
-        )
-    }
-
-
-    def __init__(self):
-        self.qualities = {
-            "Low (96kbps)": tidalapi.Quality.low_96k,
-            "Low (320kbps)": tidalapi.Quality.low_320k,
-            "High": tidalapi.Quality.high_lossless,
-            "Max": tidalapi.Quality.hi_res_lossless
-        }
-        self.tags_files = {
-            "Low (96kbps)": "mp3",
-            "Low (320kbps)": "mp3",
-            "High": "m4a",
-            "Max": "flac"
-        }
-        self.config = loader.ModuleConfig(
-            loader.ConfigValue(
-                "quality",
-                "High",
-                lambda: self.strings["_cfg_quality"],
-                validator=loader.validators.Choice(['Low (96kbps)', 'Low (320kbps)', 'High', 'Max']),
-            )
-        )
-
-
-    def tidalLogin(self):
-        login_credits = (
-            self.get("token_type"),
-            self.get("access_token"),
-            self.get("refresh_token"),
-            self.get("session_id")
-        )
-        tidal = tidalapi.Session()
-        if not all(login_credits):
-            return tidal
-
-        try:
-            tidal.load_oauth_session(*login_credits)
-            if tidal.check_login():
-                tidal.audio_quality = self.qualities.get(self.config['quality'], "High")
-                return tidal
-            return tidalapi.Session()
-        except:
-            logger.exception("Error loading OAuth session")
-            return tidalapi.Session()
-
-
-    @loader.command(
-        ru_doc="👉 Авторизация в TIDAL",
-        alias="tauth"
-    )
-    async def tlogincmd(self, message: types.Message):
-        """👉 Open OAuth window to login into TIDAL"""
-
-        tidal_session = self.tidalLogin()
-        result, future = tidal_session.login_oauth()
-        form = await self.inline.form(
-            message=message,
-            text=self.strings("oauth"),
-            reply_markup={
-                "text": self.strings("oauth_btn"),
-                "url": f"https://{result.verification_uri_complete}",
-            },
-            gif="https://0x0.st/oecP.MP4",
-        )
-
-        outer_loop = asyncio.get_event_loop()
-
-        def callback(*args, **kwargs):
-            nonlocal form, outer_loop
-            if tidal_session.check_login():
-                asyncio.ensure_future(
-                    form.edit(
-                        self.strings("success"),
-                        gif="https://x0.at/dg3A.mp4",
-                    ),
-                    loop=outer_loop,
-                )
-                self.set("token_type", tidal_session.token_type)
-                self.set("session_id", tidal_session.session_id)
-                self.set("access_token", tidal_session.access_token)
-                self.set("refresh_token", tidal_session.refresh_token)
-            else:
-                asyncio.ensure_future(
-                    form.edit(
-                        self.strings("error"),
-                        gif="https://i.gifer.com/8Z2a.gif",
-                    ),
-                    loop=outer_loop
-                )
-
-        future.add_done_callback(callback)
-
-
-    @loader.command(
-        ru_doc="<запрос> 👉 Поиск трека в TIDAL",
-        alias="tq"
-    )
-    async def tidalcmd(self, message: types.Message):
-        """<query> 👉 Search track in TIDAL"""
-
-        tidal_session = self.tidalLogin()
-        if not await utils.run_sync(tidal_session.check_login):
-            await utils.answer(message, self.strings("auth_first"))
-            return
-
-        query = utils.get_args_raw(message)
-        if not query:
-            await utils.answer(message, self.strings("args"))
-            return
-
-        message = await utils.answer(message, self.strings("searching"))
-
-        result = tidal_session.search(query=query)
-        if not result or not result.get('tracks'):
-            await utils.answer(message, self.strings("404"))
-            return
-
-        track = result['tracks'][0]
-        track_res = {
-            "url": None, "id": track.id,
-            "artists": [], "name": track.name,
-            "tags": [], "duration": track.duration
-        }
-
-        meta = (
-            tidal_session.request.request(
-                "GET",
-                f"tracks/{track_res['id']}",
-            )
-        ).json()
-
-        for i in meta["artists"]:
-            if i['name'] not in track_res['artists']:
-                track_res['artists'].append(i['name'])
-
-        tags = track_res['tags']
-        if meta.get("explicit"):
-            tags += ["#explicit🤬"]
-        if isinstance(meta.get("audioModes"), list):
-            for tag in meta["audioModes"]:
-                tags += [f"#{tag}🎧"]
-        if tags:
-            track_res['tags'] = tags
-
-        text = self.strings("search").format(
-            artist=", ".join(track_res['artists']),
-            title=track_res['name'],
-            track_id=track_res['id']
-        )
-        message = await utils.answer(
-            message, text + self.strings("downloading_file")
-        )
-
-        q = self.qualities.get(self.config['quality'], "HIGH")
-        q = q.value if type(q) != str else q
-        t = tidal_session.request.request(
-            "GET",
-            f"tracks/{track_res['id']}/playbackinfopostpaywall",
-            {
-                "audioquality": q,
-                "playbackmode": "STREAM",
-                "assetpresentation": "FULL"
-            }
-        ).json()
-        man = json.loads(base64.b64decode(t['manifest']).decode('utf-8'))
-        track_res['url'] = man['urls'][0]
-        track_res['tags'].append(f"#{q}🔈")
-
-        with requests.get(track_res['url']) as r:
-            audio = io.BytesIO(r.content)
-            audio.name = f"audio.{self.tags_files.get(self.config['quality'], 'mp3')}"
-            audio.seek(0)
-
-        text += f"\n\n{', '.join(track_res['tags'])}"
-        await utils.answer_file(
-            message, audio, text,
-            attributes=([
-                types.DocumentAttributeAudio(
-                    duration=track_res['duration'],
-                    title=track_res['name'],
-                    performer=', '.join(track_res['artists'])
-                )
-            ])
-        ) 
-
-
-    @loader.command(
-        ru_doc="<ID/ссылка> 👉 Поиск трека в TIDAL по ID или ссылке",
-        alias="tid"
-    )
-    async def turlcmd(self, message: types.Message):
-        """<ID/url> 👉 Search track in TIDAL by ID or url"""
-
-        tidal_session = self.tidalLogin()
-        if not await utils.run_sync(tidal_session.check_login):
-            await utils.answer(message, self.strings("auth_first"))
-            return
-
-        args = utils.get_args(message)
-        if (not args):
-            return await utils.answer(message, self.strings("args"))
-        res = re.findall(r"tidal\.com\/(?:track|browse\/track)\/(\d+)", args[0])
-        if (not res) and (not args[0].isdigit()):
-            return await utils.answer(message, self.strings("args"))
-
-        message = await utils.answer(message, self.strings("searching"))
-
-        try:
-            track = tidal_session.track(int(args[0]) if args[0].isdigit() else int(res[0]))
-        except tidalapi.exceptions.ObjectNotFound:
-            return await utils.answer(message, self.strings("404"))
-
-        track_res = {
-            "url": None, "id": track.id,
-            "artists": [], "name": track.name,
-            "tags": [], "duration": track.duration
-        }
-
-        meta = (
-            tidal_session.request.request(
-                "GET",
-                f"tracks/{track_res['id']}",
-            )
-        ).json()
-
-        for i in meta["artists"]:
-            if i['name'] not in track_res['artists']:
-                track_res['artists'].append(i['name'])
-
-        tags = track_res['tags']
-        if meta.get("explicit"):
-            tags += ["#explicit🤬"]
-        if isinstance(meta.get("audioModes"), list):
-            for tag in meta["audioModes"]:
-                tags += [f"#{tag}🎧"]
-        if tags:
-            track_res['tags'] = tags
-
-        text = self.strings("search").format(
-            artist=", ".join(track_res['artists']),
-            title=track_res['name'],
-            track_id=track_res['id']
-        )
-        message = await utils.answer(
-            message, text + self.strings("downloading_file")
-        )
-
-        q = self.qualities.get(self.config['quality'], "HIGH")
-        q = q.value if type(q) != str else q
-        t = tidal_session.request.request(
-            "GET",
-            f"tracks/{track_res['id']}/playbackinfopostpaywall",
-            {
-                "audioquality": q,
-                "playbackmode": "STREAM",
-                "assetpresentation": "FULL"
-            }
-        ).json()
-        man = json.loads(base64.b64decode(t['manifest']).decode('utf-8'))
-        track_res['url'] = man['urls'][0]
-        track_res['tags'].append(f"#{q}🔈")
-
-        with requests.get(track_res['url']) as r:
-            audio = io.BytesIO(r.content)
-            audio.name = f"audio.{self.tags_files.get(self.config['quality'], 'mp3')}"
-            audio.seek(0)
-
-        text += f"\n\n{', '.join(track_res['tags'])}"
-        await utils.answer_file(
-            message, audio, text,
-            attributes=([
-                types.DocumentAttributeAudio(
-                    duration=track_res['duration'],
-                    title=track_res['name'],
-                    performer=', '.join(track_res['artists'])
-                )
-            ])
-        )

unneyon/hikka-mods/warpigs.py

@@ -1,183 +0,0 @@
-__version__ = (1, 0, 0)
-#          █▄▀ ▄▀█ █▀▄▀█ █▀▀ █▄▀ █  █ █▀█ █▀█
-#          █ █ █▀█ █ ▀ █ ██▄ █ █ ▀▄▄▀ █▀▄ █▄█ ▄
-#                © Copyright 2025
-#            ✈ https://t.me/kamekuro
-
-# 🔒 Licensed under CC-BY-NC-ND 4.0 unless otherwise specified.
-# 🌐 https://creativecommons.org/licenses/by-nc-nd/4.0
-# + attribution
-# + non-commercial
-# + no-derivatives
-
-# You CANNOT edit, distribute or redistribute this file without direct permission from the author.
-
-# meta banner: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/warpigs.png
-# meta pic: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/warpigs.png
-# meta developer: @kamekuro_hmods
-# scope: hikka_only
-# scope: hikka_min 1.6.3
-
-import asyncio
-import logging
-import traceback
-
-from telethon import types
-
-from .. import loader, utils
-
-
-logger = logging.getLogger(__name__)
-
-
-@loader.tds
-class WarPigsMod(loader.Module):
-    """Some auto-functions for your pig in @warpigs_bot"""
-
-    strings = {
-        "name": "WarPigs",
-        "dforpm": "<emoji document_id=5312526098750252863>❌</emoji> <b>This command cannot be used in PM.</b>",
-        "af_started": "<emoji document_id=5454014806950429357>⚔️</emoji> <b>Autofight was enabled for this chat.</b>",
-        "af_stopped": "<emoji document_id=5462990652943904884>😴</emoji> <b>Autofight was disabled for this chat.</b>",
-        "ag_started": "<emoji document_id=5463081281048818043>🍕</emoji> <b>Autogrow was enabled for this chat.</b>",
-        "ag_stopped": "<emoji document_id=5462990652943904884>😴</emoji> <b>Autogrow was disabled for this chat.</b>",
-        "no_name": "<emoji document_id=5312526098750252863>❌</emoji> <b>You have not specified a new name for your pig.</b>",
-        "new_name": "<emoji document_id=5463071033256848094>👑</emoji> <b>Now your pig's new name is:</b> {name}"
-    }
-
-    strings_ru = {
-        "_cls_doc": "Немного авто-функций для вашего хряка в @warpigs_bot",
-        "dforpm": "<emoji document_id=5312526098750252863>❌</emoji> <b>Эту команду нельзя использовать в ЛС.</b>",
-        "af_started": "<emoji document_id=5454014806950429357>⚔️</emoji> <b>Автобой был включён для этого чата.</b>",
-        "af_stopped": "<emoji document_id=5462990652943904884>😴</emoji> <b>Автобой был отключён для этого чата.</b>",
-        "ag_started": "<emoji document_id=5463081281048818043>🍕</emoji> <b>Автокормёжка была включена для этого чата.</b>",
-        "ag_stopped": "<emoji document_id=5462990652943904884>😴</emoji> <b>Автокормёжка была отключена для этого чата.</b>",
-        "no_name": "<emoji document_id=5312526098750252863>❌</emoji> <b>Вы не указали новое имя для вашего хряка.</b>",
-        "new_name": "<emoji document_id=5463071033256848094>👑</emoji> <b>Теперь новое имя вашего хряка:</b> {name}"
-    }
-
-    bot = "@warpigs_bot"
-    bot_id = 2028629176
-
-
-    async def client_ready(self, client, db):
-        self.client = client
-        self.logger = logging.getLogger(__name__)
-        self.autofight.start()
-        self.autogrow.start()
-
-
-    async def message_q(
-        self,
-        text: str,
-        chat_id: int,
-        mark_read: bool = False,
-        delete: bool = False,
-    ):
-        async with self.client.conversation(chat_id, exclusive=False) as conv:
-            msg = await conv.send_message(text)
-            while True:
-                await asyncio.sleep(1)
-                response = await conv.get_response()
-                if response.from_id != self.bot_id:
-                    continue
-                if mark_read:
-                    await conv.mark_read()
-                if delete:
-                    await msg.delete()
-                    await response.delete()
-                return response
-            await conv.cancel_all()
-
-
-    @loader.loop(interval=86400)
-    async def autofight(self):
-        chats = self.get("chats", {})
-        for i in chats.keys():
-            if chats[i].get("autofight"):
-                try:
-                    r = await self.message_q(
-                        chat_id=int(i),
-                        text=f"/fight{self.bot}"
-                    )
-                except Exception as e:
-                    self.logger.error(f"Ошибка отправки сообщения в чат {i}:\n{traceback.format_exc()}")
-                    continue
-            await asyncio.sleep(1)
-
-
-    @loader.loop(interval=86400)
-    async def autogrow(self):
-        chats = self.get("chats", {})
-        for i in chats.keys():
-            if chats[i].get("autogrow"):
-                try:
-                    r = await self.message_q(
-                        chat_id=int(i),
-                        text=f"/grow{self.bot}"
-                    )
-                except Exception as e:
-                    self.logger.error(f"Ошибка отправки сообщения в чат {i}:\n{traceback.format_exc()}")
-                    continue
-            await asyncio.sleep(1)
-
-
-    @loader.command(
-        ru_doc="👉 Включить/отключить автобой"
-    )
-    async def afightcmd(self, message: types.Message):
-        """👉 Enable/disable autofight"""
-        if message.is_private:
-            await utils.answer(message, self.strings("dforpm"))
-            return
-
-        chats = self.get("chats", {})
-        chat = chats.get(str(message.chat_id), {"autofight": False, "autogrow": False})
-        chat['autofight'] = not chat.get('autofight', False)
-        chats[str(message.chat_id)] = chat
-        self.set("chats", chats)
-
-        self.autofight.stop()
-        await asyncio.sleep(1)
-        self.autofight.start()
-
-        await utils.answer(
-            message, self.strings("af_started") if chat['autofight'] else self.strings("af_stopped")
-        )
-
-
-    @loader.command(
-        ru_doc="👉 Включить/отключить автокормёжку"
-    )
-    async def agrowcmd(self, message: types.Message):
-        """👉 Enable/disable autogrow"""
-        if message.is_private:
-            await utils.answer(message, self.strings("dforpm"))
-            return
-
-        chats = self.get("chats", {})
-        chat = chats.get(str(message.chat_id), {"autofight": False, "autogrow": False})
-        chat['autogrow'] = not chat.get('autogrow', False)
-        chats[str(message.chat_id)] = chat
-        self.set("chats", chats)
-
-        self.autogrow.stop()
-        await asyncio.sleep(1)
-        self.autogrow.start()
-
-        await utils.answer(
-            message, self.strings("ag_started") if chat['autogrow'] else self.strings("ag_stopped")
-        )
-
-
-    @loader.command(
-        ru_doc="<имя> 👉 Меняет имя вашего хряка"
-    )
-    async def setnamecmd(self, message: types.Message):
-        """<name> 👉 Changes your pig's name"""
-        args = utils.get_args_raw(message)
-        if not args:
-            return await utils.answer(message, self.strings("no_name"))
-
-        r = await self.message_q(chat_id=message.chat_id, text=f"/name{self.bot} {args}")
-        await utils.answer(message, self.strings("new_name").format(name=args))

unneyon/hikka-mods/yamusic.py

@@ -1,798 +0,0 @@
-__version__ = (2, 0, 1)
-#                    region KAMEKURO.
-#          █▄▀ ▄▀█ █▀▄▀█ █▀▀ █▄▀ █  █ █▀█ █▀█
-#          █ █ █▀█ █ ▀ █ ██▄ █ █ ▀▄▄▀ █▀▄ █▄█ ▄
-#                © Copyright 2025
-#            ✈ https://t.me/kamekuro
-# 🔒 Licensed under CC-BY-NC-ND 4.0 unless otherwise specified.
-# 🌐 https://creativecommons.org/licenses/by-nc-nd/4.0
-# + attribution
-# + non-commercial
-# + no-derivatives
-# You CANNOT edit, distribute or redistribute this file without direct permission from the author.
-
-#                    region YaMusic
-#             ▀▄▀ ▄▀█ █▀▄▀█ █  █ █▀▀ █ █▀▀
-#              █  █▀█ █ ▀ █ ▀▄▄▀ ▄▄█ █ █▄▄
-# meta banner: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/banners/yamusic.png
-# meta pic: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/icons/yamusic.png
-# meta developer: @kamekuro_hmods
-# packurl: https://raw.githubusercontent.com/kamekuro/hikka-mods/main/langpacks/yamusic.yml
-# scope: heroku_only
-# scope: heroku_min 1.7.2
-# requires: aiohttp asyncio requests pillow==12.0.0 git+https://github.com/MarshalX/yandex-music-api
-
-import aiohttp
-import asyncio
-import io
-import json
-import logging
-import random
-import requests
-import string
-import textwrap
-import typing
-from PIL import Image, ImageDraw, ImageEnhance, ImageFilter, ImageFont
-
-import telethon
-import yandex_music
-import yandex_music.exceptions
-
-from .. import loader, utils
-
-
-logger = logging.getLogger(__name__)
-
-
-class Banners:
-    def __init__(
-        self,
-        title: str,
-        artists: list,
-        duration: int,
-        progress: int,
-        track_cover: bytes,
-    ):
-        self.title = title
-        self.artists = artists
-        self.duration = duration
-        self.progress = progress
-        self.track_cover = track_cover
-        self.onest_b = "https://raw.githubusercontent.com/kamekuro/assets/master/fonts/Onest-Bold.ttf"
-        self.onest_r = "https://raw.githubusercontent.com/kamekuro/assets/master/fonts/Onest-Regular.ttf"
-        self.ysmusic_hb = "https://raw.githubusercontent.com/kamekuro/assets/master/fonts/YSMusic-HeadlineBold.ttf"
-
-    def measure(
-        self, text: str, font: ImageFont.FreeTypeFont, draw: ImageDraw.ImageDraw
-    ):
-        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)
-
-        track_cov = Image.open(io.BytesIO(self.track_cover)).convert("RGBA")
-        banner = (
-            track_cov.resize((W, W))
-            .crop((0, (W - H) // 2, W, ((W - H) // 2) + H))
-            .filter(ImageFilter.GaussianBlur(radius=14))
-        )
-        banner = ImageEnhance.Brightness(banner).enhance(0.3)
-        draw = ImageDraw.Draw(banner)
-
-        track_cov = track_cov.resize((H - 250, H - 250))
-        mask = Image.new("L", track_cov.size, 0)
-        ImageDraw.Draw(mask).rounded_rectangle(
-            (0, 0, track_cov.size[0], track_cov.size[1]), radius=35, fill=255
-        )
-        track_cov.putalpha(mask)
-        track_cov = track_cov.crop(track_cov.getbbox())
-        banner.paste(track_cov, (75, 75), mask)
-
-        space = (643, 75, 1870, 593)
-        title_lines = textwrap.wrap(self.title, width=23)
-        if len(title_lines) > 2:
-            title_lines = title_lines[:2]
-            title_lines[-1] = title_lines[-1][:-1] + "…"
-        artist_lines = textwrap.wrap(", ".join(self.artists), width=23)
-        if len(artist_lines) > 1:
-            artist_lines = artist_lines[:1]
-            artist_lines[-1] = artist_lines[-1][:-1] + "…"
-        lines = title_lines + artist_lines
-        lines_sizes = [
-            self.measure(
-                line, artist_font if (i == len(lines)-1) else title_font, draw
-            )
-            for i, line in enumerate(lines)
-        ]
-        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]-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),
-                line,
-                font=(artist_font if (i == (len(lines)-1)) else title_font),
-                fill="#FFFFFF",
-            )
-            y_start += spacing
-
-        draw.text(
-            (75, 650),
-            f"{(self.progress//1000//60):02}:{(self.progress//1000%60):02}",
-            font=time_font,
-            fill="#FFFFFF",
-        )
-        draw.text(
-            (1745, 650),
-            f"{(self.duration//1000//60):02}:{(self.duration//1000%60):02}",
-            font=time_font,
-            fill="#FFFFFF",
-        )
-        draw.rounded_rectangle([75, 700, 1845, 715], radius=15 // 2, fill="#A0A0A0")
-        draw.rounded_rectangle(
-            [75, 700, int(75 + (1770 * self.progress / self.duration)), 715],
-            radius=15 // 2,
-            fill="#FFFFFF",
-        )
-
-        by = io.BytesIO()
-        banner.save(by, format="PNG")
-        by.seek(0)
-        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)
-
-        track_cov = Image.open(io.BytesIO(self.track_cover)).convert("RGBA")
-        banner = (
-            track_cov.resize((w, w))
-            .crop((0, (w - h) // 2, w, ((w - h) // 2) + h))
-            .filter(ImageFilter.GaussianBlur(radius=14))
-        )
-        banner = ImageEnhance.Brightness(banner).enhance(0.3)
-
-        track_cov = track_cov.resize((banner.size[1] - 150, banner.size[1] - 150))
-        mask = Image.new("L", track_cov.size, 0)
-        ImageDraw.Draw(mask).rounded_rectangle(
-            (0, 0, track_cov.size[0], track_cov.size[1]), radius=35, fill=255
-        )
-        track_cov.putalpha(mask)
-        track_cov = track_cov.crop(track_cov.getbbox())
-        banner.paste(track_cov, (75, 75), mask)
-
-        title_lines = textwrap.wrap(self.title, 23)
-        if len(title_lines) > 1:
-            title_lines[1] = (
-                title_lines[1] + "..." if len(title_lines) > 2 else title_lines[1]
-            )
-        title_lines = title_lines[:2]
-        artists_lines = textwrap.wrap(" • ".join(self.artists), width=40)
-        if len(artists_lines) > 1:
-            for index, art in enumerate(artists_lines):
-                if "•" in art[-2:]:
-                    artists_lines[index] = art[: art.rfind("•") - 1]
-
-        draw = ImageDraw.Draw(banner)
-        x, y = 150 + track_cov.size[0], 110
-        for index, line in enumerate(title_lines):
-            draw.text((x, y), line, font=title_font, fill="#FFFFFF")
-            if index != len(title_lines) - 1:
-                y += 70
-        x, y = 150 + track_cov.size[0], 110 * 2
-        if len(title_lines) > 1:
-            y += 70
-        for index, line in enumerate(artists_lines):
-            draw.text((x, y), line, font=art_font, fill="#A0A0A0")
-            if index != len(artists_lines) - 1:
-                y += 50
-
-        draw.rounded_rectangle(
-            [768, 650, 768 + 1072, 650 + 15], radius=15 // 2, fill="#A0A0A0"
-        )
-        draw.rounded_rectangle(
-            [768, 650, 768 + int(1072 * (self.progress / self.duration)), 650 + 15],
-            radius=15 // 2,
-            fill="#FFFFFF",
-        )
-        draw.text(
-            (768, 600),
-            f"{(self.progress//1000//60):02}:{(self.progress//1000%60):02}",
-            font=time_font,
-            fill="#FFFFFF",
-        )
-        draw.text(
-            (1745, 600),
-            f"{(self.duration//1000//60):02}:{(self.duration//1000%60):02}",
-            font=time_font,
-            fill="#FFFFFF",
-        )
-
-        by = io.BytesIO()
-        banner.save(by, format="PNG")
-        by.seek(0)
-        by.name = "banner.png"
-        return by
-
-
-@loader.tds
-class YaMusicMod(loader.Module):
-    """The module for Yandex.Music streaming service"""
-
-    strings = {"name": "YaMusic", "iguide": "📜 <b><a href=\"https://yandex-music.rtfd.io/en/main/token.html\">Guide for obtaining access token for Yandex.Music</a></b>"}
-    strings_ru = {"_cls_doc": "Модуль для стримингового сервиса Яндекс.Музыка", "iguide": "📜 <b><a href=\"https://yandex-music.rtfd.io/en/main/token.html\">Гайд по получению токена Яндекс.Музыки</a></b>"}
-
-    def __init__(self):
-        self.config = loader.ModuleConfig(
-            loader.ConfigValue(
-                option="token",
-                default=None,
-                doc=lambda: self.strings["_cfg"]["token"],
-                validator=loader.validators.Hidden(),
-            ),
-            loader.ConfigValue(
-                option="now_playing_text",
-                default=(
-                    "<emoji document_id=5474304919651491706>🎧</emoji> <b>{performer} — {title}</b>\n\n"
-                    "<emoji document_id=6039404727542747508>⌨️</emoji> <b>Now is listening on <code>"
-                    "{device}</code> (<emoji document_id=6039454987250044861>🔊</emoji> {volume}%)</b>\n"
-                    "<emoji document_id=6039630677182254664>🗂</emoji> <b>Playing from:</b> {playing_from}"
-                    "\n\n<emoji document_id=5242574232688298747>🎵</emoji> <b>{link} | "
-                    '<a href="https://song.link/ya/{track_id}">song.link</a></b>'
-                ),
-                doc=lambda: self.strings["_cfg"]["now_playing_text"],
-                validator=loader.validators.String(),
-            ),
-            loader.ConfigValue(
-                option="autobio_text",
-                default="{performer} — {title}",
-                doc=lambda: self.strings["_cfg"]["autobio_text"],
-                validator=loader.validators.String(),
-            ),
-            loader.ConfigValue(
-                option="no_playing_bio_text",
-                default="I use Heroku with YaMusic mod btw",
-                doc=lambda: self.strings["_cfg"]["no_playing_bio_text"],
-                validator=loader.validators.String(),
-            ),
-            loader.ConfigValue(
-                option="banner_version",
-                default="new",
-                doc=lambda: self.strings["_cfg"]["banner_version"],
-                validator=loader.validators.Choice(["old", "new"]),
-            ),
-        )
-
-    async def client_ready(self, client, db):
-        self._client: telethon.TelegramClient = client
-        self._db = db
-        if not self.get("guide_sent", False):
-            await self.inline.bot.send_message(self._tg_id, self.strings("iguide"))
-            self.set("guide_sent", True)
-        me = await self._client.get_me()
-        self._premium = me.premium if hasattr(me, "premium") else False
-        if self.get("autobio", False):
-            self.autobio.start()
-
-    @loader.loop(1800, autostart=True)
-    async def premium_check(self):
-        me = await self._client.get_me()
-        self._premium = me.premium if hasattr(me, "premium") else False
-
-    @loader.loop(30)
-    async def autobio(self):
-        if not self.config["token"]:
-            self.autobio.stop()
-            self.set("autobio", False)
-            return
-        now = await self.__get_now_playing()
-        if now and (not now["paused"]):
-            out = self.config["autobio_text"].format(
-                title=now["track"]["title"],
-                performer=", ".join(now["track"]["artist"]),
-            )
-        else:
-            out = self.config["no_playing_bio_text"]
-        try:
-            await self._client(
-                telethon.functions.account.UpdateProfileRequest(
-                    about=out[: (140 if self._premium else 70)]
-                )
-            )
-        except telethon.errors.rpcerrorlist.FloodWaitError as e:
-            logger.info(f"Sleeping {max(e.seconds, 60)} because of floodwait")
-            await asyncio.sleep(max(e.seconds, 60))
-
-
-    @loader.command(ru_doc="👉 Гайд по получению токена Яндекс.Музыки", alias="yg")
-    async def yguidecmd(self, message: telethon.types.Message):
-        """👉 Guide for obtaining a Yandex.Music token"""
-        await utils.answer(message, self.strings("guide"))
-
-
-    @loader.command(ru_doc="👉 Включить/выключить автобио", alias="yb")
-    async def ybiocmd(self, message: telethon.types.Message):
-        """👉 Enable/disable autobio"""
-        try:
-            ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        except yandex_music.exceptions.UnauthorizedError:
-            return await utils.answer(
-                message, self.strings("errors")["no_token_or_invalid"]
-            )
-
-        bio = not self.get("autobio", False)
-        self.set("autobio", bio)
-        if bio:
-            await self.autobio.func(self)
-            self.autobio.start()
-        else:
-            self.autobio.stop()
-            try:
-                await self._client(
-                    telethon.functions.account.UpdateProfileRequest(
-                        about=self.config["no_playing_bio_text"][
-                            : (140 if self._premium else 70)
-                        ]
-                    )
-                )
-            except:
-                pass
-
-        bio = self.get("autobio", False)
-        await utils.answer(
-            message, self.strings("autobio")["enabled" if bio else "disabled"]
-        )
-
-
-    @loader.command(ru_doc="👉 Поиск треков в Яндекс.Музыке", alias="yq")
-    async def ysearchcmd(self, message: telethon.types.Message):
-        """👉 Searching tracks in Yandex.Music"""
-        try:
-            ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        except yandex_music.exceptions.UnauthorizedError:
-            return await utils.answer(
-                message, self.strings("errors")["no_token_or_invalid"]
-            )
-        query = utils.get_args_raw(message)
-        if not query:
-            return await utils.answer(message, self.strings("errors")["no_query"])
-        search = await ym_client.search(query, type_="track")
-        if (not search.tracks) or (len(search.tracks.results) == 0):
-            return await utils.answer(message, self.strings("errors")["not_found"])
-
-        track = search.tracks.results[0]
-        out = self.strings("search").format(
-            title=track.title,
-            performer=", ".join(track.artists_name()),
-            track_id=track.track_id,
-        )
-        await utils.answer(message, out + self.strings("downloading_track"))
-
-        audio = await self.__download_track(ym_client, search.tracks.results[0].id)
-        await utils.answer(
-            message=message,
-            response=out,
-            file=audio,
-            attributes=(
-                [
-                    telethon.types.DocumentAttributeAudio(
-                        duration=int(search.tracks.results[0].duration_ms / 1000),
-                        title=search.tracks.results[0].title,
-                        performer=", ".join(
-                            [x.name for x in search.tracks.results[0].artists]
-                        ),
-                    )
-                ]
-            ),
-        )
-
-
-    @loader.command(
-        ru_doc="👉 Получить баннер трека, который играет сейчас", alias="yn"
-    )
-    async def ynowcmd(self, message: telethon.types.Message):
-        """👉 Get the banner of the track playing right now"""
-        try:
-            ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        except yandex_music.exceptions.UnauthorizedError:
-            return await utils.answer(
-                message, self.strings("errors")["no_token_or_invalid"]
-            )
-        await utils.answer(message, self.strings("uploading_banner"))
-        now = await self.__get_now_playing()
-        if not now:
-            return await utils.answer(message, self.strings("errors")["no_playing"])
-        track_object = (await ym_client.tracks(now["playable_id"]))[0]
-
-        playlist_name = ""
-        if now["entity_type"] == "PLAYLIST":
-            playlist = (await ym_client.playlists_list(now["entity_id"]))[0]
-            playlist_name = (
-                f'<b><a href ="https://music.yandex.ru/users/'
-                f"{playlist.owner.login}/playlists/{playlist.kind}"
-                f'">{playlist.title}</a></b>'
-            )
-        if now["entity_type"] == "ALBUM":
-            album = (await ym_client.albums(now["entity_id"]))[0]
-            playlist_name = (
-                f'<b><a href ="https://music.yandex.ru/album/'
-                f'{album.id}">{album.title}</a></b>'
-            )
-        if now["entity_type"] == "ARTIST":
-            artist = (await ym_client.artists(now["entity_id"]))[0]
-            playlist_name = (
-                f'<b><a href ="https://music.yandex.ru/artist/'
-                f'{artist.id}">{artist.name}</a></b>'
-            )
-        if now["entity_type"] not in self.strings("_entity_types").keys():
-            now["entity_type"] = "VARIOUS"
-
-        device, volume = "Unknown Device", "❔"
-        if now["device"]:
-            device = now["device"][0]["info"]["title"]
-            volume = round(now["device"][0]["volume"] * 100, 2)
-        out = self.config["now_playing_text"].format(
-            performer=", ".join(now["track"]["artist"]),
-            title=now["track"]["title"],
-            device=device,
-            volume=volume,
-            track_id=now["track"]["track_id"],
-            album_id=now["track"]["album_id"],
-            playing_from=self.strings("_entity_types")
-            .get(now["entity_type"])
-            .format(playlist_name),
-            link=f"<a href=\"https://music.yandex.ru/track/{now['playable_id']}\">Яндекс.Музыка</a>",
-        )
-        try:
-            await utils.answer(message, out + self.strings("uploading_banner"))
-        except:
-            pass
-
-        banners = Banners(
-            title=now["track"]["title"],
-            artists=now["track"]["artist"],
-            duration=now["duration_ms"],
-            progress=now["progress_ms"],
-            track_cover=requests.get(now["track"]["img"]).content,
-        )
-        file = getattr(banners, self.config["banner_version"], banners.new)()
-        await utils.answer(message=message, response=out, file=file)
-
-
-    @loader.command(ru_doc="👉 Получить трек, который играет сейчас", alias="ynt")
-    async def ynowtcmd(self, message: telethon.types.Message):
-        """👉 Get the track playing right now"""
-        try:
-            ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        except yandex_music.exceptions.UnauthorizedError:
-            return await utils.answer(
-                message, self.strings("errors")["no_token_or_invalid"]
-            )
-        await utils.answer(message, self.strings("downloading_track"))
-        now = await self.__get_now_playing()
-        if not now:
-            return await utils.answer(message, self.strings("errors")["no_playing"])
-
-        playlist_name = ""
-        if now["entity_type"] == "PLAYLIST":
-            playlist = (await ym_client.playlists_list(now["entity_id"]))[0]
-            playlist_name = (
-                f'<b><a href ="https://music.yandex.ru/users/'
-                f"{playlist.owner.login}/playlists/{playlist.kind}"
-                f'">{playlist.title}</a></b>'
-            )
-        if now["entity_type"] == "ALBUM":
-            album = (await ym_client.albums(now["entity_id"]))[0]
-            playlist_name = (
-                f'<b><a href ="https://music.yandex.ru/album/'
-                f'{album.id}">{album.title}</a></b>'
-            )
-        if now["entity_type"] == "ARTIST":
-            artist = (await ym_client.artists(now["entity_id"]))[0]
-            playlist_name = (
-                f'<b><a href ="https://music.yandex.ru/artist/'
-                f'{artist.id}">{artist.name}</a></b>'
-            )
-        if now["entity_type"] not in self.strings("_entity_types").keys():
-            now["entity_type"] = "VARIOUS"
-
-        device, volume = "Unknown Device", "❔"
-        if now["device"]:
-            device = now["device"][0]["info"]["title"]
-            volume = round(now["device"][0]["volume"] * 100, 2)
-        out = self.config["now_playing_text"].format(
-            performer=", ".join(now["track"]["artist"]),
-            title=now["track"]["title"],
-            device=device,
-            volume=volume,
-            track_id=now["track"]["track_id"],
-            album_id=now["track"]["album_id"],
-            playing_from=self.strings("_entity_types")
-            .get(now["entity_type"])
-            .format(playlist_name),
-            link=f"<a href=\"https://music.yandex.ru/track/{now['playable_id']}\">Яндекс.Музыка</a>",
-        )
-        try:
-            await utils.answer(message, out + self.strings("downloading_track"))
-        except:
-            pass
-
-        await utils.answer(
-            message=message,
-            response=out,
-            file=now["track"]["bytes_io"],
-            attributes=(
-                [
-                    telethon.types.DocumentAttributeAudio(
-                        duration=int(now["duration_ms"] / 1000),
-                        title=now["track"]["title"],
-                        performer=", ".join(now["track"]["artist"]),
-                    )
-                ]
-            ),
-        )
-
-
-    @loader.command(ru_doc="👉 Лайкнуть играющий сейчас трек")
-    async def ylikecmd(self, message: telethon.types.Message):
-        """👉 Like the track playing right now"""
-        try:
-            ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        except yandex_music.exceptions.UnauthorizedError:
-            return await utils.answer(
-                message, self.strings("errors")["no_token_or_invalid"]
-            )
-        now = await self.__get_now_playing()
-        if not now:
-            return await utils.answer(message, self.strings("errors")["no_playing"])
-        await ym_client.users_likes_tracks_add(now["track"]["track_id"])
-        await utils.answer(
-            message,
-            self.strings("likes")["liked"].format(
-                track_id=now["track"]["track_id"],
-                track=f"{', '.join(now['track']['artist'])} — {now['track']['title']}",
-            ),
-        )
-
-    @loader.command(ru_doc="👉 Снять лайк с играющего сейчас трека")
-    async def yunlikecmd(self, message: telethon.types.Message):
-        """👉 Unlike the track playing right now"""
-        try:
-            ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        except yandex_music.exceptions.UnauthorizedError:
-            return await utils.answer(
-                message, self.strings("errors")["no_token_or_invalid"]
-            )
-        now = await self.__get_now_playing()
-        if not now:
-            return await utils.answer(message, self.strings("errors")["no_playing"])
-        await ym_client.users_likes_tracks_remove(now["track"]["track_id"])
-        await utils.answer(
-            message,
-            self.strings("likes")["unliked"].format(
-                track_id=now["track"]["track_id"],
-                track=f"{', '.join(now['track']['artist'])} — {now['track']['title']}",
-            ),
-        )
-
-    @loader.command(ru_doc="👉 Дизлайкнуть играющий сейчас трек")
-    async def ydislikecmd(self, message: telethon.types.Message):
-        """👉 Dislike the track playing right now"""
-        try:
-            ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        except yandex_music.exceptions.UnauthorizedError:
-            return await utils.answer(
-                message, self.strings("errors")["no_token_or_invalid"]
-            )
-        now = await self.__get_now_playing()
-        if not now:
-            return await utils.answer(message, self.strings("errors")["no_playing"])
-        await ym_client.users_dislikes_tracks_add(now["track"]["track_id"])
-        await utils.answer(
-            message,
-            self.strings("likes")["disliked"].format(
-                track_id=now["track"]["track_id"],
-                track=f"{', '.join(now['track']['artist'])} — {now['track']['title']}",
-            ),
-        )
-
-
-    @loader.command(ru_doc="👉 Получить текст играющего сейчас трека")
-    async def ylyricscmd(self, message: telethon.types.Message):
-        """👉 Get the lyrics of the track playing right now"""
-        try:
-            ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        except yandex_music.exceptions.UnauthorizedError:
-            return await utils.answer(
-                message, self.strings("errors")["no_token_or_invalid"]
-            )
-        now = await self.__get_now_playing()
-        if not now:
-            return await utils.answer(message, self.strings("errors")["no_playing"])
-        try:
-            lyrics = await ym_client.tracks_lyrics(now["track"]["track_id"])
-            await utils.answer(
-                message,
-                self.strings("lyrics").format(
-                    track_id=now["track"]["track_id"],
-                    track=f"{', '.join(now['track']['artist'])} — {now['track']['title']}",
-                    text=requests.get(lyrics.download_url).text,
-                    writers=", ".join(lyrics.writers) if lyrics.writers else "Unknown",
-                ),
-            )
-        except yandex_music.exceptions.NotFoundError:
-            await utils.answer(
-                message,
-                self.strings("no_lyrics").format(
-                    track_id=now["track"]["track_id"],
-                    track=f"{', '.join(now['track']['artist'])} — {now['track']['title']}",
-                ),
-            )
-
-
-    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):
-            async with aiohttp.ClientSession() as session:
-                async with session.ws_connect(
-                    "wss://ynison.music.yandex.ru/redirector.YnisonRedirectService/GetRedirectToYnison",
-                    headers={
-                        "Sec-WebSocket-Protocol": f"Bearer, v2, {json.dumps(ws_proto)}",
-                        "Origin": "http://music.yandex.ru",
-                        "Authorization": f"OAuth {token}",
-                    },
-                ) as ws:
-                    response = await ws.receive()
-                    return json.loads(response.data)
-
-        device_id = "".join(random.choices(string.ascii_lowercase, k=16))
-        ws_proto = {
-            "Ynison-Device-Id": device_id,
-            "Ynison-Device-Info": json.dumps({"app_name": "Chrome", "type": 1}),
-        }
-        data = await create_ws(self.config["token"], ws_proto)
-        ws_proto["Ynison-Redirect-Ticket"] = data["redirect_ticket"]
-        payload = {
-            "update_full_state": {
-                "player_state": {
-                    "player_queue": {
-                        "current_playable_index": -1,
-                        "entity_id": "",
-                        "entity_type": "VARIOUS",
-                        "playable_list": [],
-                        "options": {"repeat_mode": "NONE"},
-                        "entity_context": "BASED_ON_ENTITY_BY_DEFAULT",
-                        "version": {
-                            "device_id": device_id,
-                            "version": 9021243204784341000,
-                            "timestamp_ms": 0,
-                        },
-                        "from_optional": "",
-                    },
-                    "status": {
-                        "duration_ms": 0,
-                        "paused": True,
-                        "playback_speed": 1,
-                        "progress_ms": 0,
-                        "version": {
-                            "device_id": device_id,
-                            "version": 8321822175199937000,
-                            "timestamp_ms": 0,
-                        },
-                    },
-                },
-                "device": {
-                    "capabilities": {
-                        "can_be_player": True,
-                        "can_be_remote_controller": False,
-                        "volume_granularity": 16,
-                    },
-                    "info": {
-                        "device_id": device_id,
-                        "type": "WEB",
-                        "title": "Chrome Browser",
-                        "app_name": "Chrome",
-                    },
-                    "volume_info": {"volume": 0},
-                    "is_shadow": True,
-                },
-                "is_currently_active": False,
-            },
-            "rid": "ac281c26-a047-4419-ad00-e4fbfda1cba3",
-            "player_action_timestamp_ms": 0,
-            "activity_interception_type": "DO_NOT_INTERCEPT_BY_DEFAULT",
-        }
-        async with aiohttp.ClientSession() as session:
-            async with session.ws_connect(
-                f"wss://{data['host']}/ynison_state.YnisonStateService/PutYnisonState",
-                headers={
-                    "Sec-WebSocket-Protocol": f"Bearer, v2, {json.dumps(ws_proto)}",
-                    "Origin": "http://music.yandex.ru",
-                    "Authorization": f"OAuth {self.config['token']}",
-                },
-            ) as ws:
-                await ws.send_str(json.dumps(payload))
-                response = await ws.receive()
-                ynison: dict = json.loads(response.data)
-        return ynison
-
-    async def __get_now_playing(self):
-        if not self.config["token"]:
-            return {}
-        try:
-            ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        except yandex_music.exceptions.UnauthorizedError:
-            return {}
-
-        ynison = await self.__get_ynison()
-        if (len(ynison.get("player_state", {}).get("player_queue", {}).get("playable_list", [])) == 0):
-            return {}
-        raw_track = ynison["player_state"]["player_queue"]["playable_list"][
-            ynison["player_state"]["player_queue"]["current_playable_index"]
-        ]
-        ym_client = await yandex_music.ClientAsync(self.config["token"]).init()
-        track_object = (await ym_client.tracks(raw_track["playable_id"]))[0]
-        return (
-            {
-                "paused": ynison["player_state"]["status"]["paused"],
-                "playable_id": raw_track["playable_id"],
-                "duration_ms": int(ynison["player_state"]["status"]["duration_ms"]),
-                "progress_ms": int(ynison["player_state"]["status"]["progress_ms"]),
-                "entity_id": ynison["player_state"]["player_queue"]["entity_id"],
-                "entity_type": ynison["player_state"]["player_queue"]["entity_type"],
-                "device": [
-                    x
-                    for x in ynison["devices"]
-                    if x["info"]["device_id"]
-                    == ynison.get("active_device_id_optional", "")
-                ],
-                "track": {
-                    "track_id": track_object.track_id,
-                    "album_id": track_object.albums[0].id,
-                    "title": track_object.title,
-                    "artist": track_object.artists_name(),
-                    "img": f"https://{track_object.cover_uri[:-2]}1000x1000",
-                    "duration": track_object.duration_ms // 1000,
-                    "minutes": round(track_object.duration_ms / 1000) // 60,
-                    "seconds": round(track_object.duration_ms / 1000) % 60,
-                    "bytes_io": (
-                        await self.__download_track(ym_client, track_object.track_id)
-                    ),
-                },
-            }
-            if raw_track["playable_type"] != "LOCAL_TRACK"
-            else {}
-        )