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

slidge/core/mixins/avatar.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Optional
 
 from slixmpp import JID
 
+from ...db.avatar import CachedAvatar, avatar_cache
 from ...util.types import (
     URL,
     AnyBaseSession,
@@ -12,7 +13,6 @@ from ...util.types import (
     AvatarType,
     LegacyFileIdType,
 )
-from ..cache import avatar_cache
 
 if TYPE_CHECKING:
     from ..pubsub import PepAvatar
@@ -28,13 +28,14 @@ class AvatarMixin:
 
     jid: JID = NotImplemented
     session: AnyBaseSession = NotImplemented
-    _avatar_pubsub_broadcast: bool = NotImplemented
     _avatar_bare_jid: bool = NotImplemented
 
     def __init__(self) -> None:
         super().__init__()
         self._set_avatar_task: Optional[Task] = None
+        self.__broadcast_task: Optional[Task] = None
         self.__avatar_unique_id: Optional[AvatarIdType] = None
+        self._avatar_pk: Optional[int] = None
 
     @property
     def __avatar_jid(self):
@@ -84,17 +85,42 @@ class AvatarMixin:
             return None
         raise TypeError("Bad avatar", a)
 
-    async def __set_avatar(self, a: Optional[AvatarType], uid: Optional[AvatarIdType]):
+    async def __set_avatar(
+        self, a: Optional[AvatarType], uid: Optional[AvatarIdType], delete: bool
+    ):
         self.__avatar_unique_id = uid
-        await self.session.xmpp.pubsub.set_avatar(
-            jid=self.__avatar_jid,
-            avatar=a,
-            unique_id=None if isinstance(uid, URL) else uid,
-            broadcast_to=self.session.user.jid.bare,
-            broadcast=self._avatar_pubsub_broadcast,
-        )
+
+        if a is None:
+            cached_avatar = None
+            self._avatar_pk = None
+        else:
+            try:
+                cached_avatar = await avatar_cache.convert_or_get(
+                    URL(a) if isinstance(a, URL) else a,
+                    None if isinstance(uid, URL) else uid,
+                )
+            except Exception as e:
+                self.session.log.error("Failed to set avatar %s", a, exc_info=e)
+                self._avatar_pk = None
+                self.__avatar_unique_id = uid
+                return
+            self._avatar_pk = cached_avatar.pk
+
+        if self.__should_pubsub_broadcast():
+            await self.session.xmpp.pubsub.broadcast_avatar(
+                self.__avatar_jid, self.session.user_jid, cached_avatar
+            )
+
+        if delete and isinstance(a, Path):
+            a.unlink()
+
         self._post_avatar_update()
 
+    def __should_pubsub_broadcast(self):
+        return getattr(self, "is_friend", False) and getattr(
+            self, "added_to_roster", False
+        )
+
     async def _no_change(self, a: Optional[AvatarType], uid: Optional[AvatarIdType]):
         if a is None:
             return self.__avatar_unique_id is None
@@ -103,23 +129,27 @@ class AvatarMixin:
         if isinstance(uid, URL):
             if self.__avatar_unique_id != uid:
                 return False
-            return not await avatar_cache.url_has_changed(uid)
+            return not await avatar_cache.url_modified(uid)
         return self.__avatar_unique_id == uid
 
     async def set_avatar(
         self,
         a: Optional[AvatarType],
         avatar_unique_id: Optional[LegacyFileIdType] = None,
+        delete: bool = False,
         blocking=False,
         cancel=True,
     ) -> None:
         """
         Set an avatar for this entity
 
-        :param a:
-        :param avatar_unique_id:
-        :param blocking:
-        :param cancel:
+        :param a: The avatar, in one of the types slidge supports
+        :param avatar_unique_id: A globally unique ID for the avatar on the
+            legacy network
+        :param delete: If the avatar is provided as a Path, whether to delete
+            it once used or not.
+        :param blocking: Internal use by slidge for tests, do not use!
+        :param cancel: Internal use by slidge, do not use!
         """
         if avatar_unique_id is None and a is not None:
             avatar_unique_id = self.__get_uid(a)
@@ -128,7 +158,7 @@ class AvatarMixin:
         if cancel and self._set_avatar_task:
             self._set_avatar_task.cancel()
         awaitable = create_task(
-            self.__set_avatar(a, avatar_unique_id),
+            self.__set_avatar(a, avatar_unique_id, delete),
             name=f"Set pubsub avatar of {self}",
         )
         if not self._set_avatar_task or self._set_avatar_task.done():
@@ -136,32 +166,67 @@ class AvatarMixin:
         if blocking:
             await awaitable
 
-    def get_avatar(self) -> Optional["PepAvatar"]:
+    def get_cached_avatar(self) -> Optional["CachedAvatar"]:
         if not self.__avatar_unique_id:
             return None
-        return self.session.xmpp.pubsub.get_avatar(self.__avatar_jid)
+        return avatar_cache.get(self.__avatar_unique_id)
+
+    def get_avatar(self) -> Optional["PepAvatar"]:
+        cached_avatar = self.get_cached_avatar()
+        if cached_avatar is None:
+            return None
+        from ..pubsub import PepAvatar
+
+        item = PepAvatar()
+        item.set_avatar_from_cache(cached_avatar)
+        return item
 
     def _post_avatar_update(self) -> None:
         return
 
+    def __get_cached_avatar_id(self):
+        i = self._get_cached_avatar_id()
+        if i is None:
+            return None
+        return self.session.xmpp.AVATAR_ID_TYPE(i)
+
+    def _get_cached_avatar_id(self) -> Optional[str]:
+        raise NotImplementedError
+
     async def avatar_wrap_update_info(self):
-        cached_id = avatar_cache.get_cached_id_for(self.__avatar_jid)
+        cached_id = self.__get_cached_avatar_id()
         self.__avatar_unique_id = cached_id
         try:
             await self.update_info()  # type:ignore
         except NotImplementedError:
             return
         new_id = self.avatar
-        if isinstance(new_id, URL) and not await avatar_cache.url_has_changed(new_id):
+        if isinstance(new_id, URL) and not await avatar_cache.url_modified(new_id):
             return
         elif new_id != cached_id:
             # at this point it means that update_info set the avatar, and we don't
             # need to do anything else
             return
 
-        await self.session.xmpp.pubsub.set_avatar_from_cache(
-            self.__avatar_jid,
-            new_id is None and cached_id is not None,
-            self.session.user.jid.bare,
-            self._avatar_pubsub_broadcast,
+        if self.__should_pubsub_broadcast():
+            if new_id is None and cached_id is None:
+                return
+            cached_avatar = avatar_cache.get(cached_id)
+            self.__broadcast_task = self.session.xmpp.loop.create_task(
+                self.session.xmpp.pubsub.broadcast_avatar(
+                    self.__avatar_jid, self.session.user_jid, cached_avatar
+                )
+            )
+
+    def _set_avatar_from_store(self, stored):
+        if stored.avatar_id is None:
+            return
+        if stored.avatar is None:
+            # seems to happen after avatar cleanup for some reason?
+            self.__avatar_unique_id = None
+            return
+        self.__avatar_unique_id = (
+            stored.avatar.legacy_id
+            if stored.avatar.legacy_id is not None
+            else URL(stored.avatar.url)
         )

slidge/core/mixins/base.py

@@ -8,7 +8,6 @@ from ...util.types import MessageOrPresenceTypeVar
 if TYPE_CHECKING:
     from slidge.core.gateway import BaseGateway
     from slidge.core.session import BaseSession
-    from slidge.util.db import GatewayUser
 
 
 class MetaBase(ABCMeta):
@@ -18,11 +17,18 @@ class MetaBase(ABCMeta):
 class Base:
     session: "BaseSession" = NotImplemented
     xmpp: "BaseGateway" = NotImplemented
-    user: "GatewayUser" = NotImplemented
 
     jid: JID = NotImplemented
     name: str = NotImplemented
 
+    @property
+    def user_jid(self):
+        return self.session.user_jid
+
+    @property
+    def user_pk(self):
+        return self.session.user_pk
+
 
 class BaseSender(Base):
     def _send(

slidge/core/mixins/db.py

@@ -0,0 +1,18 @@
+from contextlib import contextmanager
+
+
+class UpdateInfoMixin:
+    """
+    This mixin just adds a context manager that prevents commiting to the DB
+    on every attribute change.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._updating_info = False
+
+    @contextmanager
+    def updating_info(self):
+        self._updating_info = True
+        yield
+        self._updating_info = False

slidge/core/mixins/disco.py

@@ -13,10 +13,6 @@ class BaseDiscoMixin(Base):
     DISCO_NAME: str = NotImplemented
     DISCO_LANG = None
 
-    def __init__(self):
-        super().__init__()
-        self.__caps_cache: Optional[str] = None
-
     def _get_disco_name(self):
         if self.DISCO_NAME is NotImplemented:
             return self.xmpp.COMPONENT_NAME
@@ -44,17 +40,11 @@ class BaseDiscoMixin(Base):
         return info
 
     async def get_caps_ver(self, jid: OptJid = None, node: Optional[str] = None):
-        if self.__caps_cache:
-            return self.__caps_cache
         info = await self.get_disco_info(jid, node)
         caps = self.xmpp.plugin["xep_0115"]
         ver = caps.generate_verstring(info, caps.hash)
-        self.__caps_cache = ver
         return ver
 
-    def reset_caps_cache(self):
-        self.__caps_cache = None
-
 
 class ChatterDiscoMixin(BaseDiscoMixin):
     AVATAR = True

slidge/core/mixins/message.py

@@ -111,7 +111,7 @@ class MarkerMixin(MessageMaker):
                 self.xmpp.delivery_receipt.make_ack(
                     self._legacy_to_xmpp(legacy_msg_id),
                     mfrom=self.jid,
-                    mto=self.user.jid,
+                    mto=self.user_jid,
                 )
             )
         self._send(
@@ -144,7 +144,7 @@ class MarkerMixin(MessageMaker):
             # We'll see if we need to implement that later
             return
         xmpp_msg_id = self._legacy_to_xmpp(legacy_msg_id)
-        iq = Iq(sto=self.user.bare_jid, sfrom=self.user.bare_jid, stype="set")
+        iq = Iq(sto=self.user_jid.bare, sfrom=self.user_jid.bare, stype="set")
         iq["pubsub"]["publish"]["node"] = self.xmpp["xep_0490"].stanza.NS
         iq["pubsub"]["publish"]["item"]["id"] = muc_jid
         displayed = self.xmpp["xep_0490"].stanza.Displayed()
@@ -169,8 +169,8 @@ class ContentMessageMixin(AttachmentMixin):
 
     def __replace_id(self, legacy_msg_id: LegacyMessageType):
         if self.mtype == "groupchat":
-            return self.session.muc_sent_msg_ids.get(
-                legacy_msg_id
+            return self.xmpp.store.sent.get_group_xmpp_id(
+                self.session.user_pk, str(legacy_msg_id)
             ) or self._legacy_to_xmpp(legacy_msg_id)
         else:
             return self._legacy_to_xmpp(legacy_msg_id)
@@ -215,14 +215,18 @@ class ContentMessageMixin(AttachmentMixin):
             but store it in the archive. Meant to be used during ``MUC.backfill()``
         """
         if carbon:
-            if not correction and legacy_msg_id in self.session.sent:
+            if not correction and self.xmpp.store.sent.was_sent_by_user(
+                self.session.user_pk, str(legacy_msg_id)
+            ):
                 log.warning(
                     "Carbon message for a message an XMPP has sent? This is a bug! %s",
                     legacy_msg_id,
                 )
                 return
-            self.session.sent[legacy_msg_id] = self.session.legacy_to_xmpp_msg_id(
-                legacy_msg_id
+            self.xmpp.store.sent.set_message(
+                self.session.user_pk,
+                str(legacy_msg_id),
+                self.session.legacy_to_xmpp_msg_id(legacy_msg_id),
             )
         hints = self.__default_hints(hints)
         msg = self._make_message(
@@ -237,7 +241,13 @@ class ContentMessageMixin(AttachmentMixin):
         )
         if correction:
             msg["replace"]["id"] = self.__replace_id(legacy_msg_id)
-        return self._send(msg, archive_only=archive_only, carbon=carbon, **send_kwargs)
+        return self._send(
+            msg,
+            archive_only=archive_only,
+            carbon=carbon,
+            legacy_msg_id=legacy_msg_id,
+            **send_kwargs,
+        )
 
     def correct(
         self,

slidge/core/mixins/message_maker.py

@@ -7,8 +7,8 @@ from uuid import uuid4
 from slixmpp import Message
 from slixmpp.types import MessageTypes
 
+from ...db.models import GatewayUser
 from ...slixfix.link_preview.stanza import LinkPreview as LinkPreviewStanza
-from ...util.db import GatewayUser
 from ...util.types import (
     ChatState,
     LegacyMessageType,
@@ -60,8 +60,9 @@ class MessageMaker(BaseSender):
             msg["body"] = body
             state = "active"
         if thread:
-            known_threads = self.session.threads.inverse  # type:ignore
-            msg["thread"] = known_threads.get(thread) or str(thread)
+            msg["thread"] = self.xmpp.store.sent.get_legacy_thread(
+                self.user_pk, str(thread)
+            ) or str(thread)
         if state:
             msg["chat_state"] = state
         for hint in hints:
@@ -88,9 +89,9 @@ class MessageMaker(BaseSender):
             msg["stanza_id"]["by"] = self.muc.jid  # type: ignore
 
     def _legacy_to_xmpp(self, legacy_id: LegacyMessageType):
-        return self.session.sent.get(legacy_id) or self.session.legacy_to_xmpp_msg_id(
-            legacy_id
-        )
+        return self.xmpp.store.sent.get_xmpp_id(
+            self.session.user_pk, str(legacy_id)
+        ) or self.session.legacy_to_xmpp_msg_id(legacy_id)
 
     def _add_delay(self, msg: Message, when: Optional[datetime]):
         if when:
@@ -110,16 +111,23 @@ class MessageMaker(BaseSender):
         muc = getattr(self, "muc", None)
 
         if entity := reply_to.author:
-            if isinstance(entity, GatewayUser):
+            if entity == "user" or isinstance(entity, GatewayUser):
+                if isinstance(entity, GatewayUser):
+                    warnings.warn(
+                        "Using a GatewayUser as the author of a "
+                        "MessageReference is deprecated. Use the string 'user' "
+                        "instead.",
+                        DeprecationWarning,
+                    )
                 if muc:
                     jid = copy(muc.jid)
                     jid.resource = fallback_nick = muc.user_nick
                     msg["reply"]["to"] = jid
                 else:
-                    msg["reply"]["to"] = entity.jid
+                    msg["reply"]["to"] = self.session.user_jid
                     # TODO: here we should use preferably use the PEP nick of the user
                     # (but it doesn't matter much)
-                    fallback_nick = entity.jid.local
+                    fallback_nick = self.session.user_jid.local
             else:
                 if muc:
                     if hasattr(entity, "muc"):

slidge/core/mixins/presence.py

@@ -5,7 +5,7 @@ from typing import Optional
 
 from slixmpp.types import PresenceShows, PresenceTypes
 
-from ...util.sql import CachedPresence, db
+from ...util.types import CachedPresence
 from .. import config
 from .base import BaseSender
 
@@ -19,20 +19,32 @@ _FRIEND_REQUEST_PRESENCES = {"subscribe", "unsubscribe", "subscribed", "unsubscr
 
 class PresenceMixin(BaseSender):
     _ONLY_SEND_PRESENCE_CHANGES = False
+    contact_pk: Optional[int] = None
 
     def __init__(self, *a, **k):
         super().__init__(*a, **k)
+        # FIXME: this should not be an attribute of this mixin to allow garbage
+        #        collection of instances
         self.__update_last_seen_fallback_task: Optional[Task] = None
+        # this is only used when a presence is set during Contact.update_info(),
+        # when the contact does not have a DB primary key yet, and is written
+        # to DB at the end of update_info()
+        self.cached_presence: Optional[CachedPresence] = None
 
     async def __update_last_seen_fallback(self):
         await sleep(3600 * 7)
         self.send_last_presence(force=True, no_cache_online=False)
 
     def _get_last_presence(self) -> Optional[CachedPresence]:
-        return db.presence_get(self.jid, self.user)
+        if self.contact_pk is None:
+            return None
+        return self.xmpp.store.contacts.get_presence(self.contact_pk)
 
     def _store_last_presence(self, new: CachedPresence):
-        return db.presence_store(self.jid, new, self.user)
+        if self.contact_pk is None:
+            self.cached_presence = new
+            return
+        self.xmpp.store.contacts.set_presence(self.contact_pk, new)
 
     def _make_presence(
         self,
@@ -55,7 +67,8 @@ class PresenceMixin(BaseSender):
             )
             if old != new:
                 if hasattr(self, "muc") and ptype == "unavailable":
-                    db.presence_delete(self.jid, self.user)
+                    if self.contact_pk is not None:
+                        self.xmpp.store.contacts.reset_presence(self.contact_pk)
                 else:
                     self._store_last_presence(new)
             if old and not force and self._ONLY_SEND_PRESENCE_CHANGES: