slidge 0.1.0rc1__py3-none-any.whl → 0.1.2__py3-none-any.whl

slidge/plugins/telegram/group.py

@@ -1,184 +0,0 @@
-from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Optional
-
-import aiotdlib.api as tgapi
-from slixmpp import JID
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-from .util import AvailableEmojisMixin, TelegramToXMPPMixin
-
-if TYPE_CHECKING:
-    from .contact import Contact
-    from .session import Session
-
-
-class Bookmarks(LegacyBookmarks):
-    @staticmethod
-    async def legacy_id_to_jid_local_part(legacy_id: int):
-        return "group" + str(legacy_id)
-
-    @staticmethod
-    async def jid_local_part_to_legacy_id(local_part: str):
-        return int(local_part.replace("group", ""))
-
-
-class MUC(LegacyMUC["Session", int, "Participant", int], AvailableEmojisMixin):
-    MAX_SUPER_GROUP_PARTICIPANTS = 200
-    session: "Session"
-    name = "unnamed"
-
-    async def join(self, join_presence):
-        self.user_nick = await self.session.my_name
-        await self.update_subject_from_msg()
-        await super().join(join_presence)
-
-    async def update_subject_from_msg(self, msg: Optional[tgapi.Message] = None):
-        if msg is None:
-            try:
-                msg = await self.session.tg.api.get_chat_pinned_message(self.legacy_id)
-                self.log.debug("Pinned message: %s", type(msg.content))
-            except tgapi.NotFound:
-                self.log.debug("Pinned message not found?")
-                return
-        content = msg.content
-        if not isinstance(content, (tgapi.MessagePhoto, tgapi.MessageText)):
-            return
-
-        sender_id = msg.sender_id
-        self.subject_date = datetime.fromtimestamp(msg.date, tz=timezone.utc)
-        if isinstance(sender_id, tgapi.MessageSenderUser):
-            if sender_id.user_id == await self.session.tg.get_my_id():
-                self.subject_setter = self.user_nick
-            else:
-                contact = await self.session.contacts.by_legacy_id(sender_id.user_id)
-                self.subject_setter = contact.name
-        else:
-            self.subject_setter = self.name
-
-        if isinstance(content, tgapi.MessagePhoto):
-            self.subject = content.caption.text
-        if isinstance(content, tgapi.MessageText):
-            self.subject = content.text.text
-
-    async def get_participants(self):
-        self.log.debug("Getting participants")
-        chat = await self.session.tg.get_chat(chat_id=self.legacy_id)
-        if not isinstance(
-            chat.type_, (tgapi.ChatTypeBasicGroup, tgapi.ChatTypeSupergroup)
-        ):
-            raise XMPPError("item-not-found", text="This is not a valid group ID")
-
-        info = await self.session.tg.get_chat_info(chat, full=True)
-        if isinstance(info, tgapi.BasicGroupFullInfo):
-            members = info.members
-        elif isinstance(info, tgapi.SupergroupFullInfo):
-            if info.can_get_members:
-                members = (
-                    await self.session.tg.api.get_supergroup_members(
-                        supergroup_id=chat.type_.supergroup_id,
-                        filter_=None,
-                        offset=0,
-                        limit=self.MAX_SUPER_GROUP_PARTICIPANTS,
-                        skip_validation=True,
-                    )
-                ).members
-            else:
-                members = []
-        else:
-            raise RuntimeError
-        self.log.debug("%s participants", len(members))
-        for member in members:
-            sender = member.member_id
-            if not isinstance(sender, tgapi.MessageSenderUser):
-                self.log.debug("Ignoring non-user sender")  # Does this happen?
-                continue
-            if sender.user_id == await self.session.tg.get_my_id():
-                continue
-            yield await self.participant_by_tg_user(
-                await self.session.tg.get_user(sender.user_id)
-            )
-
-    async def send_text(self, text: str) -> int:
-        result = await self.session.tg.send_text(self.legacy_id, text)
-        self.log.debug("MUC SEND RESULT: %s", result)
-        msg_id = await self.session.wait_for_tdlib_success(result.id)
-        self.log.debug("MUC SEND MSG: %s", msg_id)
-        return msg_id
-
-    async def participant_by_tg_user(self, user: tgapi.User) -> "Participant":
-        return await Participant.by_tg_user(self, user)
-
-    async def participant_system(self) -> "Participant":
-        return await self.get_participant("")
-
-    async def participant_by_tg_user_id(self, user_id: int) -> "Participant":
-        return await Participant.by_tg_user(
-            self, await self.session.tg.api.get_user(user_id)
-        )
-
-    async def get_tg_chat(self):
-        return await self.session.tg.get_chat(self.legacy_id)
-
-    async def fill_history(
-        self,
-        full_jid: JID,
-        maxchars: Optional[int] = None,
-        maxstanzas: Optional[int] = None,
-        seconds: Optional[int] = None,
-        since: Optional[int] = None,
-    ):
-        for m in await self.fetch_history(50):
-            part = await self.participant_by_tg_user(
-                await self.session.tg.get_user(m.sender_id.user_id)
-            )
-            await part.send_tg_message(m, full_jid=full_jid)
-
-    async def fetch_history(self, n: int):
-        tg = self.session.tg
-        chat = await self.get_tg_chat()
-        m = chat.last_message
-        if m is None:
-            return []
-
-        messages = [chat.last_message]
-        i = 0
-        last_message_id = m.id
-        while True:
-            fetched = (
-                await tg.api.get_chat_history(
-                    chat_id=self.legacy_id,
-                    from_message_id=last_message_id,
-                    offset=0,
-                    limit=10,
-                    only_local=False,
-                )
-            ).messages
-            if len(fetched) == 0:
-                break
-            messages.extend(fetched)
-            i += len(fetched)
-            if i > n:
-                break
-
-            last_message_id = fetched[-1].id
-
-        return reversed(messages)
-
-
-class Participant(LegacyParticipant[MUC], TelegramToXMPPMixin):
-    contact: "Contact"
-    session: "Session"  # type:ignore
-
-    def __init__(self, *a, **k):
-        super().__init__(*a, **k)
-        self.chat_id = self.muc.legacy_id
-        self.session.log.debug("PARTICIPANT-N: %s", self.muc.n_participants)
-
-    @staticmethod
-    async def by_tg_user(muc: MUC, user: tgapi.User):
-        nick = " ".join((user.first_name, user.last_name)).strip()
-        p = Participant(muc, nick)
-        p.contact = await muc.session.contacts.by_legacy_id(user.id)
-        return p

slidge/plugins/telegram/session.py

@@ -1,275 +0,0 @@
-import asyncio
-import functools
-import logging
-import re
-import tempfile
-from mimetypes import guess_type
-from typing import Union
-
-import aiohttp
-import aiotdlib.api as tgapi
-from aiotdlib.api.errors import BadRequest
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-from ...util.types import Chat
-from . import config
-from .client import TelegramClient
-from .contact import Contact, Roster
-from .gateway import Gateway
-from .group import MUC
-
-
-def catch_chat_not_found(coroutine):
-    @functools.wraps(coroutine)
-    async def wrapped(*a, **k):
-        try:
-            return await coroutine(*a, **k)
-        except tgapi.BadRequest as e:
-            if e.code == 400:
-                raise XMPPError(condition="item-not-found", text="Recipient not found")
-            else:
-                raise
-
-    return wrapped
-
-
-class Session(
-    BaseSession[Gateway, int, Roster, Contact, LegacyBookmarks, MUC, LegacyParticipant]
-):
-    def __init__(self, user):
-        super().__init__(user)
-        self.sent_read_marks = set[int]()
-        self.ack_futures = dict[int, asyncio.Future]()
-        self.user_correction_futures = dict[int, asyncio.Future]()
-        self.delete_futures = dict[int, asyncio.Future]()
-
-        self.my_name: asyncio.Future[str] = self.xmpp.loop.create_future()
-
-        self.tg = TelegramClient(self)
-
-    @staticmethod
-    def xmpp_msg_id_to_legacy_msg_id(i: str) -> int:
-        return int(i)
-
-    async def login(self):
-        await self.tg.start()
-        await self.add_contacts_to_roster()
-        await self.add_groups()
-        me = await self.tg.get_user(await self.tg.get_my_id())
-        my_name = (me.first_name + " " + me.last_name).strip()
-        self.my_name.set_result(my_name)
-        return f"Connected as {my_name}"
-
-    async def logout(self):
-        await self.tg.stop()
-
-    async def wait_for_tdlib_success(self, result_id: int):
-        fut = self.xmpp.loop.create_future()
-        self.ack_futures[result_id] = fut
-        return await fut
-
-    @catch_chat_not_found
-    async def send_text(
-        self,
-        text: str,
-        chat: Union[Contact, MUC],
-        *,
-        reply_to_msg_id=None,
-        reply_to_fallback_text=None,
-        reply_to=None,
-        **kwargs,
-    ) -> int:
-        text = escape(text)
-        result = await self.tg.send_text(
-            chat_id=chat.legacy_id, text=text, reply_to_message_id=reply_to_msg_id
-        )
-        new_message_id = await self.wait_for_tdlib_success(result.id)
-        self.log.debug("Result: %s / %s", result, new_message_id)
-        return new_message_id
-
-    @catch_chat_not_found
-    async def send_file(
-        self,
-        url: str,
-        chat: Chat,
-        reply_to_msg_id=None,
-        **kwargs,
-    ) -> int:
-        type_, _ = guess_type(url)
-        if type_ is not None:
-            type_, subtype = type_.split("/")
-
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url) as response:
-                response.raise_for_status()
-                kwargs = dict(
-                    chat_id=chat.legacy_id, reply_to_message_id=reply_to_msg_id
-                )
-                with tempfile.NamedTemporaryFile() as file:
-                    bytes_ = await response.read()
-                    file.write(bytes_)
-                    if type_ == "image":
-                        result = await self.tg.send_photo(photo=file.name, **kwargs)
-                    elif type_ == "video":
-                        result = await self.tg.send_video(video=file.name, **kwargs)
-                    elif type_ == "audio":
-                        result = await self.tg.send_audio(audio=file.name, **kwargs)
-                    else:
-                        result = await self.tg.send_document(
-                            document=file.name, **kwargs
-                        )
-
-        return result.id
-
-    @catch_chat_not_found
-    async def active(self, c: "Contact"):
-        res = await self.tg.api.open_chat(chat_id=c.legacy_id)
-        self.log.debug("Open chat res: %s", res)
-
-    @catch_chat_not_found
-    async def inactive(self, c: "Contact"):
-        res = await self.tg.api.close_chat(chat_id=c.legacy_id)
-        self.log.debug("Close chat res: %s", res)
-
-    @catch_chat_not_found
-    async def composing(self, c: "Contact"):
-        res = await self.tg.api.send_chat_action(
-            chat_id=c.legacy_id,
-            action=tgapi.ChatActionTyping(),
-            message_thread_id=0,  # TODO: check what telegram's threads really are
-        )
-        self.log.debug("Send composing res: %s", res)
-
-    async def paused(self, c: "Contact"):
-        pass
-
-    @catch_chat_not_found
-    async def displayed(self, tg_id: int, c: "Contact"):
-        res = await self.tg.api.view_messages(
-            chat_id=c.legacy_id,
-            message_thread_id=0,
-            message_ids=[tg_id],
-            force_read=True,
-        )
-        self.log.debug("Send chat action res: %s", res)
-
-    @catch_chat_not_found
-    async def add_contacts_to_roster(self):
-        users = await self.tg.api.get_contacts()
-        for id_ in users.user_ids:
-            contact = await self.contacts.by_legacy_id(id_)
-            await contact.add_to_roster()
-            await contact.update_info_from_user()
-
-    async def add_groups(self):
-        for chat in await self.tg.get_main_list_chats_all():
-            if isinstance(chat.type_, tgapi.ChatTypeBasicGroup):
-                muc = await self.bookmarks.by_legacy_id(chat.id)
-                group = await self.tg.get_basic_group(chat.type_.basic_group_id)
-                muc.type = MucType.GROUP
-            elif isinstance(chat.type_, tgapi.ChatTypeSupergroup):
-                muc = await self.bookmarks.by_legacy_id(chat.id)
-                group = await self.tg.get_supergroup(chat.type_.supergroup_id)
-                muc.type = MucType.CHANNEL
-            else:
-                continue
-
-            muc.n_participants = group.member_count
-            muc.DISCO_NAME = chat.title
-
-    @catch_chat_not_found
-    async def correct(self, text: str, legacy_msg_id: int, c: "Contact"):
-        f = self.user_correction_futures[legacy_msg_id] = self.xmpp.loop.create_future()
-        await self.tg.api.edit_message_text(
-            chat_id=c.legacy_id,
-            message_id=legacy_msg_id,
-            reply_markup=None,
-            input_message_content=tgapi.InputMessageText.construct(
-                text=tgapi.FormattedText.construct(text=text)
-            ),
-            skip_validation=True,
-        )
-        await f
-
-    @catch_chat_not_found
-    async def search(self, form_values: dict[str, str]):
-        phone = form_values["phone"]
-        first = form_values.get("first", phone)
-        last = form_values.get("last", "")
-        response = await self.tg.api.import_contacts(
-            contacts=[
-                tgapi.Contact(
-                    phone_number=phone,
-                    user_id=0,
-                    first_name=first,
-                    vcard="",
-                    last_name=last,
-                )
-            ]
-        )
-        user_id = response.user_ids[0]
-        if user_id == 0:
-            return
-
-        await self.add_contacts_to_roster()
-        contact = await self.contacts.by_legacy_id(user_id)
-        await contact.update_info_from_user()
-        await contact.add_to_roster()
-
-        return SearchResult(
-            fields=[FormField("phone"), FormField("jid", type="jid-single")],
-            items=[{"phone": form_values["phone"], "jid": contact.jid.bare}],
-        )
-
-    @catch_chat_not_found
-    async def remove_reactions(self, legacy_msg_id, c: "Contact"):
-        try:
-            r = await self.tg.api.set_message_reaction(
-                chat_id=c.legacy_id,
-                message_id=legacy_msg_id,
-                reaction="",
-                is_big=False,
-            )
-        except BadRequest as e:
-            self.log.debug("Remove reaction error: %s", e)
-        else:
-            self.log.debug("Remove reaction response: %s", r)
-
-    @catch_chat_not_found
-    async def react(self, legacy_msg_id: int, emojis: list[str], c: "Contact"):
-        if len(emojis) == 0:
-            await self.remove_reactions(legacy_msg_id, c)
-            return
-
-        # we never have more than 1 emoji, slidge core makes sure of that
-        try:
-            r = await self.tg.api.set_message_reaction(
-                chat_id=c.legacy_id,
-                message_id=legacy_msg_id,
-                reaction=emojis[0],
-                is_big=False,
-            )
-        except BadRequest as e:
-            raise XMPPError("bad-request", text=e.message)
-        else:
-            self.log.debug("Message reaction response: %s", r)
-
-    @catch_chat_not_found
-    async def retract(self, legacy_msg_id, c):
-        f = self.delete_futures[legacy_msg_id] = self.xmpp.loop.create_future()
-        r = await self.tg.api.delete_messages(c.legacy_id, [legacy_msg_id], revoke=True)
-        self.log.debug("Delete message response: %s", r)
-        confirmation = await f
-        self.log.debug("Message delete confirmation: %s", confirmation)
-
-
-def escape(t: str):
-    return re.sub(ESCAPE_PATTERN, r"\\\1", t)
-
-
-RESERVED_CHARS = "_*[]()~`>#+-=|{}.!"
-ESCAPE_PATTERN = re.compile(f"([{re.escape(RESERVED_CHARS)}])")
-
-log = logging.getLogger(__name__)

slidge/plugins/telegram/util.py

@@ -1,153 +0,0 @@
-from datetime import datetime
-from typing import TYPE_CHECKING
-
-import aiotdlib.api as tgapi
-
-if TYPE_CHECKING:
-    from .session import Session
-
-
-def get_best_file(content: tgapi.MessageContent):
-    if isinstance(content, tgapi.MessagePhoto):
-        photo = content.photo
-        return max(photo.sizes, key=lambda x: x.width).photo
-    elif isinstance(content, tgapi.MessageVideo):
-        return content.video.video
-    elif isinstance(content, tgapi.MessageAnimation):
-        return content.animation.animation
-    elif isinstance(content, tgapi.MessageAudio):
-        return content.audio.audio
-    elif isinstance(content, tgapi.MessageDocument):
-        return content.document.document
-
-
-class AvailableEmojisMixin:
-    session: "Session"
-    chat_id: int
-
-    async def available_emojis(self, legacy_msg_id):
-        available = await self.session.tg.api.get_message_available_reactions(
-            chat_id=self.chat_id, message_id=legacy_msg_id
-        )
-        return {a.reaction for a in available.reactions}
-
-
-class TelegramToXMPPMixin:
-    session: "Session"  # type:ignore
-    chat_id: int
-    is_group: bool = NotImplemented
-
-    def send_text(self, *a, **k):
-        raise NotImplemented
-
-    def send_file(self, *a, **k):
-        raise NotImplemented
-
-    async def send_tg_message(self, msg: tgapi.Message, **kwargs):
-        content = msg.content
-        reply_to = msg.reply_to_message_id
-        if reply_to:
-            try:
-                reply_to_msg = await self.session.tg.api.get_message(
-                    self.chat_id, reply_to
-                )
-            except tgapi.NotFound:
-                # apparently in telegram it is possible to "reply-to" messages that have been deleted
-                # TODO: mention in the body that this is reply to a deleted message
-                reply_to = None
-                reply_to_fallback = None
-                reply_to_author = None
-                reply_self = False
-            else:
-                reply_to_content = reply_to_msg.content
-                reply_to_sender = reply_to_msg.sender_id
-                if isinstance(reply_to_sender, tgapi.MessageSenderUser):
-                    sender_user_id = reply_to_sender.user_id
-                    reply_self = (
-                        isinstance(msg.sender_id, tgapi.MessageSenderUser)
-                        and sender_user_id == msg.sender_id.user_id
-                    )
-                elif isinstance(reply_to_sender, tgapi.MessageSenderChat):
-                    reply_self = isinstance(msg.sender_id, tgapi.MessageSenderChat)
-                    sender_user_id = None
-                else:
-                    raise RuntimeError("This should not happen")
-
-                if self.is_group and not reply_self:
-                    muc = await self.session.bookmarks.by_legacy_id(msg.chat_id)
-                    if sender_user_id is None:
-                        reply_to_author = await muc.participant_system()
-                    else:
-                        reply_to_author = await muc.participant_by_tg_user_id(
-                            sender_user_id
-                        )
-                else:
-                    reply_to_author = None
-
-                if isinstance(reply_to_content, tgapi.MessageText):
-                    reply_to_fallback = reply_to_content.text.text
-                elif isinstance(reply_to_content, tgapi.MessageAnimatedEmoji):
-                    reply_to_fallback = reply_to_content.animated_emoji.sticker.emoji
-                elif isinstance(reply_to_content, tgapi.MessageSticker):
-                    reply_to_fallback = reply_to_content.sticker.emoji
-                elif best_file := get_best_file(reply_to_content):
-                    reply_to_fallback = f"Attachment {best_file.id}"
-                else:
-                    reply_to_fallback = "[unsupported by slidge]"
-        else:
-            # if reply_to = 0, telegram really means "None"
-            reply_to = None
-            reply_to_fallback = None
-            reply_to_author = None
-            reply_self = False
-
-        kwargs.update(
-            dict(
-                legacy_msg_id=msg.id,
-                reply_to_msg_id=reply_to,
-                reply_to_fallback_text=reply_to_fallback,
-                reply_to_author=reply_to_author,
-                reply_self=reply_self,
-                when=datetime.fromtimestamp(msg.date),
-            )
-        )
-        self.session.log.debug("kwargs %s", kwargs)
-        if isinstance(content, tgapi.MessageText):
-            # TODO: parse formatted text to markdown
-            formatted_text = content.text
-            self.send_text(body=formatted_text.text, **kwargs)
-        elif isinstance(content, tgapi.MessageAnimatedEmoji):
-            emoji = content.animated_emoji.sticker.emoji
-            self.send_text(body=emoji, **kwargs)
-        elif isinstance(content, tgapi.MessageSticker):
-            emoji = content.sticker.emoji
-            self.send_text(body="[Sticker] " + emoji, **kwargs)
-        elif best_file := get_best_file(content):
-            await self.send_tg_file(best_file, content.caption.text, **kwargs)
-        elif isinstance(content, tgapi.MessageBasicGroupChatCreate):
-            # TODO: work out how to map this to group invitation
-            pass
-        elif isinstance(content, tgapi.MessageChatAddMembers):
-            muc = await self.session.bookmarks.by_legacy_id(msg.chat_id)
-            for user_id in content.member_user_ids:
-                participant = await muc.participant_by_tg_user_id(user_id)
-                participant.online()
-        elif isinstance(content, tgapi.MessagePinMessage):
-            if await self.session.tg.is_private_chat(msg.chat_id):
-                return
-            muc = await self.session.bookmarks.by_legacy_id(msg.chat_id)
-            await muc.update_subject_from_msg()
-        else:
-            self.send_text(
-                "/me tried to send an unsupported content. "
-                "Please report this: https://todo.sr.ht/~nicoco/slidge",
-                **kwargs,
-            )
-            self.session.log.warning("Ignoring content: %s", type(content))
-
-    async def send_tg_file(self, best_file: tgapi.File, caption: str, **kwargs):
-        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, caption=caption, **kwargs)

slidge/plugins/whatsapp/__init__.py

@@ -1,6 +0,0 @@
-"""
-WhatsApp gateway using the multi-device API.
-"""
-
-from .gateway import Gateway
-from .session import Session

slidge/plugins/whatsapp/config.py

@@ -1,17 +0,0 @@
-"""
-Config contains plugin-specific configuration for WhatsApp, and is loaded automatically by the
-core configuration framework.
-"""
-
-from slidge import global_config
-
-DB_PATH = global_config.HOME_DIR / "whatsapp" / "whatsapp.db"
-DB_PATH__DOC = "The path to the database used for the WhatsApp plugin."
-
-ALWAYS_SYNC_ROSTER = False
-ALWAYS_SYNC_ROSTER__DOC = (
-    "Whether or not to perform a full sync of the WhatsApp roster on startup."
-)
-
-SKIP_VERIFY_TLS = False
-SKIP_VERIFY_TLS__DOC = "Whether or not HTTPS connections made by this plugin should verify TLS certificates."

slidge/plugins/whatsapp/contact.py

@@ -1,33 +0,0 @@
-from datetime import datetime
-from typing import TYPE_CHECKING
-
-from slidge import LegacyContact, LegacyRoster
-from slidge.plugins.whatsapp.generated import whatsapp
-
-if TYPE_CHECKING:
-    from .session import Session
-
-
-class Contact(LegacyContact["Session", str]):
-    # WhatsApp only allows message editing in Beta versions of their app, and support is uncertain.
-    CORRECTION = False
-    REACTIONS_SINGLE_EMOJI = True
-
-    def update_presence(self, away: bool, last_seen_timestamp: int):
-        last_seen = (
-            datetime.fromtimestamp(last_seen_timestamp)
-            if last_seen_timestamp > 0
-            else None
-        )
-        if away:
-            self.away(last_seen=last_seen)
-        else:
-            self.online(last_seen=last_seen)
-
-
-class Roster(LegacyRoster["Session", Contact, str]):
-    async def legacy_id_to_jid_username(self, legacy_id: str) -> str:
-        return "+" + legacy_id[: legacy_id.find("@")]
-
-    async def jid_username_to_legacy_id(self, jid_username: str) -> str:
-        return jid_username.removeprefix("+") + "@" + whatsapp.DefaultUserServer