slidge 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

slidge/core/mixins/message.py

@@ -1,23 +1,15 @@
 import logging
 import uuid
 import warnings
-from datetime import datetime
-from typing import TYPE_CHECKING, Iterable, Optional
+from typing import TYPE_CHECKING, Optional
 
 from slixmpp import Iq, Message
 
 from ...slixfix.xep_0490.mds import PUBLISH_OPTIONS
-from ...util.types import (
-    ChatState,
-    LegacyMessageType,
-    LegacyThreadType,
-    LinkPreview,
-    Marker,
-    MessageReference,
-    ProcessingHint,
-)
+from ...util.types import ChatState, LegacyMessageType, Marker
 from .attachment import AttachmentMixin
 from .message_maker import MessageMaker
+from .message_text import TextMessageMixin
 
 if TYPE_CHECKING:
     from ...group import LegacyMUC
@@ -111,7 +103,7 @@ class MarkerMixin(MessageMaker):
                 self.xmpp.delivery_receipt.make_ack(
                     self._legacy_to_xmpp(legacy_msg_id),
                     mfrom=self.jid,
-                    mto=self.user.jid,
+                    mto=self.user_jid,
                 )
             )
         self._send(
@@ -144,7 +136,7 @@ class MarkerMixin(MessageMaker):
             # We'll see if we need to implement that later
             return
         xmpp_msg_id = self._legacy_to_xmpp(legacy_msg_id)
-        iq = Iq(sto=self.user.bare_jid, sfrom=self.user.bare_jid, stype="set")
+        iq = Iq(sto=self.user_jid.bare, sfrom=self.user_jid.bare, stype="set")
         iq["pubsub"]["publish"]["node"] = self.xmpp["xep_0490"].stanza.NS
         iq["pubsub"]["publish"]["item"]["id"] = muc_jid
         displayed = self.xmpp["xep_0490"].stanza.Displayed()
@@ -158,195 +150,19 @@ class MarkerMixin(MessageMaker):
             self.session.log.debug("Could not MDS mark", exc_info=e)
 
 
-class ContentMessageMixin(AttachmentMixin):
-    def __default_hints(self, hints: Optional[Iterable[ProcessingHint]] = None):
-        if hints is not None:
-            return hints
-        elif self.mtype == "chat":
-            return {"markable", "store"}
-        elif self.mtype == "groupchat":
-            return {"markable"}
-
-    def __replace_id(self, legacy_msg_id: LegacyMessageType):
-        if self.mtype == "groupchat":
-            return self.session.muc_sent_msg_ids.get(
-                legacy_msg_id
-            ) or self._legacy_to_xmpp(legacy_msg_id)
-        else:
-            return self._legacy_to_xmpp(legacy_msg_id)
-
-    def send_text(
-        self,
-        body: str,
-        legacy_msg_id: Optional[LegacyMessageType] = None,
-        *,
-        when: Optional[datetime] = None,
-        reply_to: Optional[MessageReference] = None,
-        thread: Optional[LegacyThreadType] = None,
-        hints: Optional[Iterable[ProcessingHint]] = None,
-        carbon=False,
-        archive_only=False,
-        correction=False,
-        correction_event_id: Optional[LegacyMessageType] = None,
-        link_previews: Optional[list[LinkPreview]] = None,
-        **send_kwargs,
-    ):
-        """
-        Send a text message from this :term:`XMPP Entity`.
-
-        :param body: Content of the message
-        :param legacy_msg_id: If you want to be able to transport read markers from the gateway
-            user to the legacy network, specify this
-        :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
-        :param reply_to: Quote another message (:xep:`0461`)
-        :param hints:
-        :param thread:
-        :param carbon: (only used if called on a :class:`LegacyContact`)
-            Set this to ``True`` if this is actually a message sent **to** the
-            :class:`LegacyContact` by the :term:`User`.
-            Use this to synchronize outgoing history for legacy official apps.
-        :param correction: whether this message is a correction or not
-        :param correction_event_id: in the case where an ID is associated with the legacy
-            'correction event', specify it here to use it on the XMPP side. If not specified,
-            a random ID will be used.
-        :param link_previews: A little of sender (or server, or gateway)-generated
-            previews of URLs linked in the body.
-        :param archive_only: (only in groups) Do not send this message to user,
-            but store it in the archive. Meant to be used during ``MUC.backfill()``
-        """
-        if carbon:
-            if not correction and legacy_msg_id in self.session.sent:
-                log.warning(
-                    "Carbon message for a message an XMPP has sent? This is a bug! %s",
-                    legacy_msg_id,
-                )
-                return
-            self.session.sent[legacy_msg_id] = self.session.legacy_to_xmpp_msg_id(
-                legacy_msg_id
-            )
-        hints = self.__default_hints(hints)
-        msg = self._make_message(
-            mbody=body,
-            legacy_msg_id=correction_event_id if correction else legacy_msg_id,
-            when=when,
-            reply_to=reply_to,
-            hints=hints or (),
-            carbon=carbon,
-            thread=thread,
-            link_previews=link_previews,
-        )
-        if correction:
-            msg["replace"]["id"] = self.__replace_id(legacy_msg_id)
-        return self._send(msg, archive_only=archive_only, carbon=carbon, **send_kwargs)
-
-    def correct(
-        self,
-        legacy_msg_id: LegacyMessageType,
-        new_text: str,
-        *,
-        when: Optional[datetime] = None,
-        reply_to: Optional[MessageReference] = None,
-        thread: Optional[LegacyThreadType] = None,
-        hints: Optional[Iterable[ProcessingHint]] = None,
-        carbon=False,
-        archive_only=False,
-        correction_event_id: Optional[LegacyMessageType] = None,
-        link_previews: Optional[list[LinkPreview]] = None,
-        **send_kwargs,
-    ):
-        """
-        Modify a message that was previously sent by this :term:`XMPP Entity`.
-
-        Uses last message correction (:xep:`0308`)
-
-        :param new_text: New content of the message
-        :param legacy_msg_id: The legacy message ID of the message to correct
-        :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
-        :param reply_to: Quote another message (:xep:`0461`)
-        :param hints:
-        :param thread:
-        :param carbon: (only in 1:1) Reflect a message sent to this ``Contact`` by the user.
-            Use this to synchronize outgoing history for legacy official apps.
-        :param archive_only: (only in groups) Do not send this message to user,
-            but store it in the archive. Meant to be used during ``MUC.backfill()``
-        :param correction_event_id: in the case where an ID is associated with the legacy
-            'correction event', specify it here to use it on the XMPP side. If not specified,
-            a random ID will be used.
-        :param link_previews: A little of sender (or server, or gateway)-generated
-            previews of URLs linked in the body.
-        """
-        self.send_text(
-            new_text,
-            legacy_msg_id,
-            when=when,
-            reply_to=reply_to,
-            hints=hints,
-            carbon=carbon,
-            thread=thread,
-            correction=True,
-            archive_only=archive_only,
-            correction_event_id=correction_event_id,
-            link_previews=link_previews,
-            **send_kwargs,
-        )
-
-    def react(
-        self,
-        legacy_msg_id: LegacyMessageType,
-        emojis: Iterable[str] = (),
-        thread: Optional[LegacyThreadType] = None,
-        **kwargs,
-    ):
-        """
-        Send a reaction (:xep:`0444`) from this :term:`XMPP Entity`.
-
-        :param legacy_msg_id: The message which the reaction refers to.
-        :param emojis: An iterable of emojis used as reactions
-        :param thread:
-        """
-        msg = self._make_message(
-            hints={"store"}, carbon=kwargs.get("carbon"), thread=thread
-        )
-        xmpp_id = kwargs.pop("xmpp_id", None)
-        if not xmpp_id:
-            xmpp_id = self._legacy_to_xmpp(legacy_msg_id)
-        self.xmpp["xep_0444"].set_reactions(msg, to_id=xmpp_id, reactions=emojis)
-        self._send(msg, **kwargs)
-
-    def retract(
-        self,
-        legacy_msg_id: LegacyMessageType,
-        thread: Optional[LegacyThreadType] = None,
-        **kwargs,
-    ):
-        """
-        Send a message retraction (:XEP:`0424`) from this :term:`XMPP Entity`.
-
-        :param legacy_msg_id: Legacy ID of the message to delete
-        :param thread:
-        """
-        msg = self._make_message(
-            state=None,
-            hints={"store"},
-            mbody=f"/me retracted the message {legacy_msg_id}",
-            carbon=kwargs.get("carbon"),
-            thread=thread,
-        )
-        msg.enable("fallback")
-        # namespace version mismatch between slidge and slixmpp, update me later
-        msg["fallback"]["for"] = self.xmpp["xep_0424"].namespace[:-1] + "1"
-        msg["retract"]["id"] = msg["replace"]["id"] = self.__replace_id(legacy_msg_id)
-        self._send(msg, **kwargs)
+class ContentMessageMixin(AttachmentMixin, TextMessageMixin):
+    pass
 
 
 class CarbonMessageMixin(ContentMessageMixin, MarkerMixin):
     def _privileged_send(self, msg: Message):
         i = msg.get_id()
-        if not i:
-            i = str(uuid.uuid4())
+        if i:
+            self.session.ignore_messages.add(i)
+        else:
+            i = "slidge-carbon-" + str(uuid.uuid4())
             msg.set_id(i)
         msg.del_origin_id()
-        self.session.ignore_messages.add(i)
         try:
             self.xmpp["xep_0356"].send_privileged_message(msg)
         except PermissionError:

slidge/core/mixins/message_maker.py

@@ -7,8 +7,8 @@ from uuid import uuid4
 from slixmpp import Message
 from slixmpp.types import MessageTypes
 
+from ...db.models import GatewayUser
 from ...slixfix.link_preview.stanza import LinkPreview as LinkPreviewStanza
-from ...util.db import GatewayUser
 from ...util.types import (
     ChatState,
     LegacyMessageType,
@@ -60,8 +60,9 @@ class MessageMaker(BaseSender):
             msg["body"] = body
             state = "active"
         if thread:
-            known_threads = self.session.threads.inverse  # type:ignore
-            msg["thread"] = known_threads.get(thread) or str(thread)
+            msg["thread"] = self.xmpp.store.sent.get_legacy_thread(
+                self.user_pk, str(thread)
+            ) or str(thread)
         if state:
             msg["chat_state"] = state
         for hint in hints:
@@ -88,9 +89,9 @@ class MessageMaker(BaseSender):
             msg["stanza_id"]["by"] = self.muc.jid  # type: ignore
 
     def _legacy_to_xmpp(self, legacy_id: LegacyMessageType):
-        return self.session.sent.get(legacy_id) or self.session.legacy_to_xmpp_msg_id(
-            legacy_id
-        )
+        return self.xmpp.store.sent.get_xmpp_id(
+            self.session.user_pk, str(legacy_id)
+        ) or self.session.legacy_to_xmpp_msg_id(legacy_id)
 
     def _add_delay(self, msg: Message, when: Optional[datetime]):
         if when:
@@ -110,16 +111,23 @@ class MessageMaker(BaseSender):
         muc = getattr(self, "muc", None)
 
         if entity := reply_to.author:
-            if isinstance(entity, GatewayUser):
+            if entity == "user" or isinstance(entity, GatewayUser):
+                if isinstance(entity, GatewayUser):
+                    warnings.warn(
+                        "Using a GatewayUser as the author of a "
+                        "MessageReference is deprecated. Use the string 'user' "
+                        "instead.",
+                        DeprecationWarning,
+                    )
                 if muc:
                     jid = copy(muc.jid)
                     jid.resource = fallback_nick = muc.user_nick
                     msg["reply"]["to"] = jid
                 else:
-                    msg["reply"]["to"] = entity.jid
+                    msg["reply"]["to"] = self.session.user_jid
                     # TODO: here we should use preferably use the PEP nick of the user
                     # (but it doesn't matter much)
-                    fallback_nick = entity.jid.local
+                    fallback_nick = self.session.user_jid.local
             else:
                 if muc:
                     if hasattr(entity, "muc"):

slidge/core/mixins/message_text.py

@@ -0,0 +1,211 @@
+import logging
+from datetime import datetime
+from typing import Iterable, Optional
+
+from ...util.types import (
+    LegacyMessageType,
+    LegacyThreadType,
+    LinkPreview,
+    MessageReference,
+    ProcessingHint,
+)
+from .message_maker import MessageMaker
+
+
+class TextMessageMixin(MessageMaker):
+    def __default_hints(self, hints: Optional[Iterable[ProcessingHint]] = None):
+        if hints is not None:
+            return hints
+        elif self.mtype == "chat":
+            return {"markable", "store"}
+        elif self.mtype == "groupchat":
+            return {"markable"}
+
+    def _replace_id(self, legacy_msg_id: LegacyMessageType):
+        if self.mtype == "groupchat":
+            return self.xmpp.store.sent.get_group_xmpp_id(
+                self.session.user_pk, str(legacy_msg_id)
+            ) or self._legacy_to_xmpp(legacy_msg_id)
+        else:
+            return self._legacy_to_xmpp(legacy_msg_id)
+
+    def send_text(
+        self,
+        body: str,
+        legacy_msg_id: Optional[LegacyMessageType] = None,
+        *,
+        when: Optional[datetime] = None,
+        reply_to: Optional[MessageReference] = None,
+        thread: Optional[LegacyThreadType] = None,
+        hints: Optional[Iterable[ProcessingHint]] = None,
+        carbon=False,
+        archive_only=False,
+        correction=False,
+        correction_event_id: Optional[LegacyMessageType] = None,
+        link_previews: Optional[list[LinkPreview]] = None,
+        **send_kwargs,
+    ):
+        """
+        Send a text message from this :term:`XMPP Entity`.
+
+        :param body: Content of the message
+        :param legacy_msg_id: If you want to be able to transport read markers from the gateway
+            user to the legacy network, specify this
+        :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
+        :param reply_to: Quote another message (:xep:`0461`)
+        :param hints:
+        :param thread:
+        :param carbon: (only used if called on a :class:`LegacyContact`)
+            Set this to ``True`` if this is actually a message sent **to** the
+            :class:`LegacyContact` by the :term:`User`.
+            Use this to synchronize outgoing history for legacy official apps.
+        :param correction: whether this message is a correction or not
+        :param correction_event_id: in the case where an ID is associated with the legacy
+            'correction event', specify it here to use it on the XMPP side. If not specified,
+            a random ID will be used.
+        :param link_previews: A little of sender (or server, or gateway)-generated
+            previews of URLs linked in the body.
+        :param archive_only: (only in groups) Do not send this message to user,
+            but store it in the archive. Meant to be used during ``MUC.backfill()``
+        """
+        if carbon and not hasattr(self, "muc"):
+            if not correction and self.xmpp.store.sent.was_sent_by_user(
+                self.session.user_pk, str(legacy_msg_id)
+            ):
+                log.warning(
+                    "Carbon message for a message an XMPP has sent? This is a bug! %s",
+                    legacy_msg_id,
+                )
+                return
+            if hasattr(self, "muc") and not self.is_user:  # type:ignore
+                log.warning(
+                    "send_text() called with carbon=True on a participant who is not the user",
+                    legacy_msg_id,
+                )
+            self.xmpp.store.sent.set_message(
+                self.session.user_pk,
+                str(legacy_msg_id),
+                self.session.legacy_to_xmpp_msg_id(legacy_msg_id),
+            )
+        hints = self.__default_hints(hints)
+        msg = self._make_message(
+            mbody=body,
+            legacy_msg_id=correction_event_id if correction else legacy_msg_id,
+            when=when,
+            reply_to=reply_to,
+            hints=hints or (),
+            carbon=carbon,
+            thread=thread,
+            link_previews=link_previews,
+        )
+        if correction:
+            msg["replace"]["id"] = self._replace_id(legacy_msg_id)
+        return self._send(
+            msg,
+            archive_only=archive_only,
+            carbon=carbon,
+            legacy_msg_id=legacy_msg_id,
+            **send_kwargs,
+        )
+
+    def correct(
+        self,
+        legacy_msg_id: LegacyMessageType,
+        new_text: str,
+        *,
+        when: Optional[datetime] = None,
+        reply_to: Optional[MessageReference] = None,
+        thread: Optional[LegacyThreadType] = None,
+        hints: Optional[Iterable[ProcessingHint]] = None,
+        carbon=False,
+        archive_only=False,
+        correction_event_id: Optional[LegacyMessageType] = None,
+        link_previews: Optional[list[LinkPreview]] = None,
+        **send_kwargs,
+    ):
+        """
+        Modify a message that was previously sent by this :term:`XMPP Entity`.
+
+        Uses last message correction (:xep:`0308`)
+
+        :param new_text: New content of the message
+        :param legacy_msg_id: The legacy message ID of the message to correct
+        :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
+        :param reply_to: Quote another message (:xep:`0461`)
+        :param hints:
+        :param thread:
+        :param carbon: (only in 1:1) Reflect a message sent to this ``Contact`` by the user.
+            Use this to synchronize outgoing history for legacy official apps.
+        :param archive_only: (only in groups) Do not send this message to user,
+            but store it in the archive. Meant to be used during ``MUC.backfill()``
+        :param correction_event_id: in the case where an ID is associated with the legacy
+            'correction event', specify it here to use it on the XMPP side. If not specified,
+            a random ID will be used.
+        :param link_previews: A little of sender (or server, or gateway)-generated
+            previews of URLs linked in the body.
+        """
+        self.send_text(
+            new_text,
+            legacy_msg_id,
+            when=when,
+            reply_to=reply_to,
+            hints=hints,
+            carbon=carbon,
+            thread=thread,
+            correction=True,
+            archive_only=archive_only,
+            correction_event_id=correction_event_id,
+            link_previews=link_previews,
+            **send_kwargs,
+        )
+
+    def react(
+        self,
+        legacy_msg_id: LegacyMessageType,
+        emojis: Iterable[str] = (),
+        thread: Optional[LegacyThreadType] = None,
+        **kwargs,
+    ):
+        """
+        Send a reaction (:xep:`0444`) from this :term:`XMPP Entity`.
+
+        :param legacy_msg_id: The message which the reaction refers to.
+        :param emojis: An iterable of emojis used as reactions
+        :param thread:
+        """
+        msg = self._make_message(
+            hints={"store"}, carbon=kwargs.get("carbon"), thread=thread
+        )
+        xmpp_id = kwargs.pop("xmpp_id", None)
+        if not xmpp_id:
+            xmpp_id = self._legacy_to_xmpp(legacy_msg_id)
+        self.xmpp["xep_0444"].set_reactions(msg, to_id=xmpp_id, reactions=emojis)
+        self._send(msg, **kwargs)
+
+    def retract(
+        self,
+        legacy_msg_id: LegacyMessageType,
+        thread: Optional[LegacyThreadType] = None,
+        **kwargs,
+    ):
+        """
+        Send a message retraction (:XEP:`0424`) from this :term:`XMPP Entity`.
+
+        :param legacy_msg_id: Legacy ID of the message to delete
+        :param thread:
+        """
+        msg = self._make_message(
+            state=None,
+            hints={"store"},
+            mbody=f"/me retracted the message {legacy_msg_id}",
+            carbon=kwargs.get("carbon"),
+            thread=thread,
+        )
+        msg.enable("fallback")
+        # namespace version mismatch between slidge and slixmpp, update me later
+        msg["fallback"]["for"] = self.xmpp["xep_0424"].namespace[:-1] + "1"
+        msg["retract"]["id"] = msg["replace"]["id"] = self._replace_id(legacy_msg_id)
+        self._send(msg, **kwargs)
+
+
+log = logging.getLogger(__name__)

slidge/core/mixins/presence.py

@@ -5,7 +5,7 @@ from typing import Optional
 
 from slixmpp.types import PresenceShows, PresenceTypes
 
-from ...util.sql import CachedPresence, db
+from ...util.types import CachedPresence
 from .. import config
 from .base import BaseSender
 
@@ -19,20 +19,32 @@ _FRIEND_REQUEST_PRESENCES = {"subscribe", "unsubscribe", "subscribed", "unsubscr
 
 class PresenceMixin(BaseSender):
     _ONLY_SEND_PRESENCE_CHANGES = False
+    contact_pk: Optional[int] = None
 
     def __init__(self, *a, **k):
         super().__init__(*a, **k)
+        # FIXME: this should not be an attribute of this mixin to allow garbage
+        #        collection of instances
         self.__update_last_seen_fallback_task: Optional[Task] = None
+        # this is only used when a presence is set during Contact.update_info(),
+        # when the contact does not have a DB primary key yet, and is written
+        # to DB at the end of update_info()
+        self.cached_presence: Optional[CachedPresence] = None
 
     async def __update_last_seen_fallback(self):
         await sleep(3600 * 7)
         self.send_last_presence(force=True, no_cache_online=False)
 
     def _get_last_presence(self) -> Optional[CachedPresence]:
-        return db.presence_get(self.jid, self.user)
+        if self.contact_pk is None:
+            return None
+        return self.xmpp.store.contacts.get_presence(self.contact_pk)
 
     def _store_last_presence(self, new: CachedPresence):
-        return db.presence_store(self.jid, new, self.user)
+        if self.contact_pk is None:
+            self.cached_presence = new
+            return
+        self.xmpp.store.contacts.set_presence(self.contact_pk, new)
 
     def _make_presence(
         self,
@@ -55,7 +67,8 @@ class PresenceMixin(BaseSender):
             )
             if old != new:
                 if hasattr(self, "muc") and ptype == "unavailable":
-                    db.presence_delete(self.jid, self.user)
+                    if self.contact_pk is not None:
+                        self.xmpp.store.contacts.reset_presence(self.contact_pk)
                 else:
                     self._store_last_presence(new)
             if old and not force and self._ONLY_SEND_PRESENCE_CHANGES: