slidge 0.2.0a3__py3-none-any.whl → 0.2.0a4__py3-none-any.whl

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.0alpha3"
+__version__ = "0.2.0alpha4"

slidge/command/admin.py

@@ -1,5 +1,6 @@
 # Commands only accessible for slidge admins
 import functools
+import importlib
 import logging
 from datetime import datetime
 from typing import Any, Optional
@@ -7,6 +8,7 @@ from typing import Any, Optional
 from slixmpp import JID
 from slixmpp.exceptions import XMPPError
 
+from ..core import config
 from ..util.types import AnyBaseSession
 from .base import (
     Command,
@@ -90,8 +92,12 @@ class SlidgeInfo(AdminCommand):
             [a for a in (days_ago, hours_ago, minutes_ago, seconds_ago) if a]
         )
 
+        legacy_module = importlib.import_module(config.LEGACY_MODULE)
+        version = getattr(legacy_module, "__version__", "No version")
+
         return (
-            f"{self.xmpp.COMPONENT_NAME} version {__version__}\n"
+            f"{self.xmpp.COMPONENT_NAME} (slidge core {__version__},"
+            f" {config.LEGACY_MODULE} {version})\n"
             f"Up since {start:%Y-%m-%d %H:%M} ({ago} ago)"
         )
 

slidge/contact/contact.py

@@ -129,8 +129,8 @@ class LegacyContact(
         self._vcard_fetched = False
         self._vcard: str | None = None
 
-    async def get_vcard(self) -> VCard4 | None:
-        if not self._vcard_fetched:
+    async def get_vcard(self, fetch=True) -> VCard4 | None:
+        if fetch and not self._vcard_fetched:
             await self.fetch_vcard()
         if self._vcard is None:
             return None

slidge/contact/roster.py

@@ -8,6 +8,7 @@ from slixmpp.exceptions import IqError, XMPPError
 from slixmpp.jid import JID_UNESCAPE_TRANSFORMATIONS, _unescape_node
 
 from ..core.mixins.lock import NamedLockMixin
+from ..db.models import Contact
 from ..db.store import ContactStore
 from ..util import SubclassableOnce
 from ..util.types import LegacyContactType, LegacyUserIdType
@@ -63,37 +64,6 @@ class LegacyRoster(
             for stored in self.__store.get_all(user_pk=self.session.user_pk):
                 yield self._contact_cls.from_store(self.session, stored)
 
-    async def __finish_init_contact(
-        self, legacy_id: LegacyUserIdType, jid_username: str, *args, **kwargs
-    ):
-        async with self.lock(("finish", legacy_id)):
-            with self.__store.session():
-                stored = self.__store.get_by_legacy_id(
-                    self.session.user_pk, str(legacy_id)
-                )
-                if stored is not None:
-                    if stored.updated:
-                        return self._contact_cls.from_store(self.session, stored)
-                    c: LegacyContact = self._contact_cls(
-                        self.session, legacy_id, jid_username, *args, **kwargs
-                    )
-                    c.contact_pk = stored.id
-                else:
-                    c = self._contact_cls(
-                        self.session, legacy_id, jid_username, *args, **kwargs
-                    )
-                try:
-                    with c.updating_info():
-                        await c.avatar_wrap_update_info()
-                except Exception as e:
-                    raise XMPPError("internal-server-error", str(e))
-                c._caps_ver = await c.get_caps_ver(c.jid)
-                need_avatar = c.contact_pk is None
-                c.contact_pk = self.__store.update(c, commit=not self.__filling)
-                if need_avatar:
-                    c._post_avatar_update()
-        return c
-
     def known_contacts(self, only_friends=True) -> dict[str, LegacyContactType]:
         if only_friends:
             return {c.jid.bare: c for c in self if c.is_friend}
@@ -112,17 +82,15 @@ class LegacyRoster(
         # """
         username = contact_jid.node
         async with self.lock(("username", username)):
-            with self.__store.session():
-                stored = self.__store.get_by_jid(self.session.user_pk, contact_jid)
-                if stored is not None and stored.updated:
-                    return self._contact_cls.from_store(self.session, stored)
-
             legacy_id = await self.jid_username_to_legacy_id(username)
             log.debug("Contact %s not found", contact_jid)
             if self.get_lock(("legacy_id", legacy_id)):
                 log.debug("Already updating %s", contact_jid)
                 return await self.by_legacy_id(legacy_id)
-            return await self.__finish_init_contact(legacy_id, username)
+
+            with self.__store.session():
+                stored = self.__store.get_by_jid(self.session.user_pk, contact_jid)
+                return await self.__update_contact(stored, legacy_id, username)
 
     async def by_legacy_id(
         self, legacy_id: LegacyUserIdType, *args, **kwargs
@@ -145,26 +113,48 @@ class LegacyRoster(
         if legacy_id == self.user_legacy_id:
             raise ContactIsUser
         async with self.lock(("legacy_id", legacy_id)):
-            with self.__store.session():
-                stored = self.__store.get_by_legacy_id(
-                    self.session.user_pk, str(legacy_id)
-                )
-                if stored is not None and stored.updated:
-                    return self._contact_cls.from_store(
-                        self.session, stored, *args, **kwargs
-                    )
-
             username = await self.legacy_id_to_jid_username(legacy_id)
-            log.debug("Contact %s not found", legacy_id)
             if self.get_lock(("username", username)):
                 log.debug("Already updating %s", username)
                 jid = JID()
                 jid.node = username
                 jid.domain = self.session.xmpp.boundjid.bare
                 return await self.by_jid(jid)
-            return await self.__finish_init_contact(
-                legacy_id, username, *args, **kwargs
-            )
+
+            with self.__store.session():
+                stored = self.__store.get_by_legacy_id(
+                    self.session.user_pk, str(legacy_id)
+                )
+                return await self.__update_contact(
+                    stored, legacy_id, username, *args, **kwargs
+                )
+
+    async def __update_contact(
+        self,
+        stored: Contact | None,
+        legacy_id: LegacyUserIdType,
+        username: str,
+        *a,
+        **kw,
+    ) -> LegacyContactType:
+        if stored is None:
+            contact = self._contact_cls(self.session, legacy_id, username, *a, **kw)
+        else:
+            contact = self._contact_cls.from_store(self.session, stored, *a, **kw)
+            if stored.updated:
+                return contact
+
+        try:
+            with contact.updating_info():
+                await contact.avatar_wrap_update_info()
+        except Exception as e:
+            raise XMPPError("internal-server-error", str(e))
+        contact._caps_ver = await contact.get_caps_ver(contact.jid)
+        need_avatar = contact.contact_pk is None
+        contact.contact_pk = self.__store.update(contact, commit=not self.__filling)
+        if need_avatar:
+            contact._post_avatar_update()
+        return contact
 
     async def by_stanza(self, s) -> LegacyContact:
         # """
@@ -225,7 +215,7 @@ class LegacyRoster(
                 item = contact.get_roster_item()
                 old = user_roster.get(contact.jid.bare)
                 if old is not None and all(
-                    old[k] == item[contact.jid.bare][k]
+                    old[k] == item[contact.jid.bare].get(k)
                     for k in ("subscription", "groups", "name")
                 ):
                     self.log.debug("No need to update roster")

slidge/core/gateway/base.py

@@ -315,7 +315,7 @@ class BaseGateway(
 
         from ...group.room import LegacyMUC
 
-        LegacyMUC.get_unique_subclass().xmpp = self
+        LegacyMUC.get_self_or_unique_subclass().xmpp = self
 
         self.get_session_from_stanza: Callable[
             [Union[Message, Presence, Iq]], BaseSession

slidge/core/gateway/vcard_temp.py

@@ -86,7 +86,7 @@ class VCardTemp:
             avatar = entity.get_avatar()
             type_ = "image/png"
             if isinstance(entity, LegacyContact):
-                vcard = await entity.get_vcard()
+                vcard = await entity.get_vcard(fetch=False)
             else:
                 vcard = None
         v = self.xmpp.plugin["xep_0054"].make_vcard()

slidge/core/pubsub.py

@@ -22,6 +22,7 @@ from slixmpp.types import JidStr, OptJidStr
 
 from ..db.avatar import CachedAvatar, avatar_cache
 from ..db.store import ContactStore, SlidgeStore
+from ..util.types import URL
 from .mixins.lock import NamedLockMixin
 
 if TYPE_CHECKING:
@@ -171,14 +172,13 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             except XMPPError:
                 pass
             else:
-                if pep_avatar.metadata is None:
-                    raise XMPPError("internal-server-error", "Avatar but no metadata?")
-                await self.__broadcast(
-                    data=pep_avatar.metadata,
-                    from_=p.get_to(),
-                    to=from_,
-                    id=pep_avatar.metadata["info"]["id"],
-                )
+                if pep_avatar.metadata is not None:
+                    await self.__broadcast(
+                        data=pep_avatar.metadata,
+                        from_=p.get_to(),
+                        to=from_,
+                        id=pep_avatar.metadata["info"]["id"],
+                    )
         if UserNick.namespace + "+notify" in features:
             try:
                 pep_nick = await self._get_authorized_nick(p)
@@ -222,7 +222,9 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         item = PepAvatar()
         avatar_id = entity.avatar_id
         if avatar_id is not None:
-            stored = avatar_cache.get(str(avatar_id))
+            stored = avatar_cache.get(
+                avatar_id if isinstance(avatar_id, URL) else str(avatar_id)
+            )
             assert stored is not None
             item.set_avatar_from_cache(stored)
         return item

slidge/db/avatar.py

@@ -206,6 +206,11 @@ class AvatarCache:
             stored = orm.execute(select(Avatar).where(Avatar.hash == hash_)).scalar()
 
             if stored is not None:
+                if unique_id is not None:
+                    log.warning("Updating 'unique' IDs of a known avatar.")
+                    stored.legacy_id = str(unique_id)
+                    orm.add(stored)
+                    orm.commit()
                 return CachedAvatar.from_store(stored, self.dir)
 
             stored = Avatar(

slidge/db/store.py

@@ -162,12 +162,20 @@ class AvatarStore(EngineMixin):
 class SentStore(EngineMixin):
     def set_message(self, user_pk: int, legacy_id: str, xmpp_id: str) -> None:
         with self.session() as session:
-            msg = XmppToLegacyIds(
-                user_account_id=user_pk,
-                legacy_id=legacy_id,
-                xmpp_id=xmpp_id,
-                type=XmppToLegacyEnum.DM,
+            msg = (
+                session.query(XmppToLegacyIds)
+                .filter(XmppToLegacyIds.user_account_id == user_pk)
+                .filter(XmppToLegacyIds.legacy_id == legacy_id)
+                .filter(XmppToLegacyIds.xmpp_id == xmpp_id)
+                .scalar()
             )
+            if msg is None:
+                msg = XmppToLegacyIds(user_account_id=user_pk)
+            else:
+                log.debug("Resetting a DM from sent store")
+            msg.legacy_id = legacy_id
+            msg.xmpp_id = xmpp_id
+            msg.type = XmppToLegacyEnum.DM
             session.add(msg)
             session.commit()
 
@@ -625,6 +633,7 @@ class MAMStore(EngineMixin):
         with self.session() as session:
             after_timestamp = (
                 session.query(ArchivedMessage.timestamp)
+                .filter(ArchivedMessage.room_id == room_pk)
                 .filter(ArchivedMessage.legacy_id == after_id)
                 .scalar()
             )
@@ -778,7 +787,10 @@ class RoomStore(UpdatedMixin):
         with self.session() as session:
             session.execute(
                 update(Room).values(
-                    subject_setter=None, user_resources=None, history_filled=False
+                    subject_setter=None,
+                    user_resources=None,
+                    history_filled=False,
+                    participants_filled=False,
                 )
             )
             session.commit()
@@ -890,6 +902,13 @@ class RoomStore(UpdatedMixin):
             )
             session.commit()
 
+    def update_user_nick(self, room_pk, nick: str) -> None:
+        with self.session() as session:
+            session.execute(
+                update(Room).where(Room.id == room_pk).values(user_nick=nick)
+            )
+            session.commit()
+
     def delete(self, room_pk: int) -> None:
         with self.session() as session:
             session.execute(delete(Room).where(Room.id == room_pk))

slidge/group/bookmarks.py

@@ -8,6 +8,7 @@ from slixmpp.jid import _unescape_node
 
 from ..contact.roster import ESCAPE_TABLE
 from ..core.mixins.lock import NamedLockMixin
+from ..db.models import Room
 from ..util import SubclassableOnce
 from ..util.types import LegacyGroupIdType, LegacyMUCType
 from .archive import MessageArchive
@@ -57,29 +58,6 @@ class LegacyBookmarks(
     def __repr__(self):
         return f"<Bookmarks of {self.user_jid}>"
 
-    async def __finish_init_muc(self, legacy_id: LegacyGroupIdType, jid: JID):
-        with self.__store.session():
-            stored = self.__store.get_by_legacy_id(self.session.user_pk, str(legacy_id))
-            if stored is not None:
-                if stored.updated:
-                    return self._muc_class.from_store(self.session, stored)
-                muc = self._muc_class(self.session, legacy_id=legacy_id, jid=jid)
-                muc.pk = stored.id
-            else:
-                muc = self._muc_class(self.session, legacy_id=legacy_id, jid=jid)
-
-            try:
-                with muc.updating_info():
-                    await muc.avatar_wrap_update_info()
-            except Exception as e:
-                raise XMPPError("internal-server-error", str(e))
-            if not muc.user_nick:
-                muc.user_nick = self._user_nick
-            self.log.debug("MUC created: %r", muc)
-            muc.pk = self.__store.update(muc)
-            muc.archive = MessageArchive(muc.pk, self.xmpp.store.mam)
-        return muc
-
     async def legacy_id_to_jid_local_part(self, legacy_id: LegacyGroupIdType):
         return await self.legacy_id_to_jid_username(legacy_id)
 
@@ -110,24 +88,16 @@ class LegacyBookmarks(
     async def by_jid(self, jid: JID) -> LegacyMUCType:
         if jid.resource:
             jid = JID(jid.bare)
-        bare = jid.bare
-        async with self.lock(("bare", bare)):
-            assert isinstance(jid.username, str)
-            legacy_id = await self.jid_local_part_to_legacy_id(jid.username)
+        async with self.lock(("bare", jid.bare)):
+            assert isinstance(jid.local, str)
+            legacy_id = await self.jid_local_part_to_legacy_id(jid.local)
             if self.get_lock(("legacy_id", legacy_id)):
                 self.log.debug("Not instantiating %s after all", jid)
                 return await self.by_legacy_id(legacy_id)
 
             with self.__store.session():
                 stored = self.__store.get_by_jid(self.session.user_pk, jid)
-                if stored is not None and stored.updated:
-                    return self._muc_class.from_store(self.session, stored)
-
-            self.log.debug("Attempting to instantiate a new MUC for JID %s", jid)
-            local_part = jid.node
-
-            self.log.debug("%r is group %r", local_part, legacy_id)
-            return await self.__finish_init_muc(legacy_id, JID(bare))
+                return await self.__update_muc(stored, legacy_id, jid)
 
     def by_jid_only_if_exists(self, jid: JID) -> Optional[LegacyMUCType]:
         with self.__store.session():
@@ -138,22 +108,39 @@ class LegacyBookmarks(
 
     async def by_legacy_id(self, legacy_id: LegacyGroupIdType) -> LegacyMUCType:
         async with self.lock(("legacy_id", legacy_id)):
-            with self.__store.session():
-                stored = self.__store.get_by_legacy_id(
-                    self.session.user_pk, str(legacy_id)
-                )
-                if stored is not None and stored.updated:
-                    return self._muc_class.from_store(self.session, stored)
-            self.log.debug("Create new MUC instance for legacy ID %s", legacy_id)
             local = await self.legacy_id_to_jid_local_part(legacy_id)
-            bare = f"{local}@{self.xmpp.boundjid}"
-            jid = JID(bare)
-            if self.get_lock(("bare", bare)):
+            jid = JID(f"{local}@{self.xmpp.boundjid}")
+            if self.get_lock(("bare", jid.bare)):
                 self.log.debug("Not instantiating %s after all", legacy_id)
                 return await self.by_jid(jid)
-            muc = await self.__finish_init_muc(legacy_id, jid)
 
-            return muc
+            with self.__store.session():
+                stored = self.__store.get_by_legacy_id(
+                    self.session.user_pk, str(legacy_id)
+                )
+                return await self.__update_muc(stored, legacy_id, jid)
+
+    async def __update_muc(
+        self, stored: Room | None, legacy_id: LegacyGroupIdType, jid: JID
+    ):
+        if stored is None:
+            muc = self._muc_class(self.session, legacy_id=legacy_id, jid=jid)
+        else:
+            muc = self._muc_class.from_store(self.session, stored)
+            if stored.updated:
+                return muc
+
+        try:
+            with muc.updating_info():
+                await muc.avatar_wrap_update_info()
+        except Exception as e:
+            raise XMPPError("internal-server-error", str(e))
+        if not muc.user_nick:
+            muc.user_nick = self._user_nick
+        self.log.debug("MUC created: %r", muc)
+        muc.pk = self.__store.update(muc)
+        muc.archive = MessageArchive(muc.pk, self.xmpp.store.mam)
+        return muc
 
     @abc.abstractmethod
     async def fill(self):

slidge/group/participant.py

@@ -450,13 +450,21 @@ class LegacyParticipant(
         return super().get_disco_info()
 
     def moderate(self, legacy_msg_id: LegacyMessageType, reason: Optional[str] = None):
-        m = self.muc.get_system_participant()._make_message()
-        m["apply_to"]["id"] = self._legacy_to_xmpp(legacy_msg_id)
-        m["apply_to"]["moderated"].enable("retract")
-        m["apply_to"]["moderated"]["by"] = self.jid
-        if reason:
-            m["apply_to"]["moderated"]["reason"] = reason
-        self._send(m)
+        xmpp_id = self._legacy_to_xmpp(legacy_msg_id)
+        multi = self.xmpp.store.multi.get_xmpp_ids(self.session.user_pk, xmpp_id)
+        if multi is None:
+            msg_ids = [xmpp_id]
+        else:
+            msg_ids = multi + [xmpp_id]
+
+        for i in msg_ids:
+            m = self.muc.get_system_participant()._make_message()
+            m["apply_to"]["id"] = i
+            m["apply_to"]["moderated"].enable("retract")
+            m["apply_to"]["moderated"]["by"] = self.jid
+            if reason:
+                m["apply_to"]["moderated"]["reason"] = reason
+            self._send(m)
 
     def set_room_subject(
         self,

slidge/group/room.py

@@ -206,6 +206,8 @@ class LegacyMUC(
     @user_nick.setter
     def user_nick(self, nick: str):
         self._user_nick = nick
+        if not self._updating_info:
+            self.__store.update_user_nick(self.pk, nick)
 
     def add_user_resource(self, resource: str) -> None:
         self._user_resources.add(resource)
@@ -1195,7 +1197,7 @@ class LegacyMUC(
         )
         muc.pk = stored.id
         muc.type = stored.muc_type  # type: ignore
-        muc.user_nick = stored.user_nick
+        muc._user_nick = stored.user_nick
         if stored.name:
             muc.DISCO_NAME = stored.name
         if stored.description:

slidge/util/db.py

@@ -0,0 +1,5 @@
+# here to allow migration of the user store from v0.1
+# since it relies on shelf, which relies on pickle, we need to keep objects
+# importable where they were when the shelf was written
+
+from ..db.alembic.old_user_store import *  # noqa:F403

{slidge-0.2.0a3.dist-info → slidge-0.2.0a4.dist-info}/METADATA

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

{slidge-0.2.0a3.dist-info → slidge-0.2.0a4.dist-info}/RECORD

@@ -1,21 +1,21 @@
 slidge/__init__.py,sha256=S0tUjqpZlzsr8G4Y_1Xt-KCYB07qaknTB0OwHU8k29U,1587
 slidge/__main__.py,sha256=Y12eh1TD_C5MB50KgEAuMffGnRFCvKYFKHD4UYSmHA0,72
-slidge/__version__.py,sha256=Ip83rsG7PNyMNP7tUYp3yfTqTCEX_G49W_HLxj1iJ7U,170
+slidge/__version__.py,sha256=DiSDY0IeSP34Y0bfesUNWzvITu9c0Hjquli6h3JVwMk,170
 slidge/command/__init__.py,sha256=UYf1mjCYbZ5G7PIgaFTWSQRAzEJkQ6dTH8Fu_e_XnO0,613
 slidge/command/adhoc.py,sha256=5xLLoWyUJqCJB7kAwD2VKYTl_7MObCsgdz-qg_WkWGs,9417
-slidge/command/admin.py,sha256=JAN8s-b2KckgUozAQNBGOzkrEaQv-LtwezYgOsAR6Ng,5768
+slidge/command/admin.py,sha256=x_kJ0TJhzf6d3OBIOXFjudZFO8bRYUG919td7OjMCug,6008
 slidge/command/base.py,sha256=xTlzxAbTWTpbFgQ0FxKjmp3ZImzempwJvGn9UiVUUTc,13044
 slidge/command/categories.py,sha256=BJCfaga2qoAxnHfgHD7I_RKZuBA5nnNOukkWHJwsUFE,99
 slidge/command/chat_command.py,sha256=kMnxrzmD7LhWgyO1w9Rgz1eA7PhfAJ2Rf34YWjoKrwQ,9975
 slidge/command/register.py,sha256=fzPcGUoJtainnDOiC13gWV-uYLuJcsmdKGJ-jXT1qIo,6697
 slidge/command/user.py,sha256=nJnoU4t1r9oPkFFHSHHwSY8WOQNLQn9mMcwZp-yZaKA,11422
 slidge/contact/__init__.py,sha256=WMMaHk7UW7YT9EH2LtPdkU0bHQaOp4ikBhbBQskmoc8,191
-slidge/contact/contact.py,sha256=l0zolnfrcSdS7z49TI-CSzjQiqJ-ARSMnZuszBcILXk,21894
-slidge/contact/roster.py,sha256=2EGV7q0km6JEahn2brr-td0KJILtXQGFWiSPuORA86I,10756
+slidge/contact/contact.py,sha256=E7QEivJQ6GSVqi0BOe_7CohYDqCXHabGiPDe37WWKLI,21916
+slidge/contact/roster.py,sha256=2UPuf2XkCdt9mdjhbATxxIH5dyIiJaxA0en8t1BgJuc,9989
 slidge/core/__init__.py,sha256=RG7Jj5JCJERjhqJ31lOLYV-7bH_oblClQD1KF9LsTXo,68
 slidge/core/config.py,sha256=leNcN_TI0Ka1hhzOHx7cBW3fNj5xZwsiv9l8AfRY_vU,7630
 slidge/core/gateway/__init__.py,sha256=rZckY2gAE-mon77_DSsAW1XtWqhBAETE2d4FqZ8pJXk,58
-slidge/core/gateway/base.py,sha256=6AOWuJPC4GkLcsgvrxHT5Y86g2x6Kv0iMbkp2wjepxo,38483
+slidge/core/gateway/base.py,sha256=EWqDLhkCcVUJf0Cy-PZPYxdIEhXckHv1-XG7GlHYcdQ,38491
 slidge/core/gateway/caps.py,sha256=jemB4tB_2MTAxqQw5Bs4b7qNQ8gLPuAve0aoH6TzLEs,1937
 slidge/core/gateway/delivery_receipt.py,sha256=AT_9gvZrtWpSRsDJcYjE8CmF7TW-YBbUPdqNW5zWAdo,1352
 slidge/core/gateway/disco.py,sha256=uazgDXSDb5KrardjPCvElItARcxkeBRohtx82A2BlCQ,2203
@@ -26,7 +26,7 @@ slidge/core/gateway/presence.py,sha256=Ls8IY4uNQaW8F3F1CpRhfyFIVbd_py_VkZyJKMMei
 slidge/core/gateway/registration.py,sha256=JXwIQ-QqZCPXEmCU2G8FvIYDGvD8L8CqGb_Qkbycgt0,2303
 slidge/core/gateway/search.py,sha256=08ds6gvzX3EnTH-AU8X8J8JKEKYaSrRGTFwwClTT-Rc,3495
 slidge/core/gateway/session_dispatcher.py,sha256=F8YGUCB7hA1PNsGgQDaUYHmLnf4e8NWptIh-9ra_43c,32930
-slidge/core/gateway/vcard_temp.py,sha256=2FeP-comBg8A-OtB-II1jlxyDib_C4R8vfnJHGNkzyc,4626
+slidge/core/gateway/vcard_temp.py,sha256=cnzHZO6qF8OUWSvBieEdNAV_Ndv1ixZOzBCBXy2Vopw,4637
 slidge/core/mixins/__init__.py,sha256=muReAzgvENgMvlfm0Fpe6BQFfm2EMjoDe9ZhGgo6Vig,627
 slidge/core/mixins/attachment.py,sha256=YXuObz68eem2AND1q-RBeZ-X9Zi_IlUgx0DRMiwM3Xw,18706
 slidge/core/mixins/avatar.py,sha256=ke3cwm6Iiz1AM0_SiARTUTU2nGYskPZlxtFrXKQT5fI,7812
@@ -38,7 +38,7 @@ slidge/core/mixins/message.py,sha256=jJz_peNQmDf0uVQcI7TWG7oUaSGjUL8eiulNicGgWhI
 slidge/core/mixins/message_maker.py,sha256=TcCutHi0sIwL6beJNkN7XyR0aDIbA0xZyxd2Gc9ulG4,6022
 slidge/core/mixins/presence.py,sha256=yywo6KAw8C7GaZSMrSMuioNfhW08MrnobHt8XbHd0q8,7891
 slidge/core/mixins/recipient.py,sha256=U-YppozUO8pA94jmD3-qmhkykTebPNaOVWc3JDPC9w8,1302
-slidge/core/pubsub.py,sha256=ofiZEw0tgckpdJJW102fj7MovUXBrCHYufaHaad4oFo,12390
+slidge/core/pubsub.py,sha256=m70ahpZLKUWdBb4fG4e90UpPhdcGGZJD31oDU_O12Rg,12434
 slidge/core/session.py,sha256=IUZur7huNj066uy-Nh-I-R0etYmPJccgXFIimcSQ148,27161
 slidge/db/__init__.py,sha256=EBDH1JSEhgqYcli2Bw11CRC749wJk8AOucgBzmhDSvU,105
 slidge/db/alembic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -58,15 +58,15 @@ slidge/db/alembic/versions/b33993e87db3_move_everything_to_persistent_db.py,sha2
 slidge/db/alembic/versions/b64b1a793483_add_source_and_legacy_id_for_archived_.py,sha256=N6HYpFBhMckAFLZFW8PY8Us1qzXlauEQiDwEYwd9_K8,1422
 slidge/db/alembic/versions/c4a8ec35a0e8_per_room_user_nick.py,sha256=jjQmlRv6nqdm5q6LbwVpSUSkTBj1c76Hiq8e8q77q3g,933
 slidge/db/alembic/versions/e91195719c2c_store_users_avatars_persistently.py,sha256=8Ga3VFgKrzMs_-B8OPtfP-0rey_MFaDg-QGtSbaft3o,640
-slidge/db/avatar.py,sha256=khMqkhUSLOOAulhWHUtkIlE8asdqUuaY8cieij97Hsw,7640
+slidge/db/avatar.py,sha256=C3BrEkEJbBEEY42DjXMacl8wOXgooUQ9KgIOUPs9620,7881
 slidge/db/meta.py,sha256=v1Jf-npZ28QwdGpsLQWLBHEbEP3-jnPrygRg05tJ_Iw,1831
 slidge/db/models.py,sha256=UoQnDYGuwp8VPYpqMKS9uFez_Vc8IMHtLADGlDCXC1Q,13179
-slidge/db/store.py,sha256=rlDwapJhMM2iOpJsjn371qG14nuwZoS5Scd8txF3rWM,40817
+slidge/db/store.py,sha256=j-8MvzC_HVzjYXEimAq8ViPSZfrT90QLs1U3FUoYPJs,41597
 slidge/group/__init__.py,sha256=yFt7cHqeaKIMN6f9ZyhhspOcJJvBtLedGv-iICG7lto,258
 slidge/group/archive.py,sha256=xGPkdSk8-BT6t6lNVo1FEwiFVAttoxCma8Tsyk5r8Kg,5279
-slidge/group/bookmarks.py,sha256=NGEOTSrIIzSYVxUp2QlbW4cRNavPCaFLo21WrOjxBPc,6647
-slidge/group/participant.py,sha256=FhI8RjVMp5fpYMLxG38wWPI3GEke8rTs-tmLklCIpzA,16764
-slidge/group/room.py,sha256=OiV-qex_aGezGwOkKe2Uxscm7LA9F0NrvhRo-y-6Sjw,45232
+slidge/group/bookmarks.py,sha256=_LDf7A7aWkwPH88v7c-mOp8VJs3gSFM1-uCqSb4ThO8,5825
+slidge/group/participant.py,sha256=VNMtqr98QVuYgiTsJ9BaaIG1noz-xe3ewyKhLeDRhBk,17033
+slidge/group/room.py,sha256=QGi1I5O8PDm_ivQOx5vZUeJ5v_ldrPHs4s-szyM-dCQ,45326
 slidge/main.py,sha256=TbkG5m1SgNmfaZ7TOD5VGTh4Q52XltLJayWnan8M9cw,5986
 slidge/migration.py,sha256=qUrux9dYCtOfFjPIlvGfWjoyqhkdxzaOByJRqTmCoUI,1072
 slidge/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -107,11 +107,12 @@ slidge/slixfix/xep_0490/stanza.py,sha256=ztec_ipyhUFz_uWQYkS0Q6LlsNiSBBC5aZK-qSm
 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=nCldxi9dLPj-c4LqZChR9DbzXFU4WgT0o_Pe80JJIDc,13279
 slidge/util/types.py,sha256=Gif-Z9NVd_eTei1uM3_KOsdok3B1yMQwdOkOzf9vheE,5224
 slidge/util/util.py,sha256=8JeE0QObNGQr_Tw4OFPwQSz_EB_zh_0t9IJmNNhW0ic,9114
-slidge-0.2.0a3.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-slidge-0.2.0a3.dist-info/METADATA,sha256=FHnY-NweSRtVFdxm75xTdbZD2MieNfqIvlagawopsWM,4723
-slidge-0.2.0a3.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-slidge-0.2.0a3.dist-info/entry_points.txt,sha256=SNl72KSocF5plsu_67xyH6wVWfGTXQbzkQgXbLtzDrQ,47
-slidge-0.2.0a3.dist-info/RECORD,,
+slidge-0.2.0a4.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+slidge-0.2.0a4.dist-info/METADATA,sha256=idAPh52VqnQnIO6w47GLlGeDUegzVQU0sycTqDezW1I,4723
+slidge-0.2.0a4.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+slidge-0.2.0a4.dist-info/entry_points.txt,sha256=SNl72KSocF5plsu_67xyH6wVWfGTXQbzkQgXbLtzDrQ,47
+slidge-0.2.0a4.dist-info/RECORD,,