slidge 0.1.0b2__py3-none-any.whl → 0.1.1__py3-none-any.whl

slidge/plugins/telegram/client.py

@@ -1,228 +0,0 @@
-import asyncio
-import functools
-from datetime import datetime
-from typing import TYPE_CHECKING
-
-import aiotdlib
-from aiotdlib import api as tgapi
-
-if TYPE_CHECKING:
-    from .session import Session
-
-
-class TelegramClient(aiotdlib.Client):
-    def __init__(self, session: "Session", **kw):
-        super().__init__(parse_mode=aiotdlib.ClientParseMode.MARKDOWN, **kw)
-        self.session = session
-        self.contacts = session.contacts
-        self.log = self.session.log
-
-        async def input_(prompt):
-            self.session.send_gateway_status(f"Action required: {prompt}")
-            return await session.input(prompt)
-
-        self.input = input_
-        self._auth_get_code = functools.partial(input_, "Enter code")
-        self._auth_get_password = functools.partial(input_, "Enter 2FA password:")
-        self._auth_get_first_name = functools.partial(input_, "Enter first name:")
-        self._auth_get_last_name = functools.partial(input_, "Enter last name:")
-
-        self.add_event_handler(self.dispatch_update, tgapi.API.Types.ANY)
-
-    async def dispatch_update(self, _self, update: tgapi.Update):
-        try:
-            handler = getattr(self, "handle_" + update.ID[6:])
-        except AttributeError:
-            self.session.log.debug("No handler for %s, ignoring", update.ID)
-        except IndexError:
-            self.session.log.debug("Ignoring weird event: %s", update.ID)
-        else:
-            await handler(update)
-
-    async def handle_NewMessage(self, update: tgapi.UpdateNewMessage):
-        if (msg := update.message).is_channel_post:
-            self.log.debug("Ignoring channel post")
-            return
-
-        if not await self.is_private_chat(msg.chat_id):
-            self.log.debug("Ignoring group message")
-            return
-
-        session = self.session
-        if msg.is_outgoing:
-            # This means slidge is responsible for this message, so no carbon is needed;
-            # but maybe this does not handle all possible cases gracefully?
-            if msg.sending_state is not None or msg.id in session.sent:
-                return
-            content = msg.content
-            if isinstance(content, tgapi.MessageText):
-                session.contacts.by_legacy_id(msg.chat_id).carbon(
-                    content.text.text, msg.id, datetime.fromtimestamp(msg.date)
-                )
-            # TODO: implement carbons for other contents
-            return
-
-        sender = msg.sender_id
-        if not isinstance(sender, tgapi.MessageSenderUser):
-            self.log.debug("Ignoring non-user sender")  # Does this happen?
-            return
-
-        await session.contacts.by_legacy_id(sender.user_id).send_tg_message(msg)
-
-    async def handle_UserStatus(self, update: tgapi.UpdateUserStatus):
-        if update.user_id == await self.get_my_id():
-            return
-        contact = self.contacts.by_legacy_id(update.user_id)
-        if not contact.added_to_roster:
-            self.log.debug("Ignoring presence of contact not in the roster")
-            return
-        contact.update_status(update.status)
-
-    async def handle_ChatReadOutbox(self, update: tgapi.UpdateChatReadOutbox):
-        if not await self.is_private_chat(update.chat_id):
-            return
-        self.contacts.by_legacy_id(update.chat_id).displayed(
-            update.last_read_outbox_message_id
-        )
-
-    async def handle_ChatAction(self, action: tgapi.UpdateChatAction):
-        if not await self.is_private_chat(action.chat_id):
-            return
-
-        sender = action.sender_id
-        if not isinstance(sender, tgapi.MessageSenderUser):
-            self.log.debug("Ignoring action: %s", action)
-            return
-
-        if (chat_id := action.chat_id) != sender.user_id:
-            self.log.debug("Ignoring group (?) action: %s", action)
-            return
-
-        self.contacts.by_legacy_id(chat_id).composing()
-
-    async def handle_ChatReadInbox(self, action: tgapi.UpdateChatReadInbox):
-        if not await self.is_private_chat(action.chat_id):
-            return
-
-        session = self.session
-        msg_id = action.last_read_inbox_message_id
-        self.log.debug(
-            "Self read mark for %s and we sent %s", msg_id, session.sent_read_marks
-        )
-        try:
-            session.sent_read_marks.remove(msg_id)
-        except KeyError:
-            # slidge didn't send this read mark, so it comes from the official tg client
-            contact = session.contacts.by_legacy_id(action.chat_id)
-            contact.carbon_read(msg_id)
-
-    async def handle_MessageContent(self, action: tgapi.UpdateMessageContent):
-        if not await self.is_private_chat(action.chat_id):
-            return
-
-        new = action.new_content
-        if not isinstance(new, tgapi.MessageText):
-            raise NotImplementedError(new)
-        session = self.session
-        try:
-            fut = session.user_correction_futures.pop(action.message_id)
-        except KeyError:
-            contact = session.contacts.by_legacy_id(action.chat_id)
-            if action.message_id in self.session.sent:
-                contact.carbon_correct(action.message_id, new.text.text)
-            else:
-                contact.correct(action.message_id, new.text.text)
-        else:
-            self.log.debug("User correction confirmation received")
-            fut.set_result(None)
-
-    async def handle_User(self, action: tgapi.UpdateUser):
-        u = action.user
-        if u.id == await self.get_my_id():
-            return
-        contact = self.session.contacts.by_legacy_id(u.id)
-        await contact.update_info_from_user(u)
-        await contact.add_to_roster()
-
-    async def handle_MessageInteractionInfo(
-        self, update: tgapi.UpdateMessageInteractionInfo
-    ):
-        if not await self.is_private_chat(update.chat_id):
-            return
-
-        contact = self.session.contacts.by_legacy_id(update.chat_id)
-        me = await self.get_my_id()
-        if update.interaction_info is None:
-            contact.react(update.message_id, [])
-            contact.carbon_react(update.message_id, [])
-        else:
-            user_reactions = list[str]()
-            contact_reactions = list[str]()
-            # these sanity checks might not be necessary, but in doubt…
-            for reaction in update.interaction_info.reactions:
-                if reaction.total_count == 1:
-                    if len(reaction.recent_sender_ids) != 1:
-                        self.log.warning(
-                            "Weird reactions (wrong count): %s",
-                            update.interaction_info.reactions,
-                        )
-                        continue
-                    sender = reaction.recent_sender_ids[0]
-                    if isinstance(sender, tgapi.MessageSenderUser):
-                        if sender.user_id == me:
-                            user_reactions.append(reaction.reaction)
-                        elif sender.user_id == contact.legacy_id:
-                            contact_reactions.append(reaction.reaction)
-                    else:
-                        self.log.warning(
-                            "Weird reactions (neither me nor them): %s",
-                            update.interaction_info.reactions,
-                        )
-                elif reaction.total_count == 2:
-                    user_reactions.append(reaction.reaction)
-                    contact_reactions.append(reaction.reaction)
-                else:
-                    self.log.warning(
-                        "Weird reactions (empty): %s", update.interaction_info.reactions
-                    )
-
-            contact.react(update.message_id, contact_reactions)
-            contact.carbon_react(update.message_id, user_reactions)
-
-    async def handle_DeleteMessages(self, update: tgapi.UpdateDeleteMessages):
-        if not await self.is_private_chat(update.chat_id):
-            return
-
-        if not update.is_permanent:  # tdlib send 'delete from cache' updates apparently
-            self.log.debug("Ignoring non permanent delete")
-            return
-        for legacy_msg_id in update.message_ids:
-            try:
-                future = self.session.delete_futures.pop(legacy_msg_id)
-            except KeyError:
-                # FIXME: where do we filter out group chat messages here ?!
-                contact = self.session.contacts.by_legacy_id(update.chat_id)
-                if legacy_msg_id in self.session.sent:
-                    contact.carbon_retract(legacy_msg_id)
-                else:
-                    contact.retract(legacy_msg_id)
-            else:
-                future.set_result(update)
-
-    async def handle_MessageSendSucceeded(
-        self, update: tgapi.UpdateMessageSendSucceeded
-    ):
-        self.session.sent_read_marks.add(update.message.id)
-        for _ in range(10):
-            try:
-                future = self.session.ack_futures.pop(update.message.id)
-            except KeyError:
-                await asyncio.sleep(0.5)
-            else:
-                future.set_result(update.message.id)
-                return
-        self.log.warning("Ignoring Send success for %s", update.message.id)
-
-    async def is_private_chat(self, chat_id: int):
-        chat = await self.get_chat(chat_id)
-        return isinstance(chat.type_, tgapi.ChatTypePrivate)

slidge/plugins/telegram/config.py

@@ -1,12 +0,0 @@
-from argparse import ArgumentParser
-
-
-def get_parser():
-    parser = ArgumentParser()
-    parser.add_argument("--tdlib-path", help="Defaults to ${SLIDGE_HOME_DIR}/tdlib")
-    parser.add_argument(
-        "--tdlib-key",
-        default="NOT_SECURE",
-        help="Key used to encrypt tdlib persistent DB",
-    )
-    return parser

slidge/plugins/telegram/contact.py

@@ -1,176 +0,0 @@
-import asyncio
-import logging
-import time
-from datetime import datetime
-from typing import TYPE_CHECKING, Optional, Union
-
-import aiotdlib.api as tgapi
-
-from slidge import *
-
-if TYPE_CHECKING:
-    from .session import Session
-
-
-async def noop():
-    return
-
-
-class Contact(LegacyContact["Session"]):
-    legacy_id: int
-    # Telegram official clients have no XMPP presence equivalent, but a 'last seen' indication.
-    CLIENT_TYPE = "phone"
-
-    def __init__(self, *a, **k):
-        super(Contact, self).__init__(*a, **k)
-        self._online_expire_task = self.xmpp.loop.create_task(noop())
-
-    @staticmethod
-    def _format_last_seen(timestamp: Union[int, float]):
-        return f"Last seen {datetime.fromtimestamp(timestamp):%A %H:%M GMT}"
-
-    async def _expire_online(self, timestamp: Union[int, float]):
-        now = time.time()
-        how_long = timestamp - now
-        log.debug("Online status expires in %s seconds", how_long)
-        await asyncio.sleep(how_long)
-        self.away(self._format_last_seen(now))
-
-    def update_status(self, status: tgapi.UserStatus):
-        if isinstance(status, tgapi.UserStatusEmpty):
-            self.inactive()
-            self.offline()
-        elif isinstance(status, tgapi.UserStatusLastMonth):
-            self.inactive()
-            self.extended_away("Offline since last month")
-        elif isinstance(status, tgapi.UserStatusLastWeek):
-            self.inactive()
-            self.extended_away("Offline since last week")
-        elif isinstance(status, tgapi.UserStatusOffline):
-            self.inactive()
-            if self._online_expire_task.done():
-                # we've never seen the contact online, so we use the was_online timestamp
-                self.away(self._format_last_seen(status.was_online))
-        elif isinstance(status, tgapi.UserStatusOnline):
-            self.online()
-            self.active()
-            self._online_expire_task.cancel()
-            self._online_expire_task = self.xmpp.loop.create_task(
-                self._expire_online(status.expires)
-            )
-        elif isinstance(status, tgapi.UserStatusRecently):
-            self.inactive()
-            self.away("Last seen recently")
-
-    async def send_tg_message(self, msg: tgapi.Message):
-        content = msg.content
-        if isinstance(content, tgapi.MessageText):
-            # TODO: parse formatted text to markdown
-            formatted_text = content.text
-            self.send_text(
-                body=formatted_text.text,
-                legacy_msg_id=msg.id,
-                reply_to_msg_id=msg.reply_to_message_id,
-            )
-        elif isinstance(content, tgapi.MessageAnimatedEmoji):
-            emoji = content.animated_emoji.sticker.emoji
-            self.send_text(
-                body=emoji,
-                legacy_msg_id=msg.id,
-                reply_to_msg_id=msg.reply_to_message_id,
-            )
-        elif isinstance(content, tgapi.MessagePhoto):
-            photo = content.photo
-            best_file = max(photo.sizes, key=lambda x: x.width).photo
-            await self.send_tg_file(best_file, content.caption, msg.id)
-        elif isinstance(content, tgapi.MessageVideo):
-            best_file = content.video.video
-            await self.send_tg_file(best_file, content.caption, msg.id)
-        elif isinstance(content, tgapi.MessageAnimation):
-            best_file = content.animation.animation
-            await self.send_tg_file(best_file, content.caption, msg.id)
-        else:
-            self.session.log.debug("Ignoring content: %s", type(content))
-
-    async def send_tg_file(self, best_file, caption, msg_id):
-        query = tgapi.DownloadFile.construct(
-            file_id=best_file.id, synchronous=True, priority=1
-        )
-        best_file_downloaded: tgapi.File = await self.session.tg.request(query)
-        await self.send_file(best_file_downloaded.local.path)
-        if caption.text:
-            self.send_text(caption.text, legacy_msg_id=msg_id)
-
-    async def update_info_from_user(self, user: Optional[tgapi.User] = None):
-        if user is None:
-            user = await self.session.tg.api.get_user(self.legacy_id)
-        if username := user.username:
-            name = username
-        else:
-            name = user.first_name
-            if last := user.last_name:
-                name += " " + last
-        self.name = name
-
-        if photo := user.profile_photo:
-            if (local := photo.small.local) and (path := local.path):
-                with open(path, "rb") as f:
-                    self.avatar = f.read()
-            else:
-                response = await self.session.tg.api.download_file(
-                    file_id=photo.small.id,
-                    synchronous=True,
-                    priority=1,
-                    offset=0,
-                    limit=0,
-                )
-                with open(response.local.path, "rb") as f:
-                    self.avatar = f.read()
-
-        if isinstance(user.type_, tgapi.UserTypeBot) or user.id == 777000:
-            # 777000 is not marked as bot, it's the "Telegram" contact, which gives
-            # confirmation codes and announces telegram-related stuff
-            self.CLIENT_TYPE = "bot"
-
-        else:
-            if user.is_contact:
-                self._subscribe_to = True
-                self._subscribe_from = user.is_mutual_contact
-            else:
-                self._subscribe_to = self._subscribe_from = False
-
-        self.update_status(user.status)
-
-        if p := user.phone_number:
-            phone = "+" + p
-        else:
-            phone = None
-        self.set_vcard(
-            given=user.first_name, surname=user.last_name, phone=phone, full_name=name
-        )
-
-    async def update_info_from_chat(self, chat: tgapi.Chat):
-        self.name = chat.title
-        if isinstance(chat.photo, tgapi.ChatPhotoInfo):
-            if (local := chat.photo.small.local) and (path := local.path):
-                with open(path, "rb") as f:
-                    self.avatar = f.read()
-            else:
-                response = await self.session.tg.api.download_file(
-                    file_id=chat.photo.small.id,
-                    synchronous=True,
-                    priority=1,
-                    offset=0,
-                    limit=0,
-                )
-                with open(response.local.path, "rb") as f:
-                    self.avatar = f.read()
-
-
-class Roster(LegacyRoster["Contact", "Session"]):
-    @staticmethod
-    def jid_username_to_legacy_id(jid_username: str) -> int:
-        return int(jid_username)
-
-
-log = logging.getLogger(__name__)

slidge/plugins/telegram/gateway.py

@@ -1,150 +0,0 @@
-import logging
-import typing
-from argparse import Namespace
-from datetime import datetime
-
-import aiotdlib.api as tgapi
-from slixmpp import JID, Iq
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-from ...util import is_valid_phone_number
-from .config import get_parser
-
-if typing.TYPE_CHECKING:
-    from .session import Session
-
-REGISTRATION_INSTRUCTIONS = """You can visit https://my.telegram.org/apps to get an API ID and an API HASH
-
-This is the only tested login method, but other methods (password, bot token, 2FA...)
-should work too, in theory at least.
-"""
-
-
-class Gateway(BaseGateway["Session"]):
-    REGISTRATION_INSTRUCTIONS = REGISTRATION_INSTRUCTIONS
-    REGISTRATION_FIELDS = [
-        FormField(var="phone", label="Phone number", required=True),
-        FormField(var="api_id", label="API ID", required=False),
-        FormField(var="api_hash", label="API hash", required=False),
-        FormField(var="", value="The fields below have not been tested", type="fixed"),
-        FormField(var="bot_token", label="Bot token", required=False),
-        FormField(var="first", label="First name", required=False),
-        FormField(var="last", label="Last name", required=False),
-    ]
-    ROSTER_GROUP = "Telegram"
-    COMPONENT_NAME = "Telegram (slidge)"
-    COMPONENT_TYPE = "telegram"
-    COMPONENT_AVATAR = "https://web.telegram.org/img/logo_share.png"
-
-    SEARCH_FIELDS = [
-        FormField(var="phone", label="Phone number", required=True),
-        FormField(var="first", label="First name", required=True),
-        FormField(var="last", label="Last name", required=False),
-    ]
-
-    args: Namespace
-
-    def config(self, argv: list[str]):
-        Gateway.args = args = get_parser().parse_args(argv)
-        if args.tdlib_path is None:
-            args.tdlib_path = self.home_dir / "tdlib"
-
-    async def validate(
-        self, user_jid: JID, registration_form: dict[str, typing.Optional[str]]
-    ):
-        phone = registration_form.get("phone")
-        if not is_valid_phone_number(phone):
-            raise ValueError("Not a valid phone number")
-
-    async def unregister(self, user):
-        pass
-
-    def add_adhoc_commands(self):
-        self["xep_0050"].add_command(
-            node="get_sessions",
-            name="List active sessions",
-            handler=self.adhoc_active_sessions1,
-        )
-
-    async def adhoc_active_sessions1(
-        self, iq: Iq, adhoc_session: dict[str, typing.Any]
-    ):
-        user = user_store.get_by_stanza(iq)
-        if user is None:
-            raise XMPPError("subscription-required")
-        session = self._session_cls.from_stanza(iq)
-
-        form = self["xep_0004"].make_form("form", "Active telegram sessions")
-        tg_sessions = (await session.tg.api.get_active_sessions()).sessions
-        form.add_field(
-            "tg_session_id",
-            ftype="list-single",
-            label="Sessions",
-            options=[{"label": f"{s.country}", "value": s.id} for s in tg_sessions],
-        )
-
-        adhoc_session["payload"] = form
-        adhoc_session["next"] = self.adhoc_active_sessions2
-        adhoc_session["has_next"] = True
-        adhoc_session["tg_sessions"] = {s.id: s for s in tg_sessions}
-        adhoc_session["slidge_session"] = session
-
-        return adhoc_session
-
-    async def adhoc_active_sessions2(self, form, adhoc_session: dict[str, typing.Any]):
-        tg_session_id = int(form.get_values()["tg_session_id"])
-
-        form = self["xep_0004"].make_form("form", "Telegram session info")
-        tg_session: tgapi.Session = adhoc_session["tg_sessions"][str(tg_session_id)]
-        for x in fmt_tg_session(tg_session):
-            form.add_field(
-                ftype="fixed",
-                value=x,
-            )
-        if tg_session.is_current:
-            adhoc_session["has_next"] = False
-        else:
-            form.add_field(
-                "terminate", ftype="boolean", label="Terminate session", value="0"
-            )
-            form.add_field("tg_session_id", ftype="hidden", value=tg_session.id)
-            adhoc_session["has_next"] = True
-            adhoc_session["next"] = self.adhoc_active_sessions3
-
-        adhoc_session["payload"] = form
-
-        return adhoc_session
-
-    async def adhoc_active_sessions3(self, form, adhoc_session: dict[str, typing.Any]):
-        form_values = form.get_values()
-        terminate = bool(int(form_values["terminate"]))
-
-        if terminate:
-            session: Session = adhoc_session["slidge_session"]
-            await session.tg.api.terminate_session(int(form_values["tg_session_id"]))
-            info = "Session terminated."
-        else:
-            info = "Session not terminated."
-
-        adhoc_session["notes"] = [("info", info)]
-        adhoc_session["has_next"] = False
-
-        return adhoc_session
-
-
-def fmt_tg_session(s: tgapi.Session):
-    return [
-        f"Country: {s.country}",
-        f"Region: {s.region}",
-        f"Ip: {s.ip}",
-        f"App: {s.application_name}",
-        f"Device: {s.device_model}",
-        f"Platform: {s.platform}",
-        f"Since: {datetime.fromtimestamp(s.log_in_date).isoformat()}",
-        f"Last seen: {datetime.fromtimestamp(s.last_active_date).isoformat()}",
-    ]
-
-
-log = logging.getLogger(__name__)