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

slidge/core/mixins/message_maker.py

@@ -0,0 +1,154 @@
+import warnings
+from copy import copy
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Iterable, Optional, cast
+from uuid import uuid4
+
+from slixmpp import Message
+from slixmpp.types import MessageTypes
+
+from ...slixfix.link_preview.stanza import LinkPreview as LinkPreviewStanza
+from ...util.db import GatewayUser
+from ...util.types import (
+    ChatState,
+    LegacyMessageType,
+    LinkPreview,
+    MessageReference,
+    ProcessingHint,
+)
+from .. import config
+from .base import BaseSender
+
+if TYPE_CHECKING:
+    from ...group.participant import LegacyParticipant
+
+
+class MessageMaker(BaseSender):
+    mtype: MessageTypes = NotImplemented
+    _can_send_carbon: bool = NotImplemented
+    STRIP_SHORT_DELAY = False
+    USE_STANZA_ID = False
+
+    def _make_message(
+        self,
+        state: Optional[ChatState] = None,
+        hints: Iterable[ProcessingHint] = (),
+        legacy_msg_id: Optional[LegacyMessageType] = None,
+        when: Optional[datetime] = None,
+        reply_to: Optional[MessageReference] = None,
+        carbon=False,
+        link_previews: Optional[Iterable[LinkPreview]] = None,
+        **kwargs,
+    ):
+        body = kwargs.pop("mbody", None)
+        mfrom = kwargs.pop("mfrom", self.jid)
+        mto = kwargs.pop("mto", None)
+        thread = kwargs.pop("thread", None)
+        if carbon and self._can_send_carbon:
+            # the msg needs to have jabber:client as xmlns, so
+            # we don't want to associate with the XML stream
+            msg_cls = Message
+        else:
+            msg_cls = self.xmpp.Message  # type:ignore
+        msg = msg_cls(
+            sfrom=mfrom,
+            stype=kwargs.pop("mtype", None) or self.mtype,
+            sto=mto,
+            **kwargs,
+        )
+        if body:
+            msg["body"] = body
+            state = "active"
+        if thread:
+            known_threads = self.session.threads.inverse  # type:ignore
+            msg["thread"] = known_threads.get(thread) or str(thread)
+        if state:
+            msg["chat_state"] = state
+        for hint in hints:
+            msg.enable(hint)
+        self._set_msg_id(msg, legacy_msg_id)
+        self._add_delay(msg, when)
+        if link_previews:
+            self._add_link_previews(msg, link_previews)
+        if reply_to:
+            self._add_reply_to(msg, reply_to)
+        return msg
+
+    def _set_msg_id(
+        self, msg: Message, legacy_msg_id: Optional[LegacyMessageType] = None
+    ):
+        if legacy_msg_id is not None:
+            i = self._legacy_to_xmpp(legacy_msg_id)
+            msg.set_id(i)
+            if self.USE_STANZA_ID:
+                msg["stanza_id"]["id"] = i
+                msg["stanza_id"]["by"] = self.muc.jid  # type: ignore
+        elif self.USE_STANZA_ID:
+            msg["stanza_id"]["id"] = str(uuid4())
+            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
+        )
+
+    def _add_delay(self, msg: Message, when: Optional[datetime]):
+        if when:
+            if when.tzinfo is None:
+                when = when.astimezone(timezone.utc)
+            if self.STRIP_SHORT_DELAY:
+                delay = datetime.now().astimezone(timezone.utc) - when
+                if delay < config.IGNORE_DELAY_THRESHOLD:
+                    return
+            msg["delay"].set_stamp(when)
+            msg["delay"].set_from(self.xmpp.boundjid.bare)
+
+    def _add_reply_to(self, msg: Message, reply_to: MessageReference):
+        xmpp_id = self._legacy_to_xmpp(reply_to.legacy_id)
+        msg["reply"]["id"] = xmpp_id
+
+        muc = getattr(self, "muc", None)
+
+        if entity := reply_to.author:
+            if isinstance(entity, GatewayUser):
+                if muc:
+                    jid = copy(muc.jid)
+                    jid.resource = fallback_nick = muc.user_nick
+                    msg["reply"]["to"] = jid
+                else:
+                    msg["reply"]["to"] = entity.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
+            else:
+                if muc:
+                    if hasattr(entity, "muc"):
+                        # TODO: accept a Contact here and use muc.get_participant_by_legacy_id()
+                        # a bit of work because right now this is a sync function
+                        entity = cast("LegacyParticipant", entity)
+                        fallback_nick = entity.nickname
+                    else:
+                        warnings.warn(
+                            "The author of a message reference in a MUC must be a"
+                            " Participant instance, not a Contact"
+                        )
+                        fallback_nick = entity.name
+                else:
+                    fallback_nick = entity.name
+                msg["reply"]["to"] = entity.jid
+        else:
+            fallback_nick = None
+
+        if fallback := reply_to.body:
+            msg["reply"].add_quoted_fallback(fallback, fallback_nick)
+
+    @staticmethod
+    def _add_link_previews(msg: Message, link_previews: Iterable[LinkPreview]):
+        for preview in link_previews:
+            element = LinkPreviewStanza()
+            for i, name in enumerate(preview._fields):
+                val = preview[i]
+                if not val:
+                    continue
+                element[name] = val
+            msg.append(element)

slidge/core/mixins/presence.py

@@ -1,43 +1,115 @@
-from dataclasses import dataclass
-from datetime import datetime, timezone
+import re
+from asyncio import Task, sleep
+from datetime import datetime, timedelta, timezone
 from typing import Optional
 
+from slixmpp.types import PresenceShows, PresenceTypes
+
+from ...util.sql import CachedPresence, db
 from .. import config
 from .base import BaseSender
 
 
-@dataclass
-class _CachedPresence:
-    presence_kwargs: dict[str, str]
-    last_seen: Optional[datetime] = None
+class _NoChange(Exception):
+    pass
+
+
+_FRIEND_REQUEST_PRESENCES = {"subscribe", "unsubscribe", "subscribed", "unsubscribed"}
 
 
 class PresenceMixin(BaseSender):
-    _last_presence: Optional[_CachedPresence] = None
+    _ONLY_SEND_PRESENCE_CHANGES = False
+
+    def __init__(self, *a, **k):
+        super().__init__(*a, **k)
+        self.__update_last_seen_fallback_task: Optional[Task] = 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)
+
+    def _store_last_presence(self, new: CachedPresence):
+        return db.presence_store(self.jid, new, self.user)
 
     def _make_presence(
         self,
         *,
         last_seen: Optional[datetime] = None,
-        **presence_kwargs,
+        force=False,
+        bare=False,
+        ptype: Optional[PresenceTypes] = None,
+        pstatus: Optional[str] = None,
+        pshow: Optional[PresenceShows] = None,
     ):
-        self._last_presence = _CachedPresence(
-            last_seen=last_seen, presence_kwargs=presence_kwargs
+        if last_seen and last_seen.tzinfo is None:
+            last_seen = last_seen.astimezone(timezone.utc)
+
+        old = self._get_last_presence()
+
+        if ptype not in _FRIEND_REQUEST_PRESENCES:
+            new = CachedPresence(
+                last_seen=last_seen, ptype=ptype, pstatus=pstatus, pshow=pshow
+            )
+            if old != new:
+                if hasattr(self, "muc") and ptype == "unavailable":
+                    db.presence_delete(self.jid, self.user)
+                else:
+                    self._store_last_presence(new)
+            if old and not force and self._ONLY_SEND_PRESENCE_CHANGES:
+                if old == new:
+                    self.session.log.debug("Presence is the same as cached")
+                    raise _NoChange
+                self.session.log.debug(
+                    "Presence is not the same as cached: %s vs %s", old, new
+                )
+
+        p = self.xmpp.make_presence(
+            pfrom=self.jid.bare if bare else self.jid,
+            ptype=ptype,
+            pshow=pshow,
+            pstatus=pstatus,
         )
-        p = self.xmpp.make_presence(pfrom=self.jid, **presence_kwargs)
         if last_seen:
-            if config.LAST_SEEN_FALLBACK and not presence_kwargs.get("pstatus"):
-                p["status"] = f"Last seen {last_seen:%A %H:%M GMT}"
-            if last_seen.tzinfo is None:
-                last_seen = last_seen.astimezone(timezone.utc)
+            # it's ugly to check for the presence of this string, but a better fix is more work
+            if config.LAST_SEEN_FALLBACK and not re.match(
+                ".*Last seen .*", p["status"]
+            ):
+                last_seen_fallback, recent = get_last_seen_fallback(last_seen)
+                if p["status"]:
+                    p["status"] = p["status"] + " -- " + last_seen_fallback
+                else:
+                    p["status"] = last_seen_fallback
+                if recent:
+                    # if less than a week, we use sth like 'Last seen: Monday, 8:05",
+                    # but if lasts more than a week, this is not very informative, so
+                    # we need to force resend an updated presence status
+                    if self.__update_last_seen_fallback_task:
+                        self.__update_last_seen_fallback_task.cancel()
+                    self.__update_last_seen_fallback_task = self.xmpp.loop.create_task(
+                        self.__update_last_seen_fallback()
+                    )
             p["idle"]["since"] = last_seen
         return p
 
-    def _send_last_presence(self):
-        if (cache := self._last_presence) is None:
+    def send_last_presence(self, force=False, no_cache_online=False):
+        if (cache := self._get_last_presence()) is None:
+            if force:
+                if no_cache_online:
+                    self.online()
+                else:
+                    self.offline()
             return
         self._send(
-            self._make_presence(last_seen=cache.last_seen, **cache.presence_kwargs)
+            self._make_presence(
+                last_seen=cache.last_seen,
+                force=True,
+                ptype=cache.ptype,
+                pshow=cache.pshow,
+                pstatus=cache.pstatus,
+            )
         )
 
     def online(
@@ -51,7 +123,10 @@ class PresenceMixin(BaseSender):
         :param status: Arbitrary text, details of the status, eg: "Listening to Britney Spears"
         :param last_seen: For :xep:`0319`
         """
-        self._send(self._make_presence(pstatus=status, last_seen=last_seen))
+        try:
+            self._send(self._make_presence(pstatus=status, last_seen=last_seen))
+        except _NoChange:
+            pass
 
     def away(
         self,
@@ -67,9 +142,12 @@ class PresenceMixin(BaseSender):
         :param status: Arbitrary text, details of the status, eg: "Gone to fight capitalism"
         :param last_seen: For :xep:`0319`
         """
-        self._send(
-            self._make_presence(pstatus=status, pshow="away", last_seen=last_seen)
-        )
+        try:
+            self._send(
+                self._make_presence(pstatus=status, pshow="away", last_seen=last_seen)
+            )
+        except _NoChange:
+            pass
 
     def extended_away(
         self,
@@ -85,7 +163,12 @@ class PresenceMixin(BaseSender):
         :param status: Arbitrary text, details of the status, eg: "Gone to fight capitalism"
         :param last_seen: For :xep:`0319`
         """
-        self._send(self._make_presence(pstatus=status, pshow="xa", last_seen=last_seen))
+        try:
+            self._send(
+                self._make_presence(pstatus=status, pshow="xa", last_seen=last_seen)
+            )
+        except _NoChange:
+            pass
 
     def busy(
         self,
@@ -93,14 +176,17 @@ class PresenceMixin(BaseSender):
         last_seen: Optional[datetime] = None,
     ):
         """
-        Send a "busy" presence from this contact to the user,
+        Send a "busy" (ie, "dnd") presence from this contact to the user,
 
         :param status: eg: "Trying to make sense of XEP-0100"
         :param last_seen: For :xep:`0319`
         """
-        self._send(
-            self._make_presence(pstatus=status, pshow="busy", last_seen=last_seen)
-        )
+        try:
+            self._send(
+                self._make_presence(pstatus=status, pshow="dnd", last_seen=last_seen)
+            )
+        except _NoChange:
+            pass
 
     def offline(
         self,
@@ -113,8 +199,19 @@ class PresenceMixin(BaseSender):
         :param status: eg: "Trying to make sense of XEP-0100"
         :param last_seen: For :xep:`0319`
         """
-        self._send(
-            self._make_presence(
-                pstatus=status, ptype="unavailable", last_seen=last_seen
+        try:
+            self._send(
+                self._make_presence(
+                    pstatus=status, ptype="unavailable", last_seen=last_seen
+                )
             )
-        )
+        except _NoChange:
+            pass
+
+
+def get_last_seen_fallback(last_seen: datetime):
+    now = datetime.now(tz=timezone.utc)
+    if now - last_seen < timedelta(days=7):
+        return f"Last seen {last_seen:%A %H:%M GMT}", True
+    else:
+        return f"Last seen {last_seen:%b %-d %Y}", False

slidge/core/mixins/recipient.py

@@ -0,0 +1,43 @@
+from typing import TYPE_CHECKING, Optional, Union
+
+from slixmpp.plugins.xep_0004 import Form
+
+from ...util.types import LegacyMessageType
+
+if TYPE_CHECKING:
+    from ..gateway import BaseGateway
+
+
+class ReactionRecipientMixin:
+    REACTIONS_SINGLE_EMOJI = False
+    xmpp: "BaseGateway" = NotImplemented
+
+    async def restricted_emoji_extended_feature(self):
+        available = await self.available_emojis()
+        if not self.REACTIONS_SINGLE_EMOJI and available is None:
+            return None
+
+        form = Form()
+        form["type"] = "result"
+        form.add_field("FORM_TYPE", "hidden", value="urn:xmpp:reactions:0:restrictions")
+        if self.REACTIONS_SINGLE_EMOJI:
+            form.add_field("max_reactions_per_user", value="1")
+        if available:
+            form.add_field("allowlist", value=list(available))
+        return form
+
+    async def available_emojis(
+        self, legacy_msg_id: Optional[LegacyMessageType] = None
+    ) -> Optional[set[str]]:
+        """
+        Override this to restrict the subset of reactions this recipient
+        can handle.
+
+        :return: A set of emojis or None if any emoji is allowed
+        """
+        return None
+
+
+class ThreadRecipientMixin:
+    async def create_thread(self, xmpp_id: str) -> Union[int, str]:
+        return xmpp_id