libervia-backend: sat/tools/xml

comparison sat/tools/xml_tools.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	e2cb04b381bb
children	9d0df638c8b4

comparison

equal deleted inserted replaced

-:ff5bcb12ae60
+:ab2696e34d29
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # SAT: a jabber client
 # Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org)
 from twisted.words.xish import domish
 from twisted.words.protocols.jabber import jid
 from twisted.internet import defer
 from sat.core import exceptions
 from collections import OrderedDict
-from copy import deepcopy
+import html.entities
-import htmlentitydefs
 import re
 """This library help manage XML used in SàT (parameters, registration, etc)"""
 SAT_FORM_PREFIX = "SAT_FORM_"
 """
 widget_args = [field.value]
 widget_kwargs = {}
 if field.fieldType is None and field.ext_type is not None:
 # we have an extended field
-if field.ext_type == u"xml":
+if field.ext_type == "xml":
 element = field.value
 if element.uri == C.NS_XHTML:
 widget_type = "xhtmlbox"
 widget_args[0] = element.toXml()
 widget_kwargs["read_only"] = read_only
 else:
-log.warning(u"unknown XML element, falling back to textbox")
+log.warning("unknown XML element, falling back to textbox")
 widget_type = "textbox"
 widget_args[0] = element.toXml()
 widget_kwargs["read_only"] = read_only
 else:
-raise exceptions.DataError(u"unknown extended type {ext_type}".format(
+raise exceptions.DataError("unknown extended type {ext_type}".format(
 ext_type = field.ext_type))
 elif field.fieldType == "fixed" or field.fieldType is None:
 widget_type = "text"
 if field.value is None:
 if field.label is None:
-log.warning(_(u"Fixed field has neither value nor label, ignoring it"))
+log.warning(_("Fixed field has neither value nor label, ignoring it"))
 field.value = ""
 else:
 field.value = field.label
 field.label = None
 widget_args[0] = field.value
 elif field.fieldType == "jid-single":
 widget_type = "jid_input"
 widget_kwargs["read_only"] = read_only
 elif field.fieldType == "text-multi":
 widget_type = "textbox"
-widget_args[0] = u"\n".join(field.values)
+widget_args[0] = "\n".join(field.values)
 widget_kwargs["read_only"] = read_only
 elif field.fieldType == "hidden":
 widget_type = "hidden"
 elif field.fieldType == "text-private":
 widget_type = "password"
 ]
 widget_kwargs["selected"] = widget_args
 widget_args = []
 else:
 log.error(
-u"FIXME FIXME FIXME: Type [%s] is not managed yet by SàT" % field.fieldType
+"FIXME FIXME FIXME: Type [%s] is not managed yet by SàT" % field.fieldType
 )
 widget_type = "string"
 widget_kwargs["read_only"] = read_only
 if field.var:
 - headers (dict{unicode: unicode}): form headers (field labels and types)
 - xmlui_data (list[tuple]): list of (widget_type, widget_args, widget_kwargs)
 """
 headers = OrderedDict()
 try:
-reported_elt = form_xml.elements("jabber:x:data", "reported").next()
+reported_elt = next(form_xml.elements("jabber:x:data", "reported"))
 except StopIteration:
 raise exceptions.DataError(
 "Couldn't find expected <reported> tag in %s" % form_xml.toXml()
 )
 item_elts = form_xml.elements("jabber:x:data", "item")
 for item_elt in item_elts:
 for elt in item_elt.elements():
 if elt.name != "field":
-log.warning(u"Unexpected tag (%s)" % elt.name)
+log.warning("Unexpected tag (%s)" % elt.name)
 continue
 field = data_form.Field.fromElement(elt)
 xmlui_data.append(_dataFormField2XMLUIData(field))
 @return: XMLUI instance
 """
 # we deepcopy the form because _dataFormField2XMLUIData can modify the value
 # FIXME: check if it's really important, the only modified value seems to be
 #        the replacement of None by "" on fixed fields
-form = deepcopy(result_form)
+# form = deepcopy(result_form)
 form = result_form
-for name, field in form.fields.iteritems():
+for name, field in form.fields.items():
 try:
 base_field = base_form.fields[name]
 except KeyError:
 continue
 field.options = base_field.options[:]
 @param value: value to clean
 @return: value in a non DBus type (only clean string yet)
 """
 # XXX: must be removed when DBus types will no cause problems anymore
 # FIXME: should be cleaned inside D-Bus bridge itself
-if isinstance(value, basestring):
+if isinstance(value, str):
-return unicode(value)
+return str(value)
 return value
 def XMLUIResult2DataFormResult(xmlui_data):
 """ Extract form data from a XMLUI return.
 @param xmlui_data (dict): data returned by frontends for XMLUI form
 @return: dict of data usable by Wokkel's data form
 """
 ret = {}
-for key, value in xmlui_data.iteritems():
+for key, value in xmlui_data.items():
 if not key.startswith(SAT_FORM_PREFIX):
 continue
-if isinstance(value, basestring) and u'\n' in value:
+if isinstance(value, str) and '\n' in value:
 # data form expects multi-lines text to be in separated values
-value = value.split(u'\n')
+value = value.split('\n')
 ret[key[len(SAT_FORM_PREFIX) :]] = _cleanValue(value)
 return ret
 def formEscape(name):
 """Return escaped name for forms.
 @param name (unicode): form name
 @return: unicode
 """
-return u"%s%s" % (SAT_FORM_PREFIX, name)
+return "%s%s" % (SAT_FORM_PREFIX, name)
 def isXMLUICancelled(raw_xmlui):
 """Tell if an XMLUI has been cancelled by checking raw XML"""
-return C.bool(raw_xmlui.get(u'cancelled', C.BOOL_FALSE))
+return C.bool(raw_xmlui.get('cancelled', C.BOOL_FALSE))
 def XMLUIResultToElt(xmlui_data):
 """Construct result domish.Element from XMLUI result.
 @param option (string, tuple)
 @param selected (boolean)
 """
 assert isinstance(parent, ListWidget)
 super(OptionElement, self).__init__(parent.xmlui, parent)
-if isinstance(option, basestring):
+if isinstance(option, str):
 value, label = option, option
 elif isinstance(option, tuple):
 value, label = option
 else:
 raise NotImplementedError
 """
 assert isinstance(parent, JidsListWidget)
 super(JidElement, self).__init__(parent.xmlui, parent)
 if isinstance(jid_, jid.JID):
 value = jid_.full()
-elif isinstance(jid_, basestring):
+elif isinstance(jid_, str):
-value = unicode(jid_)
+value = str(jid_)
 else:
 raise NotImplementedError
 jid_txt = self.xmlui.doc.createTextNode(value)
 self.elem.appendChild(jid_txt)
 super(Widget, self).__init__(xmlui, parent)
 if name:
 self.elem.setAttribute("name", name)
 if name in xmlui.named_widgets:
 raise exceptions.ConflictError(
-_(u'A widget with the name "{name}" already exists.').format(
+_('A widget with the name "{name}" already exists.').format(
 name=name
 )
 )
 xmlui.named_widgets[name] = self
 self.elem.setAttribute("type", self.type)
 def __init__(self, xmlui, jid, name=None, parent=None):
 super(JidWidget, self).__init__(xmlui, name, parent)
 try:
 self.elem.setAttribute("value", jid.full())
 except AttributeError:
-self.elem.setAttribute("value", unicode(jid))
+self.elem.setAttribute("value", str(jid))
 class DividerWidget(Widget):
 type = "divider"
 word, set to False only if you made the XHTML yourself)
 """
 if clean:
 if cleanXHTML is None:
 raise exceptions.NotFound(
-u"No cleaning method set, can't clean the XHTML")
+"No cleaning method set, can't clean the XHTML")
 value = cleanXHTML(value)
 super(XHTMLBoxWidget, self).__init__(
 xmlui, value=value, name=name, parent=parent, read_only=read_only)
 FieldBackElement(self, field)
 class ListWidget(InputWidget):
 type = "list"
-STYLES = (u"multi", u"noselect", u"extensible", u"reducible", u"inline")
+STYLES = ("multi", "noselect", "extensible", "reducible", "inline")
 def __init__(
 self, xmlui, options, selected=None, styles=None, name=None, parent=None
 ):
 """
 styles = set() if styles is None else set(styles)
 if styles is None:
 styles = set()
 else:
 styles = set(styles)
-if u"noselect" in styles and (u"multi" in styles or selected):
+if "noselect" in styles and ("multi" in styles or selected):
 raise exceptions.DataError(
 _(
-u'"multi" flag and "selected" option are not compatible with '
+'"multi" flag and "selected" option are not compatible with '
-u'"noselect" flag'
+'"noselect" flag'
 )
 )
 if not options:
 # we can have no options if we get a submitted data form
 # but we can't use submitted values directly,
 self.setStyles(styles)
 def addOptions(self, options, selected=None):
 """Add options to a multi-values element (e.g. list) """
 if selected:
-if isinstance(selected, basestring):
+if isinstance(selected, str):
 selected = [selected]
 else:
 selected = []
 for option in options:
-assert isinstance(option, basestring) or isinstance(option, tuple)
+assert isinstance(option, str) or isinstance(option, tuple)
-value = option if isinstance(option, basestring) else option[0]
+value = option if isinstance(option, str) else option[0]
 OptionElement(self, option, value in selected)
 def setStyles(self, styles):
 if not styles.issubset(self.STYLES):
-raise exceptions.DataError(_(u"invalid styles"))
+raise exceptions.DataError(_("invalid styles"))
 for style in styles:
 self.elem.setAttribute(style, "yes")
 # TODO: check flags incompatibily (noselect and multi) like in __init__
 def setStyle(self, style):
 @property
 def value(self):
 """Return the value of first selected option"""
 for child in self.elem.childNodes:
-if child.tagName == u"option" and child.getAttribute(u"selected") == u"true":
+if child.tagName == "option" and child.getAttribute("selected") == "true":
-return child.getAttribute(u"value")
+return child.getAttribute("value")
-return u""
+return ""
 class JidsListWidget(InputWidget):
 """A list of text or jids where elements can be added/removed or modified"""
 C.XMLUI_DIALOG,
 ]:
 raise exceptions.DataError(_("Unknown panel type [%s]") % panel_type)
 if panel_type == C.XMLUI_FORM and submit_id is None:
 raise exceptions.DataError(_("form XMLUI need a submit_id"))
-if not isinstance(container, basestring):
+if not isinstance(container, str):
 raise exceptions.DataError(_("container argument must be a string"))
 if dialog_opt is not None and panel_type != C.XMLUI_DIALOG:
 raise exceptions.DataError(
 _("dialog_opt can only be used with dialog panels")
 )
 #        in bin/sat script then evaluated
 #        bin/sat should be refactored
 # log.debug(u'introspecting XMLUI widgets and containers')
 cls._containers = {}
 cls._widgets = {}
-for obj in globals().values():
+for obj in list(globals().values()):
 try:
 if issubclass(obj, Widget):
 if obj.__name__ == "Widget":
 continue
 cls._widgets[obj.type] = obj
-creator_name = u"add" + obj.__name__
+creator_name = "add" + obj.__name__
 if creator_name.endswith('Widget'):
 creator_name = creator_name[:-6]
 is_input = issubclass(obj, InputWidget)
 # FIXME: cf. above comment
 # log.debug(u"Adding {creator_name} creator (is_input={is_input}))"
 def changeContainer(self, container, **kwargs):
 """Change the current container
 @param container: either container type (container it then created),
 or an Container instance"""
-if isinstance(container, basestring):
+if isinstance(container, str):
 self.current_container = self._createContainer(
 container,
 self.current_container.getParentContainer() or self.main_container,
 **kwargs
 )
 profile=profile,
 )
 return xmlui_d
-def deferDialog(host, message, title=u"Please confirm", type_=C.XMLUI_DIALOG_CONFIRM,
+def deferDialog(host, message, title="Please confirm", type_=C.XMLUI_DIALOG_CONFIRM,
 options=None, action_extra=None, security_limit=C.NO_SECURITY_LIMIT, chained=False,
 profile=C.PROF_KEY_NONE):
 """Create a submitable dialog and manage it with a deferred
 @param message(unicode): message to display
 return new_elt
 def isXHTMLField(field):
 """Check if a data_form.Field is an XHTML one"""
-return (field.fieldType is None and field.ext_type == u"xml" and
+return (field.fieldType is None and field.ext_type == "xml" and
 field.value.uri == C.NS_XHTML)
 class ElementParser(object):
 """callable class to parse XML string into Element"""
 if entity in XML_ENTITIES:
 # we don't escape XML entities
 return matchobj.group(0)
 else:
 try:
-return unichr(htmlentitydefs.name2codepoint[entity])
+return chr(html.entities.name2codepoint[entity])
 except KeyError:
-log.warning(u"removing unknown entity {}".format(entity))
+log.warning("removing unknown entity {}".format(entity))
-return u""
+return ""
 def __call__(self, raw_xml, force_spaces=False, namespace=None):
 """
 @param raw_xml(unicode): the raw XML
 @param force_spaces (bool): if True, replace occurrences of '\n' and '\t'
 element
 """
 # we need to wrap element in case
 # there is not a unique one on the top
 if namespace is not None:
-raw_xml = u"<div xmlns='{}'>{}</div>".format(namespace, raw_xml)
+raw_xml = "<div xmlns='{}'>{}</div>".format(namespace, raw_xml)
 else:
-raw_xml = u"<div>{}</div>".format(raw_xml)
+raw_xml = "<div>{}</div>".format(raw_xml)
 # avoid ParserError on HTML escaped chars
 raw_xml = html_entity_re.sub(self._escapeHTML, raw_xml)
 self.result = None
 """
 data = []
 for child in node.childNodes:
 if child.nodeType == child.TEXT_NODE:
 data.append(child.wholeText)
-return u"".join(data)
+return "".join(data)
 def findAll(elt, namespaces=None, names=None):
 """Find child element at any depth matching criteria
 None to accept every names
 @param namespace(iterable[unicode], basestring, None): URIs to match
 None to accept every namespaces
 @return ((G)domish.Element): found elements
 """
-if isinstance(namespaces, basestring):
+if isinstance(namespaces, str):
 namespaces = tuple((namespaces,))
-if isinstance(names, basestring):
+if isinstance(names, str):
 names = tuple((names,))
 for child in elt.elements():
 if (
 domish.IElement.providedBy(child)

Mercurial > libervia-backend

comparison sat/tools/xml_tools.py @ 3028:ab2696e34d29