slidge 0.1.0b2__py3-none-any.whl → 0.1.1__py3-none-any.whl

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)

slidge/util/xep_0356/stanza.py

@@ -1,44 +0,0 @@
-from slixmpp.plugins.xep_0297 import Forwarded
-from slixmpp.stanza import Message
-from slixmpp.xmlstream import ElementBase, register_stanza_plugin
-
-
-class Privilege(ElementBase):
-    namespace = "urn:xmpp:privilege:2"
-    name = "privilege"
-    plugin_attrib = "privilege"
-
-    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 = Perm()
-        perm["type"] = type_
-        perm["access"] = access
-        self.append(perm)
-
-
-class Perm(ElementBase):
-    namespace = "urn:xmpp:privilege:2"
-    name = "perm"
-    plugin_attrib = "perm"
-    plugin_multi_attrib = "perms"
-    interfaces = {"type", "access"}
-
-
-def register():
-    register_stanza_plugin(Message, Privilege)
-    register_stanza_plugin(Privilege, Forwarded)
-    register_stanza_plugin(Privilege, Perm, iterable=True)

slidge/util/xep_0363/__init__.py

@@ -1,16 +0,0 @@
-# slixmpp: The Slick XMPP Library
-# Copyright (C) 2018 Emmanuel Gil Peyrot
-# This file is part of slixmpp.
-# See the file LICENSE for copying permission.
-from slixmpp.plugins.base import register_plugin
-
-from .http_upload import (
-    XEP_0363,
-    FileTooBig,
-    FileUploadError,
-    HTTPError,
-    UploadServiceNotFound,
-)
-from .stanza import Get, Header, Put, Request, Slot
-
-register_plugin(XEP_0363)

slidge/util/xep_0363/http_upload.py

@@ -1,215 +0,0 @@
-# slixmpp: The Slick XMPP Library
-# Copyright (C) 2018 Emmanuel Gil Peyrot
-# This file is part of slixmpp.
-# See the file LICENSE for copying permission.
-
-import logging
-import os.path
-from asyncio import Future
-from mimetypes import guess_type
-from pathlib import Path
-from typing import IO, Optional, Union
-
-from aiohttp import ClientSession
-from slixmpp import JID, __version__
-from slixmpp.plugins import BasePlugin
-from slixmpp.plugins.xep_0363 import Get, Header, Put, Request, Slot, stanza
-from slixmpp.stanza import Iq
-from slixmpp.xmlstream import register_stanza_plugin
-from slixmpp.xmlstream.handler import Callback
-from slixmpp.xmlstream.matcher import StanzaPath
-
-log = logging.getLogger(__name__)
-
-class FileUploadError(Exception):
-    pass
-
-class UploadServiceNotFound(FileUploadError):
-    """
-    Raised if no upload service can be found.
-    """
-
-class FileTooBig(FileUploadError):
-    """
-    Raised if the file size is above advertised server limits.
-
-    args:
-
-    - size of the file
-    - max file size allowed
-    """
-    def __str__(self):
-        return 'File size too large: {} (max: {} bytes)' \
-            .format(self.args[0], self.args[1])
-
-class HTTPError(FileUploadError):
-    """
-    Raised when we receive an HTTP error response during upload.
-
-    args:
-
-    - HTTP Error code
-    - Content of the HTTP response
-    """
-    def __str__(self):
-        return 'Could not upload file: %d (%s)' % (self.args[0], self.args[1])
-
-class XEP_0363(BasePlugin):
-    """
-    XEP-0363: HTTP File Upload
-    """
-
-    name = 'xep_0363'
-    description = 'XEP-0363: HTTP File Upload'
-    dependencies = {'xep_0030', 'xep_0128'}
-    stanza = stanza
-    default_config = {
-        'upload_service': None,
-        'max_file_size': float('+inf'),
-        'default_content_type': 'application/octet-stream',
-    }
-    upload_service : Optional[JID]
-    max_file_size: float
-
-    def plugin_init(self):
-        register_stanza_plugin(Iq, Request)
-        register_stanza_plugin(Iq, Slot)
-        register_stanza_plugin(Slot, Put)
-        register_stanza_plugin(Slot, Get)
-        register_stanza_plugin(Put, Header, iterable=True)
-
-        self.xmpp.register_handler(
-                Callback('HTTP Upload Request',
-                         StanzaPath('iq@type=get/http_upload_request'),
-                         self._handle_request))
-
-    def plugin_end(self):
-        self.xmpp.remove_handler('HTTP Upload Request')
-        self.xmpp['xep_0030'].del_feature(feature=Request.namespace)
-
-    def session_bind(self, jid):
-        self.xmpp.plugin['xep_0030'].add_feature(Request.namespace)
-
-    def _handle_request(self, iq):
-        self.xmpp.event('http_upload_request', iq)
-
-    async def find_upload_service(self, domain: Optional[JID] = None, **iqkwargs) -> Optional[Iq]:
-        """Find an upload service on a domain (our own by default).
-
-        :param domain: Domain to disco to find a service.
-        """
-        if domain is None and self.xmpp.is_component:
-            domain = self.xmpp.server_host
-
-        results = await self.xmpp['xep_0030'].get_info_from_domain(domain=domain)
-
-        candidates = []
-        for info in results:
-            if not info['disco_info']:
-                continue
-            for identity in info['disco_info']['identities']:
-                if identity[0] == 'store' and identity[1] == 'file':
-                    candidates.append(info)
-        for info in candidates:
-            for feature in info['disco_info']['features']:
-                if feature == Request.namespace:
-                    return info
-        else:
-            return None  # for mypy...
-
-    def request_slot(self, jid: JID, filename: Union[Path, str], size: int,
-                    content_type: Optional[str] = None, *,
-                    ifrom: Optional[JID] = None, **iqkwargs) -> Future:
-        """Request an HTTP upload slot from a service.
-
-        :param jid: Service to request the slot from.
-        :param filename: Name of the file that will be uploaded.
-        :param size: size of the file in bytes.
-        :param content_type: Type of the file that will be uploaded.
-        """
-        if ifrom is None:
-            ifrom = self.xmpp.boundjid
-        iq = self.xmpp.make_iq_get(ito=jid, ifrom=ifrom)
-        request = iq['http_upload_request']
-        request['filename'] = str(filename)
-        request['size'] = str(size)
-        request['content-type'] = content_type or self.default_content_type
-        return iq.send(**iqkwargs)
-
-    async def upload_file(self, filename: Union[Path, str], size: Optional[int] = None,
-                          content_type: Optional[str] = None, *,
-                          input_file: Optional[IO[bytes]]=None,
-                          domain: Optional[JID] = None,
-                          **iqkwargs) -> str:
-        '''Helper function which does all of the uploading discovery and
-        process.
-
-        :param filename: Path to the file to upload (or only the name if
-                         ``input_file`` is provided.
-        :param size: size of the file in bytes.
-        :param content_type: Type of the file that will be uploaded.
-        :param input_file: Binary file stream on the file.
-        :param domain: Domain to query to find an HTTP upload service.
-        :raises .UploadServiceNotFound: If slixmpp is unable to find an
-                                        an available upload service.
-        :raises .FileTooBig: If the filesize is above what is accepted by
-                             the service.
-        :raises .HTTPError: If there is an error in the HTTP operation.
-        :returns: The URL of the uploaded file.
-        '''
-        timeout = iqkwargs.get('timeout', None)
-        if self.upload_service is None:
-            info_iq = await self.find_upload_service(
-                domain=domain, **iqkwargs
-            )
-            if info_iq is None:
-                raise UploadServiceNotFound()
-            self.upload_service = info_iq['from']
-            for form in info_iq['disco_info'].iterables:
-                values = form['values']
-                if values['FORM_TYPE'] == ['urn:xmpp:http:upload:0']:
-                    try:
-                        self.max_file_size = int(values['max-file-size'])
-                    except (TypeError, ValueError):
-                        log.error('Invalid max size received from HTTP File Upload service')
-                        self.max_file_size = float('+inf')
-                    break
-
-        if input_file is None:
-            input_file = open(filename, 'rb')
-
-        if size is None:
-            size = input_file.seek(0, 2)
-            input_file.seek(0)
-
-        if size > self.max_file_size:
-            raise FileTooBig(size, self.max_file_size)
-
-        if content_type is None:
-            content_type = guess_type(filename)[0]
-            if content_type is None:
-                content_type = self.default_content_type
-
-        basename = os.path.basename(filename)
-        slot_iq = await self.request_slot(self.upload_service, basename, size,
-                                          content_type, **iqkwargs)
-        slot = slot_iq['http_upload_slot']
-
-        headers = {
-            'Content-Length': str(size),
-            'Content-Type': content_type or self.default_content_type,
-            **{header['name']: header['value'] for header in slot['put']['headers']}
-        }
-
-        # Do the actual upload here.
-        async with ClientSession(headers={'User-Agent': 'slixmpp ' + __version__}) as session:
-            response = await session.put(
-                    slot['put']['url'],
-                    data=input_file,
-                    headers=headers,
-                    timeout=timeout)
-            if response.status >= 400:
-                raise HTTPError(response.status, await response.text())
-            log.debug('Response code: %d (%s)', response.status, await response.text())
-            response.close()
-            return slot['get']['url']

slidge/util/xep_0363/stanza.py

@@ -1,46 +0,0 @@
-
-# slixmpp: The Slick XMPP Library
-# Copyright (C) 2018 Emmanuel Gil Peyrot
-# This file is part of slixmpp.
-# See the file LICENSE for copying permission.
-from slixmpp.xmlstream import ElementBase
-
-
-class Request(ElementBase):
-    plugin_attrib = 'http_upload_request'
-    name = 'request'
-    namespace = 'urn:xmpp:http:upload:0'
-    interfaces = {'filename', 'size', 'content-type'}
-
-class Slot(ElementBase):
-    plugin_attrib = 'http_upload_slot'
-    name = 'slot'
-    namespace = 'urn:xmpp:http:upload:0'
-
-class Put(ElementBase):
-    plugin_attrib = 'put'
-    name = 'put'
-    namespace = 'urn:xmpp:http:upload:0'
-    interfaces = {'url'}
-
-class Get(ElementBase):
-    plugin_attrib = 'get'
-    name = 'get'
-    namespace = 'urn:xmpp:http:upload:0'
-    interfaces = {'url'}
-
-class Header(ElementBase):
-    plugin_attrib = 'header'
-    name = 'header'
-    namespace = 'urn:xmpp:http:upload:0'
-    plugin_multi_attrib = 'headers'
-    interfaces = {'name', 'value'}
-
-    def get_value(self):
-        return self.xml.text
-
-    def set_value(self, value):
-        self.xml.text = value
-
-    def del_value(self):
-        self.xml.text = ''

slidge/util/xep_0461/__init__.py

@@ -1,6 +0,0 @@
-from slixmpp.plugins.base import register_plugin
-
-from .reply import XEP_0461
-from .stanza import *
-
-register_plugin(XEP_0461)

slidge/util/xep_0461/reply.py

@@ -1,48 +0,0 @@
-from slixmpp.plugins 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
-
-
-class XEP_0461(BasePlugin):
-    """XEP-0461: Message Replies"""
-
-    name = "xep_0461"
-    description = "XEP-0461: Message Replies"
-
-    dependencies = {"xep_0030"}
-    stanza = stanza
-    namespace = stanza.NS
-
-    def plugin_init(self) -> None:
-        stanza.register_plugins()
-        self.xmpp.register_handler(
-            Callback(
-                "Message replied to",
-                StanzaPath("message/reply"),
-                self._handle_reply_to_message,
-            )
-        )
-
-    def plugin_end(self):
-        self.xmpp.plugin["xep_0030"].del_feature(feature=stanza.NS)
-
-    def session_bind(self, jid):
-        self.xmpp.plugin["xep_0030"].add_feature(feature=stanza.NS)
-
-    def _handle_reply_to_message(self, msg: StanzaBase):
-        self.xmpp.event("message_reply", msg)
-
-    def send_reply(self, reply_to: JidStr, reply_id: str, **msg_kwargs):
-        """
-
-        :param reply_to: Full JID of the quoted author
-        :param reply_id: ID of the message to reply to
-        """
-        msg = self.xmpp.make_message(**msg_kwargs)
-        msg["reply"]["to"] = reply_to
-        msg["reply"]["id"] = reply_id
-        msg.send()

slidge/util/xep_0461/stanza.py

@@ -1,47 +0,0 @@
-from slixmpp.stanza import Message
-from slixmpp.xmlstream import ElementBase, register_stanza_plugin
-
-NS = "urn:xmpp:reply:0"
-
-
-class Reply(ElementBase):
-    namespace = NS
-    name = "reply"
-    plugin_attrib = "reply"
-    interfaces = {"id", "to"}
-
-
-class FeatureFallBack(ElementBase):
-    # should also be a multi attrib
-    namespace = "urn:xmpp:feature-fallback:0"
-    name = "fallback"
-    plugin_attrib = "feature_fallback"
-    interfaces = {"for"}
-
-    def get_stripped_body(self):
-        # only works for a single fallback_body attrib
-        start = self["fallback_body"]["start"]
-        end = self["fallback_body"]["end"]
-        body = self.parent()["body"]
-        try:
-            start = int(start)
-            end = int(end)
-        except ValueError:
-            return body
-        else:
-            return body[:start] + body[end:]
-
-
-class FallBackBody(ElementBase):
-    # According to https://xmpp.org/extensions/inbox/compatibility-fallback.html
-    # this should be a multi_attrib *but* since it's a protoXEP, we'll see...
-    namespace = FeatureFallBack.namespace
-    name = "body"
-    plugin_attrib = "fallback_body"
-    interfaces = {"start", "end"}
-
-
-def register_plugins():
-    register_stanza_plugin(Message, Reply)
-    register_stanza_plugin(Message, FeatureFallBack)
-    register_stanza_plugin(FeatureFallBack, FallBackBody)