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

slidge/core/gateway/session_dispatcher.py

@@ -9,7 +9,6 @@ from slixmpp.plugins.xep_0084.stanza import Info
 
 from ... import LegacyContact
 from ...group.room import LegacyMUC
-from ...util.sql import db
 from ...util.types import LinkPreview, Recipient, RecipientType
 from ...util.util import (
     dict_to_named_tuple,
@@ -62,6 +61,13 @@ class SessionDispatcher:
                 _exceptions_to_xmpp_errors(self.on_muc_owner_set),  # type: ignore
             )
         )
+        xmpp.register_handler(
+            CoroutineCallback(
+                "ibr_remove",
+                StanzaPath("/iq/register"),
+                _exceptions_to_xmpp_errors(self.on_ibr_remove),  # type: ignore
+            )
+        )
 
         for event in (
             "legacy_message",
@@ -157,7 +163,7 @@ class SessionDispatcher:
         reply_fallback = None
         if msg.get_plugin("reply", check=True):
             try:
-                reply_to_msg_xmpp_id = _xmpp_msg_id_to_legacy(
+                reply_to_msg_xmpp_id = self._xmpp_msg_id_to_legacy(
                     session, msg["reply"]["id"]
                 )
             except XMPPError:
@@ -170,7 +176,7 @@ class SessionDispatcher:
             else:
                 reply_to_jid = JID(msg["reply"]["to"])
                 if msg["type"] == "chat":
-                    if reply_to_jid.bare != session.user.jid.bare:
+                    if reply_to_jid.bare != session.user_jid.bare:
                         try:
                             reply_to = await session.contacts.by_jid(reply_to_jid)
                         except XMPPError:
@@ -242,13 +248,17 @@ class SessionDispatcher:
         if isinstance(e, LegacyMUC):
             await e.echo(msg, legacy_msg_id)
             if legacy_msg_id is not None:
-                session.muc_sent_msg_ids[legacy_msg_id] = msg.get_id()
+                self.xmpp.store.sent.set_group_message(
+                    session.user_pk, legacy_msg_id, msg.get_id()
+                )
         else:
             self.__ack(msg)
             if legacy_msg_id is not None:
-                session.sent[legacy_msg_id] = msg.get_id()
+                self.xmpp.store.sent.set_message(
+                    session.user_pk, legacy_msg_id, msg.get_id()
+                )
                 if session.MESSAGE_IDS_ARE_THREAD_IDS and (t := msg["thread"]):
-                    session.threads[t] = legacy_msg_id
+                    self.xmpp.store.sent.set_thread(session.user_pk, t, legacy_msg_id)
 
     async def on_groupchat_message(self, msg: Message):
         await self.on_legacy_message(msg)
@@ -257,9 +267,11 @@ class SessionDispatcher:
         session, entity, thread = await self.__get_session_entity_thread(msg)
         xmpp_id = msg["replace"]["id"]
         if isinstance(entity, LegacyMUC):
-            legacy_id = session.muc_sent_msg_ids.inverse.get(xmpp_id)
+            legacy_id = self.xmpp.store.sent.get_group_legacy_id(
+                session.user_pk, xmpp_id
+            )
         else:
-            legacy_id = _xmpp_msg_id_to_legacy(session, xmpp_id)
+            legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
 
         if isinstance(entity, LegacyMUC):
             mentions = await entity.parse_mentions(msg["body"])
@@ -323,12 +335,16 @@ class SessionDispatcher:
 
         if isinstance(entity, LegacyMUC):
             if new_legacy_msg_id is not None:
-                session.muc_sent_msg_ids[new_legacy_msg_id] = msg.get_id()
+                self.xmpp.store.sent.set_group_message(
+                    session.user_pk, new_legacy_msg_id, msg.get_id()
+                )
             await entity.echo(msg, new_legacy_msg_id)
         else:
             self.__ack(msg)
             if new_legacy_msg_id is not None:
-                session.sent[new_legacy_msg_id] = msg.get_id()
+                self.xmpp.store.sent.set_message(
+                    session.user_pk, new_legacy_msg_id, msg.get_id()
+                )
 
     async def on_message_retract(self, msg: Message):
         session, entity, thread = await self.__get_session_entity_thread(msg)
@@ -338,7 +354,7 @@ class SessionDispatcher:
                 "This legacy service does not support message retraction.",
             )
         xmpp_id: str = msg["retract"]["id"]
-        legacy_id = _xmpp_msg_id_to_legacy(session, xmpp_id)
+        legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
         if legacy_id:
             await session.on_retract(entity, legacy_id, thread=thread)
             if isinstance(entity, LegacyMUC):
@@ -362,7 +378,7 @@ class SessionDispatcher:
             to_mark = [displayed_msg_id]
         for xmpp_id in to_mark:
             await session.on_displayed(
-                e, _xmpp_msg_id_to_legacy(session, xmpp_id), legacy_thread
+                e, self._xmpp_msg_id_to_legacy(session, xmpp_id), legacy_thread
             )
             if isinstance(e, LegacyMUC):
                 await e.echo(msg, None)
@@ -397,7 +413,7 @@ class SessionDispatcher:
         if special_msg:
             legacy_id = react_to
         else:
-            legacy_id = _xmpp_msg_id_to_legacy(session, react_to)
+            legacy_id = self._xmpp_msg_id_to_legacy(session, react_to)
 
         if not legacy_id:
             log.debug("Ignored reaction from user")
@@ -434,9 +450,10 @@ class SessionDispatcher:
         else:
             self.__ack(msg)
 
-        multi = db.attachment_get_associated_xmpp_ids(react_to)
+        multi = self.xmpp.store.multi.get_xmpp_ids(session.user_pk, react_to)
         if not multi:
             return
+        multi = [m for m in multi if react_to != m]
 
         if isinstance(entity, LegacyMUC):
             for xmpp_id in multi:
@@ -461,14 +478,17 @@ class SessionDispatcher:
 
         pto = p.get_to()
         if pto == self.xmpp.boundjid.bare:
-            # NB: get_type() returns either a proper presence type or
-            #     a presence show if available. Weird, weird, weird slix.
+            session.log.debug("Received a presence from %s", p.get_from())
             if (ptype := p.get_type()) not in _USEFUL_PRESENCES:
                 return
+            if not session.user.preferences.get("sync_presence", False):
+                session.log.debug("User does not want to sync their presence")
+                return
+            # NB: get_type() returns either a proper presence type or
+            #     a presence show if available. Weird, weird, weird slix.
             resources = self.xmpp.roster[self.xmpp.boundjid.bare][
                 p.get_from()
             ].resources
-            session.log.debug("Received a presence from %s", p.get_from())
             await session.on_presence(
                 p.get_from().resource,
                 ptype,  # type: ignore
@@ -478,8 +498,12 @@ class SessionDispatcher:
             )
             return
 
-        muc = session.bookmarks._mucs_by_bare_jid.get(pto.bare)
-        if muc is None or p.get_from().resource not in muc.user_resources:
+        muc = session.bookmarks.by_jid_only_if_exists(JID(pto.bare))
+
+        if muc is not None and p.get_type() == "unavailable":
+            return muc.on_presence_unavailable(p)
+
+        if muc is None or p.get_from().resource not in muc.get_user_resources():
             return
 
         if pto.resource == muc.user_nick:
@@ -530,29 +554,36 @@ class SessionDispatcher:
             return
 
         stanza_id = msg["pubsub_event"]["items"]["item"]["displayed"]["stanza_id"]["id"]
-        await session.on_displayed(chat, _xmpp_msg_id_to_legacy(session, stanza_id))
+        await session.on_displayed(
+            chat, self._xmpp_msg_id_to_legacy(session, stanza_id)
+        )
 
     async def on_avatar_metadata_publish(self, m: Message):
-        if not config.SYNC_AVATAR:
-            return
-
         session = await self.__get_session(m, timeout=None)
+        if not session.user.preferences.get("sync_avatar", False):
+            session.log.debug("User does not want to sync their avatar")
+            return
         info = m["pubsub_event"]["items"]["item"]["avatar_metadata"]["info"]
 
         await self.on_avatar_metadata_info(session, info)
 
     async def on_avatar_metadata_info(self, session: BaseSession, info: Info):
-        session.log.debug("Avatar metadata info: %s", info)
         hash_ = info["id"]
 
-        if session.avatar_hash == hash_:
+        if session.user.avatar_hash == hash_:
+            session.log.debug("We already know this avatar hash")
             return
-        session.avatar_hash = hash_
+        with self.xmpp.store.session() as orm_session:
+            user = self.xmpp.store.users.get(session.user_jid)
+            assert user is not None
+            user.avatar_hash = hash_
+            orm_session.add(user)
+            orm_session.commit()
 
         if hash_:
             try:
                 iq = await self.xmpp.plugin["xep_0084"].retrieve_avatar(
-                    session.user.jid, hash_, ifrom=self.xmpp.boundjid.bare
+                    session.user_jid, hash_, ifrom=self.xmpp.boundjid.bare
                 )
             except IqError as e:
                 session.log.warning("Could not fetch the user's avatar: %s", e)
@@ -593,7 +624,7 @@ class SessionDispatcher:
                 "Slidge only implements moderation/retraction",
             )
 
-        legacy_id = _xmpp_msg_id_to_legacy(session, xmpp_id)
+        legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
         await session.on_moderate(muc, legacy_id, moderate["reason"] or None)
         iq.reply(clear=True).send()
 
@@ -601,14 +632,28 @@ class SessionDispatcher:
         session = await self.__get_session(iq)
         session.raise_if_not_logged()
 
-        item = iq["mucadmin_query"]["item"]
-        contact = await session.contacts.by_jid(JID(item["jid"]))
-
         muc = await session.bookmarks.by_jid(iq.get_to())
 
-        await muc.on_set_affiliation(
-            contact, item["affiliation"], item["reason"] or None, item["nick"] or None
-        )
+        item = iq["mucadmin_query"]["item"]
+        if item["jid"]:
+            contact = await session.contacts.by_jid(JID(item["jid"]))
+        else:
+            part = await muc.get_participant(
+                item["nick"], fill_first=True, raise_if_not_found=True
+            )
+            assert part.contact is not None
+            contact = part.contact
+
+        if item["affiliation"]:
+            await muc.on_set_affiliation(
+                contact,
+                item["affiliation"],
+                item["reason"] or None,
+                item["nick"] or None,
+            )
+        elif item["role"] == "none":
+            await muc.on_kick(contact, item["reason"] or None)
+
         iq.reply(clear=True).send()
 
     async def on_groupchat_direct_invite(self, msg: Message):
@@ -718,25 +763,39 @@ class SessionDispatcher:
             )
         await muc.on_set_subject(msg["subject"])
 
+    async def on_ibr_remove(self, iq: Iq):
+        if iq.get_to() == self.xmpp.boundjid.bare:
+            return
 
-def _xmpp_msg_id_to_legacy(session: "BaseSession", xmpp_id: str):
-    sent = session.sent.inverse.get(xmpp_id)
-    if sent:
-        return sent
+        session = await self.__get_session(iq)
+        session.raise_if_not_logged()
 
-    multi = db.attachment_get_legacy_id_for_xmpp_id(xmpp_id)
-    if multi:
-        return multi
+        if iq["type"] == "set" and iq["register"]["remove"]:
+            muc = await session.bookmarks.by_jid(iq.get_to())
+            await session.on_leave_group(muc.legacy_id)
+            iq.reply().send()
+            return
 
-    try:
-        return session.xmpp_to_legacy_msg_id(xmpp_id)
-    except XMPPError:
-        raise
-    except Exception as e:
-        log.debug("Couldn't convert xmpp msg ID to legacy ID.", exc_info=e)
-        raise XMPPError(
-            "internal-server-error", "Couldn't convert xmpp msg ID to legacy ID."
-        )
+        raise XMPPError("feature-not-implemented")
+
+    def _xmpp_msg_id_to_legacy(self, session: "BaseSession", xmpp_id: str):
+        sent = self.xmpp.store.sent.get_legacy_id(session.user_pk, xmpp_id)
+        if sent is not None:
+            return self.xmpp.LEGACY_MSG_ID_TYPE(sent)
+
+        multi = self.xmpp.store.multi.get_legacy_id(session.user_pk, xmpp_id)
+        if multi:
+            return self.xmpp.LEGACY_MSG_ID_TYPE(multi)
+
+        try:
+            return session.xmpp_to_legacy_msg_id(xmpp_id)
+        except XMPPError:
+            raise
+        except Exception as e:
+            log.debug("Couldn't convert xmpp msg ID to legacy ID.", exc_info=e)
+            raise XMPPError(
+                "internal-server-error", "Couldn't convert xmpp msg ID to legacy ID."
+            )
 
 
 def _ignore(session: "BaseSession", msg: Message):
@@ -755,14 +814,18 @@ async def _xmpp_to_legacy_thread(
         return
 
     if session.MESSAGE_IDS_ARE_THREAD_IDS:
-        return session.threads.get(xmpp_thread)
+        return session.xmpp.store.sent.get_legacy_thread(session.user_pk, xmpp_thread)
 
     async with session.thread_creation_lock:
-        legacy_thread = session.threads.get(xmpp_thread)
-        if legacy_thread is None:
-            legacy_thread = await recipient.create_thread(xmpp_thread)
-            session.threads[xmpp_thread] = legacy_thread
-    return legacy_thread
+        legacy_thread_str = session.xmpp.store.sent.get_legacy_thread(
+            session.user_pk, xmpp_thread
+        )
+        if legacy_thread_str is None:
+            legacy_thread = str(await recipient.create_thread(xmpp_thread))
+            session.xmpp.store.sent.set_thread(
+                session.user_pk, xmpp_thread, legacy_thread
+            )
+    return session.xmpp.LEGACY_MSG_ID_TYPE(legacy_thread)
 
 
 async def _get_entity(session: "BaseSession", m: Message) -> RecipientType:
@@ -770,7 +833,7 @@ async def _get_entity(session: "BaseSession", m: Message) -> RecipientType:
     if m.get_type() == "groupchat":
         muc = await session.bookmarks.by_jid(m.get_to())
         r = m.get_from().resource
-        if r not in muc.user_resources:
+        if r not in muc.get_user_resources():
             session.create_task(muc.kick_resource(r))
             raise XMPPError("not-acceptable", "You are not connected to this chat")
         return muc

slidge/core/gateway/vcard_temp.py

@@ -40,11 +40,13 @@ class VCardTemp:
             return await self.__handle_set_vcard_temp(iq)
 
     async def __fetch_user_avatar(self, session: BaseSession):
-        hash_ = session.avatar_hash
+        hash_ = session.user.avatar_hash
         if not hash_:
-            raise XMPPError("item-not-found", "This participant has no contact")
+            raise XMPPError(
+                "item-not-found", "The slidge user does not have any avatar set"
+            )
         meta_iq = await self.xmpp.plugin["xep_0060"].get_item(
-            session.user.jid,
+            session.user_jid,
             MetaData.namespace,
             hash_,
             ifrom=self.xmpp.boundjid.bare,
@@ -52,14 +54,14 @@ class VCardTemp:
         info = meta_iq["pubsub"]["items"]["item"]["avatar_metadata"]["info"]
         type_ = info["type"]
         data_iq = await self.xmpp.plugin["xep_0084"].retrieve_avatar(
-            session.user.jid, hash_, ifrom=self.xmpp.boundjid.bare
+            session.user_jid, hash_, ifrom=self.xmpp.boundjid.bare
         )
         bytes_ = data_iq["pubsub"]["items"]["item"]["avatar_data"]["value"]
         return bytes_, type_
 
     async def __handle_get_vcard_temp(self, iq: Iq):
         session = self.xmpp.get_session_from_stanza(iq)
-        entity = await session.get_contact_or_group_or_participant(iq.get_to())
+        entity = await session.get_contact_or_group_or_participant(iq.get_to(), False)
         if not entity:
             raise XMPPError("item-not-found")
 

slidge/core/mixins/__init__.py

@@ -2,6 +2,8 @@
 Mixins
 """
 
+from typing import Optional
+
 from .avatar import AvatarMixin
 from .disco import ChatterDiscoMixin
 from .message import MessageCarbonMixin, MessageMixin
@@ -16,4 +18,12 @@ class FullCarbonMixin(ChatterDiscoMixin, MessageCarbonMixin, PresenceMixin):
     pass
 
 
-__all__ = ("AvatarMixin",)
+class StoredAttributeMixin:
+    def serialize_extra_attributes(self) -> Optional[dict]:
+        return None
+
+    def deserialize_extra_attributes(self, data: dict) -> None:
+        pass
+
+
+__all__ = ("AvatarMixin", "FullCarbonMixin", "StoredAttributeMixin")

slidge/core/mixins/attachment.py

@@ -9,7 +9,7 @@ import warnings
 from datetime import datetime
 from mimetypes import guess_type
 from pathlib import Path
-from typing import IO, Collection, Optional, Sequence, Union
+from typing import IO, AsyncIterator, Collection, Optional, Sequence, Union
 from urllib.parse import quote as urlquote
 from uuid import uuid4
 from xml.etree import ElementTree as ET
@@ -22,7 +22,7 @@ from slixmpp.plugins.xep_0363 import FileUploadError
 from slixmpp.plugins.xep_0385.stanza import Sims
 from slixmpp.plugins.xep_0447.stanza import StatelessFileSharing
 
-from ...util.sql import db
+from ...db.avatar import avatar_cache
 from ...util.types import (
     LegacyAttachment,
     LegacyMessageType,
@@ -31,11 +31,14 @@ from ...util.types import (
 )
 from ...util.util import fix_suffix
 from .. import config
-from ..cache import avatar_cache
 from .message_maker import MessageMaker
 
 
 class AttachmentMixin(MessageMaker):
+    def __init__(self, *a, **kw):
+        super().__init__(*a, **kw)
+        self.__store = self.xmpp.store.attachments
+
     def send_text(self, *_, **k) -> Optional[Message]:
         raise NotImplementedError
 
@@ -138,6 +141,7 @@ class AttachmentMixin(MessageMaker):
     async def __get_url(
         self,
         file_path: Optional[Path] = None,
+        async_data_stream: Optional[AsyncIterator[bytes]] = None,
         data_stream: Optional[IO[bytes]] = None,
         data: Optional[bytes] = None,
         file_url: Optional[str] = None,
@@ -146,13 +150,13 @@ class AttachmentMixin(MessageMaker):
         legacy_file_id: Optional[Union[str, int]] = None,
     ) -> tuple[bool, Optional[Path], str]:
         if legacy_file_id:
-            cache = db.attachment_get_url(legacy_file_id)
+            cache = self.__store.get_url(str(legacy_file_id))
             if cache is not None:
                 async with self.session.http.head(cache) as r:
                     if r.status < 400:
                         return False, None, cache
                     else:
-                        db.attachment_remove(legacy_file_id)
+                        self.__store.remove(str(legacy_file_id))
 
         if file_url and config.USE_ATTACHMENT_ORIGINAL_URLS:
             return False, None, file_url
@@ -173,14 +177,23 @@ class AttachmentMixin(MessageMaker):
                     with file_path.open("wb") as f:
                         f.write(await r.read())
 
-            else:
-                if data_stream is not None:
-                    data = data_stream.read()
+            elif data_stream is not None:
+                data = data_stream.read()
                 if data is None:
                     raise RuntimeError
 
                 with file_path.open("wb") as f:
                     f.write(data)
+            elif async_data_stream is not None:
+                # TODO: patch slixmpp to allow this as data source for
+                #       upload_file() so we don't even have to write anything
+                #       to disk.
+                with file_path.open("wb") as f:
+                    async for chunk in async_data_stream:
+                        f.write(chunk)
+            elif data is not None:
+                with file_path.open("wb") as f:
+                    f.write(data)
 
             is_temp = not bool(config.NO_UPLOAD_PATH)
         else:
@@ -198,7 +211,7 @@ class AttachmentMixin(MessageMaker):
             local_path = file_path
             new_url = await self.__upload(file_path, file_name, content_type)
         if legacy_file_id:
-            db.attachment_store_url(legacy_file_id, new_url)
+            self.__store.set_url(self.session.user_pk, str(legacy_file_id), new_url)
 
         return is_temp, local_path, new_url
 
@@ -211,7 +224,7 @@ class AttachmentMixin(MessageMaker):
         caption: Optional[str] = None,
         file_name: Optional[str] = None,
     ):
-        cache = db.attachment_get_sims(uploaded_url)
+        cache = self.__store.get_sims(uploaded_url)
         if cache:
             msg.append(Sims(xml=ET.fromstring(cache)))
             return
@@ -238,7 +251,7 @@ class AttachmentMixin(MessageMaker):
                 thumbnail["media-type"] = "image/blurhash"
                 thumbnail["uri"] = "data:image/blurhash," + urlquote(h)
 
-        db.attachment_store_sims(uploaded_url, str(sims))
+        self.__store.set_sims(uploaded_url, str(sims))
 
         msg.append(sims)
 
@@ -251,7 +264,7 @@ class AttachmentMixin(MessageMaker):
         caption: Optional[str] = None,
         file_name: Optional[str] = None,
     ):
-        cache = db.attachment_get_sfs(uploaded_url)
+        cache = self.__store.get_sfs(uploaded_url)
         if cache:
             msg.append(StatelessFileSharing(xml=ET.fromstring(cache)))
             return
@@ -262,7 +275,7 @@ class AttachmentMixin(MessageMaker):
         sfs = self.xmpp["xep_0447"].get_sfs(path, [uploaded_url], content_type, caption)
         if file_name:
             sfs["file"]["name"] = file_name
-        db.attachment_store_sfs(uploaded_url, str(sfs))
+        self.__store.set_sfs(uploaded_url, str(sfs))
 
         msg.append(sfs)
 
@@ -293,6 +306,7 @@ class AttachmentMixin(MessageMaker):
         file_path: Optional[Union[Path, str]] = None,
         legacy_msg_id: Optional[LegacyMessageType] = None,
         *,
+        async_data_stream: Optional[AsyncIterator[bytes]] = None,
         data_stream: Optional[IO[bytes]] = None,
         data: Optional[bytes] = None,
         file_url: Optional[str] = None,
@@ -309,6 +323,7 @@ class AttachmentMixin(MessageMaker):
         Send a single file from this :term:`XMPP Entity`.
 
         :param file_path: Path to the attachment
+        :param async_data_stream: Alternatively (and ideally) an AsyncIterator yielding bytes
         :param data_stream: Alternatively, a stream of bytes (such as a File object)
         :param data: Alternatively, a bytes object
         :param file_url: Alternatively, a URL
@@ -339,6 +354,7 @@ class AttachmentMixin(MessageMaker):
 
         is_temp, local_path, new_url = await self.__get_url(
             Path(file_path) if file_path else None,
+            async_data_stream,
             data_stream,
             data,
             file_url,
@@ -472,7 +488,9 @@ class AttachmentMixin(MessageMaker):
                 ids.append(stanza_id["id"])
             else:
                 ids.append(msg.get_id())
-        db.attachment_store_legacy_to_multi_xmpp_msg_ids(legacy_msg_id, ids)
+        self.xmpp.store.multi.set_xmpp_ids(
+            self.session.user_pk, str(legacy_msg_id), ids
+        )
 
 
 def get_blurhash(path: Path, n=9) -> tuple[str, int, int]: