slidge 0.2.12__py3-none-any.whl → 0.3.0a0__py3-none-any.whl

slidge/core/dispatcher/message/message.py

@@ -16,7 +16,9 @@ from ..util import DispatcherMixin, exceptions_to_xmpp_errors
 
 
 class MessageContentMixin(DispatcherMixin):
-    def __init__(self, xmpp):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp) -> None:
         super().__init__(xmpp)
         xmpp.add_event_handler("legacy_message", self.on_legacy_message)
         xmpp.add_event_handler("message_correction", self.on_message_correction)
@@ -28,7 +30,7 @@ class MessageContentMixin(DispatcherMixin):
         await self.on_legacy_message(msg)
 
     @exceptions_to_xmpp_errors
-    async def on_legacy_message(self, msg: Message):
+    async def on_legacy_message(self, msg: Message) -> None:
         """
         Meant to be called from :class:`BaseGateway` only.
 
@@ -65,16 +67,27 @@ class MessageContentMixin(DispatcherMixin):
                         if src is not None and src.startswith("cid:"):
                             cid = src.removeprefix("cid:")
 
-        session, entity, thread = await self._get_session_entity_thread(msg)
+        session, recipient, thread = await self._get_session_recipient_thread(msg)
 
         if msg.get_plugin("oob", check=True) is not None:
             url = msg["oob"]["url"]
+        elif (
+            "reference" in msg
+            and "sims" in msg["reference"]
+            and "sources" in msg["reference"]["sims"]
+        ):
+            for source in msg["reference"]["sims"]["sources"]["substanzas"]:
+                if source["uri"].startswith("http"):
+                    url = source["uri"]
+                    break
+            else:
+                url = None
         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
+                msg, session, recipient
             )
         else:
             text = msg["body"]
@@ -93,7 +106,7 @@ class MessageContentMixin(DispatcherMixin):
             legacy_msg_id = await self.__send_url(
                 url,
                 session,
-                entity,
+                recipient,
                 reply_to_msg_id=reply_to_msg_id,
                 reply_to_fallback_text=reply_fallback,
                 reply_to=reply_to,
@@ -104,19 +117,19 @@ class MessageContentMixin(DispatcherMixin):
                 msg.get_from(),
                 cid,
                 session,
-                entity,
+                recipient,
                 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)}
+            if isinstance(recipient, LegacyMUC):
+                mentions = {"mentions": await recipient.parse_mentions(text)}
             else:
                 mentions = {}
             legacy_msg_id = await session.on_text(
-                entity,
+                recipient,
                 text,
                 reply_to_msg_id=reply_to_msg_id,
                 reply_to_fallback_text=reply_fallback,
@@ -129,43 +142,49 @@ class MessageContentMixin(DispatcherMixin):
             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()
-                )
+        if isinstance(recipient, LegacyMUC):
+            await recipient.echo(msg, legacy_msg_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 legacy_msg_id is None:
+            return
+
+        with self.xmpp.store.session() as orm:
+            self.xmpp.store.id_map.set_msg(
+                orm,
+                recipient.stored.id,
+                str(legacy_msg_id),
+                [msg.get_id()],
+                recipient.is_group,
+            )
+            if session.MESSAGE_IDS_ARE_THREAD_IDS and (t := msg["thread"]):
+                self.xmpp.store.id_map.set_thread(
+                    orm, recipient.stored.id, t, str(legacy_msg_id), recipient.is_group
                 )
-                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)
-                    )
+            orm.commit()
 
     @exceptions_to_xmpp_errors
-    async def on_message_correction(self, msg: Message):
+    async def on_message_correction(self, msg: Message) -> None:
         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)
+        session, recipient, thread = await self._get_session_recipient_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 isinstance(recipient, LegacyMUC):
+            with self.xmpp.store.session() as orm:
+                legacy_id_str = self.xmpp.store.id_map.get_legacy(
+                    orm, recipient.stored.id, xmpp_id, True
+                )
             if legacy_id_str is None:
-                legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
+                legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id, recipient)
             else:
                 legacy_id = self.xmpp.LEGACY_MSG_ID_TYPE(legacy_id_str)
         else:
-            legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
+            legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id, recipient)
 
-        if isinstance(entity, LegacyMUC):
-            mentions = await entity.parse_mentions(msg["body"])
+        if isinstance(recipient, LegacyMUC):
+            mentions = await recipient.parse_mentions(msg["body"])
         else:
             mentions = None
 
@@ -177,22 +196,18 @@ class MessageContentMixin(DispatcherMixin):
         if legacy_id is None:
             log.debug("Did not find legacy ID to correct")
             new_legacy_msg_id = await session.on_text(
-                entity,
+                recipient,
                 "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)
+        elif not msg["body"].strip() and recipient.RETRACTION:
+            await session.on_retract(recipient, legacy_id, thread=thread)
             new_legacy_msg_id = None
-        elif entity.CORRECTION:
+        elif recipient.CORRECTION:
             new_legacy_msg_id = await session.on_correct(
-                entity,
+                recipient,
                 msg["body"],
                 legacy_id,
                 thread=thread,
@@ -204,60 +219,59 @@ class MessageContentMixin(DispatcherMixin):
                 "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 recipient.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)
+                    await session.on_retract(recipient, legacy_id, thread=thread)
 
             new_legacy_msg_id = await session.on_text(
-                entity,
+                recipient,
                 "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)
+        if isinstance(recipient, LegacyMUC):
+            await recipient.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()
-                )
+        if new_legacy_msg_id is None:
+            return
+        with self.xmpp.store.session() as orm:
+            self.xmpp.store.id_map.set_msg(
+                orm,
+                recipient.stored.id,
+                new_legacy_msg_id,
+                msg.get_id(),
+                recipient.is_group,
+            )
+            orm.commit()
 
     @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:
+        session, recipient, thread = await self._get_session_recipient_thread(msg)
+        if not recipient.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)
+        legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id, recipient)
         if legacy_id:
-            await session.on_retract(entity, legacy_id, thread=thread)
-            if isinstance(entity, LegacyMUC):
-                await entity.echo(msg, None)
+            await session.on_retract(recipient, legacy_id, thread=thread)
+            if isinstance(recipient, LegacyMUC):
+                await recipient.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)
+        session, recipient, thread = await self._get_session_recipient_thread(msg)
         react_to: str = msg["reactions"]["id"]
 
         special_msg = session.SPECIAL_MSG_ID_PREFIX and react_to.startswith(
@@ -267,7 +281,7 @@ class MessageContentMixin(DispatcherMixin):
         if special_msg:
             legacy_id = react_to
         else:
-            legacy_id = self._xmpp_msg_id_to_legacy(session, react_to)
+            legacy_id = self._xmpp_msg_id_to_legacy(session, react_to, recipient)
 
         if not legacy_id:
             log.debug("Ignored reaction from user")
@@ -280,58 +294,65 @@ class MessageContentMixin(DispatcherMixin):
             remove_emoji_variation_selector_16(r["value"]) for r in msg["reactions"]
         ]
         error_msg = None
-        entity = entity
+        recipient = recipient
 
         if not special_msg:
-            if entity.REACTIONS_SINGLE_EMOJI and len(emojis) > 1:
+            if recipient.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 error_msg and (
+                subset := await recipient.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):
+            if not isinstance(recipient, 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)
+                recipient.react(legacy_id, carbon=True)
+            await session.on_react(recipient, legacy_id, [], thread=thread)
             raise XMPPError(
-                "policy-violation",  # type:ignore
+                "policy-violation",
                 text=error_msg,
             )
 
-        await session.on_react(entity, legacy_id, emojis, thread=thread)
-        if isinstance(entity, LegacyMUC):
-            await entity.echo(msg, None)
+        await session.on_react(recipient, legacy_id, emojis, thread=thread)
+        if isinstance(recipient, LegacyMUC):
+            await recipient.echo(msg, None)
         else:
             self.__ack(msg)
 
-        multi = self.xmpp.store.multi.get_xmpp_ids(session.user_pk, react_to)
+        with self.xmpp.store.session() as orm:
+            multi = self.xmpp.store.id_map.get_xmpp(
+                orm, recipient.stored.id, legacy_id, recipient.is_group
+            )
         if not multi:
             return
         multi = [m for m in multi if react_to != m]
 
-        if isinstance(entity, LegacyMUC):
+        if isinstance(recipient, LegacyMUC):
             for xmpp_id in multi:
                 mc = copy(msg)
                 mc["reactions"]["id"] = xmpp_id
-                await entity.echo(mc)
-        elif isinstance(entity, LegacyContact):
+                await recipient.echo(mc)
+        elif isinstance(recipient, LegacyContact):
             for xmpp_id in multi:
-                entity.react(legacy_id, emojis, xmpp_id=xmpp_id, carbon=True)
+                recipient.react(legacy_id, emojis, xmpp_id=xmpp_id, carbon=True)
 
-    def __ack(self, msg: Message):
+    def __ack(self, msg: Message) -> None:
         if not self.xmpp.PROPER_RECEIPTS:
             self.xmpp.delivery_receipt.ack(msg)
 
     async def __get_reply(
-        self, msg: Message, session: BaseSession, entity: Recipient
+        self, msg: Message, session: BaseSession, recipient: 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"])
+            reply_to_msg_id = self._xmpp_msg_id_to_legacy(
+                session, msg["reply"]["id"], recipient
+            )
         except XMPPError:
             session.log.debug(
                 "Could not determine reply-to legacy msg ID, sending quote instead."
@@ -359,7 +380,7 @@ class MessageContentMixin(DispatcherMixin):
                     )
 
         if msg.get_plugin("fallback", check=True) and (
-            isinstance(entity, LegacyMUC) or entity.REPLIES
+            isinstance(recipient, LegacyMUC) or recipient.REPLIES
         ):
             text = msg["fallback"].get_stripped_body(self.xmpp["xep_0461"].namespace)
             try:
@@ -373,7 +394,7 @@ class MessageContentMixin(DispatcherMixin):
         return text, reply_to_msg_id, reply_to, reply_fallback
 
     async def __send_url(
-        self, url: str, session: BaseSession, entity: Recipient, **kwargs
+        self, url: str, session: BaseSession, recipient: Recipient, **kwargs
     ) -> int | str | None:
         async with self.xmpp.http.get(url) as response:
             if response.status >= 400:
@@ -382,19 +403,23 @@ class MessageContentMixin(DispatcherMixin):
                     " instead.",
                     response,
                 )
-                return await session.on_text(entity, url, **kwargs)
+                return await session.on_text(recipient, url, **kwargs)
 
-            return await session.on_file(entity, url, http_response=response, **kwargs)
+            return await session.on_file(
+                recipient, url, http_response=response, **kwargs
+            )
 
     async def __send_bob(
-        self, from_: JID, cid: str, session: BaseSession, entity: Recipient, **kwargs
+        self, from_: JID, cid: str, session: BaseSession, recipient: Recipient, **kwargs
     ) -> int | str | None:
-        sticker = self.xmpp.store.bob.get_sticker(cid)
+        with self.xmpp.store.session() as orm:
+            sticker = self.xmpp.store.bob.get_sticker(orm, cid)
         if sticker is None:
             await self.xmpp.plugin["xep_0231"].get_bob(from_, cid)
-            sticker = self.xmpp.store.bob.get_sticker(cid)
+            with self.xmpp.store.session() as orm:
+                sticker = self.xmpp.store.bob.get_sticker(orm, cid)
         assert sticker is not None
-        return await session.on_sticker(entity, sticker, **kwargs)
+        return await session.on_sticker(recipient, sticker, **kwargs)
 
 
 log = logging.getLogger(__name__)

slidge/core/dispatcher/muc/__init__.py

@@ -6,7 +6,7 @@ from .ping import PingMixin
 
 
 class MucMixin(PingMixin, MamMixin, MucAdminMixin, MucOwnerMixin, MucMiscMixin):
-    pass
+    __slots__: list[str] = []
 
 
 __all__ = ("MucMixin",)

slidge/core/dispatcher/muc/admin.py

@@ -6,6 +6,8 @@ from ..util import DispatcherMixin, exceptions_to_xmpp_errors
 
 
 class MucAdminMixin(DispatcherMixin):
+    __slots__: list[str] = []
+
     def __init__(self, xmpp) -> None:
         super().__init__(xmpp)
         self.xmpp.register_handler(
@@ -46,7 +48,7 @@ class MucAdminMixin(DispatcherMixin):
                 "Slidge only implements moderation/retraction",
             )
 
-        legacy_id = self._xmpp_msg_id_to_legacy(muc.session, xmpp_id)
+        legacy_id = self._xmpp_msg_id_to_legacy(muc.session, xmpp_id, muc)
         await muc.session.on_moderate(muc, legacy_id, moderate["reason"] or None)
         iq.reply(clear=True).send()
 
@@ -90,8 +92,6 @@ class MucAdminMixin(DispatcherMixin):
 
         reply = iq.reply()
         reply.enable("mucadmin_query")
-        async for participant in muc.get_participants():
-            if not participant.affiliation == affiliation:
-                continue
+        async for participant in muc.get_participants(affiliation):
             reply["mucadmin_query"].append(participant.mucadmin_item())
         reply.send()

slidge/core/dispatcher/muc/mam.py

@@ -13,9 +13,11 @@ if TYPE_CHECKING:
 
 
 class MamMixin(DispatcherMixin):
-    def __init__(self, xmpp: "BaseGateway"):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp: "BaseGateway") -> None:
         super().__init__(xmpp)
-        self.__mam_cleanup_task = xmpp.loop.create_task(self.__mam_cleanup())
+        self.__mam_cleanup_task = xmpp.loop.create_task(self.__mam_cleanup())  # type:ignore[misc]
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_query",
@@ -38,15 +40,17 @@ class MamMixin(DispatcherMixin):
             )
         )
 
-    async def __mam_cleanup(self):
+    async def __mam_cleanup(self) -> None:
         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)
+            with self.xmpp.store.session() as orm:
+                self.xmpp.store.mam.nuke_older_than(orm, config.MAM_MAX_DAYS)
+                orm.commit()
 
     @exceptions_to_xmpp_errors
-    async def __handle_mam(self, iq: Iq):
+    async def __handle_mam(self, iq: Iq) -> None:
         muc = await self.get_muc_from_stanza(iq)
         await muc.send_mam(iq)
 
@@ -78,6 +82,6 @@ class MamMixin(DispatcherMixin):
         reply.send()
 
     @exceptions_to_xmpp_errors
-    async def __handle_mam_metadata(self, iq: Iq):
+    async def __handle_mam_metadata(self, iq: Iq) -> None:
         muc = await self.get_muc_from_stanza(iq)
         await muc.send_mam_metadata(iq)

slidge/core/dispatcher/muc/misc.py

@@ -7,7 +7,9 @@ from ..util import DispatcherMixin, exceptions_to_xmpp_errors
 
 
 class MucMiscMixin(DispatcherMixin):
-    def __init__(self, xmpp):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp) -> None:
         super().__init__(xmpp)
         xmpp.register_handler(
             CoroutineCallback(
@@ -22,7 +24,7 @@ class MucMiscMixin(DispatcherMixin):
         xmpp.add_event_handler("groupchat_subject", self.on_groupchat_subject)
         xmpp.add_event_handler("groupchat_message_error", self.__on_group_chat_error)
 
-    async def __on_group_chat_error(self, msg: Message):
+    async def __on_group_chat_error(self, msg: Message) -> None:
         condition = msg["error"].get_condition()
         if condition not in KICKABLE_ERRORS:
             return

slidge/core/dispatcher/muc/owner.py

@@ -7,7 +7,9 @@ from ..util import DispatcherMixin, exceptions_to_xmpp_errors
 
 
 class MucOwnerMixin(DispatcherMixin):
-    def __init__(self, xmpp):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp) -> None:
         super().__init__(xmpp)
         xmpp.register_handler(
             CoroutineCallback(
@@ -81,8 +83,8 @@ class MucOwnerMixin(DispatcherMixin):
             reason = destroy["reason"] or None
             await muc.on_destroy_request(reason)
             user_participant = await muc.get_user_participant()
-            user_participant._affiliation = "none"
-            user_participant._role = "none"
+            user_participant.stored.affiliation = "none"
+            user_participant.stored.role = "none"
             presence = user_participant._make_presence(ptype="unavailable", force=True)
             presence["muc"].enable("destroy")
             if reason is not None:

slidge/core/dispatcher/muc/ping.py

@@ -11,7 +11,9 @@ if TYPE_CHECKING:
 
 
 class PingMixin(DispatcherMixin):
-    def __init__(self, xmpp: "BaseGateway"):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp: "BaseGateway") -> None:
         super().__init__(xmpp)
 
         xmpp.remove_handler("Ping")

slidge/core/dispatcher/presence.py

@@ -9,12 +9,14 @@ from .util import DispatcherMixin, exceptions_to_xmpp_errors
 
 
 class _IsDirectedAtComponent(Exception):
-    def __init__(self, session: BaseSession):
+    def __init__(self, session: BaseSession) -> None:
         self.session = session
 
 
 class PresenceHandlerMixin(DispatcherMixin):
-    def __init__(self, xmpp):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp) -> None:
         super().__init__(xmpp)
 
         xmpp.add_event_handler("presence_subscribe", self._handle_subscribe)
@@ -33,7 +35,7 @@ class PresenceHandlerMixin(DispatcherMixin):
         return await sess.contacts.by_jid(pto)
 
     @exceptions_to_xmpp_errors
-    async def _handle_subscribe(self, pres: Presence):
+    async def _handle_subscribe(self, pres: Presence) -> None:
         try:
             contact = await self.__get_contact(pres)
         except _IsDirectedAtComponent:
@@ -46,7 +48,7 @@ class PresenceHandlerMixin(DispatcherMixin):
             await contact.on_friend_request(pres["status"])
 
     @exceptions_to_xmpp_errors
-    async def _handle_unsubscribe(self, pres: Presence):
+    async def _handle_unsubscribe(self, pres: Presence) -> None:
         pres.reply().send()
 
         try:
@@ -60,7 +62,7 @@ class PresenceHandlerMixin(DispatcherMixin):
         await contact.on_friend_delete(pres["status"])
 
     @exceptions_to_xmpp_errors
-    async def _handle_subscribed(self, pres: Presence):
+    async def _handle_subscribed(self, pres: Presence) -> None:
         try:
             contact = await self.__get_contact(pres)
         except _IsDirectedAtComponent:
@@ -69,7 +71,7 @@ class PresenceHandlerMixin(DispatcherMixin):
         await contact.on_friend_accept()
 
     @exceptions_to_xmpp_errors
-    async def _handle_unsubscribed(self, pres: Presence):
+    async def _handle_unsubscribed(self, pres: Presence) -> None:
         try:
             contact = await self.__get_contact(pres)
         except _IsDirectedAtComponent:
@@ -80,7 +82,7 @@ class PresenceHandlerMixin(DispatcherMixin):
             await contact.on_friend_delete(pres["status"])
 
     @exceptions_to_xmpp_errors
-    async def _handle_probe(self, pres: Presence):
+    async def _handle_probe(self, pres: Presence) -> None:
         try:
             contact = await self.__get_contact(pres)
         except _IsDirectedAtComponent:
@@ -120,16 +122,20 @@ class PresenceHandlerMixin(DispatcherMixin):
             resources = self.xmpp.roster[self.xmpp.boundjid.bare][
                 p.get_from()
             ].resources
-            await session.on_presence(
-                p.get_from().resource,
-                ptype,  # type: ignore
-                p["status"],
-                resources,
-                merge_resources(resources),
-            )
+            try:
+                await session.on_presence(
+                    p.get_from().resource,
+                    ptype,  # type: ignore
+                    p["status"],
+                    resources,
+                    merge_resources(resources),
+                )
+            except NotImplementedError:
+                pass
             if p.get_type() == "available":
                 await self.xmpp.pubsub.on_presence_available(p, None)
-            return
+                for contact in session.contacts:
+                    await self.xmpp.pubsub.on_presence_available(p, contact)
 
         if p.get_type() == "available":
             try: