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

slidge/group/archive.py

@@ -1,35 +1,39 @@
 import logging
 import uuid
 from copy import copy
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Collection, Optional
 
 from slixmpp import Iq, Message
 
+from ..db.models import ArchivedMessage, ArchivedMessageSource
+from ..db.store import MAMStore
 from ..util.archive_msg import HistoryMessage
-from ..util.db import GatewayUser
-from ..util.sql import db
+from ..util.types import HoleBound
 
 if TYPE_CHECKING:
     from .participant import LegacyParticipant
 
 
 class MessageArchive:
-    def __init__(self, db_id: str, user: GatewayUser):
-        self.db_id = db_id
-        self.user = user
-        db.mam_add_muc(db_id, user)
+    def __init__(self, room_pk: int, store: MAMStore):
+        self.room_pk = room_pk
+        self.__store = store
 
     def add(
         self,
         msg: Message,
         participant: Optional["LegacyParticipant"] = None,
+        archive_only=False,
+        legacy_msg_id=None,
     ):
         """
         Add a message to the archive if it is deemed archivable
 
         :param msg:
         :param participant:
+        :param archive_only:
+        :param legacy_msg_id:
         """
         if not archivable(msg):
             return
@@ -40,7 +44,7 @@ class MessageArchive:
             if participant.contact:
                 new_msg["muc"]["jid"] = participant.contact.jid.bare
             elif participant.is_user:
-                new_msg["muc"]["jid"] = participant.user.jid.bare
+                new_msg["muc"]["jid"] = participant.user_jid.bare
             elif participant.is_system:
                 new_msg["muc"]["jid"] = participant.muc.jid
             else:
@@ -49,11 +53,50 @@ class MessageArchive:
                     "jid"
                 ] = f"{uuid.uuid4()}@{participant.xmpp.boundjid.bare}"
 
-        db.mam_add_msg(self.db_id, HistoryMessage(new_msg), self.user)
+        self.__store.add_message(
+            self.room_pk,
+            HistoryMessage(new_msg),
+            archive_only,
+            None if legacy_msg_id is None else str(legacy_msg_id),
+        )
 
     def __iter__(self):
         return iter(self.get_all())
 
+    @staticmethod
+    def __to_bound(stored: ArchivedMessage):
+        return HoleBound(
+            stored.legacy_id,  # type:ignore
+            stored.timestamp.replace(tzinfo=timezone.utc),
+        )
+
+    def get_hole_bounds(self) -> tuple[HoleBound | None, HoleBound | None]:
+        most_recent = self.__store.get_most_recent_with_legacy_id(self.room_pk)
+        if most_recent is None:
+            return None, None
+        if most_recent.source == ArchivedMessageSource.BACKFILL:
+            # most recent = only backfill, fetch everything since last backfill
+            return self.__to_bound(most_recent), None
+
+        most_recent_back_filled = self.__store.get_most_recent_with_legacy_id(
+            self.room_pk, ArchivedMessageSource.BACKFILL
+        )
+        if most_recent_back_filled is None:
+            # group was never back-filled, fetch everything before first live
+            least_recent_live = self.__store.get_first(self.room_pk, True)
+            assert least_recent_live is not None
+            return None, self.__to_bound(least_recent_live)
+
+        assert most_recent_back_filled.legacy_id is not None
+        least_recent_live = self.__store.get_least_recent_with_legacy_id_after(
+            self.room_pk, most_recent_back_filled.legacy_id
+        )
+        assert least_recent_live is not None
+        # this is a hole caused by slidge downtime
+        return self.__to_bound(most_recent_back_filled), self.__to_bound(
+            least_recent_live
+        )
+
     def get_all(
         self,
         start_date: Optional[datetime] = None,
@@ -65,9 +108,8 @@ class MessageArchive:
         sender: Optional[str] = None,
         flip=False,
     ):
-        for msg in db.mam_get_messages(
-            self.user,
-            self.db_id,
+        for msg in self.__store.get_messages(
+            self.room_pk,
             before_id=before_id,
             after_id=after_id,
             ids=ids,
@@ -87,11 +129,13 @@ class MessageArchive:
         :return:
         """
         reply = iq.reply()
-        messages = db.mam_get_first_and_last(self.db_id)
+        messages = self.__store.get_first_and_last(self.room_pk)
         if messages:
             for x, m in [("start", messages[0]), ("end", messages[-1])]:
                 reply["mam_metadata"][x]["id"] = m.id
-                reply["mam_metadata"][x]["timestamp"] = m.sent_on
+                reply["mam_metadata"][x]["timestamp"] = m.sent_on.replace(
+                    tzinfo=timezone.utc
+                )
         else:
             reply.enable("mam_metadata")
         reply.send()

slidge/group/bookmarks.py

@@ -1,14 +1,17 @@
 import abc
 import logging
-from typing import TYPE_CHECKING, Generic, Type
+from typing import TYPE_CHECKING, Generic, Iterator, Optional, Type
 
 from slixmpp import JID
+from slixmpp.exceptions import XMPPError
 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
 from .room import LegacyMUC
 
 if TYPE_CHECKING:
@@ -27,17 +30,15 @@ class LegacyBookmarks(
     def __init__(self, session: "BaseSession"):
         self.session = session
         self.xmpp = session.xmpp
-        self.user = session.user
-
-        self._mucs_by_legacy_id = dict[LegacyGroupIdType, LegacyMUCType]()
-        self._mucs_by_bare_jid = dict[str, LegacyMUCType]()
+        self.user_jid = session.user_jid
+        self.__store = self.xmpp.store.rooms
 
         self._muc_class: Type[LegacyMUCType] = LegacyMUC.get_self_or_unique_subclass()
 
-        self._user_nick: str = self.session.user.jid.node
+        self._user_nick: str = self.session.user_jid.node
 
         super().__init__()
-        self.log = logging.getLogger(f"{self.user.bare_jid}:bookmarks")
+        self.log = logging.getLogger(f"{self.user_jid.bare}:bookmarks")
         self.ready = self.session.xmpp.loop.create_future()
         if not self.xmpp.GROUPS:
             self.ready.set_result(True)
@@ -50,21 +51,12 @@ class LegacyBookmarks(
     def user_nick(self, nick: str):
         self._user_nick = nick
 
-    def __iter__(self):
-        return iter(self._mucs_by_legacy_id.values())
+    def __iter__(self) -> Iterator[LegacyMUCType]:
+        for stored in self.__store.get_all(user_pk=self.session.user_pk):
+            yield self._muc_class.from_store(self.session, stored)
 
     def __repr__(self):
-        return f"<Bookmarks of {self.user}>"
-
-    async def __finish_init_muc(self, legacy_id: LegacyGroupIdType, jid: JID):
-        muc = self._muc_class(self.session, legacy_id=legacy_id, jid=jid)
-        await muc.avatar_wrap_update_info()
-        if not muc.user_nick:
-            muc.user_nick = self._user_nick
-        self.log.debug("MUC created: %r", muc)
-        self._mucs_by_legacy_id[muc.legacy_id] = muc
-        self._mucs_by_bare_jid[muc.jid.bare] = muc
-        return muc
+        return f"<Bookmarks of {self.user_jid}>"
 
     async def legacy_id_to_jid_local_part(self, legacy_id: LegacyGroupIdType):
         return await self.legacy_id_to_jid_username(legacy_id)
@@ -94,38 +86,63 @@ class LegacyBookmarks(
         return _unescape_node(username)
 
     async def by_jid(self, jid: JID) -> LegacyMUCType:
-        bare = jid.bare
-        async with self.lock(("bare", bare)):
-            muc = self._mucs_by_bare_jid.get(bare)
-            if muc is None:
-                self.log.debug("Attempting to instantiate a new MUC for JID %s", jid)
-                local_part = jid.node
-                legacy_id = await self.jid_local_part_to_legacy_id(local_part)
-                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)
-                self.log.debug("%r is group %r", local_part, legacy_id)
-                muc = await self.__finish_init_muc(legacy_id, JID(bare))
-            else:
-                self.log.trace("Found an existing MUC instance: %s", muc)  # type:ignore
-            return muc
+        if jid.resource:
+            jid = JID(jid.bare)
+        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)
+                return await self.__update_muc(stored, legacy_id, jid)
+
+    def by_jid_only_if_exists(self, jid: JID) -> Optional[LegacyMUCType]:
+        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)
+        return None
 
     async def by_legacy_id(self, legacy_id: LegacyGroupIdType) -> LegacyMUCType:
         async with self.lock(("legacy_id", legacy_id)):
-            muc = self._mucs_by_legacy_id.get(legacy_id)
-            if muc is None:
-                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)):
-                    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)
-            else:
-                self.log.trace("Found an existing MUC instance: %s", muc)  # type:ignore
-
-            return muc
+            local = await self.legacy_id_to_jid_local_part(legacy_id)
+            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)
+
+            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 XMPPError:
+            raise
+        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):
@@ -145,19 +162,26 @@ class LegacyBookmarks(
                 " LegacyBookmarks.fill() was not overridden."
             )
 
-    def remove(self, muc: LegacyMUC):
-        try:
-            del self._mucs_by_legacy_id[muc.legacy_id]
-        except KeyError:
-            self.log.warning("Removed a MUC that we didn't store by legacy ID")
-        try:
-            del self._mucs_by_bare_jid[muc.jid.bare]
-        except KeyError:
-            self.log.warning("Removed a MUC that we didn't store by JID")
-        for part in muc._participants_by_contacts.values():
-            try:
-                part.contact.participants.remove(part)
-            except KeyError:
-                part.log.warning(
-                    "That participant wasn't stored in the contact's participants attribute"
-                )
+    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

@@ -6,7 +6,7 @@ import warnings
 from copy import copy
 from datetime import datetime
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Optional, Self, Union
 
 from slixmpp import JID, InvalidJID, Message, Presence
 from slixmpp.plugins.xep_0045.stanza import MUCAdminItem
@@ -15,10 +15,16 @@ from slixmpp.types import MessageTypes, OptJid
 from slixmpp.util.stringprep_profiles import StringPrepError, prohibit_output
 
 from ..contact import LegacyContact
-from ..core.mixins import ChatterDiscoMixin, MessageMixin, PresenceMixin
+from ..core.mixins import (
+    ChatterDiscoMixin,
+    MessageMixin,
+    PresenceMixin,
+    StoredAttributeMixin,
+)
+from ..db.models import Participant
 from ..util import SubclassableOnce, strip_illegal_chars
-from ..util.sql import CachedPresence
 from ..util.types import (
+    CachedPresence,
     Hat,
     LegacyMessageType,
     MessageOrPresenceTypeVar,
@@ -40,6 +46,7 @@ def strip_non_printable(nickname: str):
 
 
 class LegacyParticipant(
+    StoredAttributeMixin,
     PresenceMixin,
     MessageMixin,
     ChatterDiscoMixin,
@@ -53,6 +60,7 @@ class LegacyParticipant(
     _can_send_carbon = False
     USE_STANZA_ID = True
     STRIP_SHORT_DELAY = False
+    pk: int
 
     def __init__(
         self,
@@ -63,12 +71,11 @@ class LegacyParticipant(
         role: MucRole = "participant",
         affiliation: MucAffiliation = "member",
     ):
+        self.session = session = muc.session
+        self.xmpp = session.xmpp
         super().__init__()
         self._hats = list[Hat]()
         self.muc = muc
-        self.session = session = muc.session
-        self.user = session.user
-        self.xmpp = session.xmpp
         self._role = role
         self._affiliation = affiliation
         self.is_user: bool = is_user
@@ -84,8 +91,19 @@ class LegacyParticipant(
         # if we didn't, we send it before the first message.
         # this way, event in plugins that don't map "user has joined" events,
         # we send a "join"-presence from the participant before the first message
-        self.__presence_sent = False
-        self.log = logging.getLogger(f"{self.user.bare_jid}:{self.jid}")
+        self._presence_sent: bool = False
+        self.log = logging.getLogger(f"{self.user_jid.bare}:{self.jid}")
+        self.__part_store = self.xmpp.store.participants
+
+    @property
+    def contact_pk(self) -> Optional[int]:  # type:ignore
+        if self.contact:
+            return self.contact.contact_pk
+        return None
+
+    @property
+    def user_jid(self):
+        return self.session.user_jid
 
     def __repr__(self):
         return f"<Participant '{self.nickname}'/'{self.jid}' of '{self.muc}'>"
@@ -99,7 +117,10 @@ class LegacyParticipant(
         if self._affiliation == affiliation:
             return
         self._affiliation = affiliation
-        if not self.__presence_sent:
+        if not self.muc._participants_filled:
+            return
+        self.__part_store.set_affiliation(self.pk, affiliation)
+        if not self._presence_sent:
             return
         self.send_last_presence(force=True, no_cache_online=True)
 
@@ -126,7 +147,10 @@ class LegacyParticipant(
         if self._role == role:
             return
         self._role = role
-        if not self.__presence_sent:
+        if not self.muc._participants_filled:
+            return
+        self.__part_store.set_role(self.pk, role)
+        if not self._presence_sent:
             return
         self.send_last_presence(force=True, no_cache_online=True)
 
@@ -134,7 +158,10 @@ class LegacyParticipant(
         if self._hats == hats:
             return
         self._hats = hats
-        if not self.__presence_sent:
+        if not self.muc._participants_filled:
+            return
+        self.__part_store.set_hats(self.pk, hats)
+        if not self._presence_sent:
             return
         self.send_last_presence(force=True, no_cache_online=True)
 
@@ -143,6 +170,7 @@ class LegacyParticipant(
 
         if self.is_system:
             self.jid = j
+            self._nickname_no_illegal = ""
             return
 
         nickname = unescaped_nickname
@@ -170,9 +198,6 @@ class LegacyParticipant(
         except InvalidJID:
             j.resource = strip_non_printable(nickname)
 
-        if nickname != unescaped_nickname:
-            self.muc._participants_by_escaped_nicknames[nickname] = self  # type:ignore
-
         self.jid = j
 
     def send_configuration_change(self, codes: tuple[int]):
@@ -213,12 +238,8 @@ class LegacyParticipant(
 
         kwargs["status_codes"] = set()
         p = self._make_presence(ptype="available", last_seen=last_seen, **kwargs)
-        self.__add_nick_element(p)
         self._send(p)
 
-        if old:
-            self.muc.rename_participant(old, new_nickname)
-
     def _make_presence(
         self,
         *,
@@ -240,14 +261,14 @@ class LegacyParticipant(
                 if user_full_jid:
                     p["muc"]["jid"] = user_full_jid
                 else:
-                    jid = copy(self.user.jid)
+                    jid = copy(self.user_jid)
                     try:
                         jid.resource = next(
-                            iter(self.muc.user_resources)  # type:ignore
+                            iter(self.muc.get_user_resources())  # type:ignore
                         )
                     except StopIteration:
                         jid.resource = "pseudo-resource"
-                    p["muc"]["jid"] = self.user.jid
+                    p["muc"]["jid"] = self.user_jid
                 codes.add(100)
             elif self.contact:
                 p["muc"]["jid"] = self.contact.jid
@@ -257,7 +278,7 @@ class LegacyParticipant(
                 warnings.warn(
                     f"Private group but no 1:1 JID associated to '{self}'",
                 )
-        if self.is_user and (hash_ := self.session.avatar_hash):
+        if self.is_user and (hash_ := self.session.user.avatar_hash):
             p["vcard_temp_update"]["photo"] = hash_
         p["muc"]["status_codes"] = codes
         return p
@@ -273,7 +294,7 @@ class LegacyParticipant(
             archive_only
             or self.is_system
             or self.is_user
-            or self.__presence_sent
+            or self._presence_sent
             or stanza["subject"]
         ):
             return
@@ -298,13 +319,16 @@ class LegacyParticipant(
         stanza: MessageOrPresenceTypeVar,
         full_jid: Optional[JID] = None,
         archive_only=False,
+        legacy_msg_id=None,
         **send_kwargs,
     ) -> MessageOrPresenceTypeVar:
         stanza["occupant-id"]["id"] = self.__occupant_id
-        if isinstance(stanza, Presence):
-            if stanza["type"] == "unavailable" and not self.__presence_sent:
+        self.__add_nick_element(stanza)
+        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
+            self._presence_sent = True
+            self.__part_store.set_presence_sent(self.pk)
         if full_jid:
             stanza["to"] = full_jid
             self.__send_presence_if_needed(stanza, full_jid, archive_only)
@@ -314,8 +338,8 @@ class LegacyParticipant(
             else:
                 stanza.send()
         else:
-            if isinstance(stanza, Message):
-                self.muc.archive.add(stanza, self)
+            if hasattr(self.muc, "archive") and isinstance(stanza, Message):
+                self.muc.archive.add(stanza, self, archive_only, legacy_msg_id)
             if archive_only:
                 return stanza
             for user_full_jid in self.muc.user_full_jids():
@@ -332,7 +356,7 @@ class LegacyParticipant(
         item["role"] = self.role
         if not self.muc.is_anonymous:
             if self.is_user:
-                item["jid"] = self.user.bare_jid
+                item["jid"] = self.user_jid.bare
             elif self.contact:
                 item["jid"] = self.contact.jid.bare
             else:
@@ -344,11 +368,11 @@ class LegacyParticipant(
                 )
         return item
 
-    def __add_nick_element(self, p: Presence):
+    def __add_nick_element(self, stanza: Union[Presence, Message]):
         if (nick := self._nickname_no_illegal) != self.jid.resource:
             n = self.xmpp.plugin["xep_0172"].stanza.UserNick()
             n["nick"] = nick
-            p.append(n)
+            stanza.append(n)
 
     def _get_last_presence(self) -> Optional[CachedPresence]:
         own = super()._get_last_presence()
@@ -400,7 +424,6 @@ class LegacyParticipant(
         )
         if presence_id:
             p["id"] = presence_id
-        self.__add_nick_element(p)
         self._send(p, full_jid)
 
     def leave(self):
@@ -409,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:
@@ -427,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,
@@ -444,7 +475,7 @@ class LegacyParticipant(
     ):
         if update_muc:
             self.muc._subject = subject  # type: ignore
-            self.muc.subject_setter = self
+            self.muc.subject_setter = self.nickname
             self.muc.subject_date = when
 
         msg = self._make_message()
@@ -454,5 +485,41 @@ class LegacyParticipant(
         msg["subject"] = subject or str(self.muc.name)
         self._send(msg, full_jid)
 
+    @classmethod
+    def from_store(
+        cls,
+        session,
+        stored: Participant,
+        contact: Optional[LegacyContact] = None,
+        muc: Optional["LegacyMUC"] = None,
+    ) -> Self:
+        from slidge.group.room import LegacyMUC
+
+        if muc is None:
+            muc = LegacyMUC.get_self_or_unique_subclass().from_store(
+                session, stored.room
+            )
+        part = cls(
+            muc,
+            stored.nickname,
+            role=stored.role,
+            affiliation=stored.affiliation,
+        )
+        part.pk = stored.id
+        if contact is not None:
+            part.contact = contact
+        elif stored.contact is not None:
+            contact = LegacyContact.get_self_or_unique_subclass().from_store(
+                session, stored.contact
+            )
+            part.contact = contact
+
+        part.is_user = stored.is_user
+        if (data := stored.extra_attributes) is not None:
+            muc.deserialize_extra_attributes(data)
+        part._presence_sent = stored.presence_sent
+        part._hats = [Hat(h.uri, h.title) for h in stored.hats]
+        return part
+
 
 log = logging.getLogger(__name__)