PyPI - slidge - Versions diffs - 0.2.0a9__py3-none-any.whl → 0.2.0b0__py3-none-any.whl - Mend

slidge 0.2.0a9py3-none-any.whl → 0.2.0b0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (56) hide show

slidge/__main__.py +2 -3
slidge/__version__.py +1 -1
slidge/command/adhoc.py +1 -1
slidge/command/base.py +4 -4
slidge/command/user.py +5 -1
slidge/contact/roster.py +9 -0
slidge/core/config.py +0 -3
slidge/core/dispatcher/__init__.py +3 -0
slidge/core/{gateway → dispatcher}/caps.py +6 -4
slidge/core/{gateway → dispatcher}/disco.py +11 -17
slidge/core/dispatcher/message/__init__.py +10 -0
slidge/core/dispatcher/message/chat_state.py +40 -0
slidge/core/dispatcher/message/marker.py +62 -0
slidge/core/dispatcher/message/message.py +397 -0
slidge/core/dispatcher/muc/__init__.py +12 -0
slidge/core/dispatcher/muc/admin.py +98 -0
slidge/core/{gateway → dispatcher/muc}/mam.py +26 -15
slidge/core/dispatcher/muc/misc.py +121 -0
slidge/core/dispatcher/muc/owner.py +96 -0
slidge/core/{gateway → dispatcher/muc}/ping.py +10 -15
slidge/core/dispatcher/presence.py +177 -0
slidge/core/{gateway → dispatcher}/registration.py +23 -2
slidge/core/{gateway → dispatcher}/search.py +9 -14
slidge/core/dispatcher/session_dispatcher.py +84 -0
slidge/core/dispatcher/util.py +174 -0
slidge/core/{gateway/vcard_temp.py → dispatcher/vcard.py} +26 -12
slidge/core/{gateway/base.py → gateway.py} +42 -137
slidge/core/mixins/attachment.py +24 -8
slidge/core/mixins/base.py +2 -2
slidge/core/mixins/lock.py +10 -8
slidge/core/mixins/message.py +9 -203
slidge/core/mixins/message_text.py +211 -0
slidge/core/pubsub.py +2 -1
slidge/core/session.py +28 -2
slidge/db/alembic/versions/15b0bd83407a_remove_bogus_unique_constraints_on_room_.py +83 -0
slidge/db/alembic/versions/45c24cc73c91_add_bob.py +42 -0
slidge/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py +12 -1
slidge/db/models.py +16 -1
slidge/db/store.py +144 -11
slidge/group/bookmarks.py +23 -1
slidge/group/participant.py +5 -5
slidge/group/room.py +10 -1
slidge/{core/gateway → slixfix}/delivery_receipt.py +1 -1
slidge/util/test.py +9 -5
slidge/util/types.py +6 -0
slidge/util/util.py +5 -2
{slidge-0.2.0a9.dist-info → slidge-0.2.0b0.dist-info}/METADATA +2 -1
{slidge-0.2.0a9.dist-info → slidge-0.2.0b0.dist-info}/RECORD +51 -40
slidge-0.2.0b0.dist-info/entry_points.txt +3 -0
slidge/core/gateway/__init__.py +0 -3
slidge/core/gateway/muc_admin.py +0 -35
slidge/core/gateway/presence.py +0 -95
slidge/core/gateway/session_dispatcher.py +0 -895
slidge-0.2.0a9.dist-info/entry_points.txt +0 -3
{slidge-0.2.0a9.dist-info → slidge-0.2.0b0.dist-info}/LICENSE +0 -0
{slidge-0.2.0a9.dist-info → slidge-0.2.0b0.dist-info}/WHEEL +0 -0

slidge/core/dispatcher/message/message.py ADDED Viewed

@@ -0,0 +1,397 @@
+import logging
+from copy import copy
+from xml.etree import ElementTree
+from slixmpp import JID, Message
+from slixmpp.exceptions import XMPPError
+from ....contact.contact import LegacyContact
+from ....group.participant import LegacyParticipant
+from ....group.room import LegacyMUC
+from ....util.types import LinkPreview, Recipient
+from ....util.util import dict_to_named_tuple, remove_emoji_variation_selector_16
+from ... import config
+from ...session import BaseSession
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
+class MessageContentMixin(DispatcherMixin):
+    def __init__(self, xmpp):
+        super().__init__(xmpp)
+        xmpp.add_event_handler("legacy_message", self.on_legacy_message)
+        xmpp.add_event_handler("message_correction", self.on_message_correction)
+        xmpp.add_event_handler("message_retract", self.on_message_retract)
+        xmpp.add_event_handler("groupchat_message", self.on_groupchat_message)
+        xmpp.add_event_handler("reactions", self.on_reactions)
+    async def on_groupchat_message(self, msg: Message) -> None:
+        await self.on_legacy_message(msg)
+    @exceptions_to_xmpp_errors
+    async def on_legacy_message(self, msg: Message):
+        """
+        Meant to be called from :class:`BaseGateway` only.
+        :param msg:
+        :return:
+        """
+        # we MUST not use `if m["replace"]["id"]` because it adds the tag if not
+        # present. this is a problem for MUC echoed messages
+        if msg.get_plugin("replace", check=True) is not None:
+            # ignore last message correction (handled by a specific method)
+            return
+        if msg.get_plugin("apply_to", check=True) is not None:
+            # ignore message retraction (handled by a specific method)
+            return
+        if msg.get_plugin("reactions", check=True) is not None:
+            # ignore message reaction fallback.
+            # the reaction itself is handled by self.react_from_msg().
+            return
+        if msg.get_plugin("retract", check=True) is not None:
+            # ignore message retraction fallback.
+            # the retraction itself is handled by self.on_retract
+            return
+        cid = None
+        if msg.get_plugin("html", check=True) is not None:
+            body = ElementTree.fromstring("<body>" + msg["html"].get_body() + "</body>")
+            p = body.findall("p")
+            if p is not None and len(p) == 1:
+                if p[0].text is None or not p[0].text.strip():
+                    images = p[0].findall("img")
+                    if len(images) == 1:
+                        # no text, single img ⇒ this is a sticker
+                        # other cases should be interpreted as "custom emojis" in text
+                        src = images[0].get("src")
+                        if src is not None and src.startswith("cid:"):
+                            cid = src.removeprefix("cid:")
+        session, entity, thread = await self._get_session_entity_thread(msg)
+        if msg.get_plugin("oob", check=True) is not None:
+            url = msg["oob"]["url"]
+        else:
+            url = None
+        if msg.get_plugin("reply", check=True):
+            text, reply_to_msg_id, reply_to, reply_fallback = await self.__get_reply(
+                msg, session, entity
+            )
+        else:
+            text = msg["body"]
+            reply_to_msg_id = None
+            reply_to = None
+            reply_fallback = None
+        if msg.get_plugin("link_previews", check=True):
+            link_previews = [
+                dict_to_named_tuple(p, LinkPreview) for p in msg["link_previews"]
+            ]
+        else:
+            link_previews = []
+        if url:
+            legacy_msg_id = await self.__send_url(
+                url,
+                session,
+                entity,
+                reply_to_msg_id=reply_to_msg_id,
+                reply_to_fallback_text=reply_fallback,
+                reply_to=reply_to,
+                thread=thread,
+            )
+        elif cid:
+            legacy_msg_id = await self.__send_bob(
+                msg.get_from(),
+                cid,
+                session,
+                entity,
+                reply_to_msg_id=reply_to_msg_id,
+                reply_to_fallback_text=reply_fallback,
+                reply_to=reply_to,
+                thread=thread,
+            )
+        elif text:
+            if isinstance(entity, LegacyMUC):
+                mentions = {"mentions": await entity.parse_mentions(text)}
+            else:
+                mentions = {}
+            legacy_msg_id = await session.on_text(
+                entity,
+                text,
+                reply_to_msg_id=reply_to_msg_id,
+                reply_to_fallback_text=reply_fallback,
+                reply_to=reply_to,
+                thread=thread,
+                link_previews=link_previews,
+                **mentions,
+            )
+        else:
+            log.debug("Ignoring %s", msg.get_id())
+            return
+        if isinstance(entity, LegacyMUC):
+            await entity.echo(msg, legacy_msg_id)
+            if legacy_msg_id is not None:
+                self.xmpp.store.sent.set_group_message(
+                    session.user_pk, str(legacy_msg_id), msg.get_id()
+                )
+        else:
+            self.__ack(msg)
+            if legacy_msg_id is not None:
+                self.xmpp.store.sent.set_message(
+                    session.user_pk, str(legacy_msg_id), msg.get_id()
+                )
+                if session.MESSAGE_IDS_ARE_THREAD_IDS and (t := msg["thread"]):
+                    self.xmpp.store.sent.set_thread(
+                        session.user_pk, t, str(legacy_msg_id)
+                    )
+    @exceptions_to_xmpp_errors
+    async def on_message_correction(self, msg: Message):
+        if msg.get_plugin("retract", check=True) is not None:
+            # ignore message retraction fallback (fallback=last msg correction)
+            return
+        session, entity, thread = await self._get_session_entity_thread(msg)
+        xmpp_id = msg["replace"]["id"]
+        if isinstance(entity, LegacyMUC):
+            legacy_id_str = self.xmpp.store.sent.get_group_legacy_id(
+                session.user_pk, xmpp_id
+            )
+            if legacy_id_str is None:
+                legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
+            else:
+                legacy_id = self.xmpp.LEGACY_MSG_ID_TYPE(legacy_id_str)
+        else:
+            legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
+        if isinstance(entity, LegacyMUC):
+            mentions = await entity.parse_mentions(msg["body"])
+        else:
+            mentions = None
+        if previews := msg["link_previews"]:
+            link_previews = [dict_to_named_tuple(p, LinkPreview) for p in previews]
+        else:
+            link_previews = []
+        if legacy_id is None:
+            log.debug("Did not find legacy ID to correct")
+            new_legacy_msg_id = await session.on_text(
+                entity,
+                "Correction:" + msg["body"],
+                thread=thread,
+                mentions=mentions,
+                link_previews=link_previews,
+            )
+        elif (
+            not msg["body"].strip()
+            and config.CORRECTION_EMPTY_BODY_AS_RETRACTION
+            and entity.RETRACTION
+        ):
+            await session.on_retract(entity, legacy_id, thread=thread)
+            new_legacy_msg_id = None
+        elif entity.CORRECTION:
+            new_legacy_msg_id = await session.on_correct(
+                entity,
+                msg["body"],
+                legacy_id,
+                thread=thread,
+                mentions=mentions,
+                link_previews=link_previews,
+            )
+        else:
+            session.send_gateway_message(
+                "Last message correction is not supported by this legacy service. "
+                "Slidge will send your correction as new message."
+            )
+            if (
+                config.LAST_MESSAGE_CORRECTION_RETRACTION_WORKAROUND
+                and entity.RETRACTION
+                and legacy_id is not None
+            ):
+                if legacy_id is not None:
+                    session.send_gateway_message(
+                        "Slidge will attempt to retract the original message you wanted"
+                        " to edit."
+                    )
+                    await session.on_retract(entity, legacy_id, thread=thread)
+            new_legacy_msg_id = await session.on_text(
+                entity,
+                "Correction: " + msg["body"],
+                thread=thread,
+                mentions=mentions,
+                link_previews=link_previews,
+            )
+        if isinstance(entity, LegacyMUC):
+            if new_legacy_msg_id is not None:
+                self.xmpp.store.sent.set_group_message(
+                    session.user_pk, new_legacy_msg_id, msg.get_id()
+                )
+            await entity.echo(msg, new_legacy_msg_id)
+        else:
+            self.__ack(msg)
+            if new_legacy_msg_id is not None:
+                self.xmpp.store.sent.set_message(
+                    session.user_pk, new_legacy_msg_id, msg.get_id()
+                )
+    @exceptions_to_xmpp_errors
+    async def on_message_retract(self, msg: Message):
+        session, entity, thread = await self._get_session_entity_thread(msg)
+        if not entity.RETRACTION:
+            raise XMPPError(
+                "bad-request",
+                "This legacy service does not support message retraction.",
+            )
+        xmpp_id: str = msg["retract"]["id"]
+        legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
+        if legacy_id:
+            await session.on_retract(entity, legacy_id, thread=thread)
+            if isinstance(entity, LegacyMUC):
+                await entity.echo(msg, None)
+        else:
+            log.debug("Ignored retraction from user")
+        self.__ack(msg)
+    @exceptions_to_xmpp_errors
+    async def on_reactions(self, msg: Message):
+        session, entity, thread = await self._get_session_entity_thread(msg)
+        react_to: str = msg["reactions"]["id"]
+        special_msg = session.SPECIAL_MSG_ID_PREFIX and react_to.startswith(
+            session.SPECIAL_MSG_ID_PREFIX
+        )
+        if special_msg:
+            legacy_id = react_to
+        else:
+            legacy_id = self._xmpp_msg_id_to_legacy(session, react_to)
+        if not legacy_id:
+            log.debug("Ignored reaction from user")
+            raise XMPPError(
+                "internal-server-error",
+                "Could not convert the XMPP msg ID to a legacy ID",
+            )
+        emojis = [
+            remove_emoji_variation_selector_16(r["value"]) for r in msg["reactions"]
+        ]
+        error_msg = None
+        entity = entity
+        if not special_msg:
+            if entity.REACTIONS_SINGLE_EMOJI and len(emojis) > 1:
+                error_msg = "Maximum 1 emoji/message"
+            if not error_msg and (subset := await entity.available_emojis(legacy_id)):
+                if not set(emojis).issubset(subset):
+                    error_msg = f"You can only react with the following emojis: {''.join(subset)}"
+        if error_msg:
+            session.send_gateway_message(error_msg)
+            if not isinstance(entity, LegacyMUC):
+                # no need to carbon for groups, we just don't echo the stanza
+                entity.react(legacy_id, carbon=True)  # type: ignore
+            await session.on_react(entity, legacy_id, [], thread=thread)
+            raise XMPPError("not-acceptable", text=error_msg)
+        await session.on_react(entity, legacy_id, emojis, thread=thread)
+        if isinstance(entity, LegacyMUC):
+            await entity.echo(msg, None)
+        else:
+            self.__ack(msg)
+        multi = self.xmpp.store.multi.get_xmpp_ids(session.user_pk, react_to)
+        if not multi:
+            return
+        multi = [m for m in multi if react_to != m]
+        if isinstance(entity, LegacyMUC):
+            for xmpp_id in multi:
+                mc = copy(msg)
+                mc["reactions"]["id"] = xmpp_id
+                await entity.echo(mc)
+        elif isinstance(entity, LegacyContact):
+            for xmpp_id in multi:
+                entity.react(legacy_id, emojis, xmpp_id=xmpp_id, carbon=True)
+    def __ack(self, msg: Message):
+        if not self.xmpp.PROPER_RECEIPTS:
+            self.xmpp.delivery_receipt.ack(msg)
+    async def __get_reply(
+        self, msg: Message, session: BaseSession, entity: Recipient
+    ) -> tuple[
+        str, str | int | None, LegacyContact | LegacyParticipant | None, str | None
+    ]:
+        try:
+            reply_to_msg_id = self._xmpp_msg_id_to_legacy(session, msg["reply"]["id"])
+        except XMPPError:
+            session.log.debug(
+                "Could not determine reply-to legacy msg ID, sending quote instead."
+            )
+            return msg["body"], None, None, None
+        reply_to_jid = JID(msg["reply"]["to"])
+        reply_to = None
+        if msg["type"] == "chat":
+            if reply_to_jid.bare != session.user_jid.bare:
+                try:
+                    reply_to = await session.contacts.by_jid(reply_to_jid)
+                except XMPPError:
+                    pass
+        elif msg["type"] == "groupchat":
+            nick = reply_to_jid.resource
+            try:
+                muc = await session.bookmarks.by_jid(reply_to_jid)
+            except XMPPError:
+                pass
+            else:
+                if nick != muc.user_nick:
+                    reply_to = await muc.get_participant(
+                        reply_to_jid.resource, store=False
+                    )
+        if msg.get_plugin("fallback", check=True) and (
+            isinstance(entity, LegacyMUC) or entity.REPLIES
+        ):
+            text = msg["fallback"].get_stripped_body(self.xmpp["xep_0461"].namespace)
+            try:
+                reply_fallback = msg["reply"].get_fallback_body()
+            except AttributeError:
+                reply_fallback = None
+        else:
+            text = msg["body"]
+            reply_fallback = None
+        return text, reply_to_msg_id, reply_to, reply_fallback
+    async def __send_url(
+        self, url: str, session: BaseSession, entity: Recipient, **kwargs
+    ) -> int | str | None:
+        async with self.xmpp.http.get(url) as response:
+            if response.status >= 400:
+                session.log.warning(
+                    "OOB url cannot be downloaded: %s, sending the URL as text"
+                    " instead.",
+                    response,
+                )
+                return await session.on_text(entity, url, **kwargs)
+            return await session.on_file(entity, url, http_response=response, **kwargs)
+    async def __send_bob(
+        self, from_: JID, cid: str, session: BaseSession, entity: Recipient, **kwargs
+    ) -> int | str | None:
+        sticker = self.xmpp.store.bob.get_sticker(cid)
+        if sticker is None:
+            await self.xmpp.plugin["xep_0231"].get_bob(from_, cid)
+            sticker = self.xmpp.store.bob.get_sticker(cid)
+        assert sticker is not None
+        return await session.on_sticker(entity, sticker, **kwargs)
+log = logging.getLogger(__name__)

slidge/core/dispatcher/muc/__init__.py ADDED Viewed

@@ -0,0 +1,12 @@
+from .admin import MucAdminMixin
+from .mam import MamMixin
+from .misc import MucMiscMixin
+from .owner import MucOwnerMixin
+from .ping import PingMixin
+class MucMixin(PingMixin, MamMixin, MucAdminMixin, MucOwnerMixin, MucMiscMixin):
+    pass
+__all__ = ("MucMixin",)

slidge/core/dispatcher/muc/admin.py ADDED Viewed

@@ -0,0 +1,98 @@
+from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
+from slixmpp.exceptions import XMPPError
+from slixmpp.xmlstream import StanzaBase
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
+class MucAdminMixin(DispatcherMixin):
+    def __init__(self, xmpp) -> None:
+        super().__init__(xmpp)
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "MUCModerate",
+                StanzaPath("iq/apply_to/moderate"),
+                self.on_user_moderation,
+            )
+        )
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "MUCSetAffiliation",
+                StanzaPath("iq@type=set/mucadmin_query"),
+                self.on_user_set_affiliation,
+            )
+        )
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "MUCGetAffiliation",
+                StanzaPath("iq@type=get/mucadmin_query"),
+                self.on_muc_admin_query_get,
+            )
+        )
+    @exceptions_to_xmpp_errors
+    async def on_user_moderation(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        muc = await self.get_muc_from_stanza(iq)
+        apply_to = iq["apply_to"]
+        xmpp_id = apply_to["id"]
+        if not xmpp_id:
+            raise XMPPError("bad-request", "Missing moderated message ID")
+        moderate = apply_to["moderate"]
+        if not moderate["retract"]:
+            raise XMPPError(
+                "feature-not-implemented",
+                "Slidge only implements moderation/retraction",
+            )
+        legacy_id = self._xmpp_msg_id_to_legacy(muc.session, xmpp_id)
+        await muc.session.on_moderate(muc, legacy_id, moderate["reason"] or None)
+        iq.reply(clear=True).send()
+    @exceptions_to_xmpp_errors
+    async def on_user_set_affiliation(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        muc = await self.get_muc_from_stanza(iq)
+        item = iq["mucadmin_query"]["item"]
+        if item["jid"]:
+            contact = await muc.session.contacts.by_jid(JID(item["jid"]))
+        else:
+            part = await muc.get_participant(
+                item["nick"], fill_first=True, raise_if_not_found=True
+            )
+            assert part.contact is not None
+            contact = part.contact
+        if item["affiliation"]:
+            await muc.on_set_affiliation(
+                contact,
+                item["affiliation"],
+                item["reason"] or None,
+                item["nick"] or None,
+            )
+        elif item["role"] == "none":
+            await muc.on_kick(contact, item["reason"] or None)
+        iq.reply(clear=True).send()
+    @exceptions_to_xmpp_errors
+    async def on_muc_admin_query_get(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        affiliation = iq["mucadmin_query"]["item"]["affiliation"]
+        if not affiliation:
+            raise XMPPError("bad-request")
+        session = await self._get_session(iq, 1, logged=True)
+        muc = await session.bookmarks.by_jid(iq.get_to())
+        reply = iq.reply()
+        reply.enable("mucadmin_query")
+        async for participant in muc.get_participants():
+            if not participant.affiliation == affiliation:
+                continue
+            reply["mucadmin_query"].append(participant.mucadmin_item())
+        reply.send()

slidge/core/{gateway → dispatcher/muc}/mam.py RENAMED Viewed

@@ -1,42 +1,57 @@
+import asyncio
 from typing import TYPE_CHECKING
 from slixmpp import CoroutineCallback, Iq, StanzaPath
 from slixmpp.exceptions import XMPPError
+from slixmpp.xmlstream import StanzaBase
+from ... import config
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
-class Mam:
+class MamMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
+        super().__init__(xmpp)
+        self.__mam_cleanup_task = xmpp.loop.create_task(self.__mam_cleanup())
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_query",
                 StanzaPath("iq@type=set/mam"),
-                self.__handle_mam,  # type:ignore
+                self.__handle_mam,
             )
         )
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_get_from",
                 StanzaPath("iq@type=get/mam"),
-                self.__handle_mam_get_form,  # type:ignore
+                self.__handle_mam_get_form,
             )
         )
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_get_meta",
                 StanzaPath("iq@type=get/mam_metadata"),
-                self.__handle_mam_metadata,  # type:ignore
+                self.__handle_mam_metadata,
             )
         )
+    async def __mam_cleanup(self):
+        if not config.MAM_MAX_DAYS:
+            return
+        while True:
+            await asyncio.sleep(3600 * 6)
+            self.xmpp.store.mam.nuke_older_than(config.MAM_MAX_DAYS)
+    @exceptions_to_xmpp_errors
     async def __handle_mam(self, iq: Iq):
-        muc = await self.xmpp.get_muc_from_stanza(iq)
+        muc = await self.get_muc_from_stanza(iq)
         await muc.send_mam(iq)
-    async def __handle_mam_get_form(self, iq: Iq):
+    async def __handle_mam_get_form(self, iq: StanzaBase):
+        assert isinstance(iq, Iq)
         ito = iq.get_to()
         if ito == self.xmpp.boundjid.bare:
@@ -44,12 +59,7 @@ class Mam:
                 text="No MAM on the component itself, use a JID with a resource"
             )
-        user = self.xmpp.store.users.get(iq.get_from())
-        if user is None:
-            raise XMPPError("registration-required")
-        session = self.xmpp.get_session_from_user(user)
+        session = await self._get_session(iq, 0, logged=True)
         await session.bookmarks.by_jid(ito)
         reply = iq.reply()
@@ -67,6 +77,7 @@ class Mam:
         reply["mam"].append(form)
         reply.send()
+    @exceptions_to_xmpp_errors
     async def __handle_mam_metadata(self, iq: Iq):
-        muc = await self.xmpp.get_muc_from_stanza(iq)
+        muc = await self.get_muc_from_stanza(iq)
         await muc.send_mam_metadata(iq)

slidge 0.2.0a9__py3-none-any.whl → 0.2.0b0__py3-none-any.whl

slidge 0.2.0a9py3-none-any.whl → 0.2.0b0py3-none-any.whl