sleamdge 0.0.0.dev0__py3-none-any.whl

sleamdge/__init__.py

@@ -0,0 +1,13 @@
+from slidge import entrypoint
+from slidge.util.util import get_version  # noqa: F401
+
+from . import contact, gateway, session
+
+
+def main():
+    entrypoint("sleamdge")
+
+
+__all__ = "contact", "gateway", "session", "main"
+
+__version__ = get_version()

sleamdge/__main__.py

@@ -0,0 +1,3 @@
+from sleamdge import main
+
+main()

sleamdge/client.py

@@ -0,0 +1,217 @@
+import asyncio
+import logging
+from asyncio import Future, get_running_loop
+from datetime import datetime
+from typing import TYPE_CHECKING, Generic, Optional, TypeVar, Union
+
+import steam
+from slixmpp.exceptions import XMPPError
+
+if TYPE_CHECKING:
+    from .contact import Contact
+    from .group import Participant
+    from .session import Session
+
+
+ClanOrGroup = Union[steam.Clan, steam.Group]
+Channel = Union[steam.GroupChannel, steam.ClanChannel]
+
+
+class CredentialsValidation(steam.Client):
+    """
+    A client for entering the OTP interactively and validating credentials
+    """
+
+    def __init__(self, **k) -> None:
+        super().__init__(**k)
+        self.code_future: Future[str] = get_running_loop().create_future()
+
+    async def code(self) -> str:
+        return await self.code_future
+
+
+class SteamClient(steam.Client):
+    """
+    The main steam client of registered users
+    """
+
+    def __init__(self, session: "Session", **k) -> None:
+        self.session = session
+        self.__outbox = Pending[int]()
+        self.__outbox_reaction = Pending[tuple[int, str, bool]]()
+        super().__init__(**k)
+
+    async def code(self) -> str:
+        return await self.session.input(
+            "You have been disconnected, please enter the code "
+            "you received via email or steam guard"
+        )
+
+    async def get_contact_or_participant(
+        self, message: steam.Message
+    ) -> Optional[Union["Contact", "Participant"]]:
+        if isinstance(message, steam.UserMessage):
+            return await self.session.contacts.by_steam_user(
+                message.channel.participant
+            )
+        elif isinstance(message, (steam.GroupMessage, steam.ClanMessage)):
+            muc = await self.session.bookmarks.by_steam_channel(message.channel)
+            return await muc.get_participant_by_legacy_id(message.author.id)
+        return None
+
+    async def on_typing(self, user: steam.User, when: datetime):
+        if user == self.user:
+            return
+        c = await self.session.contacts.by_steam_user(user)
+        c.composing()
+
+    async def on_message(self, message: steam.Message) -> None:
+        if self.__outbox.set_if_pending(message.id):
+            return
+
+        c = await self.get_contact_or_participant(message)
+        if c is None:
+            return
+
+        c.send_text(
+            message.clean_content, message.id, carbon=message.author == self.user
+        )
+
+    async def on_reaction_add(self, reaction: steam.MessageReaction) -> None:
+        if not reaction.emoticon:
+            return
+        if self.__outbox_reaction.set_if_pending(
+            (reaction.message.id, reaction.emoticon.name, True)
+        ):
+            return
+        await self.update_reactions(reaction)
+
+    async def on_reaction_remove(self, reaction: steam.MessageReaction) -> None:
+        if not reaction.emoticon:
+            return
+        if self.__outbox_reaction.set_if_pending(
+            (reaction.message.id, reaction.emoticon.name, False)
+        ):
+            return
+
+        await self.update_reactions(reaction)
+
+    async def on_clan_update(self, before: steam.Clan, after: steam.Clan, /) -> None:
+        await self.on_group_or_clan_update(before, after)
+
+    async def on_clan_join(self, clan: steam.Clan, /) -> None:
+        for c in clan.channels:
+            await self.session.bookmarks.by_steam_channel(c)
+
+    async def on_clan_leave(self, clan: steam.Clan, /) -> None:
+        # TODO:
+        pass
+
+    async def on_group_update(self, before: steam.Group, after: steam.Group, /) -> None:
+        await self.on_group_or_clan_update(before, after)
+
+    async def on_group_or_clan_update(
+        self, before: ClanOrGroup, after: ClanOrGroup, /
+    ) -> None:
+        channels_before = set[Channel](before.channels)
+        channels_after = set[Channel](after.channels)
+
+        for channel in channels_after - channels_before:
+            muc = await self.session.bookmarks.by_steam_channel(channel)
+            if isinstance(after, steam.Group):
+                await muc.add_to_bookmarks()
+        for channel in channels_before - channels_after:
+            muc = await self.session.bookmarks.by_steam_channel(channel)
+            muc.get_system_participant().send_text(
+                "This channel has been destroyed but this is not yet implemented in slidge…"
+            )
+
+        existing_mucs = [
+            await self.session.bookmarks.by_steam_channel(c) for c in channels_before
+        ]
+
+        for muc in existing_mucs:
+            await muc.update_info()
+
+    async def on_group_join(self, group: steam.Group, /) -> None:
+        for c in group.channels:
+            muc = await self.session.bookmarks.by_steam_channel(c)
+            await muc.add_to_bookmarks()
+
+    async def on_group_leave(self, group: steam.Group, /) -> None:
+        # TODO:
+        pass
+
+    async def update_reactions(self, reaction: steam.MessageReaction) -> None:
+        message = reaction.message
+        if not reaction.emoticon:
+            return
+        c = await self.get_contact_or_participant(message)
+        if c is None:
+            return
+
+        self.session.log.debug("Reaction: %s", reaction)
+        await c.update_reaction(reaction)
+
+    async def on_user_update(self, before: steam.User, after: steam.User) -> None:
+        if after.id == self.user.id:
+            return
+        c = await self.session.contacts.by_steam_user(after)
+        await c.update_info(after)
+
+    async def add_emoticon(self, msg: steam.Message, emoticon: steam.Emoticon) -> None:
+        e = self.__outbox_reaction.place((msg.id, emoticon.name, True))
+        await msg.add_emoticon(emoticon)
+        await e.wait()
+
+    async def remove_emoticon(
+        self, msg: steam.Message, emoticon: steam.Emoticon
+    ) -> None:
+        e = self.__outbox_reaction.place((msg.id, emoticon.name, False))
+        await msg.remove_emoticon(emoticon)
+        await e.wait()
+
+    async def send(
+        self,
+        recipient: Union[steam.User, steam.GroupChannel, steam.ClanChannel],
+        text: str,
+    ) -> int:
+        message = await recipient.send(text)
+        if message is None:
+            raise XMPPError("internal-server-error", "No message ID")
+        e = self.__outbox.place(message.id)
+        await e.wait()
+        return message.id
+
+    async def fetch_user_named(self, name: str):
+        id64 = await steam.utils.id64_from_url(
+            f"https://steamcommunity.com/id/{name}", self.session.http
+        )
+        return await self._state.fetch_user(id64) if id64 is not None else None
+
+
+T = TypeVar("T")
+
+
+class Pending(Generic[T]):
+    """
+    Helper for the fact that everything we send is echoed, and we mostly
+    want to ignore echoes/
+    """
+
+    def __init__(self) -> None:
+        self.__data = dict[T, asyncio.Event]()
+
+    def place(self, key: T) -> asyncio.Event:
+        e = self.__data[key] = asyncio.Event()
+        return e
+
+    def set_if_pending(self, key: T) -> bool:
+        e = self.__data.pop(key, None)
+        if e is None:
+            return False
+        e.set()
+        return True
+
+
+log = logging.getLogger(__name__)

sleamdge/contact.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, AsyncIterator, Optional
+
+import steam
+from slidge import LegacyContact, LegacyRoster
+from slixmpp.exceptions import XMPPError
+from steam.types.id import ID32
+
+from .util import EMOJIS_SET, emojize
+
+if TYPE_CHECKING:
+    from .session import Session
+
+
+class Roster(LegacyRoster[ID32, "Contact"]):
+    session: "Session"
+
+    async def by_steam_user(self, user: steam.User) -> Contact:
+        return await self.by_legacy_id(user.id)
+
+    async def jid_username_to_legacy_id(self, local: str) -> ID32:
+        try:
+            local_int = int(local)
+        except ValueError:
+            raise XMPPError("bad-request", f"This is not a valid integer: {local}")
+        return ID32(local_int)
+
+    async def fill(self) -> AsyncIterator["Contact"]:
+        for user in await self.session.steam.user.friends():
+            c = await self.by_steam_user(user)
+            c.is_friend = True
+            yield c
+
+
+class Contact(LegacyContact[ID32]):
+    MARKS = False
+    CORRECTION = False
+    RETRACTION = False
+
+    session: "Session"
+
+    async def get_steam_channel(self) -> steam.User:
+        u = self.session.steam.get_user(self.legacy_id)
+        if u is None:
+            raise XMPPError("item-not-found")
+        return u
+
+    async def update_info(self, user: Optional[steam.User] = None) -> None:
+        if user is None:
+            user = await self.get_steam_channel()
+        self.name = user.name
+        self.avatar = user.avatar.url
+        await self.update_state(user)
+
+    async def update_state(self, user: Optional[steam.User] = None) -> None:
+        if user is None:
+            user = await self.get_steam_channel()
+        self.log.debug("Rich presence: %s", user.rich_presence)
+        match user.state:
+            case steam.PersonaState.Online:
+                self.online()
+            case steam.PersonaState.Offline:
+                if user.last_seen_online:
+                    # workaround for gajim not parsing last presence for "unavailable"
+                    self.extended_away(last_seen=user.last_seen_online)
+                else:
+                    self.offline()
+            case steam.PersonaState.Busy:
+                self.busy(last_seen=user.last_seen_online)
+            case steam.PersonaState.Away:
+                self.away(last_seen=user.last_seen_online)
+            case steam.PersonaState.Snooze:
+                self.extended_away(last_seen=user.last_seen_online)
+            case steam.PersonaState.LookingToPlay:
+                self.online(status="Looking to play", last_seen=user.last_seen_online)
+            case steam.PersonaState.LookingToTrade:
+                self.online(status="Looking to trade", last_seen=user.last_seen_online)
+
+    async def available_emojis(self, legacy_msg_id=None) -> set[str]:
+        return EMOJIS_SET
+
+    async def update_reaction(self, reaction: steam.MessageReaction) -> None:
+        user = self.session.steam.user
+        carbon = reaction.user == user
+        self.log.debug("Reaction: carbon: %s - %s - %s", user, reaction.user, carbon)
+        message = await self.fetch_message(reaction.message.id)
+
+        reactions = list[str]()
+        for r in message.reactions:
+            if emoticon := r.emoticon:
+                emoji = emojize(emoticon)
+                self.log.debug("UPDATING R: %s %s %s", emoji, r.user, user)
+                if r.user == user and carbon:
+                    reactions.append(emoji)
+                elif r.user != user and not carbon:
+                    reactions.append(emoji)
+        self.log.debug("UPDATING RS: %s %s %s", message.id, reactions, carbon)
+        self.react(message.id, reactions, carbon=carbon)
+
+    async def fetch_message(self, legacy_msg_id: int) -> steam.UserMessage:
+        msg = await (await self.get_steam_channel()).fetch_message(legacy_msg_id)
+        if msg is None:
+            raise XMPPError(
+                "item-not-found", f"Could not find the legacy message {legacy_msg_id}"
+            )
+        if not isinstance(msg, steam.UserMessage):
+            raise XMPPError(
+                "internal-server-error", f"This is not a 1:1 message: '{type(msg)}'"
+            )
+        return msg

sleamdge/gateway.py

@@ -0,0 +1,87 @@
+import asyncio
+import logging
+from typing import Optional
+
+from slidge import BaseGateway, GatewayUser
+from slidge.command.register import FormField, RegistrationType
+from slixmpp import JID
+from slixmpp.exceptions import XMPPError
+
+from .client import CredentialsValidation
+from .types import ChannelId
+
+
+class Gateway(BaseGateway):
+    REGISTRATION_INSTRUCTIONS = "Enter steam credentials"
+    REGISTRATION_FIELDS = [
+        FormField(var="username", label="Steam username", required=True),
+        FormField(var="password", label="Password", private=True, required=True),
+    ]
+    REGISTRATION_TYPE = RegistrationType.TWO_FACTOR_CODE
+
+    ROSTER_GROUP = "Steam"
+
+    SEARCH_FIELDS = [
+        FormField(
+            var="user_name",
+            label="The name of the user after https://steamcommunity.com/id",
+            required=True,
+        ),
+    ]
+
+    COMPONENT_NAME = "Steam (slidge)"
+    COMPONENT_TYPE = "steam"
+
+    COMPONENT_AVATAR = "https://logos-download.com/wp-content/uploads/2016/05/Steam_icon_logo_logotype.png"
+
+    GROUPS = True
+
+    LEGACY_MSG_ID_TYPE = int
+    LEGACY_CONTACT_ID_TYPE = int
+    LEGACY_ROOM_ID_TYPE = ChannelId.from_str
+
+    def __init__(self):
+        super().__init__()
+        self.__pending = dict[JID, tuple[asyncio.Task, CredentialsValidation]]()
+
+    async def validate(
+        self, user_jid: JID, registration_form: dict[str, Optional[str]]
+    ):
+        username = registration_form["username"]
+        password = registration_form["password"]
+
+        assert isinstance(username, str)
+        assert isinstance(password, str)
+
+        client = CredentialsValidation()
+
+        async def wrap():
+            try:
+                await client.login(username, password)
+            except Exception as e:
+                self.log.exception("Login failed for %s", user_jid, exc_info=e)
+
+        task = self.xmpp.loop.create_task(wrap())
+        self.__pending[JID(user_jid.bare)] = (task, client)
+        return {}
+
+    async def validate_two_factor_code(self, user: GatewayUser, code: str) -> dict:
+        task, client = self.__pending.pop(user.jid)
+        client.code_future.set_result(code)
+        try:
+            await asyncio.wait_for(asyncio.shield(client.wait_until_ready()), 5)
+            if task.done() and (exc := task.exception()):
+                raise XMPPError("not-authorized", f"That didn't work: {exc}")
+            await asyncio.wait_for(client.wait_until_ready(), 60)
+        except (asyncio.TimeoutError, asyncio.CancelledError):
+            raise XMPPError("not-authorized", f"Authorization timed out")
+        await client.wait_until_ready()
+        token = client.refresh_token
+        await client.close()
+        # For unknown reason, closing and re-opening the connection right away hangs,
+        # waiting is a dirty but mostly functional workaround.
+        await asyncio.sleep(10)
+        return {"refresh_token": token}
+
+
+log = logging.getLogger(__name__)

sleamdge/group.py

@@ -0,0 +1,174 @@
+from typing import TYPE_CHECKING, AsyncIterator, Optional, Union
+
+from slidge import LegacyBookmarks, LegacyMUC, LegacyParticipant, MucType
+from slidge.util.types import HoleBound
+from slixmpp.exceptions import XMPPError
+from steam import (
+    Clan,
+    ClanChannel,
+    ClanMessage,
+    Group,
+    GroupChannel,
+    GroupMessage,
+    MessageReaction,
+)
+
+from .contact import Contact
+from .types import ChannelId, Parent, ParentType
+from .util import EMOJIS_SET, emojize
+
+if TYPE_CHECKING:
+    from .session import Session
+
+
+class Bookmarks(LegacyBookmarks[ChannelId, "LegacyMUC"]):
+    session: "Session"
+
+    async def by_steam_channel(self, channel: Union[GroupChannel, ClanChannel]):
+        if channel.group:
+            parent = Parent(ParentType.GROUP, channel.group.id)
+        elif channel.clan:
+            parent = Parent(ParentType.CLAN, channel.clan.id)
+        else:
+            raise XMPPError(
+                "internal-server-error", "No group or clan associated to this channel"
+            )
+        return await self.by_legacy_id(ChannelId(parent, channel.id))
+
+    async def legacy_id_to_jid_local_part(self, legacy_id: ChannelId) -> str:
+        return str(legacy_id)
+
+    async def jid_local_part_to_legacy_id(self, local_part: str) -> ChannelId:
+        try:
+            return ChannelId.from_str(local_part)
+        except ValueError as e:
+            raise XMPPError("bad-request", f"This is not a valid sleamdge MUC id: {e}")
+
+    async def fill(self):
+        for group in self.session.steam.groups:
+            for group_channel in group.channels:
+                channel_id = ChannelId(
+                    Parent(ParentType.GROUP, group.id), group_channel.id
+                )
+                muc = await self.by_legacy_id(channel_id)
+                await muc.add_to_bookmarks()
+        for clan in self.session.steam.clans:
+            for clan_channel in clan.channels:
+                channel_id = ChannelId(
+                    Parent(ParentType.CLAN, clan.id), clan_channel.id
+                )
+                await self.by_legacy_id(channel_id)
+
+
+class Participant(LegacyParticipant):
+    contact: Contact
+    muc: "MUC"
+    session: "Session"
+
+    async def update_reaction(self, reaction: MessageReaction) -> None:
+        message = await self.muc.fetch_message(reaction.message.id)
+
+        reactions = list[str]()
+        if emoticon := reaction.emoticon:
+            reactions.append(emojize(emoticon))
+        for r in message.reactions:
+            self.log.debug("add reaction: %s", r)
+            if emoticon := r.emoticon:
+                emoji = emojize(emoticon)
+                self.log.debug(
+                    "add reaction: %s %s %s", emoji, r.user.id, self.contact.legacy_id
+                )
+                if r.user.id == self.contact.legacy_id:
+                    reactions.append(emoji)
+        self.log.debug("updating reactions: %s %s", message.id, reactions)
+        self.react(message.id, reactions)
+
+
+class MUC(LegacyMUC[ChannelId, int, Participant, int]):
+    session: "Session"
+
+    async def get_steam_channel(self) -> Union[GroupChannel, ClanChannel]:
+        parent_id = self.legacy_id.parent
+        parent: Optional[Union[Group, Clan]]
+        if parent_id.type == ParentType.GROUP:
+            parent = self.session.steam.get_group(parent_id.id)
+        else:
+            parent = self.session.steam.get_clan(parent_id.id)
+        if not parent:
+            raise XMPPError("internal-server-error", "No parent for this channel")
+        channel = parent.get_channel(self.legacy_id.channel_id)
+        if not channel:
+            raise XMPPError(
+                "item-not-found",
+                f"Channel {self.legacy_id.channel_id} not found in {parent}",
+            )
+        return channel
+
+    async def fetch_message(
+        self, legacy_msg_id: int
+    ) -> Union[GroupMessage, ClanMessage]:
+        msg = await (await self.get_steam_channel()).fetch_message(legacy_msg_id)
+        if msg is None:
+            raise XMPPError(
+                "item-not-found", f"Could not find the legacy message {legacy_msg_id}"
+            )
+        if not isinstance(msg, (GroupMessage, ClanMessage)):
+            raise XMPPError(
+                "internal-server-error", f"This is not a group message: '{type(msg)}'"
+            )
+        return msg
+
+    async def update_info(self):
+        channel = await self.get_steam_channel()
+        self.log.debug("Channel: %s", channel)
+        parent: Union[Group, Clan] = channel.group  # type:ignore
+        if parent is None:
+            self.name = channel.name
+            self.type = MucType.GROUP
+            return
+
+        self.name = f"{parent.name}/{channel.name or 'Home'}"
+        self.description = parent.tagline
+        sha = parent.avatar.sha.hex()
+        if self.avatar != sha:
+            # TODO: use avatar.url when this is fixed upstream
+            await self.set_avatar(
+                f"https://avatars.akamai.steamstatic.com/{sha}_256.jpg", sha
+            )
+        if isinstance(parent, Clan):
+            self.type = MucType.CHANNEL_NON_ANONYMOUS
+        else:
+            self.type = MucType.GROUP
+
+    async def fill_participants(self) -> AsyncIterator[Participant]:
+        g = (await self.get_steam_channel()).group
+        if not g:
+            return
+        try:
+            for m in await g.chunk():
+                yield await self.get_participant_by_legacy_id(m.id)
+        except AttributeError:
+            # workaround for https://github.com/Gobot1234/steam.py/issues/565
+            for m in g.members:
+                yield await self.get_participant_by_legacy_id(m.id)
+
+    async def backfill(
+        self,
+        after: Optional[HoleBound] = None,
+        before: Optional[HoleBound] = None,
+    ):
+        c = await self.get_steam_channel()
+        async for msg in c.history(
+            before=None if before is None else before.timestamp,
+            after=None if after is None else after.timestamp,
+        ):
+            part = await self.get_participant_by_legacy_id(msg.author.id)
+            part.send_text(
+                msg.clean_content,
+                when=msg.created_at,
+                archive_only=True,
+                legacy_msg_id=msg.id,
+            )
+
+    async def available_emojis(self, legacy_msg_id=None) -> set[str]:
+        return EMOJIS_SET