libervia-backend: sat/plugins/plugin_exp_pubsub

comparison sat/plugins/plugin_exp_pubsub_schema.py @ 3028:ab2696e34d29

Python 3 port: /!\ this is a huge commit /!\ starting from this commit, SàT is needs Python 3.6+ /!\ SàT maybe be instable or some feature may not work anymore, this will improve with time This patch port backend, bridge and frontends to Python 3. Roughly this has been done this way: - 2to3 tools has been applied (with python 3.7) - all references to python2 have been replaced with python3 (notably shebangs) - fixed files not handled by 2to3 (notably the shell script) - several manual fixes - fixed issues reported by Python 3 that where not handled in Python 2 - replaced "async" with "async_" when needed (it's a reserved word from Python 3.7) - replaced zope's "implements" with @implementer decorator - temporary hack to handle data pickled in database, as str or bytes may be returned, to be checked later - fixed hash comparison for password - removed some code which is not needed anymore with Python 3 - deactivated some code which needs to be checked (notably certificate validation) - tested with jp, fixed reported issues until some basic commands worked - ported Primitivus (after porting dependencies like urwid satext) - more manual fixes

author	Goffi <goffi@goffi.org>
date	Tue, 13 Aug 2019 19:08:41 +0200
parents	989b622faff6
children	fee60f17ebac

comparison

equal deleted inserted replaced

-:ff5bcb12ae60
+:ab2696e34d29
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # SAT plugin for Pubsub Schemas
 # Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org)
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 from collections import Iterable
 import copy
 import itertools
-from zope.interface import implements
+from zope.interface import implementer
 from twisted.words.protocols.jabber import jid
 from twisted.words.protocols.jabber.xmlstream import XMPPHandler
 from twisted.internet import defer
 from wokkel import disco, iwokkel
 from wokkel import data_form
 from sat.tools.common import data_format
 from sat.core.log import getLogger
 log = getLogger(__name__)
-NS_SCHEMA = u"https://salut-a-toi/protocol/schema:0"
+NS_SCHEMA = "https://salut-a-toi/protocol/schema:0"
 PLUGIN_INFO = {
-C.PI_NAME: u"PubSub Schema",
+C.PI_NAME: "PubSub Schema",
-C.PI_IMPORT_NAME: u"PUBSUB_SCHEMA",
+C.PI_IMPORT_NAME: "PUBSUB_SCHEMA",
-C.PI_TYPE: u"EXP",
+C.PI_TYPE: "EXP",
 C.PI_PROTOCOLS: [],
-C.PI_DEPENDENCIES: [u"XEP-0060", u"IDENTITY"],
+C.PI_DEPENDENCIES: ["XEP-0060", "IDENTITY"],
-C.PI_MAIN: u"PubsubSchema",
+C.PI_MAIN: "PubsubSchema",
-C.PI_HANDLER: u"yes",
+C.PI_HANDLER: "yes",
-C.PI_DESCRIPTION: _(u"""Handle Pubsub data schemas"""),
+C.PI_DESCRIPTION: _("""Handle Pubsub data schemas"""),
 }
 class PubsubSchema(object):
 def __init__(self, host):
-log.info(_(u"PubSub Schema initialization"))
+log.info(_("PubSub Schema initialization"))
 self.host = host
 self._p = self.host.plugins["XEP-0060"]
 self._i = self.host.plugins["IDENTITY"]
 host.bridge.addMethod(
 "psSchemaGet",
 ".plugin",
 in_sign="sss",
 out_sign="s",
 method=self._getSchema,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "psSchemaSet",
 ".plugin",
 in_sign="ssss",
 out_sign="",
 method=self._setSchema,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "psSchemaUIGet",
 ".plugin",
 in_sign="sss",
 out_sign="s",
-method=utils.partial(self._getUISchema, default_node=None),
+method=lambda service, nodeIdentifier, profile_key: self._getUISchema(
-async=True,
+service, nodeIdentifier, default_node=None, profile_key=profile_key),
+async_=True,
 )
 host.bridge.addMethod(
 "psItemsFormGet",
 ".plugin",
 in_sign="ssssiassa{ss}s",
 out_sign="(asa{ss})",
 method=self._getDataFormItems,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "psItemFormSend",
 ".plugin",
 in_sign="ssa{sas}ssa{ss}s",
 out_sign="s",
 method=self._sendDataFormItem,
-async=True,
+async_=True,
 )
 def getHandler(self, client):
 return SchemaHandler()
 def _getSchemaBridgeCb(self, schema_elt):
 if schema_elt is None:
-return u""
+return ""
 return schema_elt.toXml()
 def _getSchema(self, service, nodeIdentifier, profile_key=C.PROF_KEY_NONE):
 client = self.host.getClient(profile_key)
 service = None if not service else jid.JID(service)
 None to use our PEP
 @param nodeIdentifier(unicode): node to get schema from
 @return (domish.Element, None): schema (<x> element)
 None if not schema has been set on this node
 """
-iq_elt = client.IQ(u"get")
+iq_elt = client.IQ("get")
 if service is not None:
 iq_elt["to"] = service.full()
 pubsub_elt = iq_elt.addElement((NS_SCHEMA, "pubsub"))
 schema_elt = pubsub_elt.addElement((NS_SCHEMA, "schema"))
 schema_elt["node"] = nodeIdentifier
 needed when the form is reused and it will be modified (e.g. in sendDataFormItem)
 @return(data_form.Form): data form
 the form should not be modified if copy_form is not set
 """
 if schema is None:
-log.debug(_(u"unspecified schema, we need to request it"))
+log.debug(_("unspecified schema, we need to request it"))
 schema = yield self.getSchema(client, service, nodeIdentifier)
 if schema is None:
 raise exceptions.DataError(
 _(
-u"no schema specified, and this node has no schema either, we can't construct the data form"
+"no schema specified, and this node has no schema either, we can't construct the data form"
 )
 )
 elif isinstance(schema, data_form.Form):
 if copy_form:
 schema = copy.deepcopy(schema)
 defer.returnValue(schema)
 try:
 form = data_form.Form.fromElement(schema)
 except data_form.Error as e:
-raise exceptions.DataError(_(u"Invalid Schema: {msg}").format(msg=e))
+raise exceptions.DataError(_("Invalid Schema: {msg}").format(msg=e))
 form.formType = form_type
 defer.returnValue(form)
 def schema2XMLUI(self, schema_elt):
 form = data_form.Form.fromElement(schema_elt)
 def _getUISchema(self, service, nodeIdentifier, default_node=None,
 profile_key=C.PROF_KEY_NONE):
 if not nodeIdentifier:
 if not default_node:
-raise ValueError(_(u"nodeIndentifier needs to be set"))
+raise ValueError(_("nodeIndentifier needs to be set"))
 nodeIdentifier = default_node
 client = self.host.getClient(profile_key)
 service = None if not service else jid.JID(service)
 d = self.getUISchema(client, service, nodeIdentifier)
 d.addCallback(lambda xmlui: xmlui.toXml())
 item_ids=None, sub_id=None, extra_dict=None,
 profile_key=C.PROF_KEY_NONE):
 client = self.host.getClient(profile_key)
 service = jid.JID(service) if service else None
 if not node:
-raise exceptions.DataError(_(u"empty node is not allowed"))
+raise exceptions.DataError(_("empty node is not allowed"))
 if schema:
 schema = generic.parseXml(schema.encode("utf-8"))
 else:
 schema = None
 max_items = None if max_items == C.NO_LIMIT else max_items
 @raise ValueError: one argument is invalid
 """
 if not nodeIdentifier:
 if not default_node:
 raise ValueError(
-_(u"default_node must be set if nodeIdentifier is not set")
+_("default_node must be set if nodeIdentifier is not set")
 )
 nodeIdentifier = default_node
 # we need the initial form to get options of fields when suitable
 schema_form = yield self.getSchemaForm(
 client, service, nodeIdentifier, schema, form_type="result", copy_form=False
 extra,
 )
 items, metadata = items_data
 items_xmlui = []
 for item_elt in items:
-for x_elt in item_elt.elements((data_form.NS_X_DATA, u"x")):
+for x_elt in item_elt.elements((data_form.NS_X_DATA, "x")):
 form = data_form.Form.fromElement(x_elt)
 if form_ns and form.formNamespace != form_ns:
 continue
 xmlui = xml_tools.dataFormResult2XMLUI(
 form,
 schema_form,
 # FIXME: conflicts with schema (i.e. if "id" or "publisher" already exists)
 #        are not checked
 prepend=(
 ("label", "id"),
-("text", item_elt["id"], u"id"),
+("text", item_elt["id"], "id"),
 ("label", "publisher"),
-("text", item_elt.getAttribute("publisher", ""), u"publisher"),
+("text", item_elt.getAttribute("publisher", ""), "publisher"),
 ),
 filters=filters,
 read_only=False,
 )
 items_xmlui.append(xmlui)
 schema,
 item_id or None,
 extra,
 deserialise=True,
 )
-d.addCallback(lambda ret: ret or u"")
+d.addCallback(lambda ret: ret or "")
 return d
 @defer.inlineCallbacks
 def sendDataFormItem(self, client, service, nodeIdentifier, values, schema=None,
 item_id=None, extra=None, deserialise=False):
 """
 form = yield self.getSchemaForm(
 client, service, nodeIdentifier, schema, form_type="submit"
 )
-for name, values_list in values.iteritems():
+for name, values_list in values.items():
 try:
 field = form.fields[name]
 except KeyError:
 log.warning(
-_(u"field {name} doesn't exist, ignoring it").format(name=name)
+_("field {name} doesn't exist, ignoring it").format(name=name)
 )
 continue
-if isinstance(values_list, basestring) or not isinstance(
+if isinstance(values_list, str) or not isinstance(
 values_list, Iterable
 ):
 values_list = [values_list]
 if deserialise:
-if field.fieldType == u"boolean":
+if field.fieldType == "boolean":
 values_list = [C.bool(v) for v in values_list]
-elif field.fieldType == u"text-multi":
+elif field.fieldType == "text-multi":
 # for text-multi, lines must be put on separate values
 values_list = list(
 itertools.chain(*[v.splitlines() for v in values_list])
 )
 elif xml_tools.isXHTMLField(field):
 values_list = [generic.parseXml(v.encode("utf-8"))
 for v in values_list]
-elif u"jid" in (field.fieldType or u""):
+elif "jid" in (field.fieldType or ""):
 values_list = [jid.JID(v) for v in values_list]
-if u"list" in (field.fieldType or u""):
+if "list" in (field.fieldType or ""):
 # for lists, we check that given values are allowed in form
 allowed_values = [o.value for o in field.options]
 values_list = [v for v in values_list if v in allowed_values]
 if not values_list:
 # if values don't map to allowed values, we use default ones
 def textbox2ListFilter(self, form_xmlui, widget_type, args, kwargs):
 """Split lines of a textbox in a list
 main use case is using a textbox for labels
 """
-if widget_type != u"textbox":
+if widget_type != "textbox":
 return widget_type, args, kwargs
-widget_type = u"list"
+widget_type = "list"
-options = [o for o in args.pop(0).split(u"\n") if o]
+options = [o for o in args.pop(0).split("\n") if o]
 kwargs = {
 "options": options,
 "name": kwargs.get("name"),
-"styles": (u"noselect", u"extensible", u"reducible"),
+"styles": ("noselect", "extensible", "reducible"),
 }
 return widget_type, args, kwargs
 def dateFilter(self, form_xmlui, widget_type, args, kwargs):
 """Convert a string with a date to a unix timestamp"""
-if widget_type != u"string" or not args[0]:
+if widget_type != "string" or not args[0]:
 return widget_type, args, kwargs
 # we convert XMPP date to timestamp
 try:
-args[0] = unicode(date_utils.date_parse(args[0]))
+args[0] = str(date_utils.date_parse(args[0]))
 except Exception as e:
-log.warning(_(u"Can't parse date field: {msg}").format(msg=e))
+log.warning(_("Can't parse date field: {msg}").format(msg=e))
 return widget_type, args, kwargs
 ## Helper methods ##
 def prepareBridgeGet(self, service, node, max_items, sub_id, extra_dict, profile_key):
 extra = {}
 # XXX: Q&D way to get list for labels when displaying them, but text when we
 #      have to modify them
 if C.bool(extra.get("labels_as_list", C.BOOL_FALSE)):
 filters = filters.copy()
-filters[u"labels"] = self.textbox2ListFilter
+filters["labels"] = self.textbox2ListFilter
 client, service, node, max_items, extra, sub_id = self.prepareBridgeGet(
 service, node, max_items, sub_id, extra, profile_key
 )
 d = self.getDataFormItems(
 client,
 client, service, node, item_ids=[item_id]
 )
 item_elt = items_data[0][0]
 except Exception as e:
 log.warning(
-_(u"Can't get previous item, update ignored: {reason}").format(
+_("Can't get previous item, update ignored: {reason}").format(
 reason=e
 )
 )
 else:
 # and parse it
 form = data_form.findForm(item_elt, form_ns)
 if form is None:
 log.warning(
 _(
-u"Can't parse previous item, update ignored: data form not found"
+"Can't parse previous item, update ignored: data form not found"
 ).format(reason=e)
 )
 else:
-for name, field in form.fields.iteritems():
+for name, field in form.fields.items():
 if name not in values:
-values[name] = u"\n".join(unicode(v) for v in field.values)
+values[name] = "\n".join(str(v) for v in field.values)
 def _set(self, service, node, values, schema=None, item_id=None, extra=None,
 default_node=None, form_ns=None, fill_author=True,
 profile_key=C.PROF_KEY_NONE):
 """Bridge method to set item in node with schema
 deserialise=True,
 form_ns=form_ns,
 default_node=default_node,
 fill_author=fill_author,
 )
-d.addCallback(lambda ret: ret or u"")
+d.addCallback(lambda ret: ret or "")
 return d
 @defer.inlineCallbacks
 def set(self, client, service, node, values, schema, item_id, extra, deserialise,
 form_ns, default_node=None, fill_author=True):
 """
 if extra is None:
 extra = {}
 if not node:
 if default_node is None:
-raise ValueError(_(u"default_node must be set if node is not set"))
+raise ValueError(_("default_node must be set if node is not set"))
 node = default_node
 now = utils.xmpp_date()
 if not item_id:
 values["created"] = now
-elif extra.get(u"update", False):
+elif extra.get("update", False):
 if item_id is None:
 raise exceptions.DataError(
-_(u'if extra["update"] is set, item_id must be set too')
+_('if extra["update"] is set, item_id must be set too')
 )
 yield self.copyMissingValues(client, service, node, item_id, form_ns, values)
 values["updated"] = now
 if fill_author:
 client, service, node, values, schema, item_id, extra, deserialise
 )
 defer.returnValue(item_id)
+@implementer(iwokkel.IDisco)
 class SchemaHandler(XMPPHandler):
-implements(iwokkel.IDisco)
 def getDiscoInfo(self, requestor, service, nodeIdentifier=""):
 return [disco.DiscoFeature(NS_SCHEMA)]
 def getDiscoItems(self, requestor, service, nodeIdentifier=""):

Mercurial > libervia-backend

comparison sat/plugins/plugin_exp_pubsub_schema.py @ 3028:ab2696e34d29