slidge 0.2.0a0__py3-none-any.whl → 0.2.0a1__py3-none-any.whl

slidge/__version__.py

@@ -2,4 +2,4 @@ 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"
+__version__ = "0.2.0alpha1"

slidge/command/admin.py

@@ -55,7 +55,7 @@ class SlidgeInfo(AdminCommand):
     async def run(self, _session, _ifrom, *_):
         from slidge.__version__ import __version__
 
-        start = self.xmpp.datetime_started
+        start = self.xmpp.datetime_started  # type:ignore
         uptime = datetime.now() - start
 
         if uptime.days:

slidge/command/user.py

@@ -131,7 +131,6 @@ class ListContacts(Command):
         self, session: Optional[AnyBaseSession], _ifrom: JID, *_
     ) -> TableResult:
         assert session is not None
-        await session.contacts.fill()
         contacts = sorted(
             session.contacts, key=lambda c: c.name.casefold() if c.name else ""
         )

slidge/contact/contact.py

@@ -11,6 +11,7 @@ from slixmpp.types import MessageTypes
 
 from ..core import config
 from ..core.mixins import AvatarMixin, FullCarbonMixin, StoredAttributeMixin
+from ..core.mixins.db import UpdateInfoMixin
 from ..core.mixins.disco import ContactAccountDiscoMixin
 from ..core.mixins.recipient import ReactionRecipientMixin, ThreadRecipientMixin
 from ..db.models import Contact
@@ -30,6 +31,7 @@ class LegacyContact(
     FullCarbonMixin,
     ReactionRecipientMixin,
     ThreadRecipientMixin,
+    UpdateInfoMixin,
     metaclass=SubclassableOnce,
 ):
     """
@@ -82,7 +84,6 @@ class LegacyContact(
     STRIP_SHORT_DELAY = True
     _NON_FRIEND_PRESENCES_FILTER = {"subscribe", "unsubscribed"}
 
-    _avatar_pubsub_broadcast = True
     _avatar_bare_jid = True
 
     INVITATION_RECIPIENT = True
@@ -121,7 +122,8 @@ class LegacyContact(
         self.jid.resource = self.RESOURCE
         self.log = logging.getLogger(f"{self.user_jid.bare}:{self.jid.bare}")
         self._is_friend: bool = False
-        self.added_to_roster = False
+        self._added_to_roster = False
+        self._caps_ver: str | None = None
 
     @property
     def is_friend(self):
@@ -132,9 +134,27 @@ class LegacyContact(
         if value == self._is_friend:
             return
         self._is_friend = value
+        if self._updating_info:
+            return
         assert self.contact_pk is not None
         self.xmpp.store.contacts.set_friend(self.contact_pk, value)
 
+    @property
+    def added_to_roster(self):
+        return self._added_to_roster
+
+    @added_to_roster.setter
+    def added_to_roster(self, value: bool):
+        if value == self._added_to_roster:
+            return
+        self._added_to_roster = value
+        if self._updating_info:
+            return
+        if self.contact_pk is None:
+            # during LegacyRoster.fill()
+            return
+        self.xmpp.store.contacts.set_added_to_roster(self.contact_pk, value)
+
     @property
     def participants(self) -> list["LegacyParticipant"]:
         assert self.contact_pk is not None
@@ -152,7 +172,7 @@ class LegacyContact(
         return self.session.user_jid
 
     def __repr__(self):
-        return f"<Contact '{self.legacy_id}'/'{self.jid.bare}'>"
+        return f"<Contact {self.jid.bare} - {self.name or self.legacy_id}'>"
 
     def __get_subscription_string(self):
         if self.is_friend:
@@ -198,7 +218,7 @@ class LegacyContact(
             self._privileged_send(stanza)
             return stanza  # type:ignore
 
-        if isinstance(stanza, Presence):
+        if not self._updating_info and isinstance(stanza, Presence):
             self.__propagate_to_participants(stanza)
             if (
                 not self.is_friend
@@ -209,7 +229,11 @@ class LegacyContact(
             n = self.xmpp.plugin["xep_0172"].stanza.UserNick()
             n["nick"] = self.name
             stanza.append(n)
-        if self.xmpp.MARK_ALL_MESSAGES and is_markable(stanza):
+        if (
+            not self._updating_info
+            and self.xmpp.MARK_ALL_MESSAGES
+            and is_markable(stanza)
+        ):
             assert self.contact_pk is not None
             self.xmpp.store.contacts.add_to_sent(self.contact_pk, stanza["id"])
         stanza["to"] = self.user_jid
@@ -244,21 +268,32 @@ class LegacyContact(
     def name(self, n: Optional[str]):
         if self._name == n:
             return
+        self._name = n
+        if self.is_friend and self.added_to_roster:
+            self.xmpp.pubsub.broadcast_nick(
+                user_jid=self.user_jid, jid=self.jid.bare, nick=n
+            )
+        if self._updating_info:
+            # means we're in update_info(), so no participants, and no need
+            # to write to DB now, it will be called in Roster.__finish_init_contact
+            return
         for p in self.participants:
             p.nickname = n
-        self._name = 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
+    def _get_cached_avatar_id(self) -> Optional[str]:
+        if self.contact_pk is None:
+            return 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
+        if self._updating_info:
+            return
+        if self.contact_pk is None:
+            # happens in LegacyRoster.fill(), the contact primary key is not
+            # set yet, but this will eventually be called in LegacyRoster.__finish_init_contact
+            return
         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)
@@ -313,6 +348,15 @@ class LegacyContact(
 
         self.xmpp.vcard.set_vcard(self.jid.bare, vcard, {self.user_jid.bare})
 
+    def get_roster_item(self):
+        item = {
+            "subscription": self.__get_subscription_string(),
+            "groups": [self.xmpp.ROSTER_GROUP],
+        }
+        if (n := self.name) is not None:
+            item["name"] = n
+        return {self.jid.bare: item}
+
     async def add_to_roster(self, force=False):
         """
         Add this contact to the user roster using :xep:`0356`
@@ -324,18 +368,10 @@ class LegacyContact(
         if config.NO_ROSTER_PUSH:
             log.debug("Roster push request by plugin ignored (--no-roster-push)")
             return
-        item = {
-            "subscription": self.__get_subscription_string(),
-            "groups": [self.xmpp.ROSTER_GROUP],
-        }
-        if (n := self.name) is not None:
-            item["name"] = n
-        kw = dict(
-            jid=self.user_jid,
-            roster_items={self.jid.bare: item},
-        )
         try:
-            await self._set_roster(**kw)
+            await self._set_roster(
+                jid=self.user_jid, roster_items=self.get_roster_item()
+            )
         except PermissionError:
             warnings.warn(
                 "Slidge does not have privileges to add contacts to the roster. Refer"
@@ -354,31 +390,32 @@ class LegacyContact(
             # 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.session.create_task(self.__broadcast_pubsub_items())
             self.send_last_presence()
 
     async def __broadcast_pubsub_items(self):
+        if not self.is_friend:
+            return
+        if not self.added_to_roster:
+            return
         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.xmpp.pubsub.broadcast_nick(
                 self.session.user_jid,
+                self.jid.bare,
+                nick,
             )
 
     async def _set_roster(self, **kw):
         try:
-            return await self.xmpp["xep_0356"].set_roster(**kw)
+            await self.xmpp["xep_0356"].set_roster(**kw)
         except PermissionError:
-            return await self.xmpp["xep_0356_old"].set_roster(**kw)
+            await self.xmpp["xep_0356_old"].set_roster(**kw)
 
     def send_friend_request(self, text: Optional[str] = None):
         presence = self._make_presence(ptype="subscribe", pstatus=text, bare=True)
@@ -392,8 +429,8 @@ class LegacyContact(
         :param text: Optional message from the friend to the user
         """
         self.is_friend = True
+        self.added_to_roster = 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)
@@ -486,6 +523,22 @@ class LegacyContact(
         """
         pass
 
+    def _make_presence(
+        self,
+        *,
+        last_seen: Optional[datetime.datetime] = None,
+        status_codes: Optional[set[int]] = None,
+        user_full_jid: Optional[JID] = None,
+        **presence_kwargs,
+    ):
+        p = super()._make_presence(last_seen=last_seen, **presence_kwargs)
+        caps = self.xmpp.plugin["xep_0115"]
+        if p.get_from().resource and self._caps_ver:
+            p["caps"]["node"] = caps.caps_node
+            p["caps"]["hash"] = caps.hash
+            p["caps"]["ver"] = self._caps_ver
+        return p
+
     @classmethod
     def from_store(cls, session, stored: Contact, *args, **kwargs) -> Self:
         contact = cls(
@@ -502,6 +555,7 @@ class LegacyContact(
         if (data := stored.extra_attributes) is not None:
             contact.deserialize_extra_attributes(data)
         contact._set_avatar_from_store(stored)
+        contact._caps_ver = stored.caps_ver
         return contact
 
 

slidge/contact/roster.py

@@ -1,8 +1,10 @@
 import asyncio
 import logging
-from typing import TYPE_CHECKING, Generic, Iterator, Optional, Type
+import warnings
+from typing import TYPE_CHECKING, AsyncIterator, Generic, Iterator, Optional, Type
 
 from slixmpp import JID
+from slixmpp.exceptions import IqError, XMPPError
 from slixmpp.jid import JID_UNESCAPE_TRANSFORMATIONS, _unescape_node
 
 from ..core.mixins.lock import NamedLockMixin
@@ -50,6 +52,7 @@ class LegacyRoster(
         self.log = logging.getLogger(f"{self.session.user_jid.bare}:roster")
         self.user_legacy_id: Optional[LegacyUserIdType] = None
         self.ready: asyncio.Future[bool] = self.session.xmpp.loop.create_future()
+        self.__filling = False
         super().__init__()
 
     def __repr__(self):
@@ -63,25 +66,37 @@ class LegacyRoster(
     async def __finish_init_contact(
         self, legacy_id: LegacyUserIdType, jid_username: str, *args, **kwargs
     ):
-        c = self._contact_cls(self.session, legacy_id, jid_username, *args, **kwargs)
-        async with self.lock(("finish", c.legacy_id)):
+        async with self.lock(("finish", legacy_id)):
             with self.__store.session():
                 stored = self.__store.get_by_legacy_id(
                     self.session.user_pk, str(legacy_id)
                 )
-                if stored is not None and stored.updated:
-                    self.log.debug("Already updated %s", c)
-                    return self._contact_cls.from_store(self.session, stored)
-                c.contact_pk = self.__store.add(
-                    self.session.user_pk, c.legacy_id, c.jid
-                )
-                await c.avatar_wrap_update_info()
-                self.__store.update(c)
+                if stored is not None:
+                    if stored.updated:
+                        return self._contact_cls.from_store(self.session, stored)
+                    c: LegacyContact = self._contact_cls(
+                        self.session, legacy_id, jid_username, *args, **kwargs
+                    )
+                    c.contact_pk = stored.id
+                else:
+                    c = self._contact_cls(
+                        self.session, legacy_id, jid_username, *args, **kwargs
+                    )
+                try:
+                    with c.updating_info():
+                        await c.avatar_wrap_update_info()
+                except Exception as e:
+                    raise XMPPError("internal-server-error", str(e))
+                c._caps_ver = await c.get_caps_ver(c.jid)
+                need_avatar = c.contact_pk is None
+                c.contact_pk = self.__store.update(c, commit=not self.__filling)
+                if need_avatar:
+                    c._post_avatar_update()
         return c
 
     def known_contacts(self, only_friends=True) -> dict[str, LegacyContactType]:
         if only_friends:
-            return {j: c for j, c in self if c.is_friend}  # type:ignore
+            return {c.jid.bare: c for c in self if c.is_friend}
         return {c.jid.bare: c for c in self}
 
     async def by_jid(self, contact_jid: JID) -> LegacyContactType:
@@ -189,18 +204,63 @@ class LegacyRoster(
         """
         return _unescape_node(jid_username)
 
-    async def fill(self):
+    async def _fill(self):
+        try:
+            if hasattr(self.session.xmpp, "TEST_MODE"):
+                # dirty hack to avoid mocking xmpp server replies to this
+                # during tests
+                raise PermissionError
+            iq = await self.session.xmpp["xep_0356"].get_roster(
+                self.session.user_jid.bare
+            )
+            user_roster = iq["roster"]["items"]
+        except (PermissionError, IqError):
+            user_roster = None
+
+        with self.__store.session() as orm:
+            self.__filling = True
+            async for contact in self.fill():
+                if user_roster is None:
+                    continue
+                item = contact.get_roster_item()
+                old = user_roster.get(contact.jid.bare)
+                if old is not None and all(
+                    old[k] == item[contact.jid.bare][k]
+                    for k in ("subscription", "groups", "name")
+                ):
+                    self.log.debug("No need to update roster")
+                    continue
+                self.log.debug("Updating roster")
+                try:
+                    await self.session.xmpp["xep_0356"].set_roster(
+                        self.session.user_jid.bare,
+                        item,
+                    )
+                except (PermissionError, IqError) as e:
+                    warnings.warn(f"Could not add to roster: {e}")
+                else:
+                    contact._added_to_roster = True
+            orm.commit()
+        self.__filling = False
+
+    async def fill(self) -> AsyncIterator[LegacyContact]:
         """
         Populate slidge's "virtual roster".
 
-        Override this and in it, ``await self.by_legacy_id(contact_id)``
-        for the every legacy contacts of the user for which you'd like to
-        set an avatar, nickname, vcard…
+        This should yield contacts that are meant to be added to the user's
+        roster, typically by using ``await self.by_legacy_id(contact_id)``.
+        Setting the contact nicknames, avatar, etc. should be in
+        :meth:`LegacyContact.update_info()`
+
+        It's not mandatory to override this method, but it is recommended way
+        to populate "friends" of the user. Calling
+        ``await (await self.by_legacy_id(contact_id)).add_to_roster()``
+        accomplishes the same thing, but doing it in here allows to batch
+        DB queries and is better performance-wise.
 
-        Await ``Contact.add_to_roster()`` in here to add the contact to the
-        user's XMPP roster.
         """
-        pass
+        return
+        yield
 
 
 ESCAPE_TABLE = "".maketrans({v: k for k, v in JID_UNESCAPE_TRANSFORMATIONS.items()})

slidge/core/config.py

@@ -185,10 +185,7 @@ LOG_FORMAT__DOC = (
 )
 
 MAM_MAX_DAYS = 7
-MAM_MAX_DAYS__DOC = (
-    "Maximum number of days for group archive retention. "
-    "Since all text content stored in RAM right now, "
-)
+MAM_MAX_DAYS__DOC = "Maximum number of days for group archive retention."
 
 CORRECTION_EMPTY_BODY_AS_RETRACTION = True
 CORRECTION_EMPTY_BODY_AS_RETRACTION__DOC = (

slidge/core/gateway/base.py

@@ -39,6 +39,7 @@ from ...slixfix.roster import RosterBackend
 from ...slixfix.xep_0292.vcard4 import VCard4Provider
 from ...util import ABCSubclassableOnceAtMost
 from ...util.types import AvatarType, MessageOrPresenceTypeVar
+from ...util.util import timeit
 from .. import config
 from ..mixins import MessageMixin
 from ..pubsub import PubSubComponent
@@ -271,6 +272,7 @@ class BaseGateway(
     """
 
     def __init__(self):
+        self.log = log
         self.datetime_started = datetime.now()
         self.xmpp = self  # ugly hack to work with the BaseSender mixin :/
         self.default_ns = "jabber:component:accept"
@@ -335,6 +337,8 @@ class BaseGateway(
         # with this we receive user avatar updates
         self.plugin["xep_0030"].add_feature("urn:xmpp:avatar:metadata+notify")
 
+        self.plugin["xep_0030"].add_feature("urn:xmpp:chat-markers:0")
+
         if self.GROUPS:
             self.plugin["xep_0030"].add_feature("http://jabber.org/protocol/muc")
             self.plugin["xep_0030"].add_feature("urn:xmpp:mam:2")
@@ -366,6 +370,8 @@ class BaseGateway(
 
         self.__mam_cleanup_task = self.loop.create_task(self.__mam_cleanup())
 
+        MessageMixin.__init__(self)  # ComponentXMPP does not call super().__init__()
+
     async def __mam_cleanup(self):
         if not config.MAM_MAX_DAYS:
             return
@@ -399,7 +405,7 @@ class BaseGateway(
         log.debug("Context in the exception handler: %s", context)
         exc = context.get("exception")
         if exc is None:
-            log.warning("No exception in this context: %s", context)
+            log.debug("No exception in this context: %s", context)
         elif isinstance(exc, SystemExit):
             log.debug("SystemExit called in an asyncio task")
         else:
@@ -540,6 +546,7 @@ class BaseGateway(
                 exc_info=e,
             )
 
+    @timeit
     async def __login_wrap(self, session: "BaseSession"):
         session.send_gateway_status("Logging in…", show="dnd")
         try:
@@ -557,7 +564,7 @@ class BaseGateway(
         log.info("Login success for %s", session.user_jid)
         session.logged = True
         session.send_gateway_status("Syncing contacts…", show="dnd")
-        await session.contacts.fill()
+        await session.contacts._fill()
         if not (r := session.contacts.ready).done():
             r.set_result(True)
         if self.GROUPS:

slidge/core/gateway/caps.py

@@ -5,8 +5,6 @@ from slixmpp import Presence
 from slixmpp.exceptions import XMPPError
 from slixmpp.xmlstream import StanzaBase
 
-from ...contact import LegacyContact
-
 if TYPE_CHECKING:
     from .base import BaseGateway
 
@@ -25,6 +23,9 @@ class Caps:
         if not isinstance(stanza, Presence):
             return stanza
 
+        if stanza.get_plugin("caps", check=True):
+            return stanza
+
         if stanza["type"] not in ("available", "chat", "away", "dnd", "xa"):
             return stanza
 
@@ -44,10 +45,11 @@ class Caps:
 
             await session.ready
 
-            entity = await session.get_contact_or_group_or_participant(pfrom)
-            if not isinstance(entity, LegacyContact):
+            try:
+                contact = await session.contacts.by_jid(pfrom)
+            except XMPPError:
                 return stanza
-            ver = await entity.get_caps_ver(pfrom)
+            ver = await contact.get_caps_ver(pfrom)
         else:
             ver = await caps.get_verstring(pfrom)
 

slidge/core/gateway/muc_admin.py

@@ -28,7 +28,7 @@ class MucAdmin:
 
         reply = iq.reply()
         reply.enable("mucadmin_query")
-        for participant in await muc.get_participants():
+        async for participant in muc.get_participants():
             if not participant.affiliation == affiliation:
                 continue
             reply["mucadmin_query"].append(participant.mucadmin_item())

slidge/core/gateway/session_dispatcher.py

@@ -632,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):

slidge/core/gateway/vcard_temp.py

@@ -61,7 +61,7 @@ class VCardTemp:
 
     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/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
@@ -141,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,
@@ -176,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:
@@ -296,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,
@@ -312,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
@@ -342,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,