slidge 0.1.0b2__py3-none-any.whl → 0.1.1__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/{util → slixfix}/xep_0356_old/privilege.py

@@ -4,16 +4,15 @@ from collections import defaultdict
 
 from slixmpp import JID, Iq, Message
 from slixmpp.plugins.base import BasePlugin
-from slixmpp.types import JidStr
-from slixmpp.xmlstream import StanzaBase
-from slixmpp.xmlstream.handler import Callback
-from slixmpp.xmlstream.matcher import StanzaPath
-
-from slidge.util.xep_0356.permissions import (
+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
 
@@ -72,7 +71,10 @@ class XEP_0356_OLD(BasePlugin):
         self.xmpp.event("privileges_advertised_old")
 
     def send_privileged_message(self, msg: Message):
-        if self.granted_privileges[msg.get_from().domain].message != MessagePermission.OUTGOING:
+        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"
             )

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)

slidge/slixfix/xep_0424/retraction.py

@@ -0,0 +1,77 @@
+# 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 typing import Optional
+
+from slixmpp import JID, Message
+from slixmpp.exceptions import IqError, IqTimeout
+from slixmpp.plugins import BasePlugin
+from slixmpp.xmlstream.handler import Callback
+from slixmpp.xmlstream.matcher import StanzaPath
+
+from . import stanza
+
+DEFAULT_FALLBACK = (
+    "This person attempted to retract a previous message, but your client "
+    "does not support it."
+)
+
+
+class XEP_0424(BasePlugin):
+    """XEP-0424: Message Retraction"""
+
+    name = "xep_0424"
+    description = "XEP-0424: Message Retraction (fix Slidge)"
+    dependencies = {"xep_0422", "xep_0030", "xep_0359", "xep_0428", "xep_0334"}
+    stanza = stanza
+    namespace = stanza.NS
+
+    def plugin_init(self) -> None:
+        stanza.register_plugins()
+        self.xmpp.register_handler(
+            Callback(
+                "Message Retracted",
+                StanzaPath("message/retract"),
+                self._handle_retract_message,
+            )
+        )
+
+    def session_bind(self, jid):
+        self.xmpp.plugin["xep_0030"].add_feature(feature=stanza.NS)
+
+    def plugin_end(self):
+        self.xmpp.plugin["xep_0030"].del_feature(feature=stanza.NS)
+
+    def _handle_retract_message(self, message: Message):
+        self.xmpp.event("message_retract", message)
+
+    def send_retraction(
+        self,
+        mto: JID,
+        id: str,
+        mtype: str = "chat",
+        include_fallback: bool = True,
+        fallback_text: Optional[str] = None,
+        *,
+        mfrom: Optional[JID] = None
+    ):
+        """
+        Send a message retraction
+
+        :param JID mto: The JID to retract the message from
+        :param str id: Message ID to retract
+        :param str mtype: Message type
+        :param bool include_fallback: Whether to include a fallback body
+        :param Optional[str] fallback_text: The content of the fallback
+                                            body. None will set the default value.
+        """
+        if fallback_text is None:
+            fallback_text = DEFAULT_FALLBACK
+        msg = self.xmpp.make_message(mto=mto, mtype=mtype, mfrom=mfrom)
+        if include_fallback:
+            msg["body"] = fallback_text
+            msg.enable("fallback")
+        msg["retract"]["id"] = id
+        msg.enable("store")
+        msg.send()

slidge/slixfix/xep_0424/stanza.py

@@ -0,0 +1,28 @@
+# 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 permissio
+from slixmpp.plugins.xep_0359 import OriginID
+from slixmpp.stanza import Message
+from slixmpp.xmlstream import ElementBase, register_stanza_plugin
+
+NS = "urn:xmpp:message-retract:1"
+
+
+class Retract(ElementBase):
+    namespace = NS
+    name = "retract"
+    plugin_attrib = "retract"
+
+
+class Retracted(ElementBase):
+    namespace = NS
+    name = "retracted"
+    plugin_attrib = "retracted"
+    interfaces = {"stamp"}
+
+
+def register_plugins():
+    register_stanza_plugin(Message, Retract)
+    register_stanza_plugin(Message, Retracted)
+    register_stanza_plugin(Retracted, OriginID)

slidge/slixfix/xep_0490/__init__.py

@@ -0,0 +1,8 @@
+from slixmpp.plugins.base import register_plugin
+
+from . import stanza
+from .mds import XEP_0490
+
+register_plugin(XEP_0490)
+
+__all__ = ["stanza", "XEP_0490"]

slidge/slixfix/xep_0490/mds.py

@@ -0,0 +1,47 @@
+from slixmpp import Iq
+from slixmpp.plugins import BasePlugin
+from slixmpp.plugins.xep_0004 import Form
+from slixmpp.types import JidStr
+
+from . import stanza
+
+
+class XEP_0490(BasePlugin):
+    """
+    XEP-0490: Message Displayed Synchronization
+    """
+
+    name = "xep_0490"
+    description = "XEP-0490: Message Displayed Synchronization"
+    dependencies = {"xep_0060", "xep_0163", "xep_0359"}
+    stanza = stanza
+
+    def plugin_init(self):
+        stanza.register_plugin()
+        self.xmpp.plugin["xep_0163"].register_pep(
+            "message_displayed_synchronization",
+            stanza.Displayed,
+        )
+
+    def flag_chat(self, chat: JidStr, stanza_id: str, **kwargs) -> Iq:
+        displayed = stanza.Displayed()
+        displayed["stanza_id"]["id"] = stanza_id
+        return self.xmpp.plugin["xep_0163"].publish(
+            displayed, node=stanza.NS, options=PUBLISH_OPTIONS, id=str(chat), **kwargs
+        )
+
+    def catch_up(self, **kwargs):
+        return self.xmpp.plugin["xep_0060"].get_items(
+            self.xmpp.boundjid.bare, stanza.NS, **kwargs
+        )
+
+
+PUBLISH_OPTIONS = Form()
+PUBLISH_OPTIONS["type"] = "submit"
+PUBLISH_OPTIONS.add_field(
+    "FORM_TYPE", "hidden", value="http://jabber.org/protocol/pubsub#publish-options"
+)
+PUBLISH_OPTIONS.add_field("pubsub#persist_items", value="true")
+PUBLISH_OPTIONS.add_field("pubsub#max_items", value="max")
+PUBLISH_OPTIONS.add_field("pubsub#send_last_published_item", value="never")
+PUBLISH_OPTIONS.add_field("pubsub#access_model", value="whitelist")

slidge/slixfix/xep_0490/stanza.py

@@ -0,0 +1,17 @@
+from slixmpp import register_stanza_plugin
+from slixmpp.plugins.xep_0060.stanza import Item
+from slixmpp.plugins.xep_0359.stanza import StanzaID
+from slixmpp.xmlstream import ElementBase
+
+NS = "urn:xmpp:mds:displayed:0"
+
+
+class Displayed(ElementBase):
+    namespace = NS
+    name = "displayed"
+    plugin_attrib = "displayed"
+
+
+def register_plugin():
+    register_stanza_plugin(Displayed, StanzaID)
+    register_stanza_plugin(Item, Displayed)

slidge/util/__init__.py

@@ -1,17 +1,15 @@
 from .util import (
     ABCSubclassableOnceAtMost,
-    BiDict,
-    FormField,
-    SearchResult,
     SubclassableOnce,
     is_valid_phone_number,
+    replace_mentions,
+    strip_illegal_chars,
 )
 
 __all__ = [
-    "BiDict",
-    "SearchResult",
-    "FormField",
     "SubclassableOnce",
     "ABCSubclassableOnceAtMost",
     "is_valid_phone_number",
+    "replace_mentions",
+    "strip_illegal_chars",
 ]