slidge 0.1.0__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

@@ -0,0 +1,31 @@
+from abc import ABCMeta
+from typing import TYPE_CHECKING
+
+from slixmpp import JID
+
+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):
+    pass
+
+
+class Base:
+    session: "BaseSession" = NotImplemented
+    xmpp: "BaseGateway" = NotImplemented
+    user: "GatewayUser" = NotImplemented
+
+    jid: JID = NotImplemented
+    name: str = NotImplemented
+
+
+class BaseSender(Base):
+    def _send(
+        self, stanza: MessageOrPresenceTypeVar, **send_kwargs
+    ) -> MessageOrPresenceTypeVar:
+        raise NotImplementedError

slidge/core/mixins/disco.py

@@ -0,0 +1,130 @@
+from typing import Optional
+
+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
+
+
+class BaseDiscoMixin(Base):
+    DISCO_TYPE: str = NotImplemented
+    DISCO_CATEGORY: str = NotImplemented
+    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 []
+
+    async def extended_features(self) -> Optional[list[Form]]:
+        return None
+
+    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._get_disco_name(),
+            lang=self.DISCO_LANG,
+        )
+        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
+    RECEIPTS = True
+    MARKS = True
+    CHAT_STATES = True
+    UPLOAD = True
+    CORRECTION = True
+    REACTION = True
+    RETRACTION = True
+    REPLIES = True
+    INVITATION_RECIPIENT = False
+
+    DISCO_TYPE = "pc"
+    DISCO_CATEGORY = "client"
+    DISCO_NAME = ""
+
+    def features(self):
+        features = []
+        if self.CHAT_STATES:
+            features.append("http://jabber.org/protocol/chatstates")
+        if self.RECEIPTS:
+            features.append("urn:xmpp:receipts")
+        if self.CORRECTION:
+            features.append("urn:xmpp:message-correct:0")
+        if self.MARKS:
+            features.append("urn:xmpp:chat-markers:0")
+        if self.UPLOAD:
+            features.append("jabber:x:oob")
+        if self.REACTION:
+            features.append("urn:xmpp:reactions:0")
+        if self.RETRACTION:
+            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 extended_features(self):
+        f = getattr(self, "restricted_emoji_extended_feature", None)
+        if f is None:
+            return
+
+        e = await f()
+        if not e:
+            return
+
+        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