slidge 0.1.2__tar.gz → 0.2.0a0__tar.gz

{slidge-0.1.2 → slidge-0.2.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: slidge
-Version: 0.1.2
+Version: 0.2.0a0
 Summary: XMPP bridging framework
 Home-page: https://sr.ht/~nicoco/slidge/
 License: AGPL-3.0-or-later
@@ -15,11 +15,13 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
 Requires-Dist: Pillow (>=10,<11)
 Requires-Dist: aiohttp[speedups] (>=3.8.3,<4.0.0)
+Requires-Dist: alembic (>=1.13.1,<2.0.0)
 Requires-Dist: blurhash-python (>=1.2.1,<2.0.0)
 Requires-Dist: pickle-secure (>=0.99.9,<0.100.0)
 Requires-Dist: python-magic (>=0.4.27,<0.5.0)
 Requires-Dist: qrcode (>=7.4.1,<8.0.0)
 Requires-Dist: slixmpp (>=1.8.5,<2.0.0)
+Requires-Dist: sqlalchemy (>=2.0.29,<3.0.0)
 Project-URL: Documentation, https://slidge.im/
 Project-URL: Repository, https://git.sr.ht/~nicoco/slidge/
 Description-Content-Type: text/markdown

{slidge-0.1.2 → slidge-0.2.0a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "slidge"
-version = "0.1.2"
+version = "0.2.0alpha0"
 description = "XMPP bridging framework"
 authors = ["Nicolas Cedilnik <nicoco@nicoco.fr>"]
 readme = "README.md"
@@ -20,6 +20,8 @@ pickle-secure = "^0.99.9"
 python-magic = "^0.4.27"
 slixmpp = "^1.8.5"
 blurhash-python = "^1.2.1"
+sqlalchemy = "^2.0.29"
+alembic = "^1.13.1"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{slidge-0.1.2 → slidge-0.2.0a0}/slidge/__init__.py

@@ -13,13 +13,12 @@ from .contact import LegacyContact, LegacyRoster  # noqa: F401
 from .core import config as global_config  # noqa: F401
 from .core.gateway import BaseGateway  # noqa: F401
 from .core.session import BaseSession  # noqa: F401
+from .db import GatewayUser  # noqa: F401
 from .group import LegacyBookmarks, LegacyMUC, LegacyParticipant  # noqa: F401
-from .util.db import GatewayUser, user_store  # noqa: F401
+from .main import main as main_func
 from .util.types import MucType  # noqa: F401
 from .util.util import addLoggingLevel
 
-from .__main__ import main  # isort: skip
-
 
 def entrypoint(module_name: str) -> None:
     """
@@ -29,7 +28,7 @@ def entrypoint(module_name: str) -> None:
     :param module_name: An importable :term:`Legacy Module`.
     """
     sys.argv.extend(["--legacy", module_name])
-    main()
+    main_func()
 
 
 def formatwarning(message, category, filename, lineno, line=""):
@@ -54,7 +53,6 @@ __all__ = [
     # "FormField",
     # "SearchResult",
     "entrypoint",
-    "user_store",
     "global_config",
 ]
 

slidge-0.2.0a0/slidge/__main__.py

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

slidge-0.2.0a0/slidge/__version__.py

@@ -0,0 +1,5 @@
+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.0alpha0"

{slidge-0.1.2 → slidge-0.2.0a0}/slidge/command/adhoc.py

@@ -48,7 +48,10 @@ class AdhocProvider:
     async def __handle_category_list(
         self, category: str, iq: Iq, adhoc_session: AdhocSessionType
     ) -> AdhocSessionType:
-        session = self.xmpp.get_session_from_stanza(iq)
+        try:
+            session = self.xmpp.get_session_from_stanza(iq)
+        except XMPPError:
+            session = None
         commands = []
         for command in self._categories[category]:
             try:
@@ -56,6 +59,10 @@ class AdhocProvider:
             except XMPPError:
                 continue
             commands.append(command)
+        if len(commands) == 0:
+            raise XMPPError(
+                "not-authorized", "There is no command you can run in this category"
+            )
         return await self.__handle_result(
             session,
             Form(

{slidge-0.1.2 → slidge-0.2.0a0}/slidge/command/admin.py

@@ -7,7 +7,6 @@ from typing import Any, Optional
 from slixmpp import JID
 from slixmpp.exceptions import XMPPError
 
-from ..util.db import user_store
 from ..util.types import AnyBaseSession
 from .base import (
     Command,
@@ -33,13 +32,13 @@ class ListUsers(AdminCommand):
 
     async def run(self, _session, _ifrom, *_):
         items = []
-        for u in user_store.get_all():
+        for u in self.xmpp.store.users.get_all():
             d = u.registration_date
             if d is None:
                 joined = ""
             else:
                 joined = d.isoformat(timespec="seconds")
-            items.append({"jid": u.bare_jid, "joined": joined})
+            items.append({"jid": u.jid.bare, "joined": joined})
         return TableResult(
             description="List of registered users",
             fields=[FormField("jid", type="jid-single"), FormField("joined")],
@@ -54,7 +53,7 @@ class SlidgeInfo(AdminCommand):
     ACCESS = CommandAccess.ANY
 
     async def run(self, _session, _ifrom, *_):
-        from ..__main__ import __version__
+        from slidge.__version__ import __version__
 
         start = self.xmpp.datetime_started
         uptime = datetime.now() - start
@@ -114,7 +113,7 @@ class DeleteUser(AdminCommand):
         self, form_values: FormValues, _session: AnyBaseSession, _ifrom: JID
     ) -> Confirmation:
         jid: JID = form_values.get("jid")  # type:ignore
-        user = user_store.get_by_jid(jid)
+        user = self.xmpp.store.users.get(jid)
         if user is None:
             raise XMPPError("item-not-found", text=f"There is no user '{jid}'")
 
@@ -127,7 +126,7 @@ class DeleteUser(AdminCommand):
     async def finish(
         self, _session: Optional[AnyBaseSession], _ifrom: JID, jid: JID
     ) -> None:
-        user = user_store.get_by_jid(jid)
+        user = self.xmpp.store.users.get(jid)
         if user is None:
             raise XMPPError("bad-request", f"{jid} has no account here!")
         await self.xmpp.unregister_user(user)

{slidge-0.1.2 → slidge-0.2.0a0}/slidge/command/base.py

@@ -23,7 +23,6 @@ from slixmpp.plugins.xep_0004 import (
 from slixmpp.types import JidStr
 
 from ..core import config
-from ..util.db import user_store
 from ..util.types import AnyBaseSession, FieldType
 
 if TYPE_CHECKING:
@@ -382,7 +381,7 @@ class Command(ABC):
         raise XMPPError("feature-not-implemented")
 
     def _get_session(self, jid: JID) -> Optional["BaseSession[Any, Any]"]:
-        user = user_store.get_by_jid(jid)
+        user = self.xmpp.store.users.get(jid)
         if user is None:
             return None
 

{slidge-0.1.2 → slidge-0.2.0a0}/slidge/command/register.py

@@ -6,7 +6,6 @@ step for a JID to become a slidge :term:`User`.
 import asyncio
 import functools
 import tempfile
-from datetime import datetime
 from enum import IntEnum
 from typing import Any
 
@@ -15,8 +14,10 @@ from slixmpp import JID, Iq
 from slixmpp.exceptions import XMPPError
 
 from ..core import config
-from ..util.db import GatewayUser
+from ..db import GatewayUser
+from ..util.types import UserPreferences
 from .base import Command, CommandAccess, Form, FormField, FormValues
+from .user import Preferences
 
 
 class RegistrationType(IntEnum):
@@ -66,9 +67,12 @@ class Register(Command):
 
     SUCCESS_MESSAGE = "Success, welcome!"
 
-    def _finalize(self, user: GatewayUser):
-        user.commit()
-        self.xmpp.event("user_register", Iq(sfrom=user.jid))
+    def _finalize(
+        self, form_values: UserPreferences, _session, ifrom: JID, user: GatewayUser, *_
+    ) -> str:
+        user.preferences = form_values  # type: ignore
+        self.xmpp.store.users.update(user)
+        self.xmpp.event("user_register", Iq(sfrom=ifrom.bare))
         return self.SUCCESS_MESSAGE
 
     async def run(self, _session, _ifrom, *_):
@@ -82,26 +86,26 @@ class Register(Command):
     async def register(self, form_values: dict[str, Any], _session, ifrom: JID):
         two_fa_needed = True
         try:
-            await self.xmpp.user_prevalidate(ifrom, form_values)
+            data = await self.xmpp.user_prevalidate(ifrom, form_values)
         except ValueError as e:
             raise XMPPError("bad-request", str(e))
         except TwoFactorNotRequired:
+            data = None
             if self.xmpp.REGISTRATION_TYPE == RegistrationType.TWO_FACTOR_CODE:
                 two_fa_needed = False
             else:
                 raise
 
         user = GatewayUser(
-            bare_jid=ifrom.bare,
-            registration_form=form_values,
-            registration_date=datetime.now(),
+            jid=ifrom.bare,
+            legacy_module_data=form_values if data is None else data,
         )
 
         if self.xmpp.REGISTRATION_TYPE == RegistrationType.SINGLE_STEP_FORM or (
             self.xmpp.REGISTRATION_TYPE == RegistrationType.TWO_FACTOR_CODE
             and not two_fa_needed
         ):
-            return self._finalize(user)
+            return await self.preferences(user)
 
         if self.xmpp.REGISTRATION_TYPE == RegistrationType.TWO_FACTOR_CODE:
             return Form(
@@ -113,7 +117,7 @@ class Register(Command):
 
         elif self.xmpp.REGISTRATION_TYPE == RegistrationType.QRCODE:
             self.xmpp.qr_pending_registrations[  # type:ignore
-                user.bare_jid
+                user.jid.bare
             ] = (
                 self.xmpp.loop.create_future()
             )
@@ -159,13 +163,15 @@ class Register(Command):
         self, form_values: FormValues, _session, _ifrom, user: GatewayUser
     ):
         assert isinstance(form_values["code"], str)
-        await self.xmpp.validate_two_factor_code(user, form_values["code"])
-        return self._finalize(user)
+        data = await self.xmpp.validate_two_factor_code(user, form_values["code"])
+        if data is not None:
+            user.legacy_module_data.update(data)
+        return await self.preferences(user)
 
     async def qr(self, _form_values: FormValues, _session, _ifrom, user: GatewayUser):
         try:
-            await asyncio.wait_for(
-                self.xmpp.qr_pending_registrations[user.bare_jid],  # type:ignore
+            data = await asyncio.wait_for(
+                self.xmpp.qr_pending_registrations[user.jid.bare],  # type:ignore
                 config.QR_TIMEOUT,
             )
         except asyncio.TimeoutError:
@@ -176,4 +182,14 @@ class Register(Command):
                     "or you took too much time"
                 ),
             )
-        return self._finalize(user)
+        if data is not None:
+            user.legacy_module_data.update(data)
+        return await self.preferences(user)
+
+    async def preferences(self, user: GatewayUser) -> Form:
+        return Form(
+            title="Preferences",
+            instructions=Preferences.HELP,
+            fields=self.xmpp.PREFERENCES,
+            handler=functools.partial(self._finalize, user=user),  # type:ignore
+        )

{slidge-0.1.2 → slidge-0.2.0a0}/slidge/command/user.py

@@ -1,10 +1,12 @@
 # Commands available to users
+from copy import deepcopy
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 from slixmpp import JID  # type:ignore[attr-defined]
 from slixmpp.exceptions import XMPPError
 
-from ..util.types import AnyBaseSession, LegacyGroupIdType
+from ..group.room import LegacyMUC
+from ..util.types import AnyBaseSession, LegacyGroupIdType, UserPreferences
 from .base import (
     Command,
     CommandAccess,
@@ -76,7 +78,7 @@ class SyncContacts(Command):
     async def sync(self, session: Optional[AnyBaseSession], _ifrom: JID) -> str:
         if session is None:
             raise RuntimeError
-        roster_iq = await self.xmpp["xep_0356"].get_roster(session.user.bare_jid)
+        roster_iq = await self.xmpp["xep_0356"].get_roster(session.user_jid.bare)
 
         contacts = session.contacts.known_contacts()
 
@@ -90,13 +92,13 @@ class SyncContacts(Command):
                 if contact is None:
                     if len(groups) == 1:
                         await self.xmpp["xep_0356"].set_roster(
-                            session.user.jid, {item["jid"]: {"subscription": "remove"}}
+                            session.user_jid, {item["jid"]: {"subscription": "remove"}}
                         )
                         removed += 1
                     else:
                         groups.remove(self.xmpp.ROSTER_GROUP)
                         await self.xmpp["xep_0356"].set_roster(
-                            session.user.jid,
+                            session.user_jid,
                             {
                                 item["jid"]: {
                                     "subscription": item["subscription"],
@@ -229,6 +231,39 @@ class CreateGroup(Command):
         )
 
 
+class Preferences(Command):
+    NAME = "⚙️ Preferences"
+    HELP = "Customize the gateway behaviour to your liking"
+    NODE = CHAT_COMMAND = "preferences"
+    ACCESS = CommandAccess.USER
+
+    async def run(
+        self, session: Optional[AnyBaseSession], _ifrom: JID, *_: Any
+    ) -> Form:
+        fields = deepcopy(self.xmpp.PREFERENCES)
+        assert session is not None
+        current = session.user.preferences
+        for field in fields:
+            field.value = current.get(field.var)  # type:ignore
+        return Form(
+            title="Preferences",
+            instructions=self.HELP,
+            fields=fields,
+            handler=self.finish,  # type:ignore
+        )
+
+    async def finish(
+        self, form_values: UserPreferences, session: Optional[AnyBaseSession], *_
+    ) -> str:
+        assert session is not None
+        user = session.user
+        user.preferences.update(form_values)  # type:ignore
+        self.xmpp.store.users.update(user)
+        if form_values["sync_avatar"]:
+            await self.xmpp.fetch_user_avatar(session)
+        return "Your preferences have been updated."
+
+
 class Unregister(Command):
     NAME = "❌ Unregister from the gateway"
     HELP = "Unregister from the gateway"
@@ -246,5 +281,50 @@ class Unregister(Command):
 
     async def unregister(self, session: Optional[AnyBaseSession], _ifrom: JID) -> str:
         assert session is not None
-        await self.xmpp.unregister_user(session.user)
+        user = self.xmpp.store.users.get(session.user_jid)
+        assert user is not None
+        await self.xmpp.unregister_user(user)
         return "OK"
+
+
+class LeaveGroup(Command):
+    NAME = HELP = "❌ Leave a legacy group"
+    NODE = CHAT_COMMAND = "leave-group"
+    ACCESS = CommandAccess.USER_LOGGED
+    CATEGORY = GROUPS
+
+    async def run(self, session, _ifrom, *_):
+        assert session is not None
+        await session.bookmarks.fill()
+        groups = sorted(session.bookmarks, key=lambda g: g.DISCO_NAME.casefold())
+        return Form(
+            title="Leave a group",
+            instructions="Select the group you want to leave",
+            fields=[
+                FormField(
+                    "group",
+                    "Group name",
+                    options=[{"label": g.name, "value": g.name} for g in groups],
+                )
+            ],
+            handler=self.confirm,  # type:ignore
+            handler_args=(groups,),
+        )
+
+    async def confirm(
+        self,
+        form_values: FormValues,
+        _session: AnyBaseSession,
+        _ifrom,
+        groups: list[LegacyMUC],
+    ):
+        group = groups[int(form_values["group"])]  # type:ignore
+        return Confirmation(
+            prompt=f"Are you sure you want to leave the group '{group.name}'?",
+            handler=self.finish,  # type:ignore
+            handler_args=(group,),
+        )
+
+    @staticmethod
+    async def finish(session: AnyBaseSession, _ifrom, group: LegacyMUC):
+        await session.on_leave_group(group.legacy_id)

{slidge-0.1.2 → slidge-0.2.0a0}/slidge/contact/contact.py

@@ -2,7 +2,7 @@ import datetime
 import logging
 import warnings
 from datetime import date
-from typing import TYPE_CHECKING, Generic, Iterable, Optional, Union
+from typing import TYPE_CHECKING, Generic, Iterable, Optional, Self, Union
 
 from slixmpp import JID, Message, Presence
 from slixmpp.exceptions import IqError
@@ -10,10 +10,10 @@ from slixmpp.plugins.xep_0292.stanza import VCard4
 from slixmpp.types import MessageTypes
 
 from ..core import config
-from ..core.mixins import FullCarbonMixin
-from ..core.mixins.avatar import AvatarMixin
+from ..core.mixins import AvatarMixin, FullCarbonMixin, StoredAttributeMixin
 from ..core.mixins.disco import ContactAccountDiscoMixin
 from ..core.mixins.recipient import ReactionRecipientMixin, ThreadRecipientMixin
+from ..db.models import Contact
 from ..util import SubclassableOnce
 from ..util.types import LegacyUserIdType, MessageOrPresenceTypeVar
 
@@ -24,6 +24,7 @@ if TYPE_CHECKING:
 
 class LegacyContact(
     Generic[LegacyUserIdType],
+    StoredAttributeMixin,
     AvatarMixin,
     ContactAccountDiscoMixin,
     FullCarbonMixin,
@@ -100,7 +101,6 @@ class LegacyContact(
         """
         super().__init__()
         self.session = session
-        self.user = session.user
         self.legacy_id: LegacyUserIdType = legacy_id
         """
         The legacy identifier of the :term:`Legacy Contact`.
@@ -116,16 +116,40 @@ class LegacyContact(
 
         self._name: Optional[str] = None
 
-        if self.xmpp.MARK_ALL_MESSAGES:
-            self._sent_order = list[str]()
-
         self.xmpp = session.xmpp
         self.jid = JID(self.jid_username + "@" + self.xmpp.boundjid.bare)
         self.jid.resource = self.RESOURCE
-        self.log = logging.getLogger(f"{self.user.bare_jid}:{self.jid.bare}")
-        self.participants = set["LegacyParticipant"]()
-        self.is_friend: bool = False
-        self.__added_to_roster = False
+        self.log = logging.getLogger(f"{self.user_jid.bare}:{self.jid.bare}")
+        self._is_friend: bool = False
+        self.added_to_roster = False
+
+    @property
+    def is_friend(self):
+        return self._is_friend
+
+    @is_friend.setter
+    def is_friend(self, value: bool):
+        if value == self._is_friend:
+            return
+        self._is_friend = value
+        assert self.contact_pk is not None
+        self.xmpp.store.contacts.set_friend(self.contact_pk, value)
+
+    @property
+    def participants(self) -> list["LegacyParticipant"]:
+        assert self.contact_pk is not None
+        from ..group.participant import LegacyParticipant
+
+        return [
+            LegacyParticipant.get_self_or_unique_subclass().from_store(
+                self.session, stored, contact=self
+            )
+            for stored in self.xmpp.store.participants.get_for_contact(self.contact_pk)
+        ]
+
+    @property
+    def user_jid(self):
+        return self.session.user_jid
 
     def __repr__(self):
         return f"<Contact '{self.legacy_id}'/'{self.jid.bare}'>"
@@ -170,7 +194,7 @@ class LegacyContact(
     ) -> MessageOrPresenceTypeVar:
         if carbon and isinstance(stanza, Message):
             stanza["to"] = self.jid.bare
-            stanza["from"] = self.user.jid
+            stanza["from"] = self.user_jid
             self._privileged_send(stanza)
             return stanza  # type:ignore
 
@@ -186,12 +210,13 @@ class LegacyContact(
             n["nick"] = self.name
             stanza.append(n)
         if self.xmpp.MARK_ALL_MESSAGES and is_markable(stanza):
-            self._sent_order.append(stanza["id"])
-        stanza["to"] = self.user.jid
+            assert self.contact_pk is not None
+            self.xmpp.store.contacts.add_to_sent(self.contact_pk, stanza["id"])
+        stanza["to"] = self.user_jid
         stanza.send()
         return stanza
 
-    def get_msg_xmpp_id_up_to(self, horizon_xmpp_id: str):
+    def get_msg_xmpp_id_up_to(self, horizon_xmpp_id: str) -> list[str]:
         """
         Return XMPP msg ids sent by this contact up to a given XMPP msg id.
 
@@ -205,15 +230,8 @@ class LegacyContact(
         :param horizon_xmpp_id: The latest message
         :return: A list of XMPP ids or None if horizon_xmpp_id was not found
         """
-        for i, xmpp_id in enumerate(self._sent_order):
-            if xmpp_id == horizon_xmpp_id:
-                break
-        else:
-            return
-        i += 1
-        res = self._sent_order[:i]
-        self._sent_order = self._sent_order[i:]
-        return res
+        assert self.contact_pk is not None
+        return self.xmpp.store.contacts.pop_sent_up_to(self.contact_pk, horizon_xmpp_id)
 
     @property
     def name(self):
@@ -229,9 +247,19 @@ class LegacyContact(
         for p in self.participants:
             p.nickname = n
         self._name = n
-        self.xmpp.pubsub.set_nick(user=self.user, jid=self.jid.bare, nick=n)
+        assert self.contact_pk is not None
+        self.xmpp.store.contacts.update_nick(self.contact_pk, n)
+        self.xmpp.pubsub.broadcast_nick(
+            user_jid=self.user_jid, jid=self.jid.bare, nick=n
+        )
+
+    def _get_cached_avatar_id(self):
+        assert self.contact_pk is not None
+        return self.xmpp.store.contacts.get_avatar_legacy_id(self.contact_pk)
 
     def _post_avatar_update(self):
+        assert self.contact_pk is not None
+        self.xmpp.store.contacts.set_avatar(self.contact_pk, self._avatar_pk)
         for p in self.participants:
             self.log.debug("Propagating new avatar to %s", p.muc)
             p.send_last_presence(force=True, no_cache_online=True)
@@ -283,7 +311,7 @@ class LegacyContact(
         elif country:
             vcard.add_address(country, locality)
 
-        self.xmpp.vcard.set_vcard(self.jid.bare, vcard, {self.user.jid.bare})
+        self.xmpp.vcard.set_vcard(self.jid.bare, vcard, {self.user_jid.bare})
 
     async def add_to_roster(self, force=False):
         """
@@ -291,7 +319,7 @@ class LegacyContact(
 
         :param force: add even if the contact was already added successfully
         """
-        if self.__added_to_roster and not force:
+        if self.added_to_roster and not force:
             return
         if config.NO_ROSTER_PUSH:
             log.debug("Roster push request by plugin ignored (--no-roster-push)")
@@ -303,7 +331,7 @@ class LegacyContact(
         if (n := self.name) is not None:
             item["name"] = n
         kw = dict(
-            jid=self.user.jid,
+            jid=self.user_jid,
             roster_items={self.jid.bare: item},
         )
         try:
@@ -325,12 +353,26 @@ class LegacyContact(
         else:
             # we only broadcast pubsub events for contacts added to the roster
             # so if something was set before, we need to push it now
-            self.__added_to_roster = True
+            self.added_to_roster = True
             self.session.create_task(self.__broadcast_pubsub_items())
             self.send_last_presence()
 
     async def __broadcast_pubsub_items(self):
-        await self.xmpp.pubsub.broadcast_all(JID(self.jid.bare), self.user.jid)
+        cached_avatar = self.get_cached_avatar()
+        if cached_avatar is not None:
+            await self.xmpp.pubsub.broadcast_avatar(
+                self.jid.bare, self.session.user_jid, cached_avatar
+            )
+        nick = self.name
+        from ..core.pubsub import PepNick
+
+        if nick is not None:
+            pep_nick = PepNick(nick)
+            await self.xmpp.pubsub.broadcast(
+                pep_nick.nick,
+                self.jid.bare,
+                self.session.user_jid,
+            )
 
     async def _set_roster(self, **kw):
         try:
@@ -350,6 +392,8 @@ class LegacyContact(
         :param text: Optional message from the friend to the user
         """
         self.is_friend = True
+        assert self.contact_pk is not None
+        self.xmpp.store.contacts.set_friend(self.contact_pk, True)
         self.log.debug("Accepting friend request")
         presence = self._make_presence(ptype="subscribed", pstatus=text, bare=True)
         self._send(presence, nick=True)
@@ -415,7 +459,7 @@ class LegacyContact(
         their 'friends'".
         """
         for ptype in "unsubscribe", "unsubscribed", "unavailable":
-            self.xmpp.send_presence(pfrom=self.jid, pto=self.user.jid.bare, ptype=ptype)  # type: ignore
+            self.xmpp.send_presence(pfrom=self.jid, pto=self.user_jid.bare, ptype=ptype)  # type: ignore
 
     async def update_info(self):
         """
@@ -442,6 +486,24 @@ class LegacyContact(
         """
         pass
 
+    @classmethod
+    def from_store(cls, session, stored: Contact, *args, **kwargs) -> Self:
+        contact = cls(
+            session,
+            cls.xmpp.LEGACY_CONTACT_ID_TYPE(stored.legacy_id),
+            stored.jid.username,  # type: ignore
+            *args,  # type: ignore
+            **kwargs,  # type: ignore
+        )
+        contact.contact_pk = stored.id
+        contact._name = stored.nick
+        contact._is_friend = stored.is_friend
+        contact.added_to_roster = stored.added_to_roster
+        if (data := stored.extra_attributes) is not None:
+            contact.deserialize_extra_attributes(data)
+        contact._set_avatar_from_store(stored)
+        return contact
+
 
 def is_markable(stanza: Union[Message, Presence]):
     if isinstance(stanza, Presence):