wintergram-userbot 0.1.0__py3-none-any.whl

wintergram_userbot/__init__.py

@@ -0,0 +1,47 @@
+"""wintergram_userbot - переписанный с нуля асинхронный MTProto-клиент.
+
+Пишется для ПРИВАТНОГО MTProto-сервера (не официального Telegram).
+Поддерживаются слои (layers) от 167 до 228 включительно.
+"""
+
+__version__ = "0.1.0"
+
+from .client import WinterGramClient
+from .errors import (
+    RPCError,
+    FloodWaitError,
+    AuthKeyError,
+    LayerMismatchError,
+    ConnectionClosedError,
+    UnknownLayerError,
+    AuthorizationExpiredError,
+    TimeoutError,
+    TransportError,
+    SessionPasswordNeededError,
+    PhoneCodeInvalidError,
+    PhoneNumberUnoccupiedError,
+)
+from .tl.types import TL, TLObject
+from .api.updates import NewMessage, MessageEdited, MessageDeleted
+
+__all__ = [
+    "WinterGramClient",
+    "RPCError",
+    "FloodWaitError",
+    "AuthKeyError",
+    "LayerMismatchError",
+    "ConnectionClosedError",
+    "UnknownLayerError",
+    "AuthorizationExpiredError",
+    "TimeoutError",
+    "TransportError",
+    "SessionPasswordNeededError",
+    "PhoneCodeInvalidError",
+    "PhoneNumberUnoccupiedError",
+    "TL",
+    "TLObject",
+    "NewMessage",
+    "MessageEdited",
+    "MessageDeleted",
+    "__version__",
+]

wintergram_userbot/api/__init__.py

@@ -0,0 +1 @@
+"""Высокоуровневый API юзербота."""

wintergram_userbot/api/functions.py

@@ -0,0 +1,262 @@
+"""Высокоуровневый API: auth, sendMessage, getHistory, получения метаданных.
+
+Каждый метод сам выбирает type_id и поля через SchemaResolver (по текущему слою
+соединения), поэтому один и тот же вызов работает на схемах 167..228.
+"""
+
+import logging
+import os
+import time
+
+from ..errors import (
+    RPCError,
+    SessionPasswordNeededError,
+    PhoneCodeInvalidError,
+    PhoneNumberUnoccupiedError,
+)
+from ..crypto.srp import compute_password_check
+
+__log__ = logging.getLogger("wintergram.api.functions")
+
+
+class Functions:
+    """Обёртка над MTProtoConnection с понятными методами."""
+
+    def __init__(self, conn, api_id=2040, api_hash="b18441a1ff607e10a989891a5462e627"):
+        self.conn = conn
+        self.api_id = api_id
+        self.api_hash = api_hash
+
+    @property
+    def schema(self):
+        return self.conn._schema
+
+    # ------------------------------------------------------------------ #
+    #  авторизация
+    # ------------------------------------------------------------------ #
+
+    async def send_code(self, phone: str):
+        """auth.sendCode. Возвращает auth.sentCode (phone_code_hash и пр.)."""
+        code_settings_desc = self.schema.by_name("codeSettings")
+        if code_settings_desc is None:
+            raise RPCError(0, "codeSettings not available in schema")
+        _, obj = await self.conn.rpc("auth.sendCode", {
+            "phone_number": phone,
+            "api_id": self.api_id,
+            "api_hash": self.api_hash,
+            "settings": {"_id": code_settings_desc["id"]},
+        })
+        return obj
+
+    async def sign_in(self, phone: str, code: str, phone_code_hash: str):
+        """auth.signIn (code вводится пользователем в рантайме)."""
+        try:
+            result = await self.conn.rpc("auth.signIn", {
+                "phone_number": phone,
+                "phone_code_hash": phone_code_hash,
+                "phone_code": code,
+            })
+        except RPCError as e:
+            if e.message == "SESSION_PASSWORD_NEEDED":
+                raise SessionPasswordNeededError(e.code, e.message)
+            if e.message == "PHONE_CODE_INVALID":
+                raise PhoneCodeInvalidError(e.code, e.message)
+            if e.message in ("PHONE_NUMBER_UNOCCUPIED", "KEY_UNOCCUPIED"):
+                raise PhoneNumberUnoccupiedError(e.code, e.message)
+            if e.message == "PHONE_CODE_EXPIRED":
+                from ..errors import PhoneCodeExpiredError
+                raise PhoneCodeExpiredError(e.code, e.message)
+            raise
+        self._store_auth(result)
+        return result
+
+    async def sign_up(self, phone: str, code: str, phone_code_hash: str,
+                      first_name: str, last_name: str = ""):
+        """auth.signUp."""
+        result = await self.conn.rpc("auth.signUp", {
+            "phone_number": phone,
+            "phone_code_hash": phone_code_hash,
+            "first_name": first_name,
+            "last_name": last_name,
+        })
+        self._store_auth(result)
+        return result
+
+    async def get_password(self):
+        """account.getPassword — параметры для 2FA."""
+        return await self.conn.rpc("account.getPassword", {})
+
+    async def check_password(self, password: str, password_obj):
+        """auth.checkPassword (2FA) — считает SRP по текущей схеме."""
+        _, pw = password_obj
+        algo = pw.get("current_algo")
+        if algo is None:
+            raise RPCError(0, "server has no current_algo; 2FA flow unclear")
+        salt1 = algo.get("salt1")
+        salt2 = algo.get("salt2")
+        g = algo.get("g")
+        p = algo.get("p")
+        srp_b = pw.get("srp_B")
+        srp_id = pw.get("srp_id")
+        if not (salt1 and salt2 and g and p and srp_b):
+            raise RPCError(0, "incomplete SRP params from account.getPassword")
+
+        req = compute_password_check(password, srp_id, srp_b, salt1, salt2, g, p)
+        input_desc = self.schema.by_name("inputCheckPasswordSRP")
+        password_value = {
+            "_id": input_desc["id"],
+            "srp_id": req["srp_id"],
+            "A": req["A"],
+            "M1": req["M1"],
+        }
+        result = await self.conn.rpc("auth.checkPassword", {"password": password_value})
+        self._store_auth(result)
+        return result
+
+    # ------------------------------------------------------------------ #
+    #  пользователи
+    # ------------------------------------------------------------------ #
+
+    def input_peer_self(self):
+        desc = self.schema.by_name("inputPeerSelf")
+        return {"_id": desc["id"]} if desc else None
+
+    def input_peer_user(self, user_id: int, access_hash: int):
+        desc = self.schema.by_name("inputPeerUser")
+        if desc is None:
+            return None
+        return {"_id": desc["id"], "user_id": user_id, "access_hash": access_hash}
+
+    def input_peer_chat(self, chat_id: int):
+        desc = self.schema.by_name("inputPeerChat")
+        if desc is None:
+            return None
+        return {"_id": desc["id"], "chat_id": chat_id}
+
+    def input_peer_channel(self, channel_id: int, access_hash: int):
+        desc = self.schema.by_name("inputPeerChannel")
+        if desc is None:
+            return None
+        return {"_id": desc["id"], "channel_id": channel_id, "access_hash": access_hash}
+
+    def input_user(self, user_id: int, access_hash: int):
+        desc = self.schema.by_name("inputUser")
+        if desc is None:
+            return None
+        return {"_id": desc["id"], "user_id": user_id, "access_hash": access_hash}
+
+    def input_user_self(self):
+        desc = self.schema.by_name("inputUserSelf")
+        return {"_id": desc["id"]} if desc else None
+
+    async def get_me(self):
+        """Возвращает текущего юзера. На приват-сервере users.getUsers может
+        отсутствовать — тогда берём user, сохранённый при auth.signIn/checkPassword."""
+        if self.schema.by_name("users.getUsers") is not None:
+            _, obj = await self.conn.rpc("users.getUsers", {
+                "id": [self.input_user_self()],
+            })
+            # ответ может быть Vector<User> напрямую или обёрнут в объект
+            if isinstance(obj, list):
+                users = obj
+            else:
+                users = obj.get("users") or obj if isinstance(obj, list) else []
+            if not users:
+                # если users.getUsers вернул пустоту, используем кешированного юзера
+                user = self.conn.session.user
+                if user is None:
+                    raise RPCError(0, "users.getUsers returned no users and no cached user")
+                self.conn.session.user_id = user.get("id")
+                return user
+            user = users[0]
+            self.conn.session.user = user
+            self.conn.session.user_id = user.get("id")
+            return user
+        user = self.conn.session.user
+        if user is None:
+            raise RPCError(0, "users.getUsers not in schema (layer %d) and no cached user"
+                              % self.conn._schema.layer)
+        self.conn.session.user_id = user.get("id")
+        return user
+
+    async def get_users(self, ids):
+        """users.getUsers([InputUser...])."""
+        return await self.conn.rpc("users.getUsers", {"id": ids})
+
+    # ------------------------------------------------------------------ #
+    #  отправка / история
+    # ------------------------------------------------------------------ #
+
+    async def send_message(self, peer, text: str, random_id=None, reply_to=None):
+        """messages.sendMessage(peer, text, random_id, reply_to)."""
+        params = {
+            "peer": peer,
+            "message": text,
+            "random_id": random_id if random_id is not None else int(
+                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}
+        return await self.conn.rpc("messages.sendMessage", params)
+
+    async def edit_message(self, peer, msg_id: int, text: str):
+        """messages.editMessage - редактирует существующее сообщение."""
+        params = {
+            "peer": peer,
+            "id": msg_id,
+            "message": text,
+        }
+        return await self.conn.rpc("messages.editMessage", params)
+
+    async def get_history(self, peer, limit=50):
+        """messages.getHistory."""
+        return await self.conn.rpc("messages.getHistory", {
+            "peer": peer,
+            "offset_id": 0,
+            "offset_date": 0,
+            "add_offset": 0,
+            "limit": int(limit),
+            "max_id": 0,
+            "min_id": 0,
+            "hash": 0,
+        })
+
+    # ------------------------------------------------------------------ #
+    #  состояние / различие
+    # ------------------------------------------------------------------ #
+
+    async def get_state(self):
+        return await self.conn.rpc("updates.getState", {})
+
+    async def get_difference(self, pts, date=0, qts=0, pts_total_limit=None):
+        params = {
+            "pts": int(pts),
+            "pts_total_limit": pts_total_limit,
+            "date": int(date),
+            "qts": int(qts),
+        }
+        if "pts_total_limit" not in self._param_names("updates.getDifference"):
+            params.pop("pts_total_limit", None)
+        return await self.conn.rpc("updates.getDifference", params)
+
+    # ------------------------------------------------------------------ #
+    def _param_names(self, method_name):
+        desc = self.schema.by_name(method_name)
+        if desc is None:
+            return []
+        return [p[0] for p in desc["params"]]
+
+    def _store_auth(self, result):
+        _, obj = result
+        user = obj.get("user") if hasattr(obj, "get") else (obj or {}).get("user")
+        if user:
+            self.conn.session.user_id = user.get("id")
+            self.conn.session.user = user

wintergram_userbot/api/updates.py

@@ -0,0 +1,195 @@
+"""Обработка updates: разбор, события, роутинг в зарегистрированные хендлеры.
+
+События создаются независимо от эры схемы: поля достаются из разобранного
+дерева TLObject (dict-like), поэтому одна логика работает и на слое 167,
+и на слое 228.
+"""
+
+import logging
+
+from ..tl.types import TLObject
+
+__log__ = logging.getLogger("wintergram.api.updates")
+
+# имена апдейтов (по stdout 'name' поля в схемах)
+_UPDATE_NEW_MESSAGE = {"updateNewMessage", "updateNewChannelMessage"}
+_UPDATE_EDIT = {"updateEditMessage", "updateEditChannelMessage"}
+_UPDATE_DELETE = {"updateDeleteMessages", "updateDeleteChannelMessages"}
+
+
+def _as_dict(obj):
+    if obj is None:
+        return {}
+    if isinstance(obj, dict):
+        return obj
+    if isinstance(obj, TLObject):
+        return obj.as_dict()
+    return dict(obj)
+
+
+class Event:
+    """Базовое событие."""
+
+    def __init__(self, raw):
+        self.raw = raw  # исходный TLObject (или dict)
+
+    @property
+    def raw_dict(self):
+        return _as_dict(self.raw)
+
+
+class NewMessage(Event):
+    """Новое сообщение.
+
+    Поля: id, text, date, chat_id, sender_id, out, reply_to_msg_id, raw.
+    """
+
+    def __init__(self, raw, id=None, text=None, date=None, chat_id=None,
+                 sender_id=None, out=False, from_channel=False):
+        super().__init__(raw)
+        self.id = id
+        self.text = text
+        self.date = date
+        self.chat_id = chat_id
+        self.sender_id = sender_id
+        self.out = bool(out)
+        self.from_channel = from_channel
+
+    @property
+    def is_private(self):
+        return not self.from_channel and self.chat_id is not None and self.sender_id is not None
+
+    @property
+    def is_channel(self):
+        return self.from_channel
+
+    def __repr__(self):
+        return "<NewMessage id=%s chat=%s from=%s text=%r>" % (
+            self.id, self.chat_id, self.sender_id, (self.text or "")[:40]
+        )
+
+
+class MessageEdited(NewMessage):
+    pass
+
+
+class MessageDeleted(Event):
+
+    def __init__(self, raw, deleted_ids=(), chat_id=None, channel_id=None):
+        super().__init__(raw)
+        self.deleted_ids = list(deleted_ids)
+        self.chat_id = chat_id
+        self.channel_id = channel_id
+
+    def __repr__(self):
+        return "<MessageDeleted ids=%s>" % (self.deleted_ids,)
+
+
+class MessageHandler:
+    """Реестр хендлеров по типу события."""
+
+    def __init__(self):
+        self._handlers = {}   # "NewMessage" -> list[callable]
+
+    def on(self, event_type):
+        name = getattr(event_type, "__name__", str(event_type))
+        def decorator(func):
+            self._handlers.setdefault(name, []).append(func)
+            return func
+        return decorator
+
+    async def dispatch(self, events):
+        results = []
+        for ev in events:
+            name = type(ev).__name__
+            for handler in self._handlers.get(name, []):
+                try:
+                    r = handler(ev)
+                    if hasattr(r, "__await__"):
+                        await r
+                    results.append(r)
+                except Exception as e:
+                    __log__.error("handler %s raised: %r", getattr(handler, "__qualname__", handler), e)
+        return results
+
+
+class UpdatesProcessor:
+    """Превращает входящий объект Updates в список событий."""
+
+    def __init__(self, schema):
+        self.schema = schema
+
+    def process(self, obj) -> list:
+        d = _as_dict(obj)
+        name = d.get("_")
+        events = []
+        if name in ("updates", "updatesCombined", "updateShort"):
+            inner = d.get("update")
+            if inner is not None:
+                events += self.process(inner)
+            for u in (d.get("updates") or []):
+                events += self.process(u)
+            return events
+        if name == "updateShortMessage":
+            return [NewMessage(
+                raw=d, id=d.get("id"), text=d.get("message"),
+                date=d.get("date"), chat_id=d.get("user_id"),
+                sender_id=d.get("user_id") if not d.get("out") else None,
+                out=d.get("out", False),
+            )]
+        if name == "updateShortChatMessage":
+            return [NewMessage(
+                raw=d, id=d.get("id"), text=d.get("message"),
+                date=d.get("date"), chat_id=d.get("chat_id"),
+                sender_id=d.get("from_id"), out=d.get("out", False),
+            )]
+        if name == "updateShortSentMessage":
+            return []   # подтверждение собственной отправки
+        if name in _UPDATE_NEW_MESSAGE:
+            message = d.get("message") or {}
+            md = _as_dict(message)
+            chat_id = self._chat_id(md)
+            sender = self._sender_id(md)
+            return [NewMessage(
+                raw=d, id=md.get("id") or d.get("id"), text=md.get("message"),
+                date=md.get("date"), chat_id=chat_id, sender_id=sender,
+                out=md.get("out", False), from_channel=name == "updateNewChannelMessage",
+            )]
+        if name in _UPDATE_EDIT:
+            message = d.get("message") or {}
+            md = _as_dict(message)
+            chat_id = self._chat_id(md)
+            sender = self._sender_id(md)
+            return [MessageEdited(
+                raw=d, id=md.get("id"), text=md.get("message"),
+                date=md.get("date"), chat_id=chat_id, sender_id=sender,
+                out=md.get("out", False), from_channel=name == "updateEditChannelMessage",
+            )]
+        if name in _UPDATE_DELETE:
+            return [MessageDeleted(
+                raw=d,
+                deleted_ids=d.get("messages") or [],
+                chat_id=(d.get("channel_id") if "channel_id" in d else None),
+                channel_id=d.get("channel_id"),
+            )]
+        return []
+
+    @staticmethod
+    def _chat_id(message_dict):
+        to_id = message_dict.get("to_id") or {}
+        td = _as_dict(to_id)
+        if td:
+            return td.get("user_id") or td.get("chat_id") or td.get("channel_id")
+        peer_id = message_dict.get("peer_id")
+        if isinstance(peer_id, (dict, TLObject)):
+            pd = _as_dict(peer_id)
+            return pd.get("user_id") or pd.get("chat_id") or pd.get("channel_id")
+        return None
+
+    @staticmethod
+    def _sender_id(message_dict):
+        from_id = message_dict.get("from_id")
+        if isinstance(from_id, (dict, TLObject)):
+            fd = _as_dict(from_id)
+            return fd.get("user_id") or fd.get("channel_id") or fd.get("chat_id")
+        return from_id