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

slidge/core/muc/__init__.py

@@ -1,3 +0,0 @@
-from .bookmarks import LegacyBookmarks
-from .participant import LegacyParticipant
-from .room import LegacyMUC, MucType

slidge/core/muc/bookmarks.py

@@ -1,74 +0,0 @@
-from typing import Generic, Type
-
-from slixmpp import JID
-from slixmpp.jid import _unescape_node
-
-from slidge.core.contact import ESCAPE_TABLE
-from slidge.util import SubclassableOnce
-from slidge.util.types import LegacyGroupIdType, LegacyMUCType, SessionType
-
-from .room import LegacyMUC
-
-
-class LegacyBookmarks(
-    Generic[SessionType, LegacyMUCType, LegacyGroupIdType], metaclass=SubclassableOnce
-):
-    def __init__(self, session: SessionType):
-        self.session = session
-        self.xmpp = session.xmpp
-        self.user = session.user
-        self.log = session.log
-
-        self._mucs_by_legacy_id = dict[LegacyGroupIdType, LegacyMUC]()
-        self._mucs_by_bare_jid = dict[str, LegacyMUC]()
-
-        self._muc_class: Type[LegacyMUC] = LegacyMUC.get_self_or_unique_subclass()
-
-    def set_username(self, nick: str):
-        self._muc_class.user_nick = nick
-
-    def __iter__(self):
-        return iter(self._mucs_by_legacy_id.values())
-
-    async def legacy_id_to_jid_local_part(self, legacy_id: LegacyGroupIdType):
-        return str(legacy_id).translate(ESCAPE_TABLE)
-
-    async def jid_local_part_to_legacy_id(self, local_part: str):
-        return _unescape_node(local_part)
-
-    async def by_jid(self, jid: JID):
-        bare = jid.bare
-        muc = self._mucs_by_bare_jid.get(bare)
-        if muc is None:
-            self.session.log.debug(
-                "Attempting to create new MUC instance for JID %s", jid
-            )
-            local_part = jid.node
-            legacy_id = await self.jid_local_part_to_legacy_id(local_part)
-            self.session.log.debug("%r is group %r", local_part, legacy_id)
-            muc = self._muc_class(self.session, legacy_id=legacy_id, jid=JID(bare))
-            self.session.log.debug("MUC created: %r", muc)
-            self._mucs_by_legacy_id[legacy_id] = muc
-            self._mucs_by_bare_jid[bare] = muc
-        else:
-            self.session.log.debug("Found MUC: %s -- %s", muc, type(muc))
-        return muc
-
-    async def by_legacy_id(self, legacy_id: LegacyGroupIdType):
-        muc = self._mucs_by_legacy_id.get(legacy_id)
-        if muc is None:
-            self.session.log.debug(
-                "Create new MUC instance for legacy ID %s", legacy_id
-            )
-            local = await self.legacy_id_to_jid_local_part(legacy_id)
-            jid = JID(f"{local}@{self.xmpp.boundjid}")
-            muc = self._muc_class(
-                self.session,
-                legacy_id=legacy_id,
-                jid=jid,
-            )
-            self.log.debug("MUC CLASS: %s", self._muc_class)
-
-            self._mucs_by_legacy_id[legacy_id] = muc
-            self._mucs_by_bare_jid[jid.bare] = muc
-        return muc

slidge/core/muc/participant.py

@@ -1,152 +0,0 @@
-import string
-from copy import copy
-from datetime import datetime
-from typing import Generic, Optional, Union
-
-from slixmpp import JID, InvalidJID, Message, Presence
-from slixmpp.types import MessageTypes
-
-from slidge.core.contact import LegacyContact
-from slidge.core.mixins import MessageMixin, PresenceMixin
-from slidge.util import SubclassableOnce
-from slidge.util.types import LegacyMessageType, LegacyMUCType
-
-
-class LegacyParticipant(
-    Generic[LegacyMUCType], PresenceMixin, MessageMixin, metaclass=SubclassableOnce
-):
-    mtype: MessageTypes = "groupchat"
-    USE_STANZA_ID = True
-    STRIP_SHORT_DELAY = False
-
-    def __init__(self, muc: LegacyMUCType, nickname: str, is_user=False):
-        self.muc = muc
-        self.session = session = muc.session
-        self.log = session.log
-        self.user = session.user
-        self.xmpp = session.xmpp
-        self.role = "participant"
-        self.affiliation = "member"
-        self.is_user = is_user
-
-        self.nickname = nickname
-        self.log.debug("NEW PARTICIPANT: %r", nickname)
-
-        j: JID = copy(self.muc.jid)  # type:ignore
-        try:
-            j.resource = nickname
-        except InvalidJID:
-            j.resource = (
-                "".join(x for x in nickname if x in string.printable)
-                + " [renamed by slidge]"
-            )
-        self.jid = j
-
-        self.log.debug("NEW PARTICIPANT: %r", self)
-        self.contact: Optional["LegacyContact"] = None
-
-    def __repr__(self):
-        return f"<{self.__class__} {self.nickname} of {self.muc}>"
-
-    def _make_presence(
-        self,
-        *,
-        last_seen: Optional[datetime] = None,
-        status_codes: Optional[set[int]] = None,
-        **presence_kwargs,
-    ):
-        p = super()._make_presence(last_seen=last_seen, **presence_kwargs)
-        p["muc"]["affiliation"] = self.affiliation
-        p["muc"]["role"] = self.role
-        self.log.debug("Presence - contact: %r", self.contact)
-        if self.contact:
-            p["muc"]["jid"] = self.contact.jid
-        codes = status_codes or set()
-        if self.is_user:
-            codes.add(110)
-        p["muc"]["status_codes"] = codes
-        return p
-
-    def _send(
-        self,
-        stanza: Union[Message, Presence],
-        full_jid: Optional[JID] = None,
-        **send_kwargs,
-    ):
-        if full_jid:
-            stanza["to"] = full_jid
-            stanza.send()
-        else:
-            for user_full_jid in self.muc.user_full_jids():
-                stanza = copy(stanza)
-                stanza["to"] = user_full_jid
-                stanza.send()
-
-    def send_initial_presence(
-        self,
-        full_jid: JID,
-        status: Optional[str] = None,
-        last_seen: Optional[datetime] = None,
-        nick_change=False,
-        presence_id: Optional[str] = None,
-    ):
-        """
-        Called when the user joins a MUC, as a mechanism
-        to indicate to the joining XMPP client the list of "participants".
-        (done internally by slidge)
-
-        :param full_jid: Set this to only send to a specific user XMPP resource.
-        :param status: a presence message, eg "having a bug, watching the game"
-        :param last_seen: when the participant was last online :xep:`0319` (Last User Interaction in Presence)
-        :param nick_change: Used when the user joins and the MUC renames them (code 210)
-        :param presence_id: set the presence ID. used internally by slidge
-        """
-        #  MUC status codes: https://xmpp.org/extensions/xep-0045.html#registrar-statuscodes
-        p = self._make_presence(
-            pstatus=status,
-            last_seen=last_seen,
-            status_codes={210} if nick_change else set(),
-        )
-        if presence_id:
-            p["id"] = presence_id
-        self._send(p, full_jid)
-
-    def send_text(
-        self,
-        body: str,
-        legacy_msg_id: Optional[LegacyMessageType] = None,
-        *,
-        when: Optional[datetime] = None,
-        reply_to_msg_id: Optional[LegacyMessageType] = None,
-        reply_to_fallback_text: Optional[str] = None,
-        reply_self=False,
-        reply_to_author: Optional["LegacyParticipant"] = None,
-        **kwargs,
-    ):
-        """
-        The participant sends a message in their corresponding group chat.
-
-        :param body:
-        :param legacy_msg_id:
-        :param when:
-        :param reply_to_msg_id: Quote another message (:xep:`0461`)
-        :param reply_to_fallback_text: Fallback text for clients not supporting :xep:`0461`
-        :param reply_self: Set to true is this is a self quote
-        :param reply_to_author: The participant that was quoted
-        """
-        if reply_self:
-            reply_to_jid = self.jid
-        elif reply_to_author:
-            reply_to_jid = reply_to_author.jid
-        else:
-            reply_to_jid = None
-        super().send_text(
-            body=body,
-            legacy_msg_id=legacy_msg_id,
-            when=when,
-            reply_to_msg_id=reply_to_msg_id,
-            reply_to_fallback_text=reply_to_fallback_text,
-            reply_to_jid=reply_to_jid,
-            hints={"markable"},
-            **kwargs,
-        )

slidge/core/muc/room.py

@@ -1,348 +0,0 @@
-import logging
-from copy import copy
-from datetime import datetime
-from enum import Enum
-from typing import TYPE_CHECKING, AsyncIterable, Generic, Optional
-
-from slixmpp import JID, Iq, Message, Presence
-from slixmpp.stanza import Error as BaseError
-from slixmpp.xmlstream import ET
-
-from ...util import ABCSubclassableOnceAtMost
-from ...util.types import (
-    LegacyGroupIdType,
-    LegacyMessageType,
-    LegacyParticipantType,
-    SessionType,
-)
-from ..mixins.base import ReactionRecipientMixin
-from ..mixins.disco import BaseDiscoMixin
-
-if TYPE_CHECKING:
-    from ..contact import LegacyContact
-    from ..gateway import BaseGateway
-
-
-class Error(BaseError):
-    namespace = "jabber:component:accept"
-
-
-class MucType(int, Enum):
-    GROUP = 0
-    CHANNEL = 1
-
-
-ADMIN_NS = "http://jabber.org/protocol/muc#admin"
-
-
-class LegacyMUC(
-    Generic[SessionType, LegacyGroupIdType, LegacyParticipantType, LegacyMessageType],
-    BaseDiscoMixin,
-    ReactionRecipientMixin,
-    metaclass=ABCSubclassableOnceAtMost,
-):
-    user_nick = "SlidgeUser"
-    subject_date: Optional[datetime] = None
-    n_participants: Optional[int] = None
-    max_history_fetch = 100
-    description = ""
-
-    type = MucType.CHANNEL
-    is_group = True
-
-    DISCO_TYPE = "text"
-    DISCO_CATEGORY = "conference"
-    DISCO_NAME = "unnamed-room"
-
-    def __init__(self, session: SessionType, legacy_id: LegacyGroupIdType, jid: JID):
-        from .participant import LegacyParticipant
-
-        self.session = session
-        self.xmpp: "BaseGateway" = session.xmpp
-        self.user = session.user
-        self.log = session.log
-
-        self.legacy_id = legacy_id
-        self.jid = jid
-
-        self.user_resources = set[str]()
-
-        self.Participant = LegacyParticipant.get_self_or_unique_subclass()
-
-        self.DISCO_NAME = str(legacy_id)
-
-        self.xmpp.add_event_handler(
-            "presence_unavailable", self._on_presence_unavailable
-        )
-
-        self._subject = ""
-        self.subject_setter = "unknown"
-
-    def __repr__(self):
-        return f"<MUC '{self.legacy_id}' - {self.jid}>"
-
-    def _on_presence_unavailable(self, p: Presence):
-        pto = p.get_to()
-        if pto.bare != self.jid.bare:
-            return
-
-        pfrom = p.get_from()
-        if pfrom.bare != self.user.bare_jid:
-            return
-        if (resource := pfrom.resource) in (resources := self.user_resources):
-            if pto.resource != self.user_nick:
-                self.log.warning(
-                    "Received 'leave group' request but with wrong nickname. %s", p
-                )
-            resources.remove(resource)
-        else:
-            self.log.warning(
-                "Received 'leave group' request but resource was not listed. %s", p
-            )
-
-    @property
-    def subject(self):
-        return self._subject
-
-    @subject.setter
-    def subject(self, s: str):
-        if s != self._subject:
-            self.update_subject(s)
-        self._subject = s
-
-    def update_subject(self, subject: Optional[str] = None):
-        self._subject = subject or ""
-        for r in self.user_resources:
-            to = copy(self.user.jid)
-            to.resource = r
-            self._make_subject_message(to).send()
-
-    def features(self):
-        features = [
-            "http://jabber.org/protocol/muc",
-            "http://jabber.org/protocol/muc#stable_id",
-            "http://jabber.org/protocol/muc#self-ping-optimization",
-            "urn:xmpp:sid:0",
-            "muc_persistent",
-        ]
-        if self.type == MucType.GROUP:
-            features.extend(["muc_membersonly", "muc_nonanonymous", "muc_hidden"])
-        elif self.type == MucType.CHANNEL:
-            features.extend(["muc_open", "muc_semianonymous", "muc_public"])
-        return features
-
-    def extended_features(self):
-        is_group = self.type == MucType.GROUP
-
-        form = self.xmpp.plugin["xep_0004"].make_form(ftype="result")
-
-        form.add_field(
-            "FORM_TYPE", "hidden", value="http://jabber.org/protocol/muc#roominfo"
-        )
-        form.add_field("muc#roomconfig_persistentroom", "boolean", value=True)
-        form.add_field("muc#roomconfig_changesubject", "boolean", value=False)
-        form.add_field("muc#maxhistoryfetch", value=str(self.max_history_fetch))
-        form.add_field("muc#roominfo_subjectmod", "boolean", value=False)
-
-        if (n := self.n_participants) is not None:
-            form.add_field("muc#roominfo_occupants", value=str(n))
-
-        if d := self.description:
-            form.add_field("muc#roominfo_description", value=d)
-
-        if s := self.subject:
-            form.add_field("muc#roominfo_subject", value=s)
-
-        form.add_field("muc#roomconfig_membersonly", "boolean", value=is_group)
-        form.add_field("muc#roomconfig_whois", "boolean", value=is_group)
-        form.add_field("muc#roomconfig_publicroom", "boolean", value=not is_group)
-        form.add_field("muc#roomconfig_allowpm", "boolean", value=False)
-
-        return form
-
-    def _no_nickname_error(self, join_presence: Presence):
-        presence = self.xmpp.make_presence(
-            ptype="error", pto=join_presence.get_from(), pfrom=self.jid
-        )
-        # Error.namespace
-        presence["id"] = join_presence["id"]
-        error = Error()
-        error["by"] = self.jid
-        error["condition"] = "jid-malformed"
-        error["type"] = "modify"
-        presence.append(error)
-        presence.send()
-
-    def _make_subject_message(self, user_full_jid: JID):
-        subject_setter = copy(self.jid)
-        log.debug("subject setter: %s", self.subject_setter)
-        subject_setter.resource = self.subject_setter
-        msg = self.xmpp.make_message(
-            mto=user_full_jid,
-            mfrom=subject_setter,
-            mtype="groupchat",
-        )
-        msg["delay"].set_stamp(self.subject_date or datetime.now().astimezone())
-        msg["subject"] = self.subject or str(self.DISCO_NAME)
-        return msg
-
-    def shutdown(self):
-        user_jid = copy(self.jid)
-        user_jid.resource = self.user_nick
-        for user_full_jid in self.user_full_jids():
-            presence = self.xmpp.make_presence(
-                pfrom=user_jid, pto=user_full_jid, ptype="unavailable"
-            )
-            presence["muc"]["affiliation"] = "none"
-            presence["muc"]["role"] = "none"
-            presence["muc"]["status_codes"] = {110, 332}
-            presence.send()
-
-    def handle_ping(self, iq: Iq):
-        if iq.get_from().resource in self.user_resources:
-            iq.reply().send()
-        else:
-            reply = iq.reply()
-            reply["type"] = "error"
-            error = Error()
-            error["by"] = self.jid
-            error["condition"] = "not-acceptable"
-            error["type"] = "cancel"
-            reply.append(error)
-            reply.send()
-
-    def user_full_jids(self):
-        for r in self.user_resources:
-            j = copy(self.user.jid)
-            j.resource = r
-            yield j
-
-    @property
-    def user_muc_jid(self):
-        user_muc_jid = copy(self.jid)
-        user_muc_jid.resource = self.user_nick
-        return user_muc_jid
-
-    def _legacy_to_xmpp(self, legacy_id: LegacyMessageType):
-        return self.session.sent.get(
-            legacy_id
-        ) or self.session.legacy_msg_id_to_xmpp_msg_id(legacy_id)
-
-    async def echo(self, m: Message, legacy_msg_id: Optional[LegacyMessageType] = None):
-        self.log.debug("Echoing %s -- %s", m, legacy_msg_id)
-
-        origin_id = m.get_origin_id()
-        self.log.debug(f"Origin: %r ", origin_id)
-
-        m.set_from(self.user_muc_jid)
-        for user_full_jid in self.user_full_jids():
-            self.log.debug("Echoing to %s", user_full_jid)
-            msg = copy(m)
-            msg.set_to(user_full_jid)
-            msg.set_id(m.get_id())
-
-            if origin_id:
-                set_origin_id(msg, origin_id)
-            if legacy_msg_id:
-                msg["stanza_id"]["id"] = str(legacy_msg_id)
-                msg["stanza_id"]["by"] = self.jid
-            msg.send()
-
-    async def join(self, join_presence: Presence):
-        user_full_jid = join_presence.get_from()
-        requested_nickname = join_presence.get_to().resource
-
-        if not requested_nickname:
-            self._no_nickname_error(join_presence)
-            return
-
-        client_resource = user_full_jid.resource
-        if not client_resource:
-            self._no_nickname_error(join_presence)
-            return
-
-        self.log.debug(
-            "Resource %s of %s wants to join room %s with nickname %s",
-            client_resource,
-            self.user,
-            self.legacy_id,
-            requested_nickname,
-        )
-
-        async for participant in self.get_participants():
-            participant.send_initial_presence(full_jid=user_full_jid)
-        user_nick = self.user_nick
-        user_participant = await self.get_user_participant()
-        user_participant.send_initial_presence(
-            user_full_jid,
-            presence_id=join_presence["id"],
-            nick_change=user_nick != requested_nickname,
-        )
-
-        history_params = join_presence["muc_join"]["history"]
-        maxchars = int_or_none(history_params["maxchars"])
-        maxstanzas = int_or_none(history_params["maxstanzas"])
-        seconds = int_or_none(history_params["seconds"])
-        since = int_or_none(history_params["since"])
-        if equals_zero(maxchars) or equals_zero(maxstanzas):
-            log.debug("Joining client does not want any MUC history")
-        else:
-            log.debug("Filling history %s")
-            await self.fill_history(
-                user_full_jid,
-                maxchars=maxchars,
-                maxstanzas=maxstanzas,
-                seconds=seconds,
-                since=since,
-            )
-        self._make_subject_message(user_full_jid).send()
-        self.user_resources.add(client_resource)
-
-    async def get_user_participant(self) -> LegacyParticipantType:
-        return self.Participant(self, self.user_nick, is_user=True)
-
-    async def get_participant(self, nickname: str) -> LegacyParticipantType:
-        return self.Participant(self, nickname)
-
-    async def get_participant_by_contact(
-        self, c: "LegacyContact"
-    ) -> LegacyParticipantType:
-        p = self.Participant(self, c.name)
-        p.contact = c
-        return p
-
-    async def get_participants(self) -> AsyncIterable[LegacyParticipantType]:
-        yield NotImplemented
-
-    async def fill_history(
-        self,
-        full_jid: JID,
-        maxchars: Optional[int] = None,
-        maxstanzas: Optional[int] = None,
-        seconds: Optional[int] = None,
-        since: Optional[int] = None,
-    ):
-        raise NotImplementedError
-
-
-def set_origin_id(msg: Message, origin_id: str):
-    sub = ET.Element("{urn:xmpp:sid:0}origin-id")
-    sub.attrib["id"] = origin_id
-    msg.xml.append(sub)
-
-
-def int_or_none(x):
-    try:
-        return int(x)
-    except ValueError:
-        return None
-
-
-def equals_zero(x):
-    if x is None:
-        return False
-    else:
-        return x == 0
-
-
-log = logging.getLogger(__name__)

slidge/plugins/discord/__init__.py

@@ -1,121 +0,0 @@
-import functools
-import logging
-from typing import Optional
-
-import discord as di
-from slixmpp import JID
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-from ...util import BiDict
-from .session import Session
-
-
-class Config:
-    DISCORD_VERBOSE = False
-    DISCORD_VERBOSE__DOC = (
-        "Let the discord lib at the same loglevel as others loggers. "
-        "By default, it's set it to WARNING because it's *really* verbose."
-    )
-
-
-class Gateway(BaseGateway[Session]):
-    COMPONENT_NAME = "Discord (slidge)"
-    COMPONENT_TYPE = "discord"
-    COMPONENT_AVATAR = "https://www.usff.fr/wp-content/uploads/2018/05/Discord_logo.png"
-
-    REGISTRATION_INSTRUCTIONS = (
-        "Have a look at https://discordpy-self.readthedocs.io/en/latest/token.html"
-    )
-    REGISTRATION_FIELDS = [FormField("token", label="Discord token", required=True)]
-
-    ROSTER_GROUP = "Discord"
-
-    def __init__(self):
-        super().__init__()
-        if not Config.DISCORD_VERBOSE:
-            log.debug("Disabling discord info logs")
-            logging.getLogger("discord.gateway").setLevel(logging.WARNING)
-            logging.getLogger("discord.client").setLevel(logging.WARNING)
-
-    async def validate(
-        self, user_jid: JID, registration_form: dict[str, Optional[str]]
-    ):
-        try:
-            await di.Client().login(registration_form.get("token"))
-        except di.LoginFailure as e:
-            raise ValueError(str(e))
-
-
-class Contact(LegacyContact[Session, "str"]):
-    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["Session", Contact, int]):
-    def __init__(self, *a, **k):
-        super().__init__(*a, **k)
-
-    async def by_discord_user(self, u: di.User):
-        return await self.by_legacy_id(u.id)
-
-    async def jid_username_to_legacy_id(self, username: str):
-        try:
-            user_id = int(username)
-        except ValueError:
-            raise XMPPError(
-                "bad-request",
-                text=f"Not a valid discord ID: {username}",
-            )
-        else:
-            if self.session.discord.get_user(user_id) is None:
-                raise XMPPError(
-                    "item-not-found",
-                    text=f"No discord user was found with ID: {username}",
-                )
-            return user_id
-
-    async def legacy_id_to_jid_username(self, discord_user_id: int) -> str:
-        return str(discord_user_id)
-
-
-log = logging.getLogger(__name__)