slidge 0.2.0a10__tar.gz → 0.2.0b0__tar.gz

{slidge-0.2.0a10 → slidge-0.2.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: slidge
-Version: 0.2.0a10
+Version: 0.2.0b0
 Summary: XMPP bridging framework
 Home-page: https://sr.ht/~nicoco/slidge/
 License: AGPL-3.0-or-later

{slidge-0.2.0a10 → slidge-0.2.0b0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "slidge"
-version = "0.2.0alpha10"
+version = "0.2.0beta0"
 description = "XMPP bridging framework"
 authors = ["Nicolas Cedilnik <nicoco@nicoco.fr>"]
 readme = "README.md"
@@ -57,7 +57,7 @@ git = "https://git.sr.ht/~nicoco/slidge-dev-helpers"
 branch = "master"
 
 [tool.poetry.scripts]
-slidge = 'slidge.__main__:main'
+slidge = 'slidge.main:main'
 
 [tool.mypy]
 check_untyped_defs = true
@@ -89,7 +89,6 @@ exclude_lines = [
 ]
 
 [tool.pytest.ini_options]
-log_cli = true
 log_level = "DEBUG"
 asyncio_mode = "strict"
 filterwarnings = [

slidge-0.2.0b0/slidge/__main__.py

@@ -0,0 +1,3 @@
+from slidge.main import main
+
+main()

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/__version__.py

@@ -2,4 +2,4 @@ from slidge.util.util import get_version  # noqa: F401
 
 # this is modified before publish, but if someone cloned from the repo,
 # it can help
-__version__ = "0.2.0alpha10"
+__version__ = "0.2.0beta0"

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/command/user.py

@@ -305,7 +305,10 @@ class LeaveGroup(Command):
                 FormField(
                     "group",
                     "Group name",
-                    options=[{"label": g.name, "value": g.name} for g in groups],
+                    type="list-single",
+                    options=[
+                        {"label": g.name, "value": str(i)} for i, g in enumerate(groups)
+                    ],
                 )
             ],
             handler=self.confirm,  # type:ignore
@@ -329,3 +332,4 @@ class LeaveGroup(Command):
     @staticmethod
     async def finish(session: AnyBaseSession, _ifrom, group: LegacyMUC):
         await session.on_leave_group(group.legacy_id)
+        await session.bookmarks.remove(group, reason="You left this group via slidge.")

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/contact/roster.py

@@ -154,6 +154,8 @@ class LegacyRoster(
         try:
             with contact.updating_info():
                 await contact.avatar_wrap_update_info()
+        except XMPPError:
+            raise
         except Exception as e:
             raise XMPPError("internal-server-error", str(e))
         contact._caps_ver = await contact.get_caps_ver(contact.jid)

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/core/config.py

@@ -154,9 +154,6 @@ LAST_SEEN_FALLBACK__DOC = (
 QR_TIMEOUT = 60
 QR_TIMEOUT__DOC = "Timeout for QR code flashing confirmation."
 
-DOWNLOAD_CHUNK_SIZE = 1024
-DOWNLOAD_CHUNK_SIZE__DOC = "Chunk size when slidge needs to download files using HTTP."
-
 LAST_MESSAGE_CORRECTION_RETRACTION_WORKAROUND = False
 LAST_MESSAGE_CORRECTION_RETRACTION_WORKAROUND__DOC = (
     "If the legacy service does not support last message correction but supports"

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/core/dispatcher/message/marker.py

@@ -3,12 +3,7 @@ from slixmpp.xmlstream import StanzaBase
 
 from ....group.room import LegacyMUC
 from ....util.types import Recipient
-from ..util import (
-    DispatcherMixin,
-    _get_entity,
-    _xmpp_to_legacy_thread,
-    exceptions_to_xmpp_errors,
-)
+from ..util import DispatcherMixin, _get_entity, exceptions_to_xmpp_errors
 
 
 class MarkerMixin(DispatcherMixin):
@@ -26,7 +21,7 @@ class MarkerMixin(DispatcherMixin):
         session = await self._get_session(msg)
 
         e: Recipient = await _get_entity(session, msg)
-        legacy_thread = await _xmpp_to_legacy_thread(session, msg, e)
+        legacy_thread = await self._xmpp_to_legacy_thread(session, msg, e)
         displayed_msg_id = msg["displayed"]["id"]
         if not isinstance(e, LegacyMUC) and self.xmpp.MARK_ALL_MESSAGES:
             to_mark = e.get_msg_xmpp_id_up_to(displayed_msg_id)  # type: ignore

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/core/dispatcher/muc/misc.py

@@ -54,6 +54,9 @@ class MucMiscMixin(DispatcherMixin):
             muc = await self.get_muc_from_stanza(iq)
             await muc.session.on_leave_group(muc.legacy_id)
             iq.reply().send()
+            await muc.session.bookmarks.remove(
+                muc, "You left this chat from an XMPP client."
+            )
             return
 
         raise XMPPError("feature-not-implemented")

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/core/dispatcher/muc/owner.py

@@ -88,7 +88,7 @@ class MucOwnerMixin(DispatcherMixin):
             if reason is not None:
                 presence["muc"]["destroy"]["reason"] = reason
             user_participant._send(presence)
-            muc.session.bookmarks.remove(muc)
+            await muc.session.bookmarks.remove(muc, kick=False)
             clear = True
         else:
             raise XMPPError("bad-request")

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/core/dispatcher/util.py

@@ -96,9 +96,31 @@ class DispatcherMixin:
     ) -> tuple["BaseSession", Recipient, int | str]:
         session = await self._get_session(msg)
         e: Recipient = await _get_entity(session, msg)
-        legacy_thread = await _xmpp_to_legacy_thread(session, msg, e)
+        legacy_thread = await self._xmpp_to_legacy_thread(session, msg, e)
         return session, e, legacy_thread
 
+    async def _xmpp_to_legacy_thread(
+        self, session: "BaseSession", msg: Message, recipient: RecipientType
+    ):
+        xmpp_thread = msg["thread"]
+        if not xmpp_thread:
+            return None
+
+        if session.MESSAGE_IDS_ARE_THREAD_IDS:
+            return self._xmpp_msg_id_to_legacy(session, xmpp_thread)
+
+        legacy_thread_str = session.xmpp.store.sent.get_legacy_thread(
+            session.user_pk, xmpp_thread
+        )
+        if legacy_thread_str is not None:
+            return session.xmpp.LEGACY_MSG_ID_TYPE(legacy_thread_str)
+        async with session.thread_creation_lock:
+            legacy_thread = await recipient.create_thread(xmpp_thread)
+            session.xmpp.store.sent.set_thread(
+                session.user_pk, str(legacy_thread), xmpp_thread
+            )
+            return legacy_thread
+
 
 def _ignore(session: "BaseSession", msg: Message):
     i = msg.get_id()
@@ -111,28 +133,6 @@ def _ignore(session: "BaseSession", msg: Message):
     return True
 
 
-async def _xmpp_to_legacy_thread(
-    session: "BaseSession", msg: Message, recipient: RecipientType
-):
-    xmpp_thread = msg["thread"]
-    if not xmpp_thread:
-        return
-
-    if session.MESSAGE_IDS_ARE_THREAD_IDS:
-        return session.xmpp.store.sent.get_legacy_thread(session.user_pk, xmpp_thread)
-
-    async with session.thread_creation_lock:
-        legacy_thread_str = session.xmpp.store.sent.get_legacy_thread(
-            session.user_pk, xmpp_thread
-        )
-        if legacy_thread_str is None:
-            legacy_thread = str(await recipient.create_thread(xmpp_thread))
-            session.xmpp.store.sent.set_thread(
-                session.user_pk, xmpp_thread, legacy_thread
-            )
-    return session.xmpp.LEGACY_MSG_ID_TYPE(legacy_thread)
-
-
 async def _get_entity(session: "BaseSession", m: Message) -> RecipientType:
     session.raise_if_not_logged()
     if m.get_type() == "groupchat":

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/core/mixins/attachment.py

@@ -33,17 +33,14 @@ from ...util.types import (
 )
 from ...util.util import fix_suffix
 from .. import config
-from .message_maker import MessageMaker
+from .message_text import TextMessageMixin
 
 
-class AttachmentMixin(MessageMaker):
+class AttachmentMixin(TextMessageMixin):
     def __init__(self, *a, **kw):
         super().__init__(*a, **kw)
         self.__store = self.xmpp.store.attachments
 
-    def send_text(self, *_, **k) -> Optional[Message]:
-        raise NotImplementedError
-
     async def __upload(
         self,
         file_path: Path,
@@ -261,7 +258,7 @@ class AttachmentMixin(MessageMaker):
                 thumbnail["width"] = x
                 thumbnail["height"] = y
                 thumbnail["media-type"] = "image/thumbhash"
-                thumbnail["uri"] = "data:image/thumbhash," + urlquote(h)
+                thumbnail["uri"] = "data:image/thumbhash;base64," + urlquote(h)
 
         self.__store.set_sims(uploaded_url, str(ref))
 
@@ -304,6 +301,7 @@ class AttachmentMixin(MessageMaker):
         caption: Optional[str] = None,
         carbon=False,
         when: Optional[datetime] = None,
+        correction=False,
         **kwargs,
     ) -> list[Message]:
         msg["oob"]["url"] = uploaded_url
@@ -311,11 +309,19 @@ class AttachmentMixin(MessageMaker):
         if caption:
             m1 = self._send(msg, carbon=carbon, **kwargs)
             m2 = self.send_text(
-                caption, legacy_msg_id=legacy_msg_id, when=when, carbon=carbon, **kwargs
+                caption,
+                legacy_msg_id=legacy_msg_id,
+                when=when,
+                carbon=carbon,
+                correction=correction,
+                **kwargs,
             )
             return [m1, m2] if m2 else [m1]
         else:
-            self._set_msg_id(msg, legacy_msg_id)
+            if correction:
+                msg["replace"]["id"] = self._replace_id(legacy_msg_id)
+            else:
+                self._set_msg_id(msg, legacy_msg_id)
             return [self._send(msg, carbon=carbon, **kwargs)]
 
     async def send_file(
@@ -358,6 +364,16 @@ class AttachmentMixin(MessageMaker):
         carbon = kwargs.pop("carbon", False)
         mto = kwargs.pop("mto", None)
         store_multi = kwargs.pop("store_multi", True)
+        correction = kwargs.get("correction", False)
+        if correction and (original_xmpp_id := self._legacy_to_xmpp(legacy_msg_id)):
+            xmpp_ids = self.xmpp.store.multi.get_xmpp_ids(
+                self.session.user_pk, original_xmpp_id
+            )
+
+            for xmpp_id in xmpp_ids:
+                if xmpp_id == original_xmpp_id:
+                    continue
+                self.retract(xmpp_id, thread)
         msg = self._make_message(
             when=when,
             reply_to=reply_to,

{slidge-0.2.0a10 → slidge-0.2.0b0}/slidge/core/mixins/lock.py

@@ -15,14 +15,16 @@ class NamedLockMixin:
         locks = self.__locks
         if not locks.get(id_):
             locks[id_] = asyncio.Lock()
-        async with locks[id_]:
-            log.trace("acquired %s", id_)  # type:ignore
-            yield
-        log.trace("releasing %s", id_)  # type:ignore
-        waiters = locks[id_]._waiters  # type:ignore
-        if not waiters:
-            del locks[id_]
-            log.trace("erasing %s", id_)  # type:ignore
+        try:
+            async with locks[id_]:
+                log.trace("acquired %s", id_)  # type:ignore
+                yield
+        finally:
+            log.trace("releasing %s", id_)  # type:ignore
+            waiters = locks[id_]._waiters  # type:ignore
+            if not waiters:
+                del locks[id_]
+                log.trace("erasing %s", id_)  # type:ignore
 
     def get_lock(self, id_: Hashable):
         return self.__locks.get(id_)

slidge-0.2.0b0/slidge/core/mixins/message.py

@@ -0,0 +1,214 @@
+import logging
+import uuid
+import warnings
+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, Marker
+from .attachment import AttachmentMixin
+from .message_maker import MessageMaker
+from .message_text import TextMessageMixin
+
+if TYPE_CHECKING:
+    from ...group import LegacyMUC
+
+
+class ChatStateMixin(MessageMaker):
+    def __init__(self):
+        super().__init__()
+        self.__last_chat_state: Optional[ChatState] = None
+
+    def _chat_state(self, state: ChatState, forced=False, **kwargs):
+        carbon = kwargs.get("carbon", False)
+        if carbon or (state == self.__last_chat_state and not forced):
+            return
+        self.__last_chat_state = state
+        msg = self._make_message(state=state, hints={"no-store"})
+        self._send(msg, **kwargs)
+
+    def active(self, **kwargs):
+        """
+        Send an "active" chat state (:xep:`0085`) from this
+        :term:`XMPP Entity`.
+        """
+        self._chat_state("active", **kwargs)
+
+    def composing(self, **kwargs):
+        """
+        Send a "composing" (ie "typing notification") chat state (:xep:`0085`)
+        from this :term:`XMPP Entity`.
+        """
+        self._chat_state("composing", forced=True, **kwargs)
+
+    def paused(self, **kwargs):
+        """
+        Send a "paused" (ie "typing paused notification") chat state
+        (:xep:`0085`) from this :term:`XMPP Entity`.
+        """
+        self._chat_state("paused", **kwargs)
+
+    def inactive(self, **kwargs):
+        """
+        Send an "inactive" (ie "contact has not interacted with the chat session
+        interface for an intermediate period of time") chat state (:xep:`0085`)
+        from this :term:`XMPP Entity`.
+        """
+        self._chat_state("inactive", **kwargs)
+
+    def gone(self, **kwargs):
+        """
+        Send a "gone" (ie "contact has not interacted with the chat session interface,
+        system, or device for a relatively long period of time") chat state
+        (:xep:`0085`) from this :term:`XMPP Entity`.
+        """
+        self._chat_state("gone", **kwargs)
+
+
+class MarkerMixin(MessageMaker):
+    is_group: bool = NotImplemented
+
+    def _make_marker(
+        self, legacy_msg_id: LegacyMessageType, marker: Marker, carbon=False
+    ):
+        msg = self._make_message(carbon=carbon)
+        msg[marker]["id"] = self._legacy_to_xmpp(legacy_msg_id)
+        return msg
+
+    def ack(self, legacy_msg_id: LegacyMessageType, **kwargs):
+        """
+        Send an "acknowledged" message marker (:xep:`0333`) from this :term:`XMPP Entity`.
+
+        :param legacy_msg_id: The message this marker refers to
+        """
+        self._send(
+            self._make_marker(
+                legacy_msg_id, "acknowledged", carbon=kwargs.get("carbon")
+            ),
+            **kwargs,
+        )
+
+    def received(self, legacy_msg_id: LegacyMessageType, **kwargs):
+        """
+        Send a "received" message marker (:xep:`0333`) from this :term:`XMPP Entity`.
+        If called on a :class:`LegacyContact`, also send a delivery receipt
+        marker (:xep:`0184`).
+
+        :param legacy_msg_id: The message this marker refers to
+        """
+        carbon = kwargs.get("carbon")
+        if self.mtype == "chat":
+            self._send(
+                self.xmpp.delivery_receipt.make_ack(
+                    self._legacy_to_xmpp(legacy_msg_id),
+                    mfrom=self.jid,
+                    mto=self.user_jid,
+                )
+            )
+        self._send(
+            self._make_marker(legacy_msg_id, "received", carbon=carbon), **kwargs
+        )
+
+    def displayed(self, legacy_msg_id: LegacyMessageType, **kwargs):
+        """
+        Send a "displayed" message marker (:xep:`0333`) from this :term:`XMPP Entity`.
+
+        :param legacy_msg_id: The message this marker refers to
+        """
+        self._send(
+            self._make_marker(legacy_msg_id, "displayed", carbon=kwargs.get("carbon")),
+            **kwargs,
+        )
+        if getattr(self, "is_user", False):
+            self.session.create_task(self.__send_mds(legacy_msg_id))
+
+    async def __send_mds(self, legacy_msg_id: LegacyMessageType):
+        # Send a MDS displayed marker on behalf of the user for a group chat
+        if muc := getattr(self, "muc", None):
+            muc_jid = muc.jid.bare
+        else:
+            # This is not implemented for 1:1 chat because it would rely on
+            # storing the XMPP-server injected stanza-id, which we don't track
+            # ATM.
+            # In practice, MDS should mostly be useful for public group chats,
+            # so it should not be an issue.
+            # 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_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()
+        displayed["stanza_id"]["id"] = xmpp_msg_id
+        displayed["stanza_id"]["by"] = muc_jid
+        iq["pubsub"]["publish"]["item"]["payload"] = displayed
+        iq["pubsub"]["publish_options"] = PUBLISH_OPTIONS
+        try:
+            await self.xmpp["xep_0356"].send_privileged_iq(iq)
+        except Exception as e:
+            self.session.log.debug("Could not MDS mark", exc_info=e)
+
+
+class ContentMessageMixin(AttachmentMixin, TextMessageMixin):
+    pass
+
+
+class CarbonMessageMixin(ContentMessageMixin, MarkerMixin):
+    def _privileged_send(self, msg: Message):
+        i = msg.get_id()
+        if i:
+            self.session.ignore_messages.add(i)
+        else:
+            i = "slidge-carbon-" + str(uuid.uuid4())
+            msg.set_id(i)
+        msg.del_origin_id()
+        try:
+            self.xmpp["xep_0356"].send_privileged_message(msg)
+        except PermissionError:
+            try:
+                self.xmpp["xep_0356_old"].send_privileged_message(msg)
+            except PermissionError:
+                warnings.warn(
+                    "Slidge does not have privileges to send message on behalf of"
+                    " user.Refer to"
+                    " https://slidge.readthedocs.io/en/latest/admin/xmpp_server.html"
+                    " for more info."
+                )
+
+
+class InviteMixin(MessageMaker):
+    def invite_to(
+        self,
+        muc: "LegacyMUC",
+        reason: Optional[str] = None,
+        password: Optional[str] = None,
+        **send_kwargs,
+    ):
+        """
+        Send an invitation to join a group (:xep:`0249`) from this :term:`XMPP Entity`.
+
+        :param muc: the muc the user is invited to
+        :param reason: a text explaining why the user should join this muc
+        :param password: maybe this will make sense later? not sure
+        :param send_kwargs: additional kwargs to be passed to _send()
+            (internal use by slidge)
+        """
+        msg = self._make_message(mtype="normal")
+        msg["groupchat_invite"]["jid"] = muc.jid
+        if reason:
+            msg["groupchat_invite"]["reason"] = reason
+        if password:
+            msg["groupchat_invite"]["password"] = password
+        self._send(msg, **send_kwargs)
+
+
+class MessageMixin(InviteMixin, ChatStateMixin, MarkerMixin, ContentMessageMixin):
+    pass
+
+
+class MessageCarbonMixin(InviteMixin, ChatStateMixin, CarbonMessageMixin):
+    pass
+
+
+log = logging.getLogger(__name__)