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

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)

slidge/slixfix/xep_0313/stanza.py

@@ -0,0 +1,359 @@
+# 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 permissio
+from datetime import datetime
+from typing import Any, Iterable, List, Optional, Set, Union
+
+from slixmpp.jid import JID
+from slixmpp.plugins import xep_0082
+from slixmpp.stanza import Message
+from slixmpp.xmlstream import ET, ElementBase
+
+
+class MAM(ElementBase):
+    """A MAM Query element.
+
+    .. code-block:: xml
+
+        <iq type='set' id='juliet1'>
+          <query xmlns='urn:xmpp:mam:2'>
+            <x xmlns='jabber:x:data' type='submit'>
+              <field var='FORM_TYPE' type='hidden'>
+                <value>urn:xmpp:mam:2</value>
+              </field>
+              <field var='with'>
+                <value>juliet@capulet.lit</value>
+              </field>
+            </x>
+          </query>
+        </iq>
+
+    """
+
+    name = "query"
+    namespace = "urn:xmpp:mam:2"
+    plugin_attrib = "mam"
+    #: Available interfaces:
+    #:
+    #: - ``queryid``: The MAM query id
+    #: - ``start`` and ``end``: Temporal boundaries of the query
+    #: - ``with``: JID of the other entity the conversation is with
+    #: - ``after_id``: Fetch stanzas after this specific ID
+    #: - ``before_id``: Fetch stanzas before this specific ID
+    #: - ``ids``: Fetch the stanzas matching those IDs
+    #: - ``results``: pseudo-interface used to accumulate MAM results during
+    #:   fetch, not relevant for the stanza itself.
+    interfaces = {
+        "queryid",
+        "start",
+        "end",
+        "with",
+        "results",
+        "before_id",
+        "after_id",
+        "ids",
+        "flip_page",
+    }
+    sub_interfaces = {
+        "start",
+        "end",
+        "with",
+        "before_id",
+        "after_id",
+        "ids",
+        "flip_page",
+    }
+
+    def setup(self, xml=None):
+        ElementBase.setup(self, xml)
+        self._results: List[Message] = []
+
+    def _setup_form(self):
+        found = self.xml.find(
+            "{jabber:x:data}x/"
+            '{jabber:x:data}field[@var="FORM_TYPE"]/'
+            "{jabber:x:data}value[.='urn:xmpp:mam:2']"
+        )
+        if found is None:
+            self["form"]["type"] = "submit"
+            self["form"].add_field(
+                var="FORM_TYPE", ftype="hidden", value="urn:xmpp:mam:2"
+            )
+
+    def get_fields(self):
+        form = self.get_plugin("form", check=True)
+        if not form:
+            return {}
+        return form.get_fields()
+
+    def get_start(self) -> Optional[datetime]:
+        fields = self.get_fields()
+        field = fields.get("start")
+        if field and field["value"]:
+            return xep_0082.parse(field["value"])
+        return None
+
+    def set_start(self, value: Union[str, datetime]):
+        self._setup_form()
+        if isinstance(value, datetime):
+            value = xep_0082.format_datetime(value)
+        self.set_custom_field("start", value)
+
+    def get_end(self) -> Optional[datetime]:
+        fields = self.get_fields()
+        field = fields.get("end")
+        if field and field["value"]:
+            return xep_0082.parse(field["value"])
+        return None
+
+    def set_end(self, value: Union[str, datetime]):
+        if isinstance(value, datetime):
+            value = xep_0082.format_datetime(value)
+        self.set_custom_field("end", value)
+
+    def get_with(self) -> Optional[JID]:
+        fields = self.get_fields()
+        field = fields.get("with")
+        if field:
+            return JID(field["value"])
+        return None
+
+    def set_with(self, value: JID):
+        self.set_custom_field("with", value)
+
+    def set_custom_field(self, fieldname: str, value: Any):
+        self._setup_form()
+        fields = self.get_fields()
+        field = fields.get(fieldname)
+        if field:
+            field["value"] = str(value)
+        else:
+            field = self["form"].add_field(var=fieldname)
+            field["value"] = str(value)
+
+    def get_custom_field(self, fieldname: str) -> Optional[str]:
+        fields = self.get_fields()
+        field = fields.get(fieldname)
+        if field:
+            return field["value"]
+        return None
+
+    def set_before_id(self, value: str):
+        self.set_custom_field("before-id", value)
+
+    def get_before_id(self):
+        self.get_custom_field("before-id")
+
+    def set_after_id(self, value: str):
+        self.set_custom_field("after-id", value)
+
+    def get_after_id(self):
+        self.get_custom_field("after-id")
+
+    def set_ids(self, value: List[str]):
+        self._setup_form()
+        fields = self.get_fields()
+        field = fields.get("ids")
+        if field:
+            field["ids"] = value
+        else:
+            field = self["form"].add_field(var="ids")
+            field["value"] = value
+
+    def get_ids(self):
+        self.get_custom_field("id")
+
+    # The results interface is meant only as an easy
+    # way to access the set of collected message responses
+    # from the query.
+
+    def get_results(self) -> List[Message]:
+        return self._results
+
+    def set_results(self, values: List[Message]):
+        self._results = values
+
+    def del_results(self):
+        self._results = []
+
+    def get_flip_page(self):
+        return self.xml.find(f"{{{self.namespace}}}flip-page") is not None
+
+
+class Fin(ElementBase):
+    """A MAM fin element (end of query).
+
+    .. code-block:: xml
+
+        <iq type='result' id='juliet1'>
+          <fin xmlns='urn:xmpp:mam:2'>
+            <set xmlns='http://jabber.org/protocol/rsm'>
+              <first index='0'>28482-98726-73623</first>
+              <last>09af3-cc343-b409f</last>
+            </set>
+          </fin>
+        </iq>
+
+    """
+
+    name = "fin"
+    namespace = "urn:xmpp:mam:2"
+    plugin_attrib = "mam_fin"
+    interfaces = {"results", "stable", "complete"}
+
+    def setup(self, xml=None):
+        ElementBase.setup(self, xml)
+        self._results: List[Message] = []
+
+    # The results interface is meant only as an easy
+    # way to access the set of collected message responses
+    # from the query.
+
+    def get_results(self) -> List[Message]:
+        return self._results
+
+    def set_results(self, values: List[Message]):
+        self._results = values
+
+    def del_results(self):
+        self._results = []
+
+
+class Result(ElementBase):
+    """A MAM result payload.
+
+    .. code-block:: xml
+
+        <message id='aeb213' to='juliet@capulet.lit/chamber'>
+          <result xmlns='urn:xmpp:mam:2' queryid='f27' id='28482-98726-73623'>
+            <forwarded xmlns='urn:xmpp:forward:0'>
+              <delay xmlns='urn:xmpp:delay' stamp='2010-07-10T23:08:25Z'/>
+              <message xmlns='jabber:client' from="witch@shakespeare.lit"
+                       to="macbeth@shakespeare.lit">
+                <body>Hail to thee</body>
+              </message>
+            </forwarded>
+          </result>
+        </message>
+    """
+
+    name = "result"
+    namespace = "urn:xmpp:mam:2"
+    plugin_attrib = "mam_result"
+    #: Available interfaces:
+    #:
+    #: - ``queryid``: MAM queryid
+    #: - ``id``: ID of the result
+    interfaces = {"queryid", "id"}
+
+
+class Metadata(ElementBase):
+    """Element containing archive metadata
+
+    .. code-block:: xml
+
+        <iq type='result' id='jui8921rr9'>
+          <metadata xmlns='urn:xmpp:mam:2'>
+            <start id='YWxwaGEg' timestamp='2008-08-22T21:09:04Z' />
+            <end id='b21lZ2Eg' timestamp='2020-04-20T14:34:21Z' />
+          </metadata>
+        </iq>
+
+    """
+
+    name = "metadata"
+    namespace = "urn:xmpp:mam:2"
+    plugin_attrib = "mam_metadata"
+
+
+class Start(ElementBase):
+    """Metadata about the start of an archive.
+
+    .. code-block:: xml
+
+        <iq type='result' id='jui8921rr9'>
+          <metadata xmlns='urn:xmpp:mam:2'>
+            <start id='YWxwaGEg' timestamp='2008-08-22T21:09:04Z' />
+            <end id='b21lZ2Eg' timestamp='2020-04-20T14:34:21Z' />
+          </metadata>
+        </iq>
+
+    """
+
+    name = "start"
+    namespace = "urn:xmpp:mam:2"
+    plugin_attrib = name
+    #: Available interfaces:
+    #:
+    #: - ``id``: ID of the first message of the archive
+    #: - ``timestamp`` (``datetime``): timestamp of the first message of the
+    #:   archive
+    interfaces = {"id", "timestamp"}
+
+    def get_timestamp(self) -> Optional[datetime]:
+        """Get the timestamp.
+
+        :returns: The timestamp.
+        """
+        stamp = self.xml.attrib.get("timestamp", None)
+        if stamp is not None:
+            return xep_0082.parse(stamp)
+        return stamp
+
+    def set_timestamp(self, value: Union[datetime, str]):
+        """Set the timestamp.
+
+        :param value: Value of the timestamp (either a datetime or a
+                      XEP-0082 timestamp string.
+        """
+        if isinstance(value, str):
+            value = xep_0082.parse(value)
+        value = xep_0082.format_datetime(value)
+        self.xml.attrib["timestamp"] = value
+
+
+class End(ElementBase):
+    """Metadata about the end of an archive.
+
+    .. code-block:: xml
+
+        <iq type='result' id='jui8921rr9'>
+          <metadata xmlns='urn:xmpp:mam:2'>
+            <start id='YWxwaGEg' timestamp='2008-08-22T21:09:04Z' />
+            <end id='b21lZ2Eg' timestamp='2020-04-20T14:34:21Z' />
+          </metadata>
+        </iq>
+
+    """
+
+    name = "end"
+    namespace = "urn:xmpp:mam:2"
+    plugin_attrib = name
+    #: Available interfaces:
+    #:
+    #: - ``id``: ID of the first message of the archive
+    #: - ``timestamp`` (``datetime``): timestamp of the first message of the
+    #:   archive
+    interfaces = {"id", "timestamp"}
+
+    def get_timestamp(self) -> Optional[datetime]:
+        """Get the timestamp.
+
+        :returns: The timestamp.
+        """
+        stamp = self.xml.attrib.get("timestamp", None)
+        if stamp is not None:
+            return xep_0082.parse(stamp)
+        return stamp
+
+    def set_timestamp(self, value: Union[datetime, str]):
+        """Set the timestamp.
+
+        :param value: Value of the timestamp (either a datetime or a
+                      XEP-0082 timestamp string.
+        """
+        if isinstance(value, str):
+            value = xep_0082.parse(value)
+        value = xep_0082.format_datetime(value)
+        self.xml.attrib["timestamp"] = value

slidge/slixfix/xep_0317/__init__.py

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

slidge/slixfix/xep_0317/hats.py

@@ -0,0 +1,17 @@
+from slixmpp.plugins import BasePlugin
+
+from . import stanza
+
+
+class XEP_0317(BasePlugin):
+    """
+    XEP-0317: Hats
+    """
+
+    name = "xep_0317"
+    description = "XEP-0317: Hats"
+    dependencies = {"xep_0045"}
+    stanza = stanza
+
+    def plugin_init(self):
+        stanza.register()

slidge/slixfix/xep_0317/stanza.py

@@ -0,0 +1,28 @@
+from slixmpp import Presence
+from slixmpp.xmlstream import ElementBase, register_stanza_plugin
+
+NS = "urn:xmpp:hats:0"
+
+
+class Hats(ElementBase):
+    name = plugin_attrib = "hats"
+    namespace = NS
+
+    def add_hats(self, data: list[tuple[str, str]]):
+        for uri, title in data:
+            hat = Hat()
+            hat["uri"] = uri
+            hat["title"] = title
+            self.append(hat)
+
+
+class Hat(ElementBase):
+    name = plugin_attrib = "hat"
+    namespace = NS
+    interfaces = {"uri", "title"}
+    plugin_multi_attrib = "hats"
+
+
+def register():
+    register_stanza_plugin(Hats, Hat, iterable=True)
+    register_stanza_plugin(Presence, Hats)