slidge 0.2.0a0__tar.gz → 0.2.0a2__tar.gz

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

@@ -1,16 +1,14 @@
 Metadata-Version: 2.1
 Name: slidge
-Version: 0.2.0a0
+Version: 0.2.0a2
 Summary: XMPP bridging framework
 Home-page: https://sr.ht/~nicoco/slidge/
 License: AGPL-3.0-or-later
 Author: Nicolas Cedilnik
 Author-email: nicoco@nicoco.fr
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
 Requires-Dist: Pillow (>=10,<11)

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "slidge"
-version = "0.2.0alpha0"
+version = "0.2.0alpha2"
 description = "XMPP bridging framework"
 authors = ["Nicolas Cedilnik <nicoco@nicoco.fr>"]
 readme = "README.md"
@@ -11,7 +11,7 @@ documentation = "https://slidge.im/"
 include = ["slidge/util/schema.sql"]
 
 [tool.poetry.dependencies]
-python = "^3.9"
+python = "^3.11"
 qrcode = "^7.4.1"
 Pillow = "^10"
 aiohttp = {version = "^3.8.3", extras = ["speedups"]}

{slidge-0.2.0a0 → slidge-0.2.0a2}/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.0alpha2"

{slidge-0.2.0a0 → slidge-0.2.0a2}/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-0.2.0a0 → slidge-0.2.0a2}/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-0.2.0a0 → slidge-0.2.0a2}/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
@@ -119,9 +120,11 @@ class LegacyContact(
         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_jid.bare}:{self.jid.bare}")
+        self.log = logging.getLogger(self.jid.bare)
+        self._set_logger_name()
         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,12 +135,34 @@ class LegacyContact(
         if value == self._is_friend:
             return
         self._is_friend = value
+        if self._updating_info:
+            return
+        self.__ensure_pk()
         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
+        if self.contact_pk is None:
+            return []
+
+        self.__ensure_pk()
         from ..group.participant import LegacyParticipant
 
         return [
@@ -151,8 +176,25 @@ class LegacyContact(
     def user_jid(self):
         return self.session.user_jid
 
+    def _set_logger_name(self):
+        self.log.name = f"{self.user_jid.bare}:contact:{self}"
+
     def __repr__(self):
-        return f"<Contact '{self.legacy_id}'/'{self.jid.bare}'>"
+        return f"<Contact #{self.contact_pk} '{self.name}' ({self.legacy_id} - {self.jid.local})'>"
+
+    def __ensure_pk(self):
+        if self.contact_pk is not None:
+            return
+        with self.xmpp.store.session() as orm:
+            orm.commit()
+            stored = self.xmpp.store.contacts.get_by_legacy_id(
+                self.user_pk, str(self.legacy_id)
+            )
+            if stored is None:
+                self.log.error("Cannot find our primary key!", stack_info=True)
+                raise RuntimeError("Cannot find our primary key!")
+            self.contact_pk = stored.id
+        assert self.contact_pk is not None
 
     def __get_subscription_string(self):
         if self.is_friend:
@@ -198,7 +240,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 +251,12 @@ 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)
+        ):
+            self.__ensure_pk()
             assert self.contact_pk is not None
             self.xmpp.store.contacts.add_to_sent(self.contact_pk, stanza["id"])
         stanza["to"] = self.user_jid
@@ -230,6 +277,7 @@ class LegacyContact(
         :param horizon_xmpp_id: The latest message
         :return: A list of XMPP ids or None if horizon_xmpp_id was not found
         """
+        self.__ensure_pk()
         assert self.contact_pk is not None
         return self.xmpp.store.contacts.pop_sent_up_to(self.contact_pk, horizon_xmpp_id)
 
@@ -244,21 +292,35 @@ class LegacyContact(
     def name(self, n: Optional[str]):
         if self._name == n:
             return
+        self._name = n
+        self._set_logger_name()
+        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
+        self.__ensure_pk()
         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
+            self.log.debug("Not setting avatar PK")
+            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 +375,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 +395,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 +417,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 +456,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.added_to_roster = True
+        self.__ensure_pk()
         self.log.debug("Accepting friend request")
         presence = self._make_presence(ptype="subscribed", pstatus=text, bare=True)
         self._send(presence, nick=True)
@@ -486,6 +550,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(
@@ -501,6 +581,8 @@ class LegacyContact(
         contact.added_to_roster = stored.added_to_roster
         if (data := stored.extra_attributes) is not None:
             contact.deserialize_extra_attributes(data)
+        contact._caps_ver = stored.caps_ver
+        contact._set_logger_name()
         contact._set_avatar_from_store(stored)
         return contact
 

{slidge-0.2.0a0 → slidge-0.2.0a2}/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-0.2.0a0 → slidge-0.2.0a2}/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-0.2.0a0 → slidge-0.2.0a2}/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-0.2.0a0 → slidge-0.2.0a2}/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-0.2.0a0 → slidge-0.2.0a2}/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-0.2.0a0 → slidge-0.2.0a2}/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-0.2.0a0 → slidge-0.2.0a2}/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")