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

slidge/plugins/discord/client.py

@@ -1,121 +0,0 @@
-from typing import TYPE_CHECKING, Union
-
-import discord as di
-
-if TYPE_CHECKING:
-    from .session import Session
-
-
-class Discord(di.Client):
-    def __init__(self, session: "Session"):
-        super().__init__()
-        self.session = session
-        self.log = session.log
-
-    async def on_ready(self):
-        if (f := self.session.ready_future).done():
-            return
-        f.set_result(True)
-        self.log.debug(f"Logged on as {self.user}")
-
-    async def on_message(self, message: di.Message):
-        channel = message.channel
-        if not isinstance(channel, di.DMChannel):
-            return
-
-        if (author := message.author) == self.user:
-            async with self.session.send_lock:
-                fut = self.session.send_futures.get(message.id)
-            if fut is None:
-                (
-                    await self.session.contacts.by_discord_user(channel.recipient)
-                ).send_text(message.content, carbon=True)
-            else:
-                fut.set_result(True)
-        else:
-            contact = await self.session.contacts.by_discord_user(author)
-            reply_to = message.reference.message_id if message.reference else None
-
-            text = message.content
-            attachments = message.attachments
-            msg_id = message.id
-
-            if not attachments:
-                contact.send_text(
-                    text,
-                    legacy_msg_id=msg_id,
-                    reply_to_msg_id=reply_to,
-                )
-                return
-
-            last_attachment_i = len(attachments := message.attachments) - 1
-            for i, attachment in enumerate(attachments):
-                last = i == last_attachment_i
-                await contact.send_file(
-                    url=attachment.url,
-                    filename=attachment.filename,
-                    content_type=attachment.content_type,
-                    reply_to_msg_id=reply_to if last else None,
-                    legacy_msg_id=msg_id if last else None,
-                    caption=text if last else None,
-                )
-
-    async def on_typing(self, channel, user, _when):
-        if user != self.user and isinstance(channel, di.DMChannel):
-            (await self.session.contacts.by_discord_user(user)).composing()
-
-    async def on_message_edit(self, before: di.Message, after: di.Message):
-        if not isinstance(after.channel, di.DMChannel):
-            return
-        if before.content == after.content:
-            return
-        if (author := after.author) == self.user:
-            fut = self.session.edit_futures.get(after.id)
-            if fut is None:
-                (
-                    await self.session.contacts.by_discord_user(after.channel.recipient)
-                ).correct(after.id, after.content, carbon=True)
-            else:
-                fut.set_result(True)
-        else:
-            (await self.session.contacts.by_discord_user(author)).correct(
-                after.id, after.content
-            )
-
-    async def on_message_delete(self, m: di.Message):
-        if not isinstance(m.channel, di.DMChannel):
-            return
-        if (author := m.author) == self.user:
-            fut = self.session.delete_futures.get(m.id)
-            if fut is None:
-                (
-                    await self.session.contacts.by_discord_user(m.channel.recipient)
-                ).retract(m.id, carbon=True)
-            else:
-                fut.set_result(True)
-        else:
-            (await self.session.contacts.by_discord_user(author)).retract(m.id)
-
-    async def on_reaction_add(
-        self, reaction: di.Reaction, user: Union[di.User, di.ClientUser]
-    ):
-        await self.update_reactions(reaction, user)
-
-    async def on_reaction_remove(
-        self, reaction: di.Reaction, user: Union[di.User, di.ClientUser]
-    ):
-        await self.update_reactions(reaction, user)
-
-    async def update_reactions(
-        self, reaction: di.Reaction, user: Union[di.User, di.ClientUser]
-    ):
-        message: di.Message = reaction.message
-        if not isinstance(message.channel, di.DMChannel):
-            return
-
-        if user == self.user:
-            await self.session.update_reactions(message)
-        else:
-            await (await self.session.contacts.by_discord_user(user)).update_reactions(
-                message
-            )

slidge/plugins/discord/session.py

@@ -1,172 +0,0 @@
-import asyncio
-from typing import TYPE_CHECKING, Any, Optional, Union
-
-import discord as di
-
-from slidge import *
-
-from ...util.types import Chat
-
-if TYPE_CHECKING:
-    from . import Contact, Gateway, Roster
-    from .client import Discord
-
-
-class Session(
-    BaseSession[
-        "Gateway",
-        int,
-        "Roster",
-        "Contact",
-        LegacyBookmarks,
-        LegacyMUC,
-        LegacyParticipant,
-    ]
-):
-    def __init__(self, user):
-        super().__init__(user)
-        from .client import Discord
-
-        self.discord = Discord(self)
-        self.ready_future: asyncio.Future[bool] = self.xmpp.loop.create_future()
-        self.delete_futures = dict[int, asyncio.Future[bool]]()
-        self.edit_futures = dict[int, asyncio.Future[bool]]()
-        self.send_futures = dict[int, asyncio.Future[bool]]()
-        self.send_lock = asyncio.Lock()
-
-    @staticmethod
-    def xmpp_msg_id_to_legacy_msg_id(i: str):
-        return int(i)
-
-    async def login(self):
-        await self.discord.login(self.user.registration_form["token"])
-        self.xmpp.loop.create_task(self.discord.connect())
-
-        await self.ready_future
-        for u in self.discord.users:
-            if not isinstance(u, di.User):
-                self.log.debug(f"Skipping %s", u)
-                continue
-            if not u.is_friend():
-                self.log.debug(f"%s is not a friend", u)
-                continue
-            c = await self.contacts.by_legacy_id(u.id)
-            await c.update_info()
-            await c.add_to_roster()
-            # TODO: contribute to discord.py-self so that the presence information
-            #       of relationships is parsed. logs show:
-            #       'PRESENCE_UPDATE referencing an unknown guild ID: %s. Discarding.'
-            #       https://github.com/dolfies/discord.py-self/blob/master/discord/state.py#L1044
-            c.online()
-        return f"Logged on as {self.discord.user}"
-
-    async def send_text(
-        self,
-        text: str,
-        chat,
-        reply_to_msg_id=None,
-        reply_to_fallback_text: Optional[str] = None,
-        **kwargs,
-    ):
-        async with self.send_lock:
-            mid = (
-                await chat.discord_user.send(
-                    text,
-                    reference=None
-                    if reply_to_msg_id is None
-                    else di.MessageReference(
-                        message_id=reply_to_msg_id,
-                        channel_id=chat.direct_channel_id,
-                    ),
-                )
-            ).id
-        f = self.send_futures[mid] = self.xmpp.loop.create_future()
-        await f
-        return mid
-
-    async def logout(self):
-        await self.discord.close()
-
-    async def send_file(self, url: str, chat: Chat, **kwargs):
-        # discord clients inline previews of external URLs, so no need to actually send on discord servers
-        await chat.discord_user.send(url)
-
-    async def active(self, c: "Contact"):
-        pass
-
-    async def inactive(self, c: "Contact"):
-        pass
-
-    async def composing(self, c: "Contact"):
-        await c.discord_user.trigger_typing()
-
-    async def paused(self, c: "Contact"):
-        pass
-
-    async def displayed(self, legacy_msg_id: int, c: "Contact"):
-        if not isinstance(legacy_msg_id, int):
-            self.log.debug("This is not a valid discord msg id: %s", legacy_msg_id)
-            return
-        u = c.discord_user
-        channel: di.DMChannel = u.dm_channel
-        if channel is None:
-            return
-        m = await channel.fetch_message(legacy_msg_id)
-        self.log.debug("Message %s should be marked as read", m)
-        # try:
-        #     await m.ack()  # triggers 404, maybe does not work for DM?
-        # except Exception as e:
-        #     self.log.exception("Message %s should have been marked as read but this raised %s", m, e)
-
-    async def correct(self, text: str, legacy_msg_id: Any, c: "Contact"):
-        u = c.discord_user
-        channel: di.DMChannel = u.dm_channel
-        if channel is None:
-            return
-        m = await channel.fetch_message(legacy_msg_id)
-        self.edit_futures[legacy_msg_id] = self.xmpp.loop.create_future()
-        await m.edit(content=text)
-        await self.edit_futures[legacy_msg_id]
-
-    async def react(self, legacy_msg_id: int, emojis: list[str], c: "Contact"):
-        u = c.discord_user
-        channel: di.DMChannel = u.dm_channel
-        if channel is None:
-            return
-        m = await channel.fetch_message(legacy_msg_id)
-
-        legacy_reactions = set(self.get_my_legacy_reactions(m))
-        xmpp_reactions = set(emojis)
-
-        self.log.debug("%s vs %s", legacy_reactions, xmpp_reactions)
-        for e in xmpp_reactions - legacy_reactions:
-            await m.add_reaction(e)
-        for e in legacy_reactions - xmpp_reactions:
-            await m.remove_reaction(e, self.discord.user)
-
-    async def retract(self, legacy_msg_id: Any, c: "Contact"):
-        u = c.discord_user
-        channel: di.DMChannel = u.dm_channel
-        if channel is None:
-            return
-        m = await channel.fetch_message(legacy_msg_id)
-        self.delete_futures[legacy_msg_id] = self.xmpp.loop.create_future()
-        await m.delete()
-        await self.delete_futures[legacy_msg_id]
-
-    async def update_reactions(self, message: di.Message):
-        (await self.contacts.by_discord_user(message.channel.recipient)).react(
-            message.id, self.get_my_legacy_reactions(message), carbon=True
-        )
-
-    @staticmethod
-    def get_my_legacy_reactions(message: di.Message) -> list[str]:
-        reactions = []
-        for r in message.reactions:
-            if r.me and not r.custom_emoji:
-                reactions.append(r.emoji)
-
-        return reactions
-
-    async def search(self, form_values: dict[str, str]):
-        pass

slidge/plugins/dummy.py

@@ -1,334 +0,0 @@
-"""
-A pseudo legacy network, to easily test things
-"""
-
-import asyncio
-import logging
-import uuid
-from collections import defaultdict
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Any, Optional, Union
-
-from slixmpp import JID
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-from slidge.core.adhoc import RegistrationType
-
-ASSETS_DIR = Path(__file__).parent.parent.parent / "assets"
-
-
-class Bookmarks(LegacyBookmarks):
-    @staticmethod
-    async def jid_local_part_to_legacy_id(local_part):
-        if local_part not in {"prout-1", "prout2"}:
-            raise XMPPError("not-found")
-        return local_part
-
-
-class MUC(LegacyMUC["Session", str, "Participant", str]):
-    REACTIONS_SINGLE_EMOJI = True
-
-    session: "Session"
-    msg_ids = defaultdict(int)  # type: ignore
-
-    async def join(self, p):
-        self.user_nick = "SomeNick"
-        await super().join(p)
-
-    async def fill_history(
-        self,
-        full_jid: JID,
-        maxchars: Optional[int] = None,
-        maxstanzas: Optional[int] = None,
-        seconds: Optional[int] = None,
-        since: Optional[int] = None,
-    ):
-        if maxchars is not None and maxchars == 0:
-            return
-        part = await self.get_participant("someone")
-        log.debug("PART")
-        for i in range(10, 0, -1):
-            log.debug("HISTORY")
-            part.send_text(
-                "history",
-                f"-{i}",
-                when=datetime.now() - timedelta(hours=i),
-                full_jid=full_jid,
-            )
-
-    async def get_participants(self):
-        if self.legacy_id == "prout-1":
-            for nick in "anon1", "anon2":
-                yield Participant(self, nick)
-                break
-        elif self.legacy_id == "prout2":
-            for nick in "anon1", "anon2", "anon3", "anon4":
-                yield Participant(self, nick)
-
-    async def send_text(self, text: str) -> str:
-        self.msg_ids[self.legacy_id] += 1
-        i = self.msg_ids[self.legacy_id]
-        self.xmpp.loop.create_task(self.session.muc_later(self, text, i))
-        return str(self.msg_ids[self.legacy_id])
-
-
-class Participant(LegacyParticipant[MUC]):
-    pass
-
-
-class Contact(LegacyContact):
-    REACTIONS_SINGLE_EMOJI = True
-
-    async def available_emojis(self, legacy_msg_id):
-        return {"🦅", "🧺"}
-
-
-class Gateway(BaseGateway):
-    COMPONENT_NAME = "The great legacy network (slidge)"
-    COMPONENT_AVATAR = ASSETS_DIR / "gateway.png"
-    COMPONENT_TYPE = "aim"
-    GROUPS = True
-    REGISTRATION_INSTRUCTIONS = (
-        "Only username 'n' is accepted and only 'baba' and 'bibi' contacts exist.\n"
-        "You can use any password you want."
-    )
-    REGISTRATION_TYPE = RegistrationType.QRCODE
-    MARK_ALL_MESSAGES = True
-
-    async def validate(
-        self, user_jid: JID, registration_form: dict[str, Optional[str]]
-    ):
-        if registration_form["username"] != "n":
-            raise XMPPError("bad-request", "Y a que N!")
-
-    async def validate_two_factor_code(self, user, code):
-        if code != "8":
-            raise XMPPError("not-authorized", text="Wrong code! It's 8.")
-
-    async def get_qr_text(self, user: GatewayUser) -> str:
-        self.loop.create_task(self.later_confirm_qr(user))
-        return "dummy:///SLIDGE-IS-GREAT-AGAIN/prout"
-
-    async def later_confirm_qr(self, user: GatewayUser):
-        await asyncio.sleep(1)
-        exc = (
-            XMPPError("bad-request", "Ben non")
-            if user.registration_form["password"] == "n"
-            else None
-        )
-        await self.confirm_qr(user.bare_jid, exc)
-
-
-class Roster(LegacyRoster):
-    @staticmethod
-    async def jid_username_to_legacy_id(jid_username: str):
-        if jid_username not in BUDDIES + ["bubu"]:
-            raise XMPPError("not-found")
-        return jid_username
-
-
-class Session(
-    BaseSession[
-        Gateway, int, LegacyRoster, LegacyContact, LegacyBookmarks, MUC, Participant
-    ]
-):
-    def __init__(self, user):
-        super(Session, self).__init__(user)
-        self.counter = 0
-        self.xmpp.loop.create_task(self.backfill())
-        self.xmpp.loop.create_task(
-            self.contacts.by_legacy_id("bibi")
-        ).add_done_callback(
-            lambda c: c.result().set_vcard(
-                given="FirstBi",
-                surname="LastBi",
-                phone="+555",
-                full_name="Bi bi",
-                note="A fake friend, always there for you",
-                url="https://example.org",
-                email="bibi@prout.com",
-                country="Westeros",
-                locality="The place with the thing",
-            )
-        )
-        self.xmpp.loop.create_task(self.add_groups())
-
-    async def add_groups(self):
-        muc = await self.bookmarks.by_legacy_id("prout-1")
-        muc.n_participants = 45
-        await self.bookmarks.by_legacy_id("prout2")
-        muc.n_participants = 885
-
-    async def muc_later(self, muc: MUC, text: str, trigger_msg_id: int):
-        replier = await muc.get_participant("anon1")
-        log.debug("REPLIER: %s", replier)
-        await asyncio.sleep(0.5)
-        replier.composing()
-        await asyncio.sleep(0.5)
-        replier.send_text("prout", trigger_msg_id * 1000)
-        # next(muc.participants).send_text("I agree. Ain't that great?")
-
-    async def backfill(self):
-        self.log.debug("CARBON")
-        i = uuid.uuid1()
-
-        baba = await self.contacts.by_legacy_id("baba")
-
-        baba.send_text(
-            f"You're bad!",
-            legacy_msg_id=i,
-            when=datetime.now() - timedelta(hours=5),
-            carbon=True,
-        )
-        baba.send_text(
-            f"You're worse",
-            legacy_msg_id=i,
-            when=datetime.now() - timedelta(hours=4),
-        )
-
-    async def paused(self, c: LegacyContact):
-        pass
-
-    async def correct(self, text: str, legacy_msg_id: Any, c: LegacyContact):
-        pass
-
-    async def login(self):
-        log.debug("Logging in user: %s", self.user)
-        self.send_gateway_status("Connecting...", show="dnd")
-        await asyncio.sleep(1)
-        self.send_gateway_status("Connected")
-        for b, a in zip(BUDDIES, AVATARS):
-            c = await self.contacts.by_legacy_id(b.lower())
-            c.name = b.title()
-            c.avatar = a
-            await c.add_to_roster()
-            c.online("I am not a real person, so what?")
-        return "You can talk to your fake friends now"
-
-    async def logout(self):
-        log.debug("User has disconnected")
-
-    async def send_text(
-        self,
-        text: str,
-        chat: Union[LegacyContact, MUC],
-        *,
-        reply_to_msg_id=None,
-        reply_to_fallback_text=None,
-        reply_to=None,
-    ):
-        if isinstance(chat, MUC):
-            await chat.send_text(text)
-            return
-
-        log.debug("REPLY FALLBACK: %r", reply_to_fallback_text)
-        i = self.counter
-        self.counter = i + 1
-
-        if text == "crash":
-            raise RuntimeError("PANIC!!!")
-        if text == "crash2":
-            self.xmpp.loop.create_task(self.crash())
-        elif text == "delete":
-            self.xmpp.loop.create_task(self.later_carbon_delete(chat, i))
-        elif text == "nick":
-            chat.name = "NEWNAME"
-        elif text == "avatar":
-            chat.avatar = ASSETS_DIR / "5x5.png"
-        elif text == "nonick":
-            chat.name = None
-        else:
-            self.xmpp.loop.create_task(self.later(chat, i, body=text))
-
-        return i
-
-    async def crash(self):
-        raise RuntimeError("PANIC222!!!")
-
-    async def send_file(self, url: str, chat: Union[LegacyContact, MUC], **k) -> int:
-        i = self.counter
-        self.counter = i + 1
-        if isinstance(chat, MUC):
-            replier = await chat.get_participant("uploader")
-        else:
-            replier = chat  # type: ignore
-        replier.send_text(url)
-        await replier.send_file(ASSETS_DIR / "buddy1.png", caption="This is a caption")
-        return i
-
-    async def later(self, c: LegacyContact, trigger_msg_id: int, body: str):
-        i = self.counter - 1
-        await asyncio.sleep(1)
-        c.received(i)
-        await asyncio.sleep(1)
-        c.active()
-        await asyncio.sleep(1)
-        c.displayed(i)
-        await asyncio.sleep(1)
-        c.ack(i)
-        await asyncio.sleep(1)
-        c.composing()
-        await asyncio.sleep(1)
-        c.paused()
-        await asyncio.sleep(1)
-        c.composing()
-        await asyncio.sleep(1)
-        c.send_text(
-            "OK",
-            legacy_msg_id=i,
-            reply_to_msg_id=trigger_msg_id,
-            reply_to_fallback_text=body,
-        )
-        await asyncio.sleep(1)
-        i = uuid.uuid1().int
-        c.send_text("I will retract this", legacy_msg_id=i)
-        c.retract(i)
-        c.inactive()
-
-    async def later_carbon_delete(self, c: LegacyContact, trigger_msg_id: int):
-        await asyncio.sleep(1)
-        c.retract(trigger_msg_id, carbon=True)
-
-    async def active(self, c: LegacyContact):
-        log.debug("User is active for contact %s", c)
-
-    async def inactive(self, c: LegacyContact):
-        log.debug("User is inactive for contact %s", c)
-
-    async def composing(self, c: LegacyContact):
-        log.debug("User is composing for contact %s", c)
-
-    async def displayed(self, legacy_msg_id: int, c: LegacyContact):
-        log.debug("Message #%s was read by the user", legacy_msg_id)
-
-    async def search(self, form_values: dict[str, str]):
-        if form_values["first"] == "bubu":
-            return SearchResult(
-                fields=[
-                    FormField("name", label="Name"),
-                    FormField("jid", type="jid-single"),
-                ],
-                items=[{"name": "bubu", "jid": f"bubu@{self.xmpp.boundjid.bare}"}],
-            )
-
-    async def react(self, legacy_msg_id, emojis, c):
-        if "😈" in emojis:
-            c.send_text("That's forbidden")
-            c.react(legacy_msg_id, "", carbon=True)
-            raise XMPPError("not-acceptable")
-        else:
-            c.react(legacy_msg_id, "♥")
-
-    async def retract(self, legacy_msg_id, c):
-        log.debug("User has retracted their msg: '%s' (sent to '%s')", legacy_msg_id, c)
-
-
-BUDDIES = ["baba", "bibi"]
-AVATARS = ["https://wallpapercave.com/wp/PSksftM.jpg"]
-
-with (ASSETS_DIR / "buddy2.png").open("rb") as fp:
-    AVATARS.append(fp.read())  # type:ignore
-
-log = logging.getLogger(__name__)