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

slidge/util/xep_0050/stanza.py

@@ -1,180 +0,0 @@
-
-# Slixmpp: The Slick XMPP Library
-# Copyright (C) 2011 Nathanael C. Fritz, Lance J.T. Stout
-# This file is part of Slixmpp.
-# See the file LICENSE for copying permission.
-from slixmpp.xmlstream import ET, ElementBase
-
-
-class Command(ElementBase):
-
-    """
-    XMPP's Adhoc Commands provides a generic workflow mechanism for
-    interacting with applications. The result is similar to menu selections
-    and multi-step dialogs in normal desktop applications. Clients do not
-    need to know in advance what commands are provided by any particular
-    application or agent. While adhoc commands provide similar functionality
-    to Jabber-RPC, adhoc commands are used primarily for human interaction.
-
-    Also see <http://xmpp.org/extensions/xep-0050.html>
-
-    Example command stanzas:
-
-    ::
-
-          <iq type="set">
-            <command xmlns="http://jabber.org/protocol/commands"
-                     node="run_foo"
-                     action="execute" />
-          </iq>
-
-          <iq type="result">
-            <command xmlns="http://jabber.org/protocol/commands"
-                     node="run_foo"
-                     sessionid="12345"
-                     status="executing">
-              <actions>
-                <complete />
-              </actions>
-              <note type="info">Information!</note>
-              <x xmlns="jabber:x:data">
-                <field var="greeting"
-                       type="text-single"
-                       label="Greeting" />
-              </x>
-            </command>
-          </iq>
-
-    Stanza Interface:
-    ::
-
-        action    -- The action to perform.
-        actions   -- The set of allowable next actions.
-        node      -- The node associated with the command.
-        notes     -- A list of tuples for informative notes.
-        sessionid -- A unique identifier for a command session.
-        status    -- May be one of: canceled, completed, or executing.
-
-    """
-
-    name = 'command'
-    namespace = 'http://jabber.org/protocol/commands'
-    plugin_attrib = 'command'
-    interfaces = {'action', 'sessionid', 'node',
-                  'status', 'actions', 'notes'}
-    actions = {'cancel', 'complete', 'execute', 'next', 'prev'}
-    statuses = {'canceled', 'completed', 'executing'}
-    next_actions = {'prev', 'next', 'complete'}
-
-    def get_action(self):
-        """
-        Return the value of the action attribute.
-
-        If the Iq stanza's type is "set" then use a default
-        value of "execute".
-        """
-        if self.parent()['type'] == 'set':
-            return self._get_attr('action', default='execute')
-        return self._get_attr('action')
-
-    def set_actions(self, values):
-        """
-        Assign the set of allowable next actions.
-
-        :param values: A list containing any combination of:
-                       'prev', 'next', and 'complete'
-        """
-        self.del_actions()
-        if values:
-            self._set_sub_text('{%s}actions' % self.namespace, '', True)
-            actions = self.xml.find('{%s}actions' % self.namespace)
-            for val in values:
-                if val in self.next_actions:
-                    action = ET.Element('{%s}%s' % (self.namespace, val))
-                    actions.append(action)
-
-    def get_actions(self):
-        """
-        Return the set of allowable next actions.
-        """
-        actions = set()
-        actions_xml = self.xml.find('{%s}actions' % self.namespace)
-        if actions_xml is not None:
-            for action in self.next_actions:
-                action_xml = actions_xml.find('{%s}%s' % (self.namespace,
-                                                          action))
-                if action_xml is not None:
-                    actions.add(action)
-        return actions
-
-    def del_actions(self):
-        """
-        Remove all allowable next actions.
-        """
-        self._del_sub('{%s}actions' % self.namespace)
-
-    def get_notes(self):
-        """
-        Return a list of note information.
-
-        Example:
-            [('info', 'Some informative data'),
-             ('warning', 'Use caution'),
-             ('error', 'The command ran, but had errors')]
-        """
-        notes = []
-        notes_xml = self.xml.findall('{%s}note' % self.namespace)
-        for note in notes_xml:
-            notes.append((note.attrib.get('type', 'info'),
-                          note.text))
-        return notes
-
-    def set_notes(self, notes):
-        """
-        Add multiple notes to the command result.
-
-        Each note is a tuple, with the first item being one of:
-        'info', 'warning', or 'error', and the second item being
-        any human readable message.
-
-        Example:
-            [('info', 'Some informative data'),
-             ('warning', 'Use caution'),
-             ('error', 'The command ran, but had errors')]
-
-
-        Arguments:
-            notes -- A list of tuples of note information.
-        """
-        self.del_notes()
-        for note in notes:
-            self.add_note(note[1], note[0])
-
-    def del_notes(self):
-        """
-        Remove all notes associated with the command result.
-        """
-        notes_xml = self.xml.findall('{%s}note' % self.namespace)
-        for note in notes_xml:
-            self.xml.remove(note)
-
-    def add_note(self, msg='', ntype='info'):
-        """
-        Add a single note annotation to the command.
-
-        Arguments:
-            msg   -- A human readable message.
-            ntype -- One of: 'info', 'warning', 'error'
-        """
-        xml = ET.Element('{%s}note' % self.namespace)
-        xml.attrib['type'] = ntype
-        xml.text = msg
-        self.xml.append(xml)
-
-
-class Note(ElementBase):
-    name = 'note'
-    namespace = 'http://jabber.org/protocol/commands'
-    plugin_attrib = 'note'
-    interfaces = {'type'}
-    

slidge/util/xep_0077/stanza.py

@@ -1,71 +0,0 @@
-# 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 __future__ import unicode_literals
-
-from typing import ClassVar, Set
-
-from slixmpp.xmlstream import ElementBase
-
-
-class Register(ElementBase):
-
-    namespace = 'jabber:iq:register'
-    name = 'query'
-    plugin_attrib = 'register'
-    interfaces = {'username', 'password', 'email', 'nick', 'name',
-                  'first', 'last', 'address', 'city', 'state', 'zip',
-                  'phone', 'url', 'date', 'misc', 'text', 'key',
-                  'registered', 'remove', 'instructions', 'fields'}
-    sub_interfaces = interfaces
-    form_fields = {'username', 'password', 'email', 'nick', 'name',
-                   'first', 'last', 'address', 'city', 'state', 'zip',
-                   'phone', 'url', 'date', 'misc', 'text', 'key'}
-
-    def get_registered(self):
-        present = self.xml.find('{%s}registered' % self.namespace)
-        return present is not None
-
-    def get_remove(self):
-        present = self.xml.find('{%s}remove' % self.namespace)
-        return present is not None
-
-    def set_registered(self, value):
-        if value:
-            self.add_field('registered')
-        else:
-            del self['registered']
-
-    def set_remove(self, value):
-        if value:
-            self.add_field('remove')
-        else:
-            del self['remove']
-
-    def add_field(self, value):
-        self._set_sub_text(value, '', keep=True)
-
-    def get_fields(self):
-        fields = set()
-        for field in self.form_fields:
-            if self.xml.find('{%s}%s' % (self.namespace, field)) is not None:
-                fields.add(field)
-        return fields
-
-    def set_fields(self, fields):
-        del self['fields']
-        for field in fields:
-            self._set_sub_text(field, '', keep=True)
-
-    def del_fields(self):
-        for field in self.form_fields:
-            self._del_sub(field)
-
-
-class RegisterFeature(ElementBase):
-
-    name = 'register'
-    namespace = 'http://jabber.org/features/iq-register'
-    plugin_attrib = name
-    interfaces: ClassVar[Set[str]] = set()

slidge/util/xep_0292/__init__.py

@@ -1 +0,0 @@
-from . import stanza, vcard4

slidge/util/xep_0292/stanza.py

@@ -1,167 +0,0 @@
-import datetime
-from typing import Optional
-
-from slixmpp import ElementBase, Iq, register_stanza_plugin
-
-NS = "urn:ietf:params:xml:ns:vcard-4.0"
-
-
-class _VCardElementBase(ElementBase):
-    namespace = NS
-
-
-class VCard4(_VCardElementBase):
-    name = plugin_attrib = "vcard"
-    interfaces = {"full_name", "given", "surname", "birthday"}
-
-    def set_full_name(self, full_name: str):
-        self["fn"]["text"] = full_name
-
-    def get_full_name(self):
-        return self["fn"]["text"]
-
-    def set_given(self, given: str):
-        self["n"]["given"] = given
-
-    def get_given(self):
-        return self["n"]["given"]
-
-    def set_surname(self, surname: str):
-        self["n"]["surname"] = surname
-
-    def get_surname(self):
-        return self["n"]["surname"]
-
-    def set_birthday(self, birthday: datetime.date):
-        self["bday"]["date"] = birthday
-
-    def get_birthday(self):
-        return self["bday"]["date"]
-
-    def add_tel(self, number: str, name: Optional[str] = None):
-        tel = Tel()
-        if name:
-            tel["parameters"]["type_"]["text"] = name
-        tel["uri"] = f"tel:{number}"
-        self.append(tel)
-
-    def add_address(
-        self, country: Optional[str] = None, locality: Optional[str] = None
-    ):
-        adr = Adr()
-        if locality:
-            adr["locality"] = locality
-        if country:
-            adr["country"] = country
-        self.append(adr)
-
-    def add_nickname(self, nick: str):
-        el = Nickname()
-        el["text"] = nick
-        self.append(el)
-
-    def add_note(self, note: str):
-        el = Note()
-        el["text"] = note
-        self.append(el)
-
-    def add_impp(self, impp: str):
-        el = Impp()
-        el["uri"] = impp
-        self.append(el)
-
-    def add_url(self, url: str):
-        el = Url()
-        el["uri"] = url
-        self.append(el)
-
-    def add_email(self, email: str):
-        el = Email()
-        el["text"] = email
-        self.append(el)
-
-
-class _VCardTextElementBase(_VCardElementBase):
-    interfaces = {"text"}
-    sub_interfaces = {"text"}
-
-
-class Fn(_VCardTextElementBase):
-    name = plugin_attrib = "fn"
-
-
-class Nickname(_VCardTextElementBase):
-    name = plugin_attrib = "nickname"
-
-
-class Note(_VCardTextElementBase):
-    name = plugin_attrib = "note"
-
-
-class _VCardUriElementBase(_VCardElementBase):
-    interfaces = {"uri"}
-    sub_interfaces = {"uri"}
-
-
-class Url(_VCardUriElementBase):
-    name = plugin_attrib = "url"
-
-
-class Impp(_VCardUriElementBase):
-    name = plugin_attrib = "impp"
-
-
-class Email(_VCardTextElementBase):
-    name = plugin_attrib = "email"
-
-
-class N(_VCardElementBase):
-    name = "n"
-    plugin_attrib = "n"
-    interfaces = sub_interfaces = {"given", "surname", "additional"}
-
-
-class BDay(_VCardElementBase):
-    name = plugin_attrib = "bday"
-    interfaces = {"date"}
-
-    def set_date(self, date: datetime.date):
-        d = Date()
-        d.xml.text = date.strftime("%Y-%m-%d")
-        self.append(d)
-
-    def get_date(self):
-        for elem in self.xml:
-            try:
-                return datetime.date.fromisoformat(elem.text)
-            except ValueError:
-                return None
-
-
-class Date(_VCardElementBase):
-    name = "date"
-
-
-class Tel(_VCardUriElementBase):
-    name = plugin_attrib = "tel"
-
-
-class Parameters(_VCardElementBase):
-    name = plugin_attrib = "parameters"
-
-
-class Type(_VCardTextElementBase):
-    name = "type"
-    plugin_attrib = "type_"
-
-
-class Adr(_VCardElementBase):
-    name = plugin_attrib = "adr"
-    interfaces = sub_interfaces = {"locality", "country"}
-
-
-register_stanza_plugin(Parameters, Type)
-register_stanza_plugin(Tel, Parameters)
-for p in N, Fn, Nickname, Note, Url, Impp, Email, BDay, Tel, Adr:
-    register_stanza_plugin(VCard4, p, iterable=True)
-register_stanza_plugin(Iq, VCard4)

slidge/util/xep_0292/vcard4.py

@@ -1,74 +0,0 @@
-import logging
-from dataclasses import dataclass, field
-from typing import Optional
-
-from slixmpp import JID, ComponentXMPP, CoroutineCallback, Iq, StanzaPath
-from slixmpp.plugins.base import BasePlugin, register_plugin
-from slixmpp.types import JidStr
-
-from .stanza import NS, VCard4
-
-
-@dataclass
-class StoredVCard:
-    content: VCard4
-    authorized_jids: set[JidStr] = field(default_factory=set)
-
-
-class VCard4Provider(BasePlugin):
-    xmpp: ComponentXMPP
-
-    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_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 handle_vcard_get(self, iq: Iq):
-        r = iq.reply()
-        if vcard := 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,
-    ):
-        self._vcards[jid] = StoredVCard(
-            vcard, authorized_jids if authorized_jids is not None else set()
-        )
-        if self.xmpp["pubsub"] and authorized_jids:
-            for to in authorized_jids:
-                self.xmpp["pubsub"].broadcast_vcard_event(jid, to)
-
-
-register_plugin(VCard4Provider)
-log = logging.getLogger(__name__)

slidge/util/xep_0356/__init__.py

@@ -1,7 +0,0 @@
-from slixmpp.plugins.base import register_plugin
-
-from . import stanza
-from .privilege import XEP_0356
-from .stanza import Perm, Privilege
-
-register_plugin(XEP_0356)

slidge/util/xep_0356/permissions.py

@@ -1,35 +0,0 @@
-import dataclasses
-from enum import Enum
-
-
-class RosterAccess(str, Enum):
-    NONE = "none"
-    GET = "get"
-    SET = "set"
-    BOTH = "both"
-
-
-class MessagePermission(str, Enum):
-    NONE = "none"
-    OUTGOING = "outgoing"
-
-
-class IqPermission(str, Enum):
-    NONE = "none"
-    GET = "get"
-    SET = "set"
-    BOTH = "both"
-
-
-class PresencePermission(str, Enum):
-    NONE = "none"
-    MANAGED_ENTITY = "managed_entity"
-    ROSTER = "roster"
-
-
-@dataclasses.dataclass
-class Permissions:
-    roster = RosterAccess.NONE
-    message = MessagePermission.NONE
-    iq = MessagePermission.NONE
-    presence = PresencePermission.NONE

slidge/util/xep_0356/privilege.py

@@ -1,160 +0,0 @@
-import logging
-import typing
-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 . import stanza
-from .permissions import MessagePermission, Permissions, RosterAccess
-
-log = logging.getLogger(__name__)
-
-
-# noinspection PyPep8Naming
-class XEP_0356(BasePlugin):
-    """
-    XEP-0356: Privileged Entity
-
-    Events:
-
-    ::
-
-        privileges_advertised  -- Received message/privilege from the server
-    """
-
-    name = "xep_0356"
-    description = "XEP-0356: Privileged Entity (slidge)"
-    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",
-                StanzaPath("message/privilege"),
-                self._handle_privilege,
-            )
-        )
-
-    def plugin_end(self):
-        self.xmpp.remove_handler("Privileges")
-
-    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"]["perms"]:
-            setattr(
-                self.granted_privileges[msg.get_from()], perm["access"], perm["type"]
-            )
-        log.debug(f"Privileges: {self.granted_privileges}")
-        self.xmpp.event("privileges_advertised")
-
-    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"]["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)