slidge 0.1.3__py3-none-any.whl → 0.2.0a1__py3-none-any.whl

slidge/core/pubsub.py

@@ -1,12 +1,8 @@
-import hashlib
-import io
 import logging
 from copy import copy
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional, Type, Union
+from typing import TYPE_CHECKING, Optional, Union
 
-from PIL import Image, UnidentifiedImageError
-from PIL.Image import Image as PILImage
 from slixmpp import (
     JID,
     CoroutineCallback,
@@ -24,12 +20,8 @@ from slixmpp.plugins.xep_0172 import UserNick
 from slixmpp.plugins.xep_0292.stanza import VCard4
 from slixmpp.types import JidStr, OptJidStr
 
-from ..contact.contact import LegacyContact
-from ..contact.roster import ContactIsUser
-from ..util.db import GatewayUser, user_store
-from ..util.sql import db
-from ..util.types import AvatarType, LegacyFileIdType, PepItemType
-from .cache import CachedAvatar, avatar_cache
+from ..db.avatar import CachedAvatar, avatar_cache
+from ..db.store import ContactStore, SlidgeStore
 from .mixins.lock import NamedLockMixin
 
 if TYPE_CHECKING:
@@ -39,19 +31,15 @@ VCARD4_NAMESPACE = "urn:xmpp:vcard4"
 
 
 class PepItem:
-    @staticmethod
-    def from_db(jid: JID, user: Optional[GatewayUser] = None) -> Optional["PepItem"]:
-        raise NotImplementedError
-
-    def to_db(self, jid: JID, user: Optional[GatewayUser] = None):
-        raise NotImplementedError
+    pass
 
 
 class PepAvatar(PepItem):
-    def __init__(self, jid: JID):
+    store: SlidgeStore
+
+    def __init__(self):
         self.metadata: Optional[AvatarMetadata] = None
         self.id: Optional[str] = None
-        self.jid = jid
         self._avatar_data_path: Optional[Path] = None
 
     @property
@@ -62,63 +50,7 @@ class PepAvatar(PepItem):
         data.set_value(self._avatar_data_path.read_bytes())
         return data
 
-    @staticmethod
-    def _sha(b: bytes):
-        return hashlib.sha1(b).hexdigest()
-
-    def _get_weak_unique_id(self, avatar: AvatarType):
-        if isinstance(avatar, str):
-            return avatar  # url
-        elif isinstance(avatar, bytes):
-            return self._sha(avatar)
-        elif isinstance(avatar, Path):
-            return self._sha(avatar.read_bytes())
-
-    @staticmethod
-    async def _get_image(avatar: AvatarType) -> PILImage:
-        if isinstance(avatar, str):
-            # async with aiohttp.ClientSession() as session:
-            async with avatar_cache.http.get(avatar) as response:
-                return Image.open(io.BytesIO(await response.read()))
-        elif isinstance(avatar, bytes):
-            return Image.open(io.BytesIO(avatar))
-        elif isinstance(avatar, Path):
-            return Image.open(avatar)
-        else:
-            raise TypeError("Avatar must be bytes, a Path or a str (URL)", avatar)
-
-    async def set_avatar(
-        self, avatar: AvatarType, unique_id: Optional[LegacyFileIdType] = None
-    ):
-        if unique_id is None:
-            if isinstance(avatar, str):
-                await self._set_avatar_from_url_alone(avatar)
-                return
-            unique_id = self._get_weak_unique_id(avatar)
-
-        await self._set_avatar_from_unique_id(avatar, unique_id)
-
-    async def _set_avatar_from_unique_id(
-        self, avatar: AvatarType, unique_id: LegacyFileIdType
-    ):
-        cached_avatar = avatar_cache.get(unique_id)
-        if cached_avatar:
-            # this shouldn't be necessary but here to re-use avatars downloaded
-            # before the change introducing the JID to unique ID mapping
-            avatar_cache.store_jid(self.jid, unique_id)
-        else:
-            img = await self._get_image(avatar)
-            cached_avatar = await avatar_cache.convert_and_store(
-                img, unique_id, self.jid
-            )
-
-        self._set_avatar_from_cache(cached_avatar)
-
-    async def _set_avatar_from_url_alone(self, url: str):
-        cached_avatar = await avatar_cache.get_avatar_from_url_alone(url, self.jid)
-        self._set_avatar_from_cache(cached_avatar)
-
-    def _set_avatar_from_cache(self, cached_avatar: CachedAvatar):
+    def set_avatar_from_cache(self, cached_avatar: CachedAvatar):
         metadata = AvatarMetadata()
         self.id = cached_avatar.hash
         metadata.add_info(
@@ -131,31 +63,10 @@ class PepAvatar(PepItem):
         self.metadata = metadata
         self._avatar_data_path = cached_avatar.path
 
-    @staticmethod
-    def from_db(jid: JID, user: Optional[GatewayUser] = None) -> Optional["PepAvatar"]:
-        cached_id = db.avatar_get(jid)
-        if cached_id is None:
-            return None
-        item = PepAvatar(jid)
-        cached_avatar = avatar_cache.get(cached_id)
-        if cached_avatar is None:
-            raise XMPPError("internal-server-error")
-        item._set_avatar_from_cache(cached_avatar)
-        return item
-
-    def to_db(self, jid: JID, user=None):
-        cached_id = avatar_cache.get_cached_id_for(jid)
-        if cached_id is None:
-            log.warning("Could not store avatar for %s", jid)
-            return
-        db.avatar_store(jid, cached_id)
-
-    @staticmethod
-    def remove_from_db(jid: JID):
-        db.avatar_delete(jid)
-
 
 class PepNick(PepItem):
+    contact_store: ContactStore
+
     def __init__(self, nick: Optional[str] = None):
         nickname = UserNick()
         if nick is not None:
@@ -163,20 +74,6 @@ class PepNick(PepItem):
         self.nick = nickname
         self.__nick_str = nick
 
-    @staticmethod
-    def from_db(jid: JID, user: Optional[GatewayUser] = None) -> Optional["PepNick"]:
-        if user is None:
-            raise XMPPError("not-allowed")
-        nick = db.nick_get(jid, user)
-        if nick is None:
-            return None
-        return PepNick(nick)
-
-    def to_db(self, jid: JID, user: Optional[GatewayUser] = None):
-        if user is None:
-            raise XMPPError("not-allowed")
-        db.nick_store(jid, str(self.__nick_str), user)
-
 
 class PubSubComponent(NamedLockMixin, BasePlugin):
     xmpp: "BaseGateway"
@@ -186,7 +83,6 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
     dependencies = {
         "xep_0030",
         "xep_0060",
-        # "xep_0084",
         "xep_0115",
         "xep_0163",
     }
@@ -276,7 +172,7 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             else:
                 if pep_avatar.metadata is None:
                     raise XMPPError("internal-server-error", "Avatar but no metadata?")
-                await self._broadcast(
+                await self.__broadcast(
                     data=pep_avatar.metadata,
                     from_=p.get_to(),
                     to=from_,
@@ -288,7 +184,7 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             except XMPPError:
                 pass
             else:
-                await self._broadcast(data=pep_nick.nick, from_=p.get_to(), to=from_)
+                await self.__broadcast(data=pep_nick.nick, from_=p.get_to(), to=from_)
 
         if VCARD4_NAMESPACE + "+notify" in features:
             await self.broadcast_vcard_event(p.get_to(), to=from_)
@@ -303,7 +199,7 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         # but movim expects it to be here, and I guess
 
         log.debug("Broadcast vcard4 event: %s", vcard)
-        await self._broadcast(
+        await self.__broadcast(
             data=vcard,
             from_=JID(from_).bare,
             to=to,
@@ -311,26 +207,34 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             node=VCARD4_NAMESPACE,
         )
 
-    async def _get_authorized_item(
-        self, cls: Type[PepItemType], stanza: Union[Iq, Presence]
-    ) -> PepItemType:
-        sto = stanza.get_to()
-        user = user_store.get_by_jid(stanza.get_from())
-        item = cls.from_db(sto, user)
-        if item is None:
-            raise XMPPError("item-not-found")
-
-        if sto != self.xmpp.boundjid.bare:
-            session = self.xmpp.get_session_from_stanza(stanza)
-            await session.contacts.by_jid(sto)
-
-        return item  # type:ignore
-
     async def _get_authorized_avatar(self, stanza: Union[Iq, Presence]) -> PepAvatar:
-        return await self._get_authorized_item(PepAvatar, stanza)
+        if stanza.get_to() == self.xmpp.boundjid.bare:
+            item = PepAvatar()
+            item.set_avatar_from_cache(avatar_cache.get_by_pk(self.xmpp.avatar_pk))
+            return item
+
+        session = self.xmpp.get_session_from_stanza(stanza)
+        entity = await session.get_contact_or_group_or_participant(stanza.get_to())
+
+        item = PepAvatar()
+        avatar_id = entity.avatar_id
+        if avatar_id is not None:
+            stored = avatar_cache.get(str(avatar_id))
+            assert stored is not None
+            item.set_avatar_from_cache(stored)
+        return item
 
     async def _get_authorized_nick(self, stanza: Union[Iq, Presence]) -> PepNick:
-        return await self._get_authorized_item(PepNick, stanza)
+        if stanza.get_to() == self.xmpp.boundjid.bare:
+            return PepNick(self.xmpp.COMPONENT_NAME)
+
+        session = self.xmpp.get_session_from_stanza(stanza)
+        entity = await session.contacts.by_jid(stanza.get_to())
+
+        if entity.name is not None:
+            return PepNick(entity.name)
+        else:
+            return PepNick()
 
     async def _get_avatar_data(self, iq: Iq):
         pep_avatar = await self._get_authorized_avatar(iq)
@@ -372,10 +276,6 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             raise XMPPError("item-not-found")
         self._reply_with_payload(iq, vcard, "current", VCARD4_NAMESPACE)
 
-    @staticmethod
-    def get_avatar(jid: JID):
-        return PepAvatar.from_db(jid)
-
     @staticmethod
     def _reply_with_payload(
         iq: Iq,
@@ -394,7 +294,7 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         result["pubsub"]["items"].append(item)
         result.send()
 
-    async def _broadcast(self, data, from_: JidStr, to: OptJidStr = None, **kwargs):
+    async def __broadcast(self, data, from_: JidStr, to: OptJidStr = None, **kwargs):
         from_ = JID(from_)
         if from_ != self.xmpp.boundjid.bare and to is not None:
             to = JID(to)
@@ -402,12 +302,6 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             if session is None:
                 return
             await session.ready
-            try:
-                entity = await session.get_contact_or_group_or_participant(from_)
-            except ContactIsUser:
-                return
-            if isinstance(entity, LegacyContact) and not entity.is_friend:
-                return
 
         item = EventItem()
         if data:
@@ -428,97 +322,37 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         msg.append(event)
 
         if to is None:
-            for u in user_store.get_all():
+            for u in self.xmpp.store.users.get_all():
                 new_msg = copy(msg)
-                new_msg.set_to(u.bare_jid)
+                new_msg.set_to(u.jid.bare)
                 new_msg.send()
         else:
             msg.set_to(to)
             msg.send()
 
-    async def set_avatar(
-        self,
-        jid: JidStr,
-        avatar: Optional[AvatarType] = None,
-        broadcast_to: OptJidStr = None,
-        unique_id=None,
-        broadcast=True,
-    ):
-        jid = JID(jid)
-        if avatar is None:
-            PepAvatar.remove_from_db(jid)
-            await self._broadcast(AvatarMetadata(), jid, broadcast_to)
-            avatar_cache.delete_jid(jid)
-        else:
-            pep_avatar = PepAvatar(jid)
-            try:
-                await pep_avatar.set_avatar(avatar, unique_id)
-            except (UnidentifiedImageError, FileNotFoundError) as e:
-                log.warning("Failed to set avatar for %s: %r", self, e)
-                return
-            pep_avatar.to_db(jid)
-            if pep_avatar.metadata is None:
-                raise RuntimeError
-            if not broadcast:
-                return
-            await self._broadcast(
-                pep_avatar.metadata,
-                jid,
-                broadcast_to,
-                id=pep_avatar.metadata["info"]["id"],
-            )
-
-    async def set_avatar_from_cache(
-        self, jid: JID, send_empty: bool, broadcast_to: OptJidStr = None, broadcast=True
-    ):
-        uid = avatar_cache.get_cached_id_for(jid)
-        if uid is None:
-            if not send_empty:
-                return
-            self.xmpp.loop.create_task(
-                self.set_avatar(jid, None, broadcast_to, uid, broadcast)
-            )
-            return
-        cached_avatar = avatar_cache.get(str(uid))
+    async def broadcast_avatar(
+        self, from_: JidStr, to: JidStr, cached_avatar: Optional[CachedAvatar]
+    ) -> None:
         if cached_avatar is None:
-            # should not happen but well…
-            log.warning(
-                "Something is wrong with the avatar, %s won't have an "
-                "avatar because avatar not found in cache",
-                jid,
+            await self.__broadcast(AvatarMetadata(), from_, to)
+        else:
+            pep_avatar = PepAvatar()
+            pep_avatar.set_avatar_from_cache(cached_avatar)
+            assert pep_avatar.metadata is not None
+            await self.__broadcast(
+                pep_avatar.metadata, from_, to, id=pep_avatar.metadata["info"]["id"]
             )
-            return
-        self.xmpp.loop.create_task(
-            self.set_avatar(jid, cached_avatar.path, broadcast_to, uid, broadcast)
-        )
 
-    def set_nick(
+    def broadcast_nick(
         self,
-        user: GatewayUser,
+        user_jid: JID,
         jid: JidStr,
         nick: Optional[str] = None,
     ):
         jid = JID(jid)
         nickname = PepNick(nick)
-        nickname.to_db(jid, user)
         log.debug("New nickname: %s", nickname.nick)
-        self.xmpp.loop.create_task(self._broadcast(nickname.nick, jid, user.bare_jid))
-
-    async def broadcast_all(self, from_: JID, to: JID):
-        """
-        Force push avatar and nick for a stored JID.
-        """
-        a = PepAvatar.from_db(from_)
-        if a:
-            if a.metadata:
-                await self._broadcast(
-                    a.metadata, from_, to, id=a.metadata["info"]["id"]
-                )
-            else:
-                log.warning("No metadata associated to this cached avatar?!")
-        n = PepNick.from_db(from_, user_store.get_by_jid(to))
-        if n:
-            await self._broadcast(n.nick, from_, to)
+        self.xmpp.loop.create_task(self.__broadcast(nickname.nick, jid, user_jid.bare))
 
 
 log = logging.getLogger(__name__)

slidge/core/session.py

@@ -18,11 +18,10 @@ from slixmpp.types import PresenceShows
 
 from ..command import SearchResult
 from ..contact import LegacyContact, LegacyRoster
+from ..db.models import GatewayUser
 from ..group.bookmarks import LegacyBookmarks
 from ..group.room import LegacyMUC
 from ..util import ABCSubclassableOnceAtMost
-from ..util.db import GatewayUser, user_store
-from ..util.sql import SQLBiDict
 from ..util.types import (
     LegacyGroupIdType,
     LegacyMessageType,
@@ -92,16 +91,10 @@ class BaseSession(
     """
 
     def __init__(self, user: GatewayUser):
-        self.log = logging.getLogger(user.bare_jid)
+        self.log = logging.getLogger(user.jid.bare)
 
-        self.user = user
-        self.sent = SQLBiDict[LegacyMessageType, str](
-            "session_message_sent", "legacy_id", "xmpp_id", self.user
-        )
-        # message ids (*not* stanza-ids), needed for last msg correction
-        self.muc_sent_msg_ids = SQLBiDict[LegacyMessageType, str](
-            "session_message_sent_muc", "legacy_id", "xmpp_id", self.user
-        )
+        self.user_jid = user.jid
+        self.user_pk = user.id
 
         self.ignore_messages = set[str]()
 
@@ -115,26 +108,26 @@ class BaseSession(
 
         self.http = self.xmpp.http
 
-        self.threads = SQLBiDict[str, LegacyThreadType](  # type:ignore
-            "session_thread_sent_muc", "legacy_id", "xmpp_id", self.user
-        )
         self.thread_creation_lock = asyncio.Lock()
 
         self.__cached_presence: Optional[CachedPresence] = None
 
-        self.avatar_hash: Optional[str] = None
-
         self.__tasks = set[asyncio.Task]()
 
+    @property
+    def user(self) -> GatewayUser:
+        return self.xmpp.store.users.get(self.user_jid)  # type:ignore
+
     def __remove_task(self, fut):
         self.log.debug("Removing fut %s", fut)
         self.__tasks.remove(fut)
 
-    def create_task(self, coro) -> None:
+    def create_task(self, coro) -> asyncio.Task:
         task = self.xmpp.loop.create_task(coro)
         self.__tasks.add(task)
         self.log.debug("Creating task %s", task)
         task.add_done_callback(lambda _: self.__remove_task(task))
+        return task
 
     def cancel_all_tasks(self):
         for task in self.__tasks:
@@ -488,6 +481,17 @@ class BaseSession(
         """
         await muc.on_set_affiliation(contact, "member", reason, None)
 
+    async def on_leave_group(self, muc_legacy_id: LegacyGroupIdType):
+        """
+        Triggered when the user leaves a group via the dedicated slidge command
+        or the :xep:`0077` ``<remove />`` mechanism.
+
+        This should be interpreted as definitely leaving the group.
+
+        :param muc_legacy_id: The legacy ID of the group to leave
+        """
+        raise NotImplementedError
+
     def __reset_ready(self):
         self.ready = self.xmpp.loop.create_future()
 
@@ -507,7 +511,7 @@ class BaseSession(
                 self.ready.set_result(True)
 
     def __repr__(self):
-        return f"<Session of {self.user}>"
+        return f"<Session of {self.user_jid}>"
 
     def shutdown(self) -> asyncio.Task:
         for c in self.contacts:
@@ -571,9 +575,9 @@ class BaseSession(
             log.debug("user not found", stack_info=True)
             raise XMPPError(text="User not found", condition="subscription-required")
 
-        session = _sessions.get(user)
+        session = _sessions.get(user.jid.bare)
         if session is None:
-            _sessions[user] = session = cls(user)
+            _sessions[user.jid.bare] = session = cls(user)
         return session
 
     @classmethod
@@ -590,7 +594,7 @@ class BaseSession(
         # :param s:
         # :return:
         # """
-        return cls._from_user_or_none(user_store.get_by_stanza(s))
+        return cls.from_jid(s.get_from())
 
     @classmethod
     def from_jid(cls, jid: JID) -> "BaseSession":
@@ -602,7 +606,11 @@ class BaseSession(
         # :param jid:
         # :return:
         # """
-        return cls._from_user_or_none(user_store.get_by_jid(jid))
+        session = _sessions.get(jid.bare)
+        if session is not None:
+            return session
+        user = cls.xmpp.store.users.get(jid)
+        return cls._from_user_or_none(user)
 
     @classmethod
     async def kill_by_jid(cls, jid: JID):
@@ -615,16 +623,21 @@ class BaseSession(
         # :return:
         # """
         log.debug("Killing session of %s", jid)
-        for user, session in _sessions.items():
-            if user.jid == jid.bare:
+        for user_jid, session in _sessions.items():
+            if user_jid == jid.bare:
                 break
         else:
             log.debug("Did not find a session for %s", jid)
             return
         for c in session.contacts:
             c.unsubscribe()
+        user = cls.xmpp.store.users.get(jid)
+        if user is None:
+            log.warning("User not found during unregistration")
+            return
         await cls.xmpp.unregister(user)
-        del _sessions[user]
+        cls.xmpp.store.users.delete(user.jid)
+        del _sessions[user.jid.bare]
         del user
         del session
 
@@ -649,7 +662,7 @@ class BaseSession(
         """
         self.__cached_presence = CachedPresence(status, show, kwargs)
         self.xmpp.send_presence(
-            pto=self.user.bare_jid, pstatus=status, pshow=show, **kwargs
+            pto=self.user_jid.bare, pstatus=status, pshow=show, **kwargs
         )
 
     def send_cached_presence(self, to: JID):
@@ -671,7 +684,7 @@ class BaseSession(
 
         :param text: A text
         """
-        self.xmpp.send_text(text, mto=self.user.jid, **msg_kwargs)
+        self.xmpp.send_text(text, mto=self.user_jid, **msg_kwargs)
 
     def send_gateway_invite(
         self,
@@ -686,7 +699,7 @@ class BaseSession(
         :param reason:
         :param password:
         """
-        self.xmpp.invite_to(muc, reason=reason, password=password, mto=self.user.jid)
+        self.xmpp.invite_to(muc, reason=reason, password=password, mto=self.user_jid)
 
     async def input(self, text: str, **msg_kwargs):
         """
@@ -698,7 +711,7 @@ class BaseSession(
         :param msg_kwargs: Extra attributes
         :return:
         """
-        return await self.xmpp.input(self.user.jid, text, **msg_kwargs)
+        return await self.xmpp.input(self.user_jid, text, **msg_kwargs)
 
     async def send_qr(self, text: str):
         """
@@ -707,7 +720,7 @@ class BaseSession(
 
         :param text: Text to encode as a QR code
         """
-        await self.xmpp.send_qr(text, mto=self.user.jid)
+        await self.xmpp.send_qr(text, mto=self.user_jid)
 
     def re_login(self):
         # Logout then re-login
@@ -715,14 +728,17 @@ class BaseSession(
         # No reason to override this
         self.xmpp.re_login(self)
 
-    async def get_contact_or_group_or_participant(self, jid: JID):
+    async def get_contact_or_group_or_participant(self, jid: JID, create=True):
         if jid.bare in (contacts := self.contacts.known_contacts(only_friends=False)):
             return contacts[jid.bare]
-        if jid.bare in (mucs := self.bookmarks._mucs_by_bare_jid):
-            return await self.__get_muc_or_participant(mucs[jid.bare], jid)
+        if (muc := self.bookmarks.by_jid_only_if_exists(JID(jid.bare))) is not None:
+            return await self.__get_muc_or_participant(muc, jid)
         else:
             muc = None
 
+        if not create:
+            return None
+
         try:
             return await self.contacts.by_jid(jid)
         except XMPPError:
@@ -763,6 +779,25 @@ class BaseSession(
                 "Legacy session is not fully initialized, retry later",
             )
 
+    def legacy_module_data_update(self, data: dict):
+        with self.xmpp.store.session():
+            user = self.user
+            user.legacy_module_data.update(data)
+            self.xmpp.store.users.update(user)
+
+    def legacy_module_data_set(self, data: dict):
+        with self.xmpp.store.session():
+            user = self.user
+            user.legacy_module_data = data
+            self.xmpp.store.users.update(user)
+
+    def legacy_module_data_clear(self):
+        with self.xmpp.store.session():
+            user = self.user
+            user.legacy_module_data.clear()
+            self.xmpp.store.users.update(user)
+
 
-_sessions: dict[GatewayUser, BaseSession] = {}
+# keys = user.jid.bare
+_sessions: dict[str, BaseSession] = {}
 log = logging.getLogger(__name__)

slidge/db/__init__.py

@@ -0,0 +1,4 @@
+from .models import GatewayUser
+from .store import SlidgeStore
+
+__all__ = ("GatewayUser", "SlidgeStore")