slidge 0.1.0__py3-none-any.whl

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)

slidge/slixfix/xep_0356_old/__init__.py

@@ -0,0 +1,7 @@
+from slixmpp.plugins.base import register_plugin
+
+from . import stanza
+from .privilege import XEP_0356_OLD
+from .stanza import PermOld, PrivilegeOld
+
+register_plugin(XEP_0356_OLD)

slidge/slixfix/xep_0356_old/privilege.py

@@ -0,0 +1,167 @@
+import logging
+import typing
+from collections import defaultdict
+
+from slixmpp import JID, Iq, Message
+from slixmpp.plugins.base import BasePlugin
+from slixmpp.plugins.xep_0356.permissions import (
+    MessagePermission,
+    Permissions,
+    RosterAccess,
+)
+from slixmpp.types import JidStr
+from slixmpp.xmlstream import StanzaBase
+from slixmpp.xmlstream.handler import Callback
+from slixmpp.xmlstream.matcher import StanzaPath
+
+from . import stanza
+
+log = logging.getLogger(__name__)
+
+
+# noinspection PyPep8Naming
+class XEP_0356_OLD(BasePlugin):
+    """
+    XEP-0356: Privileged Entity
+
+    Events:
+
+    ::
+
+        privileges_advertised_old -- Received message/privilege from the server
+    """
+
+    name = "xep_0356_old"
+    description = "XEP-0356: Privileged Entity (slidge - old namespace)"
+    dependencies = {"xep_0297"}
+    stanza = stanza
+
+    granted_privileges: defaultdict[JidStr, Permissions] = defaultdict(Permissions)
+
+    def plugin_init(self):
+        if not self.xmpp.is_component:
+            log.error("XEP 0356 is only available for components")
+            return
+
+        stanza.register()
+
+        self.xmpp.register_handler(
+            Callback(
+                "Privileges_old",
+                StanzaPath("message/privilege_old"),
+                self._handle_privilege,
+            )
+        )
+
+    def plugin_end(self):
+        self.xmpp.remove_handler("Privileges_old")
+
+    def _handle_privilege(self, msg: StanzaBase):
+        """
+        Called when the XMPP server advertise the component's privileges.
+
+        Stores the privileges in this instance's granted_privileges attribute (a dict)
+        and raises the privileges_advertised event
+        """
+        for perm in msg["privilege_old"]["perms"]:
+            setattr(
+                self.granted_privileges[msg.get_from()], perm["access"], perm["type"]
+            )
+        log.debug(f"Privileges (old): {self.granted_privileges}")
+        self.xmpp.event("privileges_advertised_old")
+
+    def send_privileged_message(self, msg: Message):
+        if (
+            self.granted_privileges[msg.get_from().domain].message
+            != MessagePermission.OUTGOING
+        ):
+            raise PermissionError(
+                "The server hasn't authorized us to send messages on behalf of other users"
+            )
+        else:
+            self._make_privileged_message(msg).send()
+
+    def _make_privileged_message(self, msg: Message):
+        server = msg.get_from().domain
+        wrapped = self.xmpp.make_message(mto=server, mfrom=self.xmpp.boundjid.bare)
+        wrapped["privilege_old"]["forwarded"].append(msg)
+        return wrapped
+
+    def _make_get_roster(self, jid: typing.Union[JID, str], **iq_kwargs):
+        return self.xmpp.make_iq_get(
+            queryxmlns="jabber:iq:roster",
+            ifrom=self.xmpp.boundjid.bare,
+            ito=jid,
+            **iq_kwargs,
+        )
+
+    def _make_set_roster(
+        self,
+        jid: typing.Union[JID, str],
+        roster_items: dict,
+        **iq_kwargs,
+    ):
+        iq = self.xmpp.make_iq_set(
+            ifrom=self.xmpp.boundjid.bare,
+            ito=jid,
+            **iq_kwargs,
+        )
+        iq["roster"]["items"] = roster_items
+        return iq
+
+    async def get_roster(self, jid: typing.Union[JID, str], **send_kwargs) -> Iq:
+        """
+        Return the roster of user on the server the component has privileged access to.
+
+        Raises ValueError if the server did not advertise the corresponding privileges
+
+        :param jid: user we want to fetch the roster from
+        """
+        if isinstance(jid, str):
+            jid = JID(jid)
+        if self.granted_privileges[jid.domain].roster not in (
+            RosterAccess.GET,
+            RosterAccess.BOTH,
+        ):
+            raise PermissionError(
+                "The server did not grant us privileges to get rosters"
+            )
+        else:
+            return await self._make_get_roster(jid).send(**send_kwargs)
+
+    async def set_roster(
+        self, jid: typing.Union[JID, str], roster_items: dict, **send_kwargs
+    ) -> Iq:
+        """
+        Return the roster of user on the server the component has privileged access to.
+
+        Raises ValueError if the server did not advertise the corresponding privileges
+
+        :param jid: user we want to add or modify roster items
+        :param roster_items: a dict containing the roster items' JIDs as keys and
+            nested dicts containing names, subscriptions and groups.
+            Example:
+            {
+                "friend1@example.com": {
+                    "name": "Friend 1",
+                    "subscription": "both",
+                    "groups": ["group1", "group2"],
+                },
+                "friend2@example.com": {
+                    "name": "Friend 2",
+                    "subscription": "from",
+                    "groups": ["group3"],
+            },
+        }
+        """
+        if isinstance(jid, str):
+            jid = JID(jid)
+        if self.granted_privileges[jid.domain].roster not in (
+            RosterAccess.GET,
+            RosterAccess.BOTH,
+        ):
+            raise PermissionError(
+                "The server did not grant us privileges to set rosters"
+            )
+        else:
+            return await self._make_set_roster(jid, roster_items).send(**send_kwargs)

slidge/slixfix/xep_0356_old/stanza.py

@@ -0,0 +1,44 @@
+from slixmpp.plugins.xep_0297 import Forwarded
+from slixmpp.stanza import Message
+from slixmpp.xmlstream import ElementBase, register_stanza_plugin
+
+
+class PrivilegeOld(ElementBase):
+    namespace = "urn:xmpp:privilege:1"
+    name = "privilege"
+    plugin_attrib = "privilege_old"
+
+    def permission(self, access):
+        for perm in self["perms"]:
+            if perm["access"] == access:
+                return perm["type"]
+
+    def roster(self):
+        return self.permission("roster")
+
+    def message(self):
+        return self.permission("message")
+
+    def presence(self):
+        return self.permission("presence")
+
+    def add_perm(self, access, type):
+        # This should only be needed for servers, so maybe out of scope for slixmpp
+        perm = PermOld()
+        perm["type"] = type
+        perm["access"] = access
+        self.append(perm)
+
+
+class PermOld(ElementBase):
+    namespace = "urn:xmpp:privilege:1"
+    name = "perm"
+    plugin_attrib = "perm"
+    plugin_multi_attrib = "perms"
+    interfaces = {"type", "access"}
+
+
+def register():
+    register_stanza_plugin(Message, PrivilegeOld)
+    register_stanza_plugin(PrivilegeOld, Forwarded)
+    register_stanza_plugin(PrivilegeOld, PermOld, iterable=True)

slidge/slixfix/xep_0424/__init__.py

@@ -0,0 +1,9 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2020 Mathieu Pasquet <mathieui@mathieui.net>
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from slixmpp.plugins.base import register_plugin
+
+from .retraction import XEP_0424
+
+register_plugin(XEP_0424)