slidge 0.1.0rc1__py3-none-any.whl → 0.1.2__py3-none-any.whl

slidge/core/mixins/avatar.py

@@ -0,0 +1,167 @@
+from asyncio import Task, create_task
+from hashlib import sha1
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+from slixmpp import JID
+
+from ...util.types import (
+    URL,
+    AnyBaseSession,
+    AvatarIdType,
+    AvatarType,
+    LegacyFileIdType,
+)
+from ..cache import avatar_cache
+
+if TYPE_CHECKING:
+    from ..pubsub import PepAvatar
+
+
+class AvatarMixin:
+    """
+    Mixin for XMPP entities that have avatars that represent them.
+
+    Both :py:class:`slidge.LegacyContact` and :py:class:`slidge.LegacyMUC` use
+    :py: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.__avatar_unique_id: Optional[AvatarIdType] = None
+
+    @property
+    def __avatar_jid(self):
+        return JID(self.jid.bare) if self._avatar_bare_jid else self.jid
+
+    @property
+    def avatar_id(self) -> Optional[AvatarIdType]:
+        """
+        The unique ID of this entity's avatar.
+        """
+        return self.__avatar_unique_id
+
+    @property
+    def avatar(self) -> Optional[AvatarIdType]:
+        """
+        This property can be used to set the avatar, but
+        :py:meth:`~.AvatarMixin.set_avatar()` should be preferred because you can
+        provide a unique ID for the avatar for efficient caching.
+        Setting this is OKish in case the avatar type is a URL or a local path
+        that can act as a legacy ID.
+
+        Python's ``property`` is abused here to maintain backwards
+        compatibility, but when getting it you actually get the avatar legacy
+        ID.
+        """
+        return self.__avatar_unique_id
+
+    @avatar.setter
+    def avatar(self, a: Optional[AvatarType]):
+        if self._set_avatar_task:
+            self._set_avatar_task.cancel()
+        self.session.log.debug("Setting avatar with property")
+        self._set_avatar_task = self.session.xmpp.loop.create_task(
+            self.set_avatar(a, None, blocking=True, cancel=False),
+            name=f"Set avatar of {self} from property",
+        )
+
+    @staticmethod
+    def __get_uid(a: Optional[AvatarType]) -> Optional[AvatarIdType]:
+        if isinstance(a, str):
+            return URL(a)
+        elif isinstance(a, Path):
+            return str(a)
+        elif isinstance(a, bytes):
+            return sha1(a).hexdigest()
+        elif a is None:
+            return None
+        raise TypeError("Bad avatar", a)
+
+    async def __set_avatar(self, a: Optional[AvatarType], uid: Optional[AvatarIdType]):
+        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,
+        )
+        self._post_avatar_update()
+
+    async def _no_change(self, a: Optional[AvatarType], uid: Optional[AvatarIdType]):
+        if a is None:
+            return self.__avatar_unique_id is None
+        if not self.__avatar_unique_id:
+            return False
+        if isinstance(uid, URL):
+            if self.__avatar_unique_id != uid:
+                return False
+            return not await avatar_cache.url_has_changed(uid)
+        return self.__avatar_unique_id == uid
+
+    async def set_avatar(
+        self,
+        a: Optional[AvatarType],
+        avatar_unique_id: Optional[LegacyFileIdType] = None,
+        blocking=False,
+        cancel=True,
+    ) -> None:
+        """
+        Set an avatar for this entity
+
+        :param a:
+        :param avatar_unique_id:
+        :param blocking:
+        :param cancel:
+        """
+        if avatar_unique_id is None and a is not None:
+            avatar_unique_id = self.__get_uid(a)
+        if await self._no_change(a, avatar_unique_id):
+            return
+        if cancel and self._set_avatar_task:
+            self._set_avatar_task.cancel()
+        awaitable = create_task(
+            self.__set_avatar(a, avatar_unique_id),
+            name=f"Set pubsub avatar of {self}",
+        )
+        if not self._set_avatar_task or self._set_avatar_task.done():
+            self._set_avatar_task = awaitable
+        if blocking:
+            await awaitable
+
+    def get_avatar(self) -> Optional["PepAvatar"]:
+        if not self.__avatar_unique_id:
+            return None
+        return self.session.xmpp.pubsub.get_avatar(self.__avatar_jid)
+
+    def _post_avatar_update(self) -> None:
+        return
+
+    async def avatar_wrap_update_info(self):
+        cached_id = avatar_cache.get_cached_id_for(self.__avatar_jid)
+        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):
+            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,
+        )

slidge/core/mixins/base.py

@@ -1,9 +1,9 @@
 from abc import ABCMeta
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
-from slixmpp import JID, Message, Presence
+from slixmpp import JID
 
-from slidge.util.types import LegacyMessageType
+from ...util.types import MessageOrPresenceTypeVar
 
 if TYPE_CHECKING:
     from slidge.core.gateway import BaseGateway
@@ -25,20 +25,7 @@ class Base:
 
 
 class BaseSender(Base):
-    def _send(self, stanza: Union[Message, Presence], **send_kwargs):
+    def _send(
+        self, stanza: MessageOrPresenceTypeVar, **send_kwargs
+    ) -> MessageOrPresenceTypeVar:
         raise NotImplementedError
-
-
-class ReactionRecipientMixin:
-    REACTIONS_SINGLE_EMOJI = False
-
-    async def available_emojis(
-        self, legacy_msg_id: LegacyMessageType
-    ) -> Optional[set[str]]:
-        """
-        Override this to restrict the subset of reactions this recipient
-        can handle.
-
-        :return: A set of emojis or None if any emoji is allowed
-        """
-        return None

slidge/core/mixins/disco.py

@@ -1,6 +1,8 @@
-import functools
+from typing import Optional
 
-from slidge.util.xep_0030.stanza.info import DiscoInfo
+from slixmpp.plugins.xep_0004 import Form
+from slixmpp.plugins.xep_0030.stanza.info import DiscoInfo
+from slixmpp.types import OptJid
 
 from .base import Base
 
@@ -11,26 +13,48 @@ 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
+        return self.DISCO_NAME or self.xmpp.COMPONENT_NAME
+
     def features(self):
         return []
 
-    def extended_features(self):
-        return
+    async def extended_features(self) -> Optional[list[Form]]:
+        return None
 
-    def get_disco_info(self):
+    async def get_disco_info(self, jid: OptJid = None, node: Optional[str] = None):
         info = DiscoInfo()
         for feature in self.features():
             info.add_feature(feature)
         info.add_identity(
             category=self.DISCO_CATEGORY,
             itype=self.DISCO_TYPE,
-            name=self.DISCO_NAME,
+            name=self._get_disco_name(),
             lang=self.DISCO_LANG,
         )
-        if x := self.extended_features():
-            info.append(x)
+        if forms := await self.extended_features():
+            for form in forms:
+                info.append(form)
         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
@@ -42,6 +66,7 @@ class ChatterDiscoMixin(BaseDiscoMixin):
     REACTION = True
     RETRACTION = True
     REPLIES = True
+    INVITATION_RECIPIENT = False
 
     DISCO_TYPE = "pc"
     DISCO_CATEGORY = "client"
@@ -65,15 +90,41 @@ class ChatterDiscoMixin(BaseDiscoMixin):
             features.append("urn:xmpp:message-retract:0")
         if self.REPLIES:
             features.append("urn:xmpp:reply:0")
+        if self.INVITATION_RECIPIENT:
+            features.append("jabber:x:conference")
         features.append("urn:ietf:params:xml:ns:vcard-4.0")
         return features
 
-    async def update_caps(self):
-        jid = self.jid
-        xmpp = self.xmpp
+    async def extended_features(self):
+        f = getattr(self, "restricted_emoji_extended_feature", None)
+        if f is None:
+            return
 
-        add_feature = functools.partial(xmpp["xep_0030"].add_feature, jid=jid)
-        for f in self.features():
-            await add_feature(f)
+        e = await f()
+        if not e:
+            return
 
-        await xmpp["xep_0115"].update_caps(jid=jid)
+        return [e]
+
+
+class ContactAccountDiscoMixin(BaseDiscoMixin):
+    async def get_disco_info(self, jid: OptJid = None, node: Optional[str] = None):
+        if jid and jid.resource:
+            return await super().get_disco_info()
+        info = DiscoInfo()
+        info.add_feature("http://jabber.org/protocol/pubsub")
+        info.add_feature("http://jabber.org/protocol/pubsub#retrieve-items")
+        info.add_feature("http://jabber.org/protocol/pubsub#subscribe")
+        info.add_identity(
+            category="account",
+            itype="registered",
+            name=self._get_disco_name(),
+            lang=self.DISCO_LANG,
+        )
+        info.add_identity(
+            category="pubsub",
+            itype="pep",
+            name=self._get_disco_name(),
+            lang=self.DISCO_LANG,
+        )
+        return info

slidge/core/mixins/lock.py

@@ -0,0 +1,31 @@
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from typing import Hashable
+
+
+class NamedLockMixin:
+    def __init__(self, *a, **k):
+        super().__init__(*a, **k)
+        self.__locks = dict[Hashable, asyncio.Lock]()
+
+    @asynccontextmanager
+    async def lock(self, id_: Hashable):
+        log.trace("getting %s", id_)  # type:ignore
+        locks = self.__locks
+        if not locks.get(id_):
+            locks[id_] = asyncio.Lock()
+        async with locks[id_]:
+            log.trace("acquired %s", id_)  # type:ignore
+            yield
+        log.trace("releasing %s", id_)  # type:ignore
+        waiters = locks[id_]._waiters  # type:ignore
+        if not waiters:
+            del locks[id_]
+            log.trace("erasing %s", id_)  # type:ignore
+
+    def get_lock(self, id_: Hashable):
+        return self.__locks.get(id_)
+
+
+log = logging.getLogger(__name__)  # type:ignore