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

slidge/__main__.py

@@ -1,4 +1,3 @@
-if __name__ == "__main__":
-    from slidge.main import main
+from slidge.main import main
 
-    main()
+main()

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/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/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/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/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/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/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/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/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/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/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
@@ -158,200 +150,8 @@ 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.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)
+class ContentMessageMixin(AttachmentMixin, TextMessageMixin):
+    pass
 
 
 class CarbonMessageMixin(ContentMessageMixin, MarkerMixin):

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/db/alembic/versions/15b0bd83407a_remove_bogus_unique_constraints_on_room_.py

@@ -0,0 +1,83 @@
+"""Remove bogus unique constraints on room table
+
+Revision ID: 15b0bd83407a
+Revises: 45c24cc73c91
+Create Date: 2024-08-28 06:57:25.022994
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+import slidge.db.meta
+
+# revision identifiers, used by Alembic.
+revision: str = "15b0bd83407a"
+down_revision: Union[str, None] = "45c24cc73c91"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+meta = sa.MetaData()
+room_table = sa.Table(
+    "room",
+    meta,
+    sa.Column("id", sa.Integer(), nullable=False),
+    sa.Column("user_account_id", sa.Integer(), nullable=False),
+    sa.Column("legacy_id", sa.String(), nullable=False),
+    sa.Column("jid", slidge.db.meta.JIDType(), nullable=False),
+    sa.Column("avatar_id", sa.Integer(), nullable=True),
+    sa.Column("name", sa.String(), nullable=True),
+    sa.Column("description", sa.String(), nullable=True),
+    sa.Column("subject", sa.String(), nullable=True),
+    sa.Column("subject_date", sa.DateTime(), nullable=True),
+    sa.Column("subject_setter", sa.String(), nullable=True),
+    sa.Column("n_participants", sa.Integer(), nullable=True),
+    sa.Column(
+        "muc_type",
+        sa.Enum("GROUP", "CHANNEL", "CHANNEL_NON_ANONYMOUS", name="muctype"),
+        nullable=True,
+    ),
+    sa.Column("user_nick", sa.String(), nullable=True),
+    sa.Column("user_resources", sa.String(), nullable=True),
+    sa.Column("participants_filled", sa.Boolean(), nullable=False),
+    sa.Column("history_filled", sa.Boolean(), nullable=False),
+    sa.Column("extra_attributes", slidge.db.meta.JSONEncodedDict(), nullable=True),
+    sa.Column("updated", sa.Boolean(), nullable=False),
+    sa.Column("avatar_legacy_id", sa.String(), nullable=True),
+    sa.ForeignKeyConstraint(
+        ["avatar_id"],
+        ["avatar.id"],
+    ),
+    sa.ForeignKeyConstraint(
+        ["user_account_id"],
+        ["user_account.id"],
+    ),
+    sa.PrimaryKeyConstraint("id"),
+)
+
+
+def upgrade() -> None:
+    with op.batch_alter_table(
+        "room",
+        schema=None,
+        # without copy_from, the newly created table keeps the constraints
+        # we actually want to ditch.
+        copy_from=room_table,
+    ) as batch_op:
+        batch_op.create_unique_constraint(
+            "uq_room_user_account_id_jid", ["user_account_id", "jid"]
+        )
+        batch_op.create_unique_constraint(
+            "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
+        )
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.drop_constraint("uq_room_user_account_id_legacy_id", type_="unique")
+        batch_op.drop_constraint("uq_room_user_account_id_jid", type_="unique")
+
+    # ### end Alembic commands ###

slidge/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py

@@ -4,8 +4,12 @@ Revision ID: 5bd48bfdffa2
 Revises: b64b1a793483
 Create Date: 2024-07-24 10:29:23.467851
 
+Broken; fixed by "Remove bogus unique constraints on room table",
+rev 15b0bd83407a.
+
 """
 
+import logging
 from typing import Sequence, Union
 
 from alembic import op
@@ -26,6 +30,8 @@ def upgrade() -> None:
             schema=None,
             # without copy_from, the newly created table keeps the constraints
             # we actually want to ditch.
+            # LATER EDIT: this actually does not work, I should have copied the
+            # schema in here.
             copy_from=Room.__table__,  # type:ignore
         ) as batch_op:
             batch_op.create_unique_constraint(
@@ -35,9 +41,11 @@ def upgrade() -> None:
                 "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
             )
     except Exception:
-        # happens when migration is not needed
+        # This only works when upgrading rev by rev because I messed up. It
         # wouldn't be necessary if the constraint was named in the first place,
         # cf https://alembic.sqlalchemy.org/en/latest/naming.html
+        # This is fixed by rev 15b0bd83407a
+        log.info("Skipping")
         pass
 
 
@@ -48,3 +56,6 @@ def downgrade() -> None:
         batch_op.drop_constraint("uq_room_user_account_id_jid", type_="unique")
 
     # ### end Alembic commands ###
+
+
+log = logging.getLogger(__name__)

slidge/db/models.py

@@ -156,7 +156,9 @@ class Contact(Base):
 
     is_friend: Mapped[bool] = mapped_column(default=False)
     added_to_roster: Mapped[bool] = mapped_column(default=False)
-    sent_order: Mapped[list["ContactSent"]] = relationship(back_populates="contact")
+    sent_order: Mapped[list["ContactSent"]] = relationship(
+        back_populates="contact", cascade="all, delete-orphan"
+    )
 
     extra_attributes: Mapped[Optional[JSONSerializable]] = mapped_column(
         default=None, nullable=True

slidge/db/store.py

@@ -251,15 +251,6 @@ class SentStore(EngineMixin):
                 .where(XmppToLegacyIds.type == XmppToLegacyEnum.THREAD)
             ).scalar()
 
-    def get_xmpp_thread(self, user_pk: int, legacy_id: str) -> Optional[str]:
-        with self.session() as session:
-            return session.execute(
-                select(XmppToLegacyIds.xmpp_id)
-                .where(XmppToLegacyIds.user_account_id == user_pk)
-                .where(XmppToLegacyIds.legacy_id == legacy_id)
-                .where(XmppToLegacyIds.type == XmppToLegacyEnum.THREAD)
-            ).scalar()
-
     def was_sent_by_user(self, user_pk: int, legacy_id: str) -> bool:
         with self.session() as session:
             return (
@@ -414,6 +405,16 @@ class ContactStore(UpdatedMixin):
 
     def add_to_sent(self, contact_pk: int, msg_id: str) -> None:
         with self.session() as session:
+            if (
+                session.query(ContactSent.id)
+                .where(ContactSent.contact_id == contact_pk)
+                .where(ContactSent.msg_id == msg_id)
+                .first()
+            ) is not None:
+                log.warning(
+                    "Contact %s has already sent message %s", contact_pk, msg_id
+                )
+                return
             new = ContactSent(contact_id=contact_pk, msg_id=msg_id)
             session.add(new)
             session.commit()
@@ -504,6 +505,12 @@ class MAMStore(EngineMixin):
                 .where(ArchivedMessage.room_id == room_pk)
                 .where(ArchivedMessage.stanza_id == message.id)
             ).scalar()
+            if existing is None and legacy_msg_id is not None:
+                existing = session.execute(
+                    select(ArchivedMessage)
+                    .where(ArchivedMessage.room_id == room_pk)
+                    .where(ArchivedMessage.legacy_id == legacy_msg_id)
+                ).scalar()
             if existing is not None:
                 log.debug("Updating message %s in room %s", message.id, room_pk)
                 existing.timestamp = message.when

slidge/group/bookmarks.py

@@ -133,6 +133,8 @@ class LegacyBookmarks(
         try:
             with muc.updating_info():
                 await muc.avatar_wrap_update_info()
+        except XMPPError:
+            raise
         except Exception as e:
             raise XMPPError("internal-server-error", str(e))
         if not muc.user_nick:
@@ -160,6 +162,26 @@ class LegacyBookmarks(
                 " LegacyBookmarks.fill() was not overridden."
             )
 
-    def remove(self, muc: LegacyMUC):
+    async def remove(
+        self,
+        muc: LegacyMUC,
+        reason="You left this group from the official client.",
+        kick=True,
+    ) -> None:
+        """
+        Delete everything about a specific group.
+
+        This should be called when the user leaves the group from the official
+        app.
+
+        :param muc: The MUC to remove.
+        :param reason: Optionally, a reason why this group was removed.
+        :param kick: Whether the user should be kicked from this group. Set this
+            to False in case you do this somewhere else in your code, eg, on
+            receiving the confirmation that the group was deleted.
+        """
         assert muc.pk is not None
+        if kick:
+            user_participant = await muc.get_user_participant()
+            user_participant.kick(reason)
         self.__store.delete(muc.pk)

slidge/group/participant.py

@@ -324,7 +324,7 @@ class LegacyParticipant(
     ) -> MessageOrPresenceTypeVar:
         stanza["occupant-id"]["id"] = self.__occupant_id
         self.__add_nick_element(stanza)
-        if isinstance(stanza, Presence):
+        if not self.is_user and isinstance(stanza, Presence):
             if stanza["type"] == "unavailable" and not self._presence_sent:
                 return stanza  # type:ignore
             self._presence_sent = True
@@ -432,17 +432,17 @@ class LegacyParticipant(
         """
         self.muc.remove_participant(self)
 
-    def kick(self):
+    def kick(self, reason: str | None = None):
         """
         Call this when the participant is kicked from the room
         """
-        self.muc.remove_participant(self, kick=True)
+        self.muc.remove_participant(self, kick=True, reason=reason)
 
-    def ban(self):
+    def ban(self, reason: str | None = None):
         """
         Call this when the participant is banned from the room
         """
-        self.muc.remove_participant(self, ban=True)
+        self.muc.remove_participant(self, ban=True, reason=reason)
 
     def get_disco_info(self, jid: OptJid = None, node: Optional[str] = None):
         if self.contact is not None:

slidge/group/room.py

@@ -814,13 +814,20 @@ class LegacyMUC(
             return await self.get_user_participant(**kwargs)
         return await self.get_participant_by_contact(c, **kwargs)
 
-    def remove_participant(self, p: "LegacyParticipantType", kick=False, ban=False):
+    def remove_participant(
+        self,
+        p: "LegacyParticipantType",
+        kick=False,
+        ban=False,
+        reason: str | None = None,
+    ):
         """
         Call this when a participant leaves the room
 
         :param p: The participant
         :param kick: Whether the participant left because they were kicked
         :param ban: Whether the participant left because they were banned
+        :param reason: Optionally, a reason why the participant was removed.
         """
         if kick and ban:
             raise TypeError("Either kick or ban")
@@ -834,6 +841,8 @@ class LegacyMUC(
         presence = p._make_presence(ptype="unavailable", status_codes=codes)
         p._affiliation = "outcast" if ban else "none"
         p._role = "none"
+        if reason:
+            presence["muc"].set_item_attr("reason", reason)
         p._send(presence)
 
     def rename_participant(self, old_nickname: str, new_nickname: str):

slidge/util/test.py

@@ -215,13 +215,13 @@ class SlidgeTest(SlixTestPlus):
                 self.plugin, LegacyBookmarks, base_ok=True
             )
 
+        # workaround for duplicate output of sql alchemy's log, cf
+        # https://stackoverflow.com/a/76498428/5902284
         from sqlalchemy import log as sqlalchemy_log
 
         sqlalchemy_log._add_default_handler = lambda x: None
 
-        engine = self.db_engine = create_engine(
-            "sqlite+pysqlite:///:memory:", echo=True
-        )
+        engine = self.db_engine = create_engine("sqlite+pysqlite:///:memory:")
         Base.metadata.create_all(engine)
         BaseGateway.store = SlidgeStore(engine)
         BaseGateway._test_mode = True
@@ -293,7 +293,7 @@ class SlidgeTest(SlixTestPlus):
             )
         )
         welcome = self.next_sent()
-        assert welcome["body"]
+        assert welcome["body"], welcome
         stanza = self.next_sent()
         assert "logging in" in stanza["status"].lower(), stanza
         stanza = self.next_sent()

{slidge-0.2.0a10.dist-info → slidge-0.2.0b0.dist-info}/METADATA

@@ -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.dist-info → slidge-0.2.0b0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 slidge/__init__.py,sha256=S0tUjqpZlzsr8G4Y_1Xt-KCYB07qaknTB0OwHU8k29U,1587
-slidge/__main__.py,sha256=Y12eh1TD_C5MB50KgEAuMffGnRFCvKYFKHD4UYSmHA0,72
-slidge/__version__.py,sha256=05G747WHKOvpl1x4M5U-3t3qszlgbNfnUxAxrATG8ck,171
+slidge/__main__.py,sha256=ydjUklOoavS4YlGfjRX_8BQN2DaSbaXPMi47RkOgcFI,37
+slidge/__version__.py,sha256=9HCdKNn7jsnGlM4hiADRgDmlQEfeHOYi3XRNJ7Fe-2w,169
 slidge/command/__init__.py,sha256=UYf1mjCYbZ5G7PIgaFTWSQRAzEJkQ6dTH8Fu_e_XnO0,613
 slidge/command/adhoc.py,sha256=9PsTsGMPKAK_YXQpwdcH9SSDki8YQ49OZ5p65W5HA6k,9412
 slidge/command/admin.py,sha256=x_kJ0TJhzf6d3OBIOXFjudZFO8bRYUG919td7OjMCug,6008
@@ -8,41 +8,42 @@ slidge/command/base.py,sha256=7NSzPZdBLZElrm3smzvFKgP0GUggxXdkhclxIKCjtT8,13036
 slidge/command/categories.py,sha256=BJCfaga2qoAxnHfgHD7I_RKZuBA5nnNOukkWHJwsUFE,99
 slidge/command/chat_command.py,sha256=VBs6IuDka1IyyMzz0ZyE9zMImaEzUZLcnffxq_vwb4M,10565
 slidge/command/register.py,sha256=fzPcGUoJtainnDOiC13gWV-uYLuJcsmdKGJ-jXT1qIo,6697
-slidge/command/user.py,sha256=uFheYOprhypkHEEl6qSTEM7T2N28xXaDi7v1he-AET8,11512
+slidge/command/user.py,sha256=P4mU1wn1ywtquo0KKQsWddOhIKMV4HOueZAXOgmVvek,11700
 slidge/contact/__init__.py,sha256=WMMaHk7UW7YT9EH2LtPdkU0bHQaOp4ikBhbBQskmoc8,191
 slidge/contact/contact.py,sha256=kKtJ9NPLS9DPVyyahx_K-Mtp5k5UQdQJZavC1XCmWlc,23104
-slidge/contact/roster.py,sha256=AQTfmM4hrlxkXSM7ZX-C8P9NDN5RqNMNuPrSjt_3MJM,10223
+slidge/contact/roster.py,sha256=-Ei0f0cXX1LFpY29u4Ik68ikno3m2WRA5n5l8Nbjd_E,10267
 slidge/core/__init__.py,sha256=RG7Jj5JCJERjhqJ31lOLYV-7bH_oblClQD1KF9LsTXo,68
-slidge/core/config.py,sha256=leNcN_TI0Ka1hhzOHx7cBW3fNj5xZwsiv9l8AfRY_vU,7630
+slidge/core/config.py,sha256=voRFIlVDtKTZCdjc-zbwgnngFZrGvJjJ1dxRZm0BJK0,7514
 slidge/core/dispatcher/__init__.py,sha256=1EXcjXietUKlxEqdrCWCV3xZ3q_DSsjHoqWrPMbtYao,84
 slidge/core/dispatcher/caps.py,sha256=vzCAXo_bhALuLEpJWtyJTzVfWx96g1AsWD8_wkoDl0Y,2028
 slidge/core/dispatcher/disco.py,sha256=j56VY9NIFzwPEWFKQQZ7YIqS9GdD-ZaF_K8a2L-JvRk,2006
 slidge/core/dispatcher/message/__init__.py,sha256=vpDGOc_U9XvkUU_ws9n9-5M2NPJ87XGTVpuIxM7Z99k,223
 slidge/core/dispatcher/message/chat_state.py,sha256=sCdEpzbgmvBmTovNOCv9uY6v0eJZcWVvDYAGlAV3FJ4,1735
-slidge/core/dispatcher/message/marker.py,sha256=VbD1-2QeOCC4EbrS-wpJxHwIcmvPF4Q4qd0eiv95c7I,2451
+slidge/core/dispatcher/message/marker.py,sha256=f1ezaMoHupBFZY7aUMsWLAQG7G1J9b3ihxICCkpGtis,2411
 slidge/core/dispatcher/message/message.py,sha256=HwauW2kGionLyDWG01OSa9a14gYzoovJuJvGbfB4nt4,15296
 slidge/core/dispatcher/muc/__init__.py,sha256=V8URHLJ_y7mk-7Id6FzRuczb1Uq_Z69fhxvzHuVLH1w,269
 slidge/core/dispatcher/muc/admin.py,sha256=s21V2LEqc0e_DIpipEhhQdpae762lW1lVqj4wjFhX8M,3364
 slidge/core/dispatcher/muc/mam.py,sha256=1ROVP4ZPEVEH-HR5qRV4YwHz-V15uu5gyhv1ZwwKhk8,2821
-slidge/core/dispatcher/muc/misc.py,sha256=L5I2nt23qvQ-2qS5qgW3hSg6Z7DKnGvwxgXqn_WLvpQ,3943
-slidge/core/dispatcher/muc/owner.py,sha256=Vwwz15fdLq40XTnyDcMmRtMOXdY3T3_BwpSV3Nr8FNw,3290
+slidge/core/dispatcher/muc/misc.py,sha256=bHBjMC-Pu3jR5hAPGMzXf-C05UbACIwg38YbJUxHIxk,4068
+slidge/core/dispatcher/muc/owner.py,sha256=1a6YV7b_mmi1jC6q1ko8weeL8imQA-s-hYGPLIHd10I,3308
 slidge/core/dispatcher/muc/ping.py,sha256=lb1VQPhiUPZ19KhbofRXMVCcY6wwQ2w-asnqtANaAwA,1660
 slidge/core/dispatcher/presence.py,sha256=ZxAmC34yxKxbk_-h6g_S8pTssL7ovULm3q2ishpYaB4,6393
 slidge/core/dispatcher/registration.py,sha256=Xmbw9NF3LUppCOa3XzreopdKDitZnwl_5HE-kds74n8,3155
 slidge/core/dispatcher/search.py,sha256=9cGj0wwvyYlP_Yk440Y12sgo4Y1p-JWUDSJP5Zxch0M,3296
 slidge/core/dispatcher/session_dispatcher.py,sha256=_njTftgpUKKMP-hgAo99Hu0YrIa6E9OTzSYdiMW000w,2844
-slidge/core/dispatcher/util.py,sha256=x_vC7OXcaDaSz3RPPGnK9fOvimmMaKPM3RkgmHvU0Qw,5676
+slidge/core/dispatcher/util.py,sha256=YtXyVxM3orE7aYWs-GbJumtLTI63OpaQY_t4FMTjoZo,5754
 slidge/core/dispatcher/vcard.py,sha256=Rmx-wCz6Lps0mXCO48HppNQlS3GOgMuzuw9hZYBdlVU,5130
 slidge/core/gateway.py,sha256=NhIgxZKPnOpwsx50OKgyZyk9nfU8ZlUSMddwIDIhFcw,36351
 slidge/core/mixins/__init__.py,sha256=muReAzgvENgMvlfm0Fpe6BQFfm2EMjoDe9ZhGgo6Vig,627
-slidge/core/mixins/attachment.py,sha256=5Xa_GkSL_rRTC45TRjW98jztk__4M5P-3EG4IF91K0c,19022
+slidge/core/mixins/attachment.py,sha256=qHtv2I1buTmPO1jwRIpq2rixq5XTAljeWYj2eMWSw2k,19623
 slidge/core/mixins/avatar.py,sha256=kGIIZzLSNuxF9bIvt5Bv03_uT_pU5QV1kS7cRu6-GUA,7874
 slidge/core/mixins/base.py,sha256=MOd-pas38_52VawQVlxWtBtmTKC6My9G0ZaCeQxOJbs,748
 slidge/core/mixins/db.py,sha256=5Qpegd7D8e5TLXLLINYcf_DuVdN-7wNmsfztUuFYPcU,442
 slidge/core/mixins/disco.py,sha256=jk3Z1B6zTuisHv8VKNRJodIo0ee5btYHh2ZrlflPj_Q,3670
-slidge/core/mixins/lock.py,sha256=mVzwVVEoq1hrAMgGLh4K84BTLt7JTJ33B8HSGSorTdY,913
-slidge/core/mixins/message.py,sha256=6X0MskF1fC9Ih8aLRfdqNe7H3jpnFGEJb0EykRKze0c,15384
+slidge/core/mixins/lock.py,sha256=Vf1rrkbyNbSprr38WGfZiMgTB7AdbqH8ppFHY8N2yXE,975
+slidge/core/mixins/message.py,sha256=FB3VoaT81xUNVnaBMSwNJoHfrVv4Iv2678yDQH-23Rw,7551
 slidge/core/mixins/message_maker.py,sha256=TcCutHi0sIwL6beJNkN7XyR0aDIbA0xZyxd2Gc9ulG4,6022
+slidge/core/mixins/message_text.py,sha256=pCY4tezEuwB2ZuUyUi72i4v9AJkxp_SWF1jrFsn94Ns,8096
 slidge/core/mixins/presence.py,sha256=yywo6KAw8C7GaZSMrSMuioNfhW08MrnobHt8XbHd0q8,7891
 slidge/core/mixins/recipient.py,sha256=U-YppozUO8pA94jmD3-qmhkykTebPNaOVWc3JDPC9w8,1302
 slidge/core/pubsub.py,sha256=oTiS5KFQJAmsgkhOsvfvthT-LkuZGQSCrrUG0JskNkI,11907
@@ -53,12 +54,13 @@ slidge/db/alembic/env.py,sha256=hsBlRNs0zF5diSHGRSa8Fi3qRVQDA2rJdR41AEIdvxc,1642
 slidge/db/alembic/old_user_store.py,sha256=zFOv0JEWQQK0_TMRlU4Z0G5Mc9pxvEErLyOzXmRAe5Q,5209
 slidge/db/alembic/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
 slidge/db/alembic/versions/09f27f098baa_add_missing_attributes_in_room.py,sha256=mUL-0Io6ZPd_QbnKfwGYyjdMcM2uxQ0Wg72H23-2t_E,1033
+slidge/db/alembic/versions/15b0bd83407a_remove_bogus_unique_constraints_on_room_.py,sha256=bc_H_tPCVjiiUDqWE3oQtnIvsv2tlrzt0NB2f24mbdk,2862
 slidge/db/alembic/versions/2461390c0af2_store_contacts_caps_verstring_in_db.py,sha256=CLB-kOP9Rc0FJIKDLef912L5sYkjpTIPC8fhrIdrC7k,1084
 slidge/db/alembic/versions/29f5280c61aa_store_subject_setter_in_room.py,sha256=f8TFS28CXjGhvIn41UYMoHYeODfqhKfo4O7gk-JwA1E,1134
 slidge/db/alembic/versions/2b1f45ab7379_store_room_subject_setter_by_nickname.py,sha256=CMVP2wFz6s7t57eWdSaGtck8BXzfVPJhHE5AoWi34tI,1359
 slidge/db/alembic/versions/3071e0fa69d4_add_contact_client_type.py,sha256=O5BY1vpbtuYT5j6i3EMuuJAf6loIYT1kco8c-c6TF5g,1391
 slidge/db/alembic/versions/45c24cc73c91_add_bob.py,sha256=UjMySZ5LaInyPt0KbAxx0rF4GQhZh8CwBeqHtNPdG1c,1249
-slidge/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py,sha256=cObfqUzqdNezIeJdHe7YKFwRwtelXk8y1PwZ75chXDc,1629
+slidge/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py,sha256=m3USa76h0O2Xut-NePXIOZfkXl0bx0d5FyjOYpd34Jo,1977
 slidge/db/alembic/versions/82a4af84b679_add_muc_history_filled.py,sha256=g37po0ydp8ZmzJrE5oFV7GscnploxjCtPDpw28SqVGk,1429
 slidge/db/alembic/versions/8b993243a536_add_vcard_content_to_contact_table.py,sha256=18tG8B03Kq8Qz_-mMd28Beed6jow8XNTtrz7gT5QY3g,1210
 slidge/db/alembic/versions/8d2ced764698_rely_on_db_to_store_contacts_rooms_and_.py,sha256=olXaOEEsUSasqaaKdlP1cBODsMhmV1i90qbpDM2vTm4,4696
@@ -70,13 +72,13 @@ slidge/db/alembic/versions/c4a8ec35a0e8_per_room_user_nick.py,sha256=jjQmlRv6nqd
 slidge/db/alembic/versions/e91195719c2c_store_users_avatars_persistently.py,sha256=8Ga3VFgKrzMs_-B8OPtfP-0rey_MFaDg-QGtSbaft3o,640
 slidge/db/avatar.py,sha256=FfRt2Vu11ZKD9F3x1_drawvUd-TDE3mp7SE3BZ9hOOg,6467
 slidge/db/meta.py,sha256=v1Jf-npZ28QwdGpsLQWLBHEbEP3-jnPrygRg05tJ_Iw,1831
-slidge/db/models.py,sha256=bsZCEtBDkvwiZiJNyp0cqxLHphtCUBIGnOPIaaG9opc,13738
-slidge/db/store.py,sha256=1p-wAgG4K_QUehnmqRz-zvmW_PbXYYVq5qYMViF0cNY,46432
+slidge/db/models.py,sha256=mazginFllRNsC2w-SW_Y9HUMtruYnzSDCGGjsJwwsp8,13782
+slidge/db/store.py,sha256=7-HIml_wmgwwKe1AxI9yXbtWGz7yxH0cMc_IY4p1Wl4,46696
 slidge/group/__init__.py,sha256=yFt7cHqeaKIMN6f9ZyhhspOcJJvBtLedGv-iICG7lto,258
 slidge/group/archive.py,sha256=xGPkdSk8-BT6t6lNVo1FEwiFVAttoxCma8Tsyk5r8Kg,5279
-slidge/group/bookmarks.py,sha256=_LDf7A7aWkwPH88v7c-mOp8VJs3gSFM1-uCqSb4ThO8,5825
-slidge/group/participant.py,sha256=VNMtqr98QVuYgiTsJ9BaaIG1noz-xe3ewyKhLeDRhBk,17033
-slidge/group/room.py,sha256=v5mCV7ZrCdgXtDu_K7oDTdtjNYJV-y9wPmlg_RN_4s4,45789
+slidge/group/bookmarks.py,sha256=AvFL34bEX6n3OP1Np309T5hrLK9GnjkjdyLJ3uiLZyc,6616
+slidge/group/participant.py,sha256=Wtq03Ix55AxlK4pvYVIalLwmKklJiIAsZdeLADJNJgU,17138
+slidge/group/room.py,sha256=IizSwUBoKLvcvLpDseHIW_2KAky38uWsSv-poJuCAF0,46019
 slidge/main.py,sha256=8oND7xpR3eLw7b62fT61UhYlmNp_9gv3tNz2N3xR7-c,6232
 slidge/migration.py,sha256=4BJmPIRB56_WIhRTqBFIIBXuvnhhBjjOMl4CE7jY6oc,1541
 slidge/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -119,11 +121,11 @@ slidge/util/__init__.py,sha256=BELovoTMPcPPGz3D48esBr8A4BRRHXTvavfgnArBgEc,301
 slidge/util/archive_msg.py,sha256=xXAR0BI5r3d6KKWjae9594izCOv6iI03z2WLuTecNw8,1724
 slidge/util/conf.py,sha256=1j2OnOsCBar1tOObErhXR5RC3Vl3faliOZ1U8J3My58,6613
 slidge/util/db.py,sha256=4LxZj8oBYgiSnyBUnF_ALjr0TblkfNQq_p28sCfkHMY,242
-slidge/util/test.py,sha256=movqj7rxDPZG4RF46CN1z73PSYAHIc_LuudquGRwLVU,13909
+slidge/util/test.py,sha256=xnGXK0wvua49ncQm4linIfH24Ux6oCkm5A71k2V80zI,14007
 slidge/util/types.py,sha256=R_xfS5mRL0XUJIoDpnaAkZlTOoLPerduXBFftaVwIAI,5489
 slidge/util/util.py,sha256=DyJWO2pmE-RiB9Rsy6TUTcvB-BDlmLZBW4PELx4arFQ,9156
-slidge-0.2.0a10.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-slidge-0.2.0a10.dist-info/METADATA,sha256=_sFwLHhxETI7mHO1Hoetd6FVtNVYpyHHnboPxJucnkU,5006
-slidge-0.2.0a10.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-slidge-0.2.0a10.dist-info/entry_points.txt,sha256=SNl72KSocF5plsu_67xyH6wVWfGTXQbzkQgXbLtzDrQ,47
-slidge-0.2.0a10.dist-info/RECORD,,
+slidge-0.2.0b0.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+slidge-0.2.0b0.dist-info/METADATA,sha256=JrkUpw6lNEWr3ESfNKv-NMuvLPIwqz-3G2Gt7i9nkkk,5005
+slidge-0.2.0b0.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+slidge-0.2.0b0.dist-info/entry_points.txt,sha256=btz6mbzx1X6fjFWAS_Bo5qNi8PtxUsDgunt-6r4JDHw,43
+slidge-0.2.0b0.dist-info/RECORD,,

slidge-0.2.0b0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+slidge=slidge.main:main
+

slidge-0.2.0a10.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-slidge=slidge.__main__:main
-