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

slidge/plugins/discord/__init__.py

@@ -1,90 +0,0 @@
-import functools
-import logging
-from argparse import ArgumentParser
-
-import discord as di
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-from .session import Session
-
-
-class Gateway(BaseGateway[Session]):
-    COMPONENT_NAME = "Discord (slidge)"
-    COMPONENT_TYPE = "discord"
-    REGISTRATION_INSTRUCTIONS = (
-        "Have a look at https://discordpy-self.readthedocs.io/en/latest/token.html"
-    )
-    REGISTRATION_FIELDS = [FormField("token", required=True)]
-
-    ROSTER_GROUP = "Discord"
-
-    def config(self, argv: list[str]):
-        parser = ArgumentParser()
-        parser.add_argument("--discord-verbose", action="store_true")
-        args = parser.parse_args(argv)
-        if not args.discord_verbose:
-            log.debug("Disabling discord info logs")
-            logging.getLogger("discord.gateway").setLevel(logging.WARNING)
-            logging.getLogger("discord.client").setLevel(logging.WARNING)
-
-
-class Contact(LegacyContact[Session]):
-    MARKS = False
-
-    @functools.cached_property
-    def discord_user(self) -> di.User:
-        logging.debug("Searching for user: %s", self.legacy_id)
-        if (u := self.session.discord.get_user(self.legacy_id)) is None:
-            raise XMPPError(
-                "not-found", text=f"Cannot find the discord user {self.legacy_id}"
-            )
-        return u
-
-    @functools.cached_property
-    def direct_channel_id(self):
-        return self.discord_user.dm_channel.id
-
-    async def update_reactions(self, m: di.Message):
-        legacy_reactions = []
-        user = self.discord_user
-        for r in m.reactions:
-            async for u in r.users():
-                if u == user:
-                    legacy_reactions.append(r.emoji)
-        self.react(m.id, legacy_reactions)
-
-    async def update_info(self):
-        u = self.discord_user
-        self.name = name = u.display_name
-        self.avatar = str(u.avatar_url)
-
-        try:
-            profile = await u.profile()
-        except di.Forbidden:
-            log.debug("Forbidden to fetch the profile of %s", u)
-        except di.HTTPException as e:
-            log.debug("HTTP exception %s when fetch the profile of %s", e, u)
-        else:
-            self.set_vcard(full_name=name, note=profile.bio)
-
-        # TODO: use the relationship here
-        # relationship = u.relationship
-
-
-class Roster(LegacyRoster[Contact, "Session"]):
-    def by_discord_user(self, u: di.User):
-        return self.by_legacy_id(u.id)
-
-    @staticmethod
-    def jid_username_to_legacy_id(discord_id: str):
-        try:
-            return int(discord_id)
-        except ValueError:
-            raise XMPPError(
-                "not-found", text=f"Not a valid discord user ID: {discord_id}"
-            )
-
-
-log = logging.getLogger(__name__)

slidge/plugins/discord/client.py

@@ -1,108 +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:
-                self.session.contacts.by_discord_user(channel.recipient).carbon(
-                    message.content
-                )
-            else:
-                fut.set_result(True)
-        else:
-            contact = self.session.contacts.by_discord_user(author)
-            reply_to = message.reference.message_id if message.reference else None
-            if content := message.content:
-                contact.send_text(
-                    content,
-                    legacy_msg_id=message.id,
-                    reply_to_msg_id=reply_to,
-                )
-            for attachment in message.attachments:
-                await contact.send_file(
-                    url=attachment.url,
-                    filename=attachment.filename,
-                    content_type=attachment.content_type,
-                    reply_to_msg_id=reply_to,
-                )
-
-    async def on_typing(self, channel, user, _when):
-        if user != self.user and isinstance(channel, di.DMChannel):
-            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:
-                self.session.contacts.by_discord_user(
-                    after.channel.recipient
-                ).carbon_correct(after.id, after.content)
-            else:
-                fut.set_result(True)
-        else:
-            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:
-                self.session.contacts.by_discord_user(
-                    m.channel.recipient
-                ).carbon_retract(m.id)
-            else:
-                fut.set_result(True)
-        else:
-            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:
-            self.session.update_reactions(message)
-        else:
-            await self.session.contacts.by_discord_user(user).update_reactions(message)

slidge/plugins/discord/session.py

@@ -1,162 +0,0 @@
-import asyncio
-from typing import TYPE_CHECKING, Any, Union
-
-import discord as di
-
-from slidge import *
-
-if TYPE_CHECKING:
-    from . import Contact, Gateway, Roster
-    from .client import Discord
-
-
-class Session(BaseSession["Contact", "Roster", "Gateway"]):
-    discord: "Discord"
-    ready_future: asyncio.Future[bool]
-    delete_futures: dict[int, asyncio.Future[bool]]
-    edit_futures: dict[int, asyncio.Future[bool]]
-    send_futures: dict[int, asyncio.Future[bool]]
-    send_lock: asyncio.Lock
-
-    def post_init(self):
-        from .client import Discord
-
-        self.discord = Discord(self)
-        self.ready_future = self.xmpp.loop.create_future()
-        self.delete_futures = {}
-        self.edit_futures = {}
-        self.send_futures = {}
-        self.send_lock = asyncio.Lock()
-
-    @staticmethod
-    def xmpp_msg_id_to_legacy_msg_id(i: str) -> Union[int, str]:
-        try:
-            return int(i)
-        except ValueError:
-            return i
-
-    async def login(self):
-        self.xmpp.loop.create_task(
-            self.discord.start(self.user.registration_form["token"])
-        )
-        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 = 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, t: str, c: "Contact", *, reply_to_msg_id=None):
-        async with self.send_lock:
-            mid = (
-                await c.discord_user.send(
-                    t,
-                    reference=None
-                    if reply_to_msg_id is None
-                    else di.MessageReference(
-                        message_id=reply_to_msg_id,
-                        channel_id=c.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, u: str, c: "Contact", *, reply_to_msg_id=None):
-        # discord clients inline previews of external URLs, so no need to actually send on discord servers
-        await c.discord_user.send(u)
-
-    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: str, 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]
-
-    def update_reactions(self, message: di.Message):
-        self.contacts.by_discord_user(message.channel.recipient).carbon_react(
-            message.id, self.get_my_legacy_reactions(message)
-        )
-
-    @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]) -> SearchResult:
-        pass

slidge/plugins/dummy.py

@@ -1,203 +0,0 @@
-"""
-A pseudo legacy network, to easily test things
-"""
-
-import asyncio
-import logging
-import uuid
-from pathlib import Path
-from typing import Any, Optional
-
-from slixmpp import JID
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-ASSETS_DIR = Path(__file__).parent.parent.parent / "assets"
-
-
-class Gateway(BaseGateway):
-    COMPONENT_NAME = "The great legacy network (slidge)"
-    COMPONENT_AVATAR = ASSETS_DIR / "gateway.png"
-    COMPONENT_TYPE = "aim"
-    REGISTRATION_INSTRUCTIONS = (
-        "Only username 'n' is accepted and only 'baba' and 'bibi' contacts exist.\n"
-        "You can use any password you want."
-    )
-    REGISTRATION_FIELDS = list(BaseGateway.REGISTRATION_FIELDS) + [
-        FormField(
-            var="something_else",
-            label="Some optional stuff not covered by jabber:iq:register",
-            required=False,
-            private=False,
-        ),
-        FormField(
-            var="device",
-            type="list-single",
-            label="What do you want to do?",
-            options=[
-                {"label": "Choice #1", "value": "choice1"},
-                {"label": "Choice #2", "value": "choice2"},
-            ],
-            required=True,
-        ),
-    ]
-
-    async def validate(
-        self, user_jid: JID, registration_form: dict[str, Optional[str]]
-    ):
-        if registration_form["username"] != "n":
-            raise ValueError("Y a que N!")
-
-
-class Session(BaseSession[LegacyContact, LegacyRoster, Gateway]):
-    def __init__(self, user):
-        super(Session, self).__init__(user)
-        self.counter = 0
-        self.xmpp.loop.create_task(self.backfill())
-        self.contacts.by_legacy_id("bibi").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",
-        )
-
-    async def backfill(self):
-        self.log.debug("CARBON")
-        i = uuid.uuid1()
-
-        self.contacts.by_legacy_id("bibi").carbon(
-            f"Sent by the component on behalf of the user, and this should reach MAM. Msg ID: {i}",
-            legacy_id=i,
-        )
-
-    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 = 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, t: str, c: LegacyContact, *, reply_to_msg_id=None):
-        i = self.counter
-        self.counter = i + 1
-
-        if t == "crash":
-            raise RuntimeError("PANIC!!!")
-        if t == "crash2":
-            self.xmpp.loop.create_task(self.crash())
-        elif t == "delete":
-            self.xmpp.loop.create_task(self.later_carbon_delete(c, i))
-        elif t == "nick":
-            c.name = "NEWNAME"
-        elif t == "avatar":
-            c.avatar = ASSETS_DIR / "5x5.png"
-        elif t == "nonick":
-            c.name = None
-        else:
-            self.xmpp.loop.create_task(self.later(c, i))
-
-        return i
-
-    async def crash(self):
-        raise RuntimeError("PANIC222!!!")
-
-    async def send_file(self, u: str, c: LegacyContact, *, reply_to_msg_id=None) -> int:
-        i = self.counter
-        self.counter = i + 1
-        c.send_text(u)
-        await c.send_file(ASSETS_DIR / "buddy1.png")
-        return i
-
-    async def later(self, c: LegacyContact, trigger_msg_id: int):
-        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)
-        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.carbon_retract(trigger_msg_id)
-
-    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.carbon_react(legacy_msg_id, "")
-            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 = []
-
-with (ASSETS_DIR / "buddy1.png").open("rb") as fp:
-    AVATARS.append(fp.read())
-
-with (ASSETS_DIR / "buddy2.png").open("rb") as fp:
-    AVATARS.append(fp.read())
-
-log = logging.getLogger(__name__)