slidge 0.1.0__py3-none-any.whl

slidge/slixfix/xep_0100/gateway.py

@@ -0,0 +1,121 @@
+import logging
+import warnings
+
+from slixmpp import JID, Iq, Message, Presence, register_stanza_plugin
+from slixmpp.exceptions import XMPPError
+from slixmpp.plugins.base import BasePlugin
+
+from slidge.core import config
+
+from . import stanza
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0100(BasePlugin):
+    name = "xep_0100"
+    description = "XEP-0100: Gateway interaction (slidge)"
+    dependencies = {
+        "xep_0030",  # Service discovery
+        "xep_0077",  # In band registration
+        "xep_0356",  # Privileged entities
+    }
+
+    default_config = {
+        "component_name": "SliXMPP gateway",
+        "type": "xmpp",
+        "needs_registration": True,
+    }
+
+    def plugin_init(self):
+        if not self.xmpp.is_component:
+            log.error("Only components can be gateways, aborting plugin load")
+            return
+
+        self.xmpp["xep_0030"].add_identity(
+            name=self.component_name, category="gateway", itype=self.type
+        )
+
+        # Without that BaseXMPP sends unsub/unavailable on sub requests, and we don't want that
+        self.xmpp.client_roster.auto_authorize = False
+        self.xmpp.client_roster.auto_subscribe = False
+
+        self.xmpp.add_event_handler("user_register", self.on_user_register)
+        self.xmpp.add_event_handler("user_unregister", self.on_user_unregister)
+        self.xmpp.add_event_handler(
+            "presence_unsubscribe", self.on_presence_unsubscribe
+        )
+
+        self.xmpp.add_event_handler("message", self.on_message)
+
+        register_stanza_plugin(Iq, stanza.Gateway)
+
+    def plugin_end(self):
+        if not self.xmpp.is_component:
+            self.xmpp.remove_event_handler("user_register", self.on_user_register)
+            self.xmpp.remove_event_handler("user_unregister", self.on_user_unregister)
+            self.xmpp.remove_event_handler(
+                "presence_unsubscribe", self.on_presence_unsubscribe
+            )
+
+            self.xmpp.remove_event_handler("message", self.on_message)
+
+    async def get_user(self, stanza):
+        return await self.xmpp["xep_0077"].api["user_get"](None, None, None, stanza)
+
+    async def on_user_unregister(self, iq: Iq):
+        self.xmpp.send_presence(pto=iq.get_from().bare, ptype="unavailable")
+        self.xmpp.send_presence(pto=iq.get_from().bare, ptype="unsubscribe")
+        self.xmpp.send_presence(pto=iq.get_from().bare, ptype="unsubscribed")
+
+    async def on_user_register(self, iq: Iq):
+        self.xmpp.client_roster[iq.get_from()].load()
+        await self.add_component_to_roster(jid=iq.get_from())
+
+    async def add_component_to_roster(self, jid: JID):
+        if config.NO_ROSTER_PUSH:
+            return
+        items = {
+            self.xmpp.boundjid.bare: {
+                "name": self.component_name,
+                "subscription": "both",
+                "groups": ["Slidge"],
+            }
+        }
+        try:
+            await self._set_roster(jid, items)
+        except PermissionError:
+            warnings.warn(
+                "Slidge does not have the privilege to manage users' rosters. "
+                "Users should add the slidge component to their rosters manually."
+            )
+            if config.ROSTER_PUSH_PRESENCE_SUBSCRIPTION_REQUEST_FALLBACK:
+                self.xmpp.send_presence(ptype="subscribe", pto=jid.bare)
+
+    async def _set_roster(self, jid, items):
+        try:
+            await self.xmpp["xep_0356"].set_roster(jid=jid.bare, roster_items=items)
+        except PermissionError:
+            await self.xmpp["xep_0356_old"].set_roster(jid=jid.bare, roster_items=items)
+
+    def on_presence_unsubscribe(self, p: Presence):
+        if p.get_to() == self.xmpp.boundjid.bare:
+            log.debug("REMOVE: Our roster: %s", self.xmpp.client_roster)
+            self.xmpp["xep_0077"].api["user_remove"](None, None, p["from"], p)
+            self.xmpp.event("user_unregister", p)
+
+    async def on_message(self, msg: Message):
+        if msg["type"] == "groupchat":
+            return  # groupchat messages are out of scope of XEP-0100
+
+        if msg["to"] == self.xmpp.boundjid.bare:
+            # It may be useful to exchange direct messages with the component
+            self.xmpp.event("gateway_message", msg)
+            return
+
+        if self.needs_registration and await self.get_user(msg) is None:
+            raise XMPPError(
+                "registration-required", text="You are not registered to this gateway"
+            )
+
+        self.xmpp.event("legacy_message", msg)

slidge/slixfix/xep_0100/stanza.py

@@ -0,0 +1,9 @@
+from slixmpp.xmlstream import ElementBase
+
+
+class Gateway(ElementBase):
+    namespace = "jabber:iq:gateway"
+    name = "query"
+    plugin_attrib = "gateway"
+    interfaces = {"desc", "prompt", "jid"}
+    sub_interfaces = interfaces

slidge/slixfix/xep_0153/__init__.py

@@ -0,0 +1,10 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from slixmpp.plugins.base import register_plugin
+
+from .stanza import VCardTempUpdate
+from .vcard_avatar import XEP_0153
+
+register_plugin(XEP_0153)

slidge/slixfix/xep_0153/stanza.py

@@ -0,0 +1,25 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from slixmpp.xmlstream import ElementBase
+
+
+class VCardTempUpdate(ElementBase):
+    name = "x"
+    namespace = "vcard-temp:x:update"
+    plugin_attrib = "vcard_temp_update"
+    interfaces = {"photo"}
+    sub_interfaces = interfaces
+
+    def set_photo(self, value):
+        if value is not None:
+            self._set_sub_text("photo", value, keep=True)
+        else:
+            self._del_sub("photo")
+
+    def get_photo(self):
+        photo = self.xml.find("{%s}photo" % self.namespace)
+        if photo is None:
+            return None
+        return photo.text

slidge/slixfix/xep_0153/vcard_avatar.py

@@ -0,0 +1,23 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+import logging
+
+from slixmpp.plugins.base import BasePlugin
+from slixmpp.stanza import Presence
+from slixmpp.xmlstream import register_stanza_plugin
+
+from . import VCardTempUpdate, stanza
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0153(BasePlugin):
+    name = "xep_0153"
+    description = "XEP-0153: vCard-Based Avatars (slidge, just for MUCs)"
+    dependencies = {"xep_0054"}
+    stanza = stanza
+
+    def plugin_init(self):
+        register_stanza_plugin(Presence, VCardTempUpdate)

slidge/slixfix/xep_0264/__init__.py

@@ -0,0 +1,5 @@
+from slixmpp.plugins.base import register_plugin
+
+from .thumbnail import XEP_0264
+
+register_plugin(XEP_0264)

slidge/slixfix/xep_0264/stanza.py

@@ -0,0 +1,36 @@
+from typing import Optional
+
+from slixmpp import register_stanza_plugin
+from slixmpp.plugins.xep_0234.stanza import File
+from slixmpp.xmlstream import ElementBase
+
+NS = "urn:xmpp:thumbs:1"
+
+
+class Thumbnail(ElementBase):
+    name = plugin_attrib = "thumbnail"
+    namespace = NS
+    interfaces = {"uri", "media-type", "width", "height"}
+
+    def get_width(self) -> float:
+        return _int_or_none(self._get_attr("width"))
+
+    def get_height(self) -> float:
+        return _int_or_none(self._get_attr("height"))
+
+    def set_width(self, v: int) -> None:
+        self._set_attr("width", str(v))
+
+    def set_height(self, v: int) -> None:
+        self._set_attr("height", str(v))
+
+
+def _int_or_none(v) -> Optional[int]:
+    try:
+        return int(v)
+    except ValueError:
+        return None
+
+
+def register_plugin():
+    register_stanza_plugin(File, Thumbnail)

slidge/slixfix/xep_0264/thumbnail.py

@@ -0,0 +1,23 @@
+import logging
+
+from slixmpp.plugins import BasePlugin
+
+from . import stanza
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0264(BasePlugin):
+    """
+    XEP-0264: Jingle Content Thumbnails
+
+    Minimum needed for xep 0385 (Stateless inline media sharing)
+    """
+
+    name = "xep_0264"
+    description = "XEP-0264: Jingle Content Thumbnails"
+    dependencies = {"xep_0234"}
+    stanza = stanza
+
+    def plugin_init(self):
+        stanza.register_plugin()

slidge/slixfix/xep_0292/__init__.py

@@ -0,0 +1,5 @@
+from slixmpp.plugins.xep_0292 import stanza
+
+from . import vcard4
+
+__all__ = ("stanza", "vcard4")

slidge/slixfix/xep_0292/vcard4.py

@@ -0,0 +1,100 @@
+import logging
+from typing import TYPE_CHECKING, NamedTuple, Optional
+
+from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
+from slixmpp.plugins.base import BasePlugin, register_plugin
+from slixmpp.plugins.xep_0292.stanza import NS, VCard4
+from slixmpp.types import JidStr
+
+from slidge.contact import LegacyContact
+
+if TYPE_CHECKING:
+    from slidge.core.gateway import BaseGateway
+
+
+class StoredVCard(NamedTuple):
+    content: VCard4
+    authorized_jids: set[JidStr]
+
+
+class VCard4Provider(BasePlugin):
+    xmpp: "BaseGateway"
+
+    name = "xep_0292_provider"
+    description = "VCard4 Provider"
+    dependencies = {"xep_0030"}
+
+    def __init__(self, *a, **k):
+        super(VCard4Provider, self).__init__(*a, **k)
+        self._vcards = dict[JidStr, StoredVCard]()
+
+    def plugin_init(self):
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "get_vcard",
+                StanzaPath(f"iq@type=get/vcard"),
+                self.handle_vcard_get,  # type:ignore
+            )
+        )
+
+        self.xmpp.plugin["xep_0030"].add_feature(NS)
+
+    def _get_cached_vcard(self, jid: JidStr, requested_by: JidStr) -> Optional[VCard4]:
+        vcard = self._vcards.get(JID(jid).bare)
+        if vcard:
+            if auth := vcard.authorized_jids:
+                if JID(requested_by).bare in auth:
+                    return vcard.content
+            else:
+                return vcard.content
+        return None
+
+    async def get_vcard(self, jid: JidStr, requested_by: JidStr) -> Optional[VCard4]:
+        if vcard := self._get_cached_vcard(jid, requested_by):
+            log.debug("Found a cached vcard")
+            return vcard
+        if not hasattr(self.xmpp, "get_session_from_jid"):
+            return None
+        jid = JID(jid)
+        requested_by = JID(requested_by)
+        session = self.xmpp.get_session_from_jid(requested_by)
+        if session is None:
+            return
+        entity = await session.get_contact_or_group_or_participant(jid)
+        if isinstance(entity, LegacyContact):
+            log.debug("Fetching vcard")
+            await entity.fetch_vcard()
+            return self._get_cached_vcard(jid, requested_by)
+        return None
+
+    async def handle_vcard_get(self, iq: Iq):
+        r = iq.reply()
+        if vcard := await self.get_vcard(iq.get_to().bare, iq.get_from().bare):
+            r.append(vcard)
+        else:
+            r.enable("vcard")
+        r.send()
+
+    def set_vcard(
+        self,
+        jid: JidStr,
+        vcard: VCard4,
+        /,
+        authorized_jids: Optional[set[JidStr]] = None,
+    ):
+        cache = self._vcards.get(jid)
+        new = StoredVCard(
+            vcard, authorized_jids if authorized_jids is not None else set()
+        )
+        self._vcards[jid] = new
+        if cache == new:
+            return
+        if self.xmpp["pubsub"] and authorized_jids:
+            for to in authorized_jids:
+                self.xmpp.loop.create_task(
+                    self.xmpp["pubsub"].broadcast_vcard_event(jid, to)
+                )
+
+
+register_plugin(VCard4Provider)
+log = logging.getLogger(__name__)

slidge/slixfix/xep_0313/__init__.py

@@ -0,0 +1,12 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission
+from slixmpp.plugins.base import register_plugin
+
+from .mam import XEP_0313
+from .stanza import MAM, Metadata, Result
+
+register_plugin(XEP_0313)
+
+__all__ = ["XEP_0313", "Result", "MAM", "Metadata"]

slidge/slixfix/xep_0313/mam.py

@@ -0,0 +1,262 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission
+import logging
+from asyncio import Future
+from collections.abc import AsyncGenerator
+from datetime import datetime
+from typing import Any, Awaitable, Callable, Dict, Optional, Tuple
+
+from slixmpp import JID
+from slixmpp.plugins import BasePlugin
+from slixmpp.plugins.xep_0004.stanza import Form
+from slixmpp.stanza import Iq, Message
+from slixmpp.xmlstream import register_stanza_plugin
+from slixmpp.xmlstream.handler import Collector
+from slixmpp.xmlstream.matcher import MatchXMLMask
+
+from . import stanza
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0313(BasePlugin):
+    """
+    XEP-0313 Message Archive Management
+    """
+
+    name = "xep_0313"
+    description = "XEP-0313: Message Archive Management"
+    dependencies = {"xep_0004", "xep_0030", "xep_0050", "xep_0059", "xep_0297"}
+    stanza = stanza
+
+    def plugin_init(self):
+        register_stanza_plugin(stanza.MAM, Form)
+        register_stanza_plugin(Iq, stanza.MAM)
+        register_stanza_plugin(Message, stanza.Result)
+        register_stanza_plugin(Iq, stanza.Fin)
+        register_stanza_plugin(stanza.Result, self.xmpp["xep_0297"].stanza.Forwarded)
+        register_stanza_plugin(stanza.MAM, self.xmpp["xep_0059"].stanza.Set)
+        register_stanza_plugin(stanza.Fin, self.xmpp["xep_0059"].stanza.Set)
+        register_stanza_plugin(Iq, stanza.Metadata)
+        register_stanza_plugin(stanza.Metadata, stanza.Start)
+        register_stanza_plugin(stanza.Metadata, stanza.End)
+
+    def retrieve(
+        self,
+        jid: Optional[JID] = None,
+        start: Optional[datetime] = None,
+        end: Optional[datetime] = None,
+        with_jid: Optional[JID] = None,
+        ifrom: Optional[JID] = None,
+        reverse: bool = False,
+        timeout: int = None,
+        callback: Callable[[Iq], None] = None,
+        iterator: bool = False,
+        rsm: Optional[Dict[str, Any]] = None,
+    ) -> Awaitable:
+        """
+        Send a MAM query and retrieve the results.
+
+        :param JID jid: Entity holding the MAM records
+        :param datetime start,end: MAM query temporal boundaries
+        :param JID with_jid: Filter results on this JID
+        :param JID ifrom: To change the from address of the query
+        :param bool reverse: Get the results in reverse order
+        :param int timeout: IQ timeout
+        :param func callback: Custom callback for handling results
+        :param bool iterator: Use RSM and iterate over a paginated query
+        :param dict rsm: RSM custom options
+        """
+        iq, stanza_mask = self._pre_mam_retrieve(jid, start, end, with_jid, ifrom)
+        query_id = iq["id"]
+        amount = 10
+        if rsm:
+            for key, value in rsm.items():
+                iq["mam"]["rsm"][key] = str(value)
+                if key == "max":
+                    amount = value
+        cb_data = {}
+
+        xml_mask = str(stanza_mask)
+
+        def pre_cb(query: Iq) -> None:
+            stanza_mask["mam_result"]["queryid"] = query["id"]
+            xml_mask = str(stanza_mask)
+            query["mam"]["queryid"] = query["id"]
+            collector = Collector("MAM_Results_%s" % query_id, MatchXMLMask(xml_mask))
+            self.xmpp.register_handler(collector)
+            cb_data["collector"] = collector
+
+        def post_cb(result: Iq) -> None:
+            results = cb_data["collector"].stop()
+            if result["type"] == "result":
+                result["mam"]["results"] = results
+                result["mam_fin"]["results"] = results
+
+        if iterator:
+            return self.xmpp["xep_0059"].iterate(
+                iq,
+                "mam",
+                "results",
+                amount=amount,
+                reverse=reverse,
+                recv_interface="mam_fin",
+                pre_cb=pre_cb,
+                post_cb=post_cb,
+            )
+
+        collector = Collector("MAM_Results_%s" % query_id, MatchXMLMask(xml_mask))
+        self.xmpp.register_handler(collector)
+
+        def wrapped_cb(iq: Iq) -> None:
+            results = collector.stop()
+            if iq["type"] == "result":
+                iq["mam"]["results"] = results
+            if callback:
+                callback(iq)
+
+        return iq.send(timeout=timeout, callback=wrapped_cb)
+
+    async def iterate(
+        self,
+        jid: Optional[JID] = None,
+        start: Optional[datetime] = None,
+        end: Optional[datetime] = None,
+        with_jid: Optional[JID] = None,
+        ifrom: Optional[JID] = None,
+        reverse: bool = False,
+        rsm: Optional[Dict[str, Any]] = None,
+        total: Optional[int] = None,
+    ) -> AsyncGenerator:
+        """
+        Iterate over each message of MAM query.
+
+        .. versionadded:: 1.8.0
+
+        :param jid: Entity holding the MAM records
+        :param start: MAM query start time
+        :param end: MAM query end time
+        :param with_jid: Filter results on this JID
+        :param ifrom: To change the from address of the query
+        :param reverse: Get the results in reverse order
+        :param rsm: RSM custom options
+        :param total: A number of messages received after which the query
+                      should stop.
+        """
+        iq, stanza_mask = self._pre_mam_retrieve(jid, start, end, with_jid, ifrom)
+        query_id = iq["id"]
+        amount = 10
+
+        if rsm:
+            for key, value in rsm.items():
+                iq["mam"]["rsm"][key] = str(value)
+                if key == "max":
+                    amount = value
+        cb_data = {}
+
+        def pre_cb(query: Iq) -> None:
+            stanza_mask["mam_result"]["queryid"] = query["id"]
+            xml_mask = str(stanza_mask)
+            query["mam"]["queryid"] = query["id"]
+            collector = Collector("MAM_Results_%s" % query_id, MatchXMLMask(xml_mask))
+            self.xmpp.register_handler(collector)
+            cb_data["collector"] = collector
+
+        def post_cb(result: Iq) -> None:
+            results = cb_data["collector"].stop()
+            if result["type"] == "result":
+                result["mam"]["results"] = results
+                result["mam_fin"]["results"] = results
+
+        iterator = self.xmpp["xep_0059"].iterate(
+            iq,
+            "mam",
+            "results",
+            amount=amount,
+            reverse=reverse,
+            recv_interface="mam_fin",
+            pre_cb=pre_cb,
+            post_cb=post_cb,
+        )
+        recv_count = 0
+
+        async for page in iterator:
+            messages = [message for message in page["mam"]["results"]]
+            if reverse:
+                messages.reverse()
+            for message in messages:
+                yield message
+                recv_count += 1
+                if total is not None and recv_count >= total:
+                    break
+            if total is not None and recv_count >= total:
+                break
+
+    def _pre_mam_retrieve(
+        self,
+        jid: Optional[JID] = None,
+        start: Optional[datetime] = None,
+        end: Optional[datetime] = None,
+        with_jid: Optional[JID] = None,
+        ifrom: Optional[JID] = None,
+    ) -> Tuple[Iq, Message]:
+        """Build the IQ and stanza mask for MAM results"""
+        iq = self.xmpp.make_iq_set(ito=jid, ifrom=ifrom)
+        query_id = iq["id"]
+        iq["mam"]["queryid"] = query_id
+        iq["mam"]["start"] = start
+        iq["mam"]["end"] = end
+        iq["mam"]["with"] = with_jid
+
+        stanza_mask = self.xmpp.Message()
+
+        auto_origin = stanza_mask.xml.find("{urn:xmpp:sid:0}origin-id")
+        if auto_origin is not None:
+            stanza_mask.xml.remove(auto_origin)
+        del stanza_mask["id"]
+        del stanza_mask["lang"]
+        stanza_mask["from"] = jid
+        stanza_mask["mam_result"]["queryid"] = query_id
+
+        return (iq, stanza_mask)
+
+    async def get_fields(self, jid: Optional[JID] = None, **iqkwargs) -> Form:
+        """Get MAM query fields.
+
+        .. versionadded:: 1.8.0
+
+        :param jid: JID to retrieve the policy from.
+        :return: The Form of allowed options
+        """
+        ifrom = iqkwargs.pop("ifrom", None)
+        iq = self.xmpp.make_iq_get(ito=jid, ifrom=ifrom)
+        iq.enable("mam")
+        result = await iq.send(**iqkwargs)
+        return result["mam"]["form"]
+
+    async def get_configuration_commands(
+        self, jid: Optional[JID], **discokwargs
+    ) -> Future:
+        """Get the list of MAM advanced configuration commands.
+
+        .. versionchanged:: 1.8.0
+
+        :param jid: JID to get the commands from.
+        """
+        if jid is None:
+            jid = self.xmpp.boundjid.bare
+        return await self.xmpp["xep_0030"].get_items(
+            jid=jid, node="urn:xmpp:mam#configure", **discokwargs
+        )
+
+    def get_archive_metadata(self, jid: Optional[JID] = None, **iqkwargs) -> Future:
+        """Get the archive metadata from a JID.
+
+        :param jid: JID to get the metadata from.
+        """
+        ifrom = iqkwargs.pop("ifrom", None)
+        iq = self.xmpp.make_iq_get(ito=jid, ifrom=ifrom)
+        iq.enable("mam_metadata")
+        return iq.send(**iqkwargs)