wintergram-userbot 1.1.2__tar.gz → 1.2__tar.gz

wintergram_userbot-1.2/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+recursive-include wintergram_userbot *.py
+recursive-include wintergram_userbot *.json

{wintergram_userbot-1.1.2/wintergram_userbot.egg-info → wintergram_userbot-1.2}/PKG-INFO

@@ -1,30 +1,13 @@
 Metadata-Version: 2.4
 Name: wintergram-userbot
-Version: 1.1.2
-Summary: Полнофункциональный асинхронный MTProto-клиент для приватных Telegram-серверов (layers 167-228) с поддержкой отправки медиа
-Author-email: femboychik <your.email@example.com>
-License: MIT
-Project-URL: Homepage, https://github.com/femboychik/wintergram-userbot
-Project-URL: Repository, https://github.com/femboychik/wintergram-userbot
-Project-URL: Issues, https://github.com/femboychik/wintergram-userbot/issues
-Keywords: telegram,mtproto,userbot,async,client
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Communications :: Chat
+Version: 1.2
+Summary: WinterGram Userbot for custom MTProto server
+Author: WinterGram Team
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp>=3.8.0
-Dynamic: license-file
+Requires-Dist: pycryptodome>=3.19.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
 
 # wintergram-userbot
 

wintergram_userbot-1.2/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wintergram-userbot"
+version = "1.2"
+description = "WinterGram Userbot for custom MTProto server"
+readme = "README.md"
+authors = [{name = "WinterGram Team"}]
+requires-python = ">=3.8"
+dependencies = [
+    "pycryptodome>=3.19.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["wintergram_userbot*"]
+
+[tool.setuptools.package-data]
+wintergram_userbot = ["tl/schemas/data/*.json"]

{wintergram_userbot-1.1.2 → wintergram_userbot-1.2}/wintergram_userbot/__init__.py

@@ -4,7 +4,7 @@
 Поддерживаются слои (layers) от 167 до 228 включительно.
 """
 
-__version__ = "1.1.2"
+__version__ = "1.2"
 
 from .client import WinterGramClient
 from .errors import (

{wintergram_userbot-1.1.2 → wintergram_userbot-1.2}/wintergram_userbot/api/functions.py

@@ -187,6 +187,32 @@ class Functions:
     #  отправка / история
     # ------------------------------------------------------------------ #
 
+    # ------------------------------------------------------------------ #
+    #  ответы на сообщения (разные эры схемы)
+    # ------------------------------------------------------------------ #
+    def reply_params(self, method: str, reply_to):
+        """Параметры ответа на сообщение для метода - с учётом эры слоя.
+
+        Старые слои ждут int в reply_to_msg_id, новые - объект
+        inputReplyToMessage. Возвращает то, что нужно добавить в params.
+        """
+        if not reply_to:
+            return {}
+        if not isinstance(reply_to, int):
+            return {"reply_to": reply_to}
+
+        out = {}
+        names = self._param_names(method)
+        if "reply_to_msg_id" in names:
+            out["reply_to_msg_id"] = reply_to
+        if "reply_to" in names:
+            reply_desc = self.schema.by_name("inputReplyToMessage")
+            if reply_desc is None:
+                out["reply_to_msg_id"] = reply_to
+            else:
+                out["reply_to"] = {"_id": reply_desc["id"], "reply_to_msg_id": reply_to}
+        return out
+
     async def send_message(self, peer, text: str, random_id=None, reply_to=None, reply_markup=None):
         """messages.sendMessage(peer, text, random_id, reply_to, reply_markup)."""
         params = {
@@ -196,15 +222,8 @@ class Functions:
                 int.from_bytes(os.urandom(8), "little", signed=True)
             ),
         }
-        if reply_to is not None:
-            # разные эры: reply_to_msg_id (int) или reply_to (InputReplyTo)
-            if "reply_to_msg_id" in self._param_names("messages.sendMessage"):
-                if isinstance(reply_to, int):
-                    params["reply_to_msg_id"] = reply_to
-            if "reply_to" in self._param_names("messages.sendMessage"):
-                if isinstance(reply_to, int):
-                    reply_desc = self.schema.by_name("inputReplyToMessage")
-                    params["reply_to"] = {"_id": reply_desc["id"], "reply_to_msg_id": reply_to}
+        # разные эры: reply_to_msg_id (int) или reply_to (InputReplyTo)
+        params.update(self.reply_params("messages.sendMessage", reply_to))
         if reply_markup is not None:
             params["reply_markup"] = reply_markup
         return await self.conn.rpc("messages.sendMessage", params)
@@ -384,6 +403,240 @@ class Functions:
         params = {"offline": offline}
         return await self.conn.rpc("account.updateStatus", params)
 
+    # ------------------------------------------------------------------ #
+    #  профиль: юзернеймы, аватар, приватность, сессии
+    # ------------------------------------------------------------------ #
+
+    _PRIVACY_KEYS = {
+        "status_timestamp": "inputPrivacyKeyStatusTimestamp",
+        "last_seen": "inputPrivacyKeyStatusTimestamp",
+        "phone_call": "inputPrivacyKeyPhoneCall",
+        "phone_p2p": "inputPrivacyKeyPhoneP2P",
+        "chat_invite": "inputPrivacyKeyChatInvite",
+        "phone_number": "inputPrivacyKeyPhoneNumber",
+        "profile_photo": "inputPrivacyKeyProfilePhoto",
+        "forwards": "inputPrivacyKeyForwards",
+        "about": "inputPrivacyKeyAbout",
+        "voice_messages": "inputPrivacyKeyVoiceMessages",
+    }
+
+    _PRIVACY_VALUES = {
+        "all": "inputPrivacyValueAllowAll",
+        "everyone": "inputPrivacyValueAllowAll",
+        "contacts": "inputPrivacyValueAllowContacts",
+        "close_friends": "inputPrivacyValueAllowCloseFriends",
+        "bots": "inputPrivacyValueAllowBots",
+        "premium": "inputPrivacyValueAllowPremium",
+        "nobody": "inputPrivacyValueAllowUsers",
+        "chats": "inputPrivacyValueAllowChatParticipants",
+    }
+
+    def _construct(self, ctor, **fields):
+        """Собирает конструктор текущей эры по имени; fields — его поля."""
+        desc = self.schema.by_name(ctor)
+        if desc is None:
+            raise RPCError(0, "%s not available on layer %d" % (ctor, self.schema.layer))
+        obj = {"_id": desc["id"]}
+        obj.update(fields)
+        return obj
+
+    # -------------------------------------------------------------- #
+    #  юзернеймы
+    # -------------------------------------------------------------- #
+
+    async def check_username(self, username: str):
+        """account.checkUsername - свободен ли юзернейм (True/False)."""
+        return await self.conn.rpc("account.checkUsername", {"username": username})
+
+    async def update_username(self, username: str):
+        """account.updateUsername - ставит основной юзернейм.
+
+        Пустая строка снимает текущий юзернейм.
+        """
+        return await self.conn.rpc("account.updateUsername", {"username": username})
+
+    async def toggle_username(self, username: str, active=True):
+        """account.toggleUsername - вкл/выкл дополнительный юзернейм."""
+        return await self.conn.rpc("account.toggleUsername", {
+            "username": username,
+            "active": bool(active),
+        })
+
+    async def reorder_usernames(self, order):
+        """account.reorderUsernames - первый в списке становится основным."""
+        return await self.conn.rpc("account.reorderUsernames", {"order": list(order)})
+
+    # -------------------------------------------------------------- #
+    #  аватар
+    # -------------------------------------------------------------- #
+
+    async def upload_file(self, data: bytes, file_name="file", part_size=524288):
+        """Заливает байты по кускам через upload.saveFilePart.
+
+        Returns:
+            inputFile текущей эры - готов к передаче в photos.* / messages.sendMedia.
+        """
+        if not isinstance(data, (bytes, bytearray)):
+            raise TypeError("upload_file expects bytes, got %r" % type(data).__name__)
+        chunks = [bytes(data[i:i + part_size]) for i in range(0, len(data), part_size)] or [b""]
+        file_id = int.from_bytes(os.urandom(8), "little", signed=True)
+        for idx, chunk in enumerate(chunks):
+            await self.conn.rpc("upload.saveFilePart", {
+                "file_id": file_id,
+                "file_part": idx,
+                "bytes": chunk,
+            })
+        return self._construct(
+            "inputFile", id=file_id, parts=len(chunks), name=file_name, md5_checksum="",
+        )
+
+    async def upload_profile_photo(self, data: bytes, file_name="avatar.jpg", fallback=None):
+        """photos.uploadProfilePhoto - ставит фото основной аватаркой.
+
+        Args:
+            data: байты изображения
+            file_name: имя файла (для сервера)
+            fallback: True - запасная аватарка (если сервер/слой поддерживает)
+        """
+        input_file = await self.upload_file(data, file_name=file_name)
+        params = {"file": input_file}
+        if fallback is not None:
+            params["fallback"] = bool(fallback)
+        return await self.conn.rpc("photos.uploadProfilePhoto", params)
+
+    async def delete_profile_photo(self, photo_id):
+        """photos.deletePhotos - удаляет аватарки по id (списком или по одному)."""
+        ids = photo_id if isinstance(photo_id, (list, tuple)) else [photo_id]
+        payload = [self._construct("inputPhoto", id=int(i)) for i in ids]
+        return await self.conn.rpc("photos.deletePhotos", {"id": payload})
+
+    async def get_profile_photos(self, user_id=None, offset=0, max_id=0, limit=20):
+        """photos.getUserPhotos - аватарки пользователя (свои, если user_id не задан)."""
+        return await self.conn.rpc("photos.getUserPhotos", {
+            "user_id": user_id if user_id is not None else self.input_user_self(),
+            "offset": int(offset),
+            "max_id": int(max_id),
+            "limit": int(limit),
+        })
+
+    # -------------------------------------------------------------- #
+    #  приватность
+    # -------------------------------------------------------------- #
+
+    def privacy_key(self, key):
+        """Имя ключа ('last_seen', 'phone_number', ...) -> InputPrivacyKey."""
+        if isinstance(key, dict):
+            return key
+        name = self._PRIVACY_KEYS.get(str(key).lower())
+        if name is None:
+            raise ValueError("unknown privacy key %r; known: %s"
+                             % (key, ", ".join(sorted(self._PRIVACY_KEYS))))
+        return self._construct(name)
+
+    def privacy_rule(self, rule, chats=None):
+        """Имя правила ('all', 'contacts', 'nobody', ...) -> InputPrivacyRule.
+
+        Для 'chats' передай chats=[InputChat,...].
+        """
+        if isinstance(rule, dict):
+            return rule
+        name = self._PRIVACY_VALUES.get(str(rule).lower())
+        if name is None:
+            raise ValueError("unknown privacy rule %r; known: %s"
+                             % (rule, ", ".join(sorted(self._PRIVACY_VALUES))))
+        if name == "inputPrivacyValueAllowChatParticipants":
+            return self._construct(name, chats=list(chats or []))
+        return self._construct(name)
+
+    async def get_privacy(self, key):
+        """account.getPrivacy - текущие правила приватности."""
+        return await self.conn.rpc("account.getPrivacy", {"key": self.privacy_key(key)})
+
+    async def set_privacy(self, key, rules):
+        """account.setPrivacy - правила приватности.
+
+        Args:
+            key: ключ ('last_seen', 'profile_photo', ...)
+            rules: список правил: ['nobody'], ['contacts'], ['chats'] и т.п.
+                   Для конкретных чатов - пара ('chats', [InputChat, ...])
+        """
+        built = []
+        for rule in rules:
+            if isinstance(rule, (list, tuple)):
+                if not rule:
+                    raise ValueError("empty privacy rule")
+                built.append(self.privacy_rule(rule[0], chats=rule[1] if len(rule) > 1 else None))
+            else:
+                built.append(self.privacy_rule(rule))
+        return await self.conn.rpc("account.setPrivacy", {
+            "key": self.privacy_key(key),
+            "rules": built,
+        })
+
+    # -------------------------------------------------------------- #
+    #  оформление профиля
+    # -------------------------------------------------------------- #
+
+    async def update_birthday(self, day, month, year=None):
+        """account.updateBirthday - день рождения (layer >= latest only)."""
+        return await self.conn.rpc("account.updateBirthday", {
+            "birthday": self._construct("birthday", day=int(day), month=int(month), year=int(year or 0)),
+        })
+
+    async def update_profile_color(self, color=None, for_profile=True):
+        """account.updateColor - цвет профиля/градиент аватарки."""
+        return await self.conn.rpc("account.updateColor", {
+            "for_profile": bool(for_profile),
+            "color": self._construct("peerColor", color=int(color) if color is not None else 0),
+        })
+
+    async def set_emoji_status(self, emoji=None):
+        """account.updateEmojiStatus - эмодзи-статус.
+
+        emoji=None очищает статус. Установка конкретного эмодзи требует
+        конструктор emojiStatusEmoji, которого нет в собранных схемах.
+        """
+        if emoji is None:
+            return await self.conn.rpc("account.updateEmojiStatus", {
+                "emoji_status": self._construct("emojiStatusEmpty"),
+            })
+        desc = self.schema.by_name("emojiStatusEmoji")
+        if desc is None:
+            raise RPCError(0, "emojiStatusEmoji not available on layer %d; "
+                              "only clearing is possible" % self.schema.layer)
+        document_id = getattr(emoji, "document_id", None)
+        return await self.conn.rpc("account.updateEmojiStatus", {
+            "emoji_status": self._construct(
+                desc["name"], document_id=int(document_id or emoji), until=None,
+            ),
+        })
+
+    async def get_recent_emoji_statuses(self, hash=0):
+        """account.getRecentEmojiStatuses - недавние эмодзи-статусы."""
+        return await self.conn.rpc("account.getRecentEmojiStatuses", {"hash": int(hash)})
+
+    # -------------------------------------------------------------- #
+    #  сессии и прочее
+    # -------------------------------------------------------------- #
+
+    async def get_authorizations(self):
+        """account.getAuthorizations - список активных сессий аккаунта."""
+        return await self.conn.rpc("account.getAuthorizations", {})
+
+    async def reset_authorization(self, auth_hash):
+        """account.resetAuthorization - завершает чужую сессию по hash."""
+        return await self.conn.rpc("account.resetAuthorization", {"hash": int(auth_hash)})
+
+    async def get_account_ttl(self):
+        """account.getAccountTTL - настройка автоудаления аккаунта."""
+        return await self.conn.rpc("account.getAccountTTL", {})
+
+    async def set_account_ttl(self, days=0):
+        """account.setAccountTTL - автоудаление через N дней (0 — выключить)."""
+        return await self.conn.rpc("account.setAccountTTL", {
+            "ttl": self._construct("accountDaysTTL", days=int(days)),
+        })
+
     # ------------------------------------------------------------------ #
     #  управление чатами
     # ------------------------------------------------------------------ #
@@ -548,6 +801,146 @@ class Functions:
 
         return await self.conn.rpc("messages.setBotCallbackAnswer", params)
 
+    # ------------------------------------------------------------------ #
+    #  подарки (star gifts)
+    # ------------------------------------------------------------------ #
+
+    async def get_star_gifts(self, hash=0):
+        """payments.getStarGifts - получает список доступных подарков.
+
+        Args:
+            hash: хэш для проверки изменений (0 = получить все)
+
+        Returns:
+            Объект payments.StarGifts с полями: gifts, chats, users
+        """
+        params = {"hash": int(hash)}
+        return await self.conn.rpc("payments.getStarGifts", params)
+
+    async def send_star_gift(self, peer, gift_id, message=None, hide_name=False):
+        """Отправляет StarGift пользователю.
+
+        Args:
+            peer: InputPeer получателя подарка
+            gift_id: ID подарка (из списка payments.getStarGifts)
+            message: текст сообщения к подарку (опционально)
+            hide_name: скрыть имя отправителя
+
+        Returns:
+            Результат отправки подарка
+        """
+        # Создаем InputInvoice для подарка
+        invoice_params = {
+            "_": "inputInvoiceStarGift",
+            "peer": peer,
+            "gift_id": int(gift_id),
+            "flags": 0
+        }
+
+        if hide_name:
+            invoice_params["flags"] |= 1  # flags.0
+
+        if message:
+            invoice_params["flags"] |= 2  # flags.1
+            # Создаем TextWithEntities
+            invoice_params["message"] = {
+                "_": "textWithEntities",
+                "text": message,
+                "entities": []
+            }
+
+        # Получаем форму оплаты
+        _, payment_form = await self.conn.rpc("payments.getPaymentForm", {
+            "invoice": invoice_params
+        })
+
+        form_id = payment_form.get("form_id")
+        if form_id is None:
+            raise RPCError(0, "payment form has no form_id")
+
+        # Отправляем подарок
+        return await self.conn.rpc("payments.sendStarsForm", {
+            "form_id": form_id,
+            "invoice": invoice_params
+        })
+
+    async def get_saved_star_gifts(self, peer, offset="", limit=100, exclude_unsaved=False):
+        """payments.getSavedStarGifts - получает сохраненные подарки.
+
+        Args:
+            peer: InputPeer пользователя
+            offset: смещение для пагинации
+            limit: количество подарков
+            exclude_unsaved: исключить несохраненные
+
+        Returns:
+            Объект payments.SavedStarGifts
+        """
+        params = {
+            "peer": peer,
+            "offset": str(offset),
+            "limit": int(limit),
+            "flags": 0
+        }
+
+        if exclude_unsaved:
+            params["flags"] |= 1  # flags.0
+
+        return await self.conn.rpc("payments.getSavedStarGifts", params)
+
+    async def convert_star_gift(self, msg_id):
+        """payments.convertStarGift - конвертирует подарок в звезды.
+
+        Args:
+            msg_id: ID сообщения с подарком
+
+        Returns:
+            Результат конвертации
+        """
+        # Создаем InputSavedStarGift
+        stargift = {
+            "_": "inputSavedStarGiftUser",
+            "msg_id": int(msg_id)
+        }
+
+        return await self.conn.rpc("payments.convertStarGift", {
+            "stargift": stargift
+        })
+
+    async def transfer_star_gift(self, msg_id, to_peer):
+        """Переводит уникальный подарок другому пользователю.
+
+        Args:
+            msg_id: ID сообщения с подарком
+            to_peer: InputPeer получателя
+
+        Returns:
+            Результат перевода
+        """
+        # Создаем InputSavedStarGift
+        stargift = {
+            "_": "inputSavedStarGiftUser",
+            "msg_id": int(msg_id)
+        }
+
+        return await self.conn.rpc("payments.transferStarGift", {
+            "stargift": stargift,
+            "to_id": to_peer
+        })
+
+    async def check_can_send_gift(self, gift_id):
+        """payments.checkCanSendGift - проверяет возможность отправки подарка.
+
+        Args:
+            gift_id: ID подарка
+
+        Returns:
+            payments.CheckCanSendGiftResult (Ok или Fail с причиной)
+        """
+        return await self.conn.rpc("payments.checkCanSendGift", {
+            "gift_id": int(gift_id)
+        })
+
     # ------------------------------------------------------------------ #
     def _param_names(self, method_name):
         desc = self.schema.by_name(method_name)

{wintergram_userbot-1.1.2 → wintergram_userbot-1.2}/wintergram_userbot/client.py

@@ -3,6 +3,7 @@
 import asyncio
 import inspect
 import logging
+import os
 
 from .errors import (
     WinterGramError,
@@ -277,13 +278,14 @@ class WinterGramClient:
             raise RPCError(0, "peer %r could not be resolved" % (peer,))
         return await self.functions.send_message(peer_obj, text)
 
-    async def send_photo(self, peer, photo_path_or_url, caption=""):
+    async def send_photo(self, peer, photo_path_or_url, caption="", reply_to=0):
         """Отправляет фото по URL или локальному пути с подписью.
 
         Args:
             peer: ID чата, username или "me"
             photo_path_or_url: URL фото или путь к локальному файлу
             caption: подпись к фото (опционально)
+            reply_to: ID сообщения, на которое отвечаем (опционально)
         """
         import os
         import tempfile
@@ -341,7 +343,7 @@ class WinterGramClient:
                 })
 
             # Отправляем медиа-сообщение
-            result = await self.conn.rpc("messages.sendMedia", {
+            media_params = {
                 "peer": peer_obj,
                 "media": {
                     "_": "inputMediaUploadedPhoto",
@@ -355,7 +357,19 @@ class WinterGramClient:
                 },
                 "message": caption,
                 "random_id": random.randint(1, 2**63 - 1)
-            })
+            }
+            media_params.update(self.functions.reply_params("messages.sendMedia", reply_to))
+
+            try:
+                result = await self.conn.rpc("messages.sendMedia", media_params)
+            except Exception as e:
+                if not reply_to:
+                    raise
+                # сервер не принял ответ на сообщение — шлём фото без него
+                __log__.warning("sendMedia with reply_to failed (%r), retrying without", e)
+                media_params.pop("reply_to", None)
+                media_params.pop("reply_to_msg_id", None)
+                result = await self.conn.rpc("messages.sendMedia", media_params)
 
             return result
 
@@ -566,6 +580,170 @@ class WinterGramClient:
         """
         return await self.functions.update_status(offline)
 
+    # ------------------------------------------------------------------ #
+    #  профиль: юзернейм, аватар, приватность, сессии
+    # ------------------------------------------------------------------ #
+
+    async def check_username(self, username):
+        """Проверяет, свободен ли юзернейм.
+
+        Args:
+            username: имя без @
+
+        Returns:
+            True, если можно занять
+        """
+        return await self.functions.check_username(username)
+
+    async def set_username(self, username):
+        """Меняет основной юзернейм аккаунта.
+
+        Args:
+            username: новый юзернейм без @
+
+        Raises:
+            RPCError: если юзернейм занят или сервер его отклонил
+        """
+        return await self.functions.update_username((username or "").lstrip("@"))
+
+    async def remove_username(self):
+        """Снимает основной юзернейм (то же, что set_username(""))."""
+        return await self.functions.update_username("")
+
+    async def toggle_username(self, username, active=True):
+        """Включает/выключает дополнительный юзернейм."""
+        return await self.functions.toggle_username((username or "").lstrip("@"), active)
+
+    async def reorder_usernames(self, order):
+        """Задаёт порядок юзернеймов (первый становится основным)."""
+        return await self.functions.reorder_usernames([u.lstrip("@") for u in order])
+
+    async def set_avatar(self, photo, fallback=None):
+        """Загружает новую аватарку.
+
+        Args:
+            photo: путь к файлу, http(s)-ссылка или сами байты
+            fallback: True - поставить как запасную аватарку
+
+        Returns:
+            photos.Photo от сервера
+        """
+        data = await self._load_media(photo)
+        if isinstance(photo, str) and not photo.startswith(("http://", "https://")):
+            name = os.path.basename(photo) or "avatar.jpg"
+        else:
+            name = "avatar.jpg"
+        return await self.functions.upload_profile_photo(data, file_name=name, fallback=fallback)
+
+    async def remove_avatar(self, photo_id=None):
+        """Удаляет аватарки.
+
+        Args:
+            photo_id: id фото; если не задан - удаляется самая свежая своя
+        """
+        if photo_id is None:
+            _, res = await self.functions.get_profile_photos(limit=1)
+            photos = res.get("photos") or []
+            if not photos:
+                raise WinterGramError("no profile photos to remove")
+            photo_id = photos[0].get("id")
+        return await self.functions.delete_profile_photo(photo_id)
+
+    async def get_avatars(self, peer=None, limit=20):
+        """Возвращает список аватарок (своих, если peer не задан)."""
+        user = await self._resolve_input_user(peer) if peer is not None else None
+        _, result = await self.functions.get_profile_photos(user_id=user, limit=limit)
+        return result.get("photos", [])
+
+    async def get_profile(self, peer=None):
+        """Полная информация о профиле (users.getFullUser)."""
+        if peer is None:
+            return await self.functions.get_full_user(self.functions.input_user_self())
+        return await self.functions.get_full_user(await self._resolve_input_user(peer))
+
+    async def set_privacy(self, key, rules):
+        """Меняет правила приватности.
+
+        Args:
+            key: last_seen | phone_number | profile_photo | chat_invite | forwards | about
+            rules: ['all'] | ['contacts'] | ['close_friends'] | ['nobody'] |
+                   ['bots'] | ['premium'] | [('chats', chats)]
+
+        Examples:
+            await client.set_privacy("last_seen", ["nobody"])
+            await client.set_privacy("profile_photo", ["contacts"])
+        """
+        return await self.functions.set_privacy(key, rules)
+
+    async def get_privacy(self, key):
+        """Текущие правила приватности по ключу."""
+        return await self.functions.get_privacy(key)
+
+    async def set_birthday(self, day, month, year=None):
+        """Задаёт день рождения в профиле."""
+        return await self.functions.update_birthday(day, month, year)
+
+    async def set_profile_color(self, color=None, for_profile=True):
+        """Задаёт цвет профиля (None - сбросить)."""
+        return await self.functions.update_profile_color(color, for_profile)
+
+    async def set_emoji_status(self, emoji=None):
+        """Ставит эмодзи-статус (None - очистить)."""
+        return await self.functions.set_emoji_status(emoji)
+
+    async def get_sessions(self):
+        """Список активных сессий аккаунта (account.getAuthorizations)."""
+        _, result = await self.functions.get_authorizations()
+        return result.get("authorizations", [])
+
+    async def terminate_session(self, auth_hash):
+        """Завершает чужую сессию по её hash."""
+        return await self.functions.reset_authorization(auth_hash)
+
+    async def get_account_ttl(self):
+        """Текущая настройка автоудаления аккаунта."""
+        return await self.functions.get_account_ttl()
+
+    async def set_account_ttl(self, days=0):
+        """Автоудаление аккаунта через N дней (0 — выключить)."""
+        return await self.functions.set_account_ttl(days)
+
+    async def _load_media(self, source):
+        """Приводит путь / http-ссылку / bytes к байтам файла."""
+        if isinstance(source, (bytes, bytearray)):
+            return bytes(source)
+        import urllib.request
+
+        if isinstance(source, str) and source.startswith(("http://", "https://")):
+            def _download():
+                with urllib.request.urlopen(source, timeout=30) as resp:
+                    return resp.read()
+            return await asyncio.to_thread(_download)
+
+        if isinstance(source, str) and os.path.isfile(source):
+            def _read():
+                with open(source, "rb") as f:
+                    return f.read()
+            return await asyncio.to_thread(_read)
+
+        raise WinterGramError(
+            "expected bytes, file path or http(s) URL, got %r" % type(source).__name__
+        )
+
+    async def _resolve_input_user(self, peer):
+        """InputPeer (или 'me'/None -> self) -> InputUser для users.*/photos.*."""
+        peer_obj = await self._resolve_peer_helper(peer)
+        if peer_obj is None or "user_id" not in peer_obj:
+            raise WinterGramError("peer %r is not a user" % (peer,))
+        _, res = await self.functions.get_users([
+            self.functions.input_user(peer_obj["user_id"], peer_obj.get("access_hash"))
+        ])
+        users = res if isinstance(res, list) else (res.get("users") if isinstance(res, dict) else None)
+        if not users:
+            raise WinterGramError("cannot resolve user for peer %r" % (peer,))
+        user = users[0]
+        return self.functions.input_user(user.get("id"), user.get("access_hash"))
+
     async def join_chat(self, peer):
         """Присоединяется к каналу/супергруппе.
 
@@ -628,6 +806,106 @@ class WinterGramClient:
         _, obj = await self.conn.rpc(method, params)
         return obj
 
+    # ------------------------------------------------------------------ #
+    #  подарки (star gifts и NFT)
+    # ------------------------------------------------------------------ #
+
+    async def get_available_gifts(self):
+        """Получает список всех доступных подарков для отправки.
+
+        Returns:
+            Список подарков с информацией о цене, иконке и т.д.
+        """
+        _, result = await self.functions.get_star_gifts()
+        return result.get("gifts", [])
+
+    async def send_gift(self, peer, gift_id, message=None, hide_name=False):
+        """Отправляет подарок (мишка, NFT и т.д.) пользователю.
+
+        Args:
+            peer: ID пользователя, username или "me"
+            gift_id: ID подарка из списка get_available_gifts()
+            message: текст сообщения к подарку (опционально)
+            hide_name: True - скрыть имя отправителя, False - показать
+
+        Returns:
+            Результат отправки подарка
+
+        Example:
+            # Получаем список подарков
+            gifts = await client.get_available_gifts()
+            # Отправляем первый подарок с сообщением
+            await client.send_gift(user_id, gifts[0]["id"], "С Днём Рождения!")
+        """
+        peer_obj = await self._resolve_peer_helper(peer)
+
+        # Проверяем, можно ли отправить этот подарок
+        try:
+            _, check_result = await self.functions.check_can_send_gift(gift_id)
+            result_type = check_result.get("_", "")
+            if "Fail" in result_type:
+                reason = check_result.get("reason", {})
+                reason_text = reason.get("text", "Unknown reason") if isinstance(reason, dict) else str(reason)
+                raise RPCError(0, f"Cannot send gift: {reason_text}")
+        except RPCError as e:
+            if "METHOD_NOT_FOUND" not in str(e):
+                raise
+            # Метод checkCanSendGift не поддерживается, продолжаем
+
+        # Отправляем подарок
+        return await self.functions.send_star_gift(peer_obj, gift_id, message, hide_name)
+
+    async def get_my_gifts(self, exclude_unsaved=False, limit=100):
+        """Получает подарки, полученные текущим пользователем.
+
+        Args:
+            exclude_unsaved: True - только сохраненные подарки
+            limit: максимальное количество подарков
+
+        Returns:
+            Список полученных подарков
+        """
+        peer_obj = self.functions.input_peer_self()
+        _, result = await self.functions.get_saved_star_gifts(
+            peer_obj,
+            offset="",
+            limit=limit,
+            exclude_unsaved=exclude_unsaved
+        )
+        return result.get("gifts", [])
+
+    async def convert_gift_to_stars(self, msg_id):
+        """Конвертирует полученный подарок в звезды (Stars).
+
+        Args:
+            msg_id: ID сообщения с подарком
+
+        Returns:
+            Результат конвертации
+
+        Note:
+            Конвертированный подарок исчезнет из коллекции!
+        """
+        return await self.functions.convert_star_gift(msg_id)
+
+    async def transfer_gift(self, msg_id, to_peer):
+        """Переводит уникальный подарок (NFT) другому пользователю.
+
+        Args:
+            msg_id: ID сообщения с подарком
+            to_peer: ID получателя, username или "me"
+
+        Returns:
+            Результат перевода
+
+        Note:
+            Работает только для уникальных подарков (NFT), которые можно передавать
+        """
+        to_peer_obj = await self._resolve_peer_helper(to_peer)
+        return await self.functions.transfer_star_gift(msg_id, to_peer_obj)
+
+    # ------------------------------------------------------------------ #
+
     async def __aenter__(self):
         return await self.connect()
 

{wintergram_userbot-1.1.2 → wintergram_userbot-1.2/wintergram_userbot.egg-info}/PKG-INFO

@@ -1,30 +1,13 @@
 Metadata-Version: 2.4
 Name: wintergram-userbot
-Version: 1.1.2
-Summary: Полнофункциональный асинхронный MTProto-клиент для приватных Telegram-серверов (layers 167-228) с поддержкой отправки медиа
-Author-email: femboychik <your.email@example.com>
-License: MIT
-Project-URL: Homepage, https://github.com/femboychik/wintergram-userbot
-Project-URL: Repository, https://github.com/femboychik/wintergram-userbot
-Project-URL: Issues, https://github.com/femboychik/wintergram-userbot/issues
-Keywords: telegram,mtproto,userbot,async,client
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Communications :: Chat
+Version: 1.2
+Summary: WinterGram Userbot for custom MTProto server
+Author: WinterGram Team
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp>=3.8.0
-Dynamic: license-file
+Requires-Dist: pycryptodome>=3.19.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
 
 # wintergram-userbot
 

{wintergram_userbot-1.1.2 → wintergram_userbot-1.2}/wintergram_userbot.egg-info/SOURCES.txt

@@ -1,4 +1,3 @@
-LICENSE
 MANIFEST.in
 README.md
 pyproject.toml

wintergram_userbot-1.2/wintergram_userbot.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pycryptodome>=3.19.0
+
+[dev]
+pytest>=7.0.0

wintergram_userbot-1.1.2/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 femboychik
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

wintergram_userbot-1.1.2/MANIFEST.in

@@ -1,17 +0,0 @@
-include README.md
-include LICENSE
-include pyproject.toml
-recursive-include wintergram_userbot *.py
-recursive-include wintergram_userbot/tl/schemas/data *.json
-exclude userbot_demo.py
-exclude check_session.py
-exclude wintergram_session.db
-exclude промпт.txt
-recursive-exclude tests *
-recursive-exclude tools *
-recursive-exclude __pycache__ *
-recursive-exclude .pytest_cache *
-recursive-exclude .claude *
-global-exclude *.pyc
-global-exclude *.pyo
-global-exclude *~

wintergram_userbot-1.1.2/pyproject.toml

@@ -1,43 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "wintergram-userbot"
-version = "1.1.2"
-description = "Полнофункциональный асинхронный MTProto-клиент для приватных Telegram-серверов (layers 167-228) с поддержкой отправки медиа"
-readme = "README.md"
-requires-python = ">=3.8"
-license = {text = "MIT"}
-authors = [
-    {name = "femboychik", email = "your.email@example.com"}
-]
-dependencies = [
-    "aiohttp>=3.8.0"
-]
-keywords = ["telegram", "mtproto", "userbot", "async", "client"]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Operating System :: OS Independent",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Topic :: Communications :: Chat",
-]
-
-[project.urls]
-Homepage = "https://github.com/femboychik/wintergram-userbot"
-Repository = "https://github.com/femboychik/wintergram-userbot"
-Issues = "https://github.com/femboychik/wintergram-userbot/issues"
-
-[tool.setuptools]
-packages = ["wintergram_userbot"]
-
-[tool.setuptools.package-data]
-wintergram_userbot = ["tl/schemas/data/*.json"]

wintergram_userbot-1.1.2/wintergram_userbot.egg-info/requires.txt

@@ -1 +0,0 @@
-aiohttp>=3.8.0