libervia-backend: sat/tools/xml

comparison sat/tools/xml_tools.py @ 2624:56f94936df1e

code style reformatting using black

author	Goffi <goffi@goffi.org>
date	Wed, 27 Jun 2018 20:14:46 +0200
parents	26edcf3a30eb
children	a55a14c3cbf4

comparison

equal deleted inserted replaced

-:49533de4540b
+:56f94936df1e
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 from sat.core.i18n import _
 from sat.core.constants import Const as C
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from xml.dom import minidom, NotFoundErr
 from wokkel import data_form
 from twisted.words.xish import domish
 """This library help manage XML used in SàT (parameters, registration, etc)"""
 SAT_FORM_PREFIX = "SAT_FORM_"
 SAT_PARAM_SEPARATOR = "_XMLUI_PARAM_"  # used to have unique elements names
-html_entity_re = re.compile(r'&([a-zA-Z]+?);')
+html_entity_re = re.compile(r"&([a-zA-Z]+?);")
-XML_ENTITIES = ('quot', 'amp', 'apos', 'lt', 'gt')
+XML_ENTITIES = ("quot", "amp", "apos", "lt", "gt")
 # TODO: move XMLUI stuff in a separate module
 # TODO: rewrite this with lxml or ElementTree or domish.Element: it's complicated and difficult to maintain with current minidom implementation
 # Helper functions
 def _dataFormField2XMLUIData(field, read_only=False):
 """Get data needed to create an XMLUI's Widget from Wokkel's data_form's Field.
 The attribute field can be modified (if it's fixed and it has no value).
 @param read_only (bool): if True and it makes sense, create a read only input widget
 @return: a tuple (widget_type, widget_args, widget_kwargs)
 """
 widget_args = [field.value]
 widget_kwargs = {}
-if field.fieldType == 'fixed' or field.fieldType is None:
+if field.fieldType == "fixed" or field.fieldType is None:
-widget_type = 'text'
+widget_type = "text"
 if field.value is None:
 if field.label is None:
 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 == 'text-single':
+elif field.fieldType == "text-single":
 widget_type = "string"
-widget_kwargs['read_only'] = read_only
+widget_kwargs["read_only"] = read_only
-elif field.fieldType == 'jid-single':
+elif field.fieldType == "jid-single":
 widget_type = "jid_input"
-widget_kwargs['read_only'] = read_only
+widget_kwargs["read_only"] = read_only
-elif field.fieldType == 'text-multi':
+elif field.fieldType == "text-multi":
 widget_type = "textbox"
-widget_args[0] = u'\n'.join(field.values)
+widget_args[0] = u"\n".join(field.values)
-widget_kwargs['read_only'] = read_only
+widget_kwargs["read_only"] = read_only
-elif field.fieldType == 'text-private':
+elif field.fieldType == "text-private":
 widget_type = "password"
-widget_kwargs['read_only'] = read_only
+widget_kwargs["read_only"] = read_only
-elif field.fieldType == 'boolean':
+elif field.fieldType == "boolean":
 widget_type = "bool"
 if widget_args[0] is None:
-widget_args[0] = 'false'
+widget_args[0] = "false"
-widget_kwargs['read_only'] = read_only
+widget_kwargs["read_only"] = read_only
-elif field.fieldType == 'integer':
+elif field.fieldType == "integer":
 widget_type = "integer"
-widget_kwargs['read_only'] = read_only
+widget_kwargs["read_only"] = read_only
-elif field.fieldType == 'list-single':
+elif field.fieldType == "list-single":
 widget_type = "list"
-widget_kwargs["options"] = [(option.value, option.label or option.value) for option in field.options]
+widget_kwargs["options"] = [
+(option.value, option.label or option.value) for option in field.options
+]
 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)
+log.error(
+u"FIXME FIXME FIXME: Type [%s] is not managed yet by SàT" % field.fieldType
+)
 widget_type = "string"
-widget_kwargs['read_only'] = read_only
+widget_kwargs["read_only"] = read_only
 if field.var:
 widget_kwargs["name"] = field.var
 return widget_type, widget_args, widget_kwargs
 @return: the completed XMLUI instance
 """
 if filters is None:
 filters = {}
 if form.instructions:
-form_ui.addText('\n'.join(form.instructions), 'instructions')
+form_ui.addText("\n".join(form.instructions), "instructions")
 form_ui.changeContainer("label")
 if prepend is not None:
 for widget_args in prepend:
 form_ui.addWidget(*widget_args)
 for field in form.fieldList:
-widget_type, widget_args, widget_kwargs = _dataFormField2XMLUIData(field, read_only)
+widget_type, widget_args, widget_kwargs = _dataFormField2XMLUIData(
+field, read_only
+)
 try:
-widget_filter = filters[widget_kwargs['name']]
+widget_filter = filters[widget_kwargs["name"]]
 except KeyError:
 pass
 else:
-widget_type, widget_args, widget_kwargs = widget_filter(form_ui, widget_type, widget_args, widget_kwargs)
+widget_type, widget_args, widget_kwargs = widget_filter(
+form_ui, widget_type, widget_args, widget_kwargs
+)
 label = field.label or field.var
 if label:
 form_ui.addLabel(label)
 else:
 form_ui.addEmpty()
 - 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 = form_xml.elements("jabber:x:data", "reported").next()
 except StopIteration:
-raise exceptions.DataError("Couldn't find expected <reported> tag in %s" % form_xml.toXml())
+raise exceptions.DataError(
+"Couldn't find expected <reported> tag in %s" % form_xml.toXml()
+)
 for elt in reported_elt.elements():
 if elt.name != "field":
 raise exceptions.DataError("Unexpected tag")
 name = elt["var"]
-label = elt.attributes.get('label', '')
+label = elt.attributes.get("label", "")
-type_ = elt.attributes.get('type')
+type_ = elt.attributes.get("type")
 headers[name] = (label, type_)
 if not headers:
 raise exceptions.DataError("No reported fields (see XEP-0004 §3.4)")
 xmlui_data = []
-item_elts = form_xml.elements('jabber:x:data', 'item')
+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':
+if elt.name != "field":
 log.warning(u"Unexpected tag (%s)" % elt.name)
 continue
 field = data_form.Field.fromElement(elt)
 xmlui_data.append(_dataFormField2XMLUIData(field))
 @param xmlui (XMLUI): the XMLUI where the AdvancedList will be added
 @param headers (dict{unicode: unicode}): form headers (field labels and types)
 @param xmlui_data (list[tuple]): list of (widget_type, widget_args, widget_kwargs)
 @return: the completed XMLUI instance
 """
-adv_list = AdvancedListContainer(xmlui, headers=headers, columns=len(headers), parent=xmlui.current_container)
+adv_list = AdvancedListContainer(
+xmlui, headers=headers, columns=len(headers), parent=xmlui.current_container
+)
 xmlui.changeContainer(adv_list)
 for widget_type, widget_args, widget_kwargs in xmlui_data:
 xmlui.addWidget(widget_type, *widget_args, **widget_kwargs)
 except exceptions.DataError:
 parsed_form = data_form.Form.fromElement(form_elt)
 dataForm2Widgets(xml_ui, parsed_form, read_only=True)
 return xml_ui
-def dataFormResult2XMLUI(result_form, base_form, session_id=None, prepend=None, filters=None):
+def dataFormResult2XMLUI(
+result_form, base_form, session_id=None, prepend=None, filters=None
+):
 """Convert data form result to SàT XMLUI.
 @param result_form (data_form.Form): result form to convert
 @param base_form (data_form.Form): initial form (i.e. of form type "form")
 this one is necessary to reconstruct options when needed (e.g. list elements)
 """ 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
 """
-return {key[len(SAT_FORM_PREFIX):]: _cleanValue(value) for key, value in xmlui_data.iteritems() if key.startswith(SAT_FORM_PREFIX)}
+return {
+key[len(SAT_FORM_PREFIX) :]: _cleanValue(value)
+for key, value in xmlui_data.iteritems()
+if key.startswith(SAT_FORM_PREFIX)
+}
 def formEscape(name):
 """Return escaped name for forms.
 """Construct result domish.Element from XMLUI result.
 @param xmlui_data (dict): data returned by frontends for XMLUI form
 @return: domish.Element
 """
-form = data_form.Form('submit')
+form = data_form.Form("submit")
 form.makeFields(XMLUIResult2DataFormResult(xmlui_data))
 return form.toElement()
 def tupleList2dataForm(values):
 """Convert a list of tuples (name, value) to a wokkel submit data form.
 @param values (list): list of tuples
 @return: data_form.Form
 """
-form = data_form.Form('submit')
+form = data_form.Form("submit")
 for value in values:
 field = data_form.Field(var=value[0], value=value[1])
 form.addField(field)
 return form
 @param xml (unicode)
 @return: XMLUI
 """
 # TODO: refactor params and use Twisted directly to parse XML
-params_doc = minidom.parseString(xml.encode('utf-8'))
+params_doc = minidom.parseString(xml.encode("utf-8"))
 top = params_doc.documentElement
-if top.nodeName != 'params':
+if top.nodeName != "params":
-raise exceptions.DataError(_('INTERNAL ERROR: parameters xml not valid'))
+raise exceptions.DataError(_("INTERNAL ERROR: parameters xml not valid"))
 param_ui = XMLUI("param", "tabs")
 tabs_cont = param_ui.current_container
 for category in top.getElementsByTagName("category"):
-category_name = category.getAttribute('name')
+category_name = category.getAttribute("name")
-label = category.getAttribute('label')
+label = category.getAttribute("label")
 if not category_name:
-raise exceptions.DataError(_('INTERNAL ERROR: params categories must have a name'))
+raise exceptions.DataError(
+_("INTERNAL ERROR: params categories must have a name")
+)
 tabs_cont.addTab(category_name, label=label, container=LabelContainer)
 for param in category.getElementsByTagName("param"):
 widget_kwargs = {}
-param_name = param.getAttribute('name')
+param_name = param.getAttribute("name")
-param_label = param.getAttribute('label')
+param_label = param.getAttribute("label")
-type_ = param.getAttribute('type')
+type_ = param.getAttribute("type")
-if not param_name and type_ != 'text':
+if not param_name and type_ != "text":
-raise exceptions.DataError(_('INTERNAL ERROR: params must have a name'))
+raise exceptions.DataError(_("INTERNAL ERROR: params must have a name"))
-value = param.getAttribute('value') or None
+value = param.getAttribute("value") or None
-callback_id = param.getAttribute('callback_id') or None
+callback_id = param.getAttribute("callback_id") or None
-if type_ == 'list':
+if type_ == "list":
 options, selected = _paramsGetListOptions(param)
-widget_kwargs['options'] = options
+widget_kwargs["options"] = options
-widget_kwargs['selected'] = selected
+widget_kwargs["selected"] = selected
-widget_kwargs['styles'] = ['extensible']
+widget_kwargs["styles"] = ["extensible"]
-elif type_ == 'jids_list':
+elif type_ == "jids_list":
-widget_kwargs['jids'] = _paramsGetListJids(param)
+widget_kwargs["jids"] = _paramsGetListJids(param)
 if type_ in ("button", "text"):
 param_ui.addEmpty()
 value = param_label
 else:
 if value:
 widget_kwargs["value"] = value
 if callback_id:
-widget_kwargs['callback_id'] = callback_id
+widget_kwargs["callback_id"] = callback_id
-others = ["%s%s%s" % (category_name, SAT_PARAM_SEPARATOR, other.getAttribute('name'))
+others = [
-for other in category.getElementsByTagName('param')
+"%s%s%s"
-if other.getAttribute('type') != 'button']
+% (category_name, SAT_PARAM_SEPARATOR, other.getAttribute("name"))
-widget_kwargs['fields_back'] = others
+for other in category.getElementsByTagName("param")
+if other.getAttribute("type") != "button"
-widget_kwargs['name'] = "%s%s%s" % (category_name, SAT_PARAM_SEPARATOR, param_name)
+]
+widget_kwargs["fields_back"] = others
+widget_kwargs["name"] = "%s%s%s" % (
+category_name,
+SAT_PARAM_SEPARATOR,
+param_name,
+)
 param_ui.addWidget(type_, **widget_kwargs)
 return param_ui.toXml()
 The <option/> tags must be direct children of <param/>.
 @param param (domish.Element): element
 @return: a tuple (options, selected_value)
 """
 if len(param.getElementsByTagName("options")) > 0:
-raise exceptions.DataError(_("The 'options' tag is not allowed in parameter of type 'list'!"))
+raise exceptions.DataError(
+_("The 'options' tag is not allowed in parameter of type 'list'!")
+)
 elems = param.getElementsByTagName("option")
 if len(elems) == 0:
 return []
 options = [elem.getAttribute("value") for elem in elems]
-selected = [elem.getAttribute("value") for elem in elems if elem.getAttribute("selected") == 'true']
+selected = [
+elem.getAttribute("value")
+for elem in elems
+if elem.getAttribute("selected") == "true"
+]
 return (options, selected)
 def _paramsGetListJids(param):
 """Retrive jids from a jids_list element.
 the <jid/> tags must be direct children of <param/>
 @param param (domish.Element): element
 @return: a list of jids
 """
 elems = param.getElementsByTagName("jid")
-jids = [elem.firstChild.data for elem in elems
+jids = [
-if elem.firstChild is not None
+elem.firstChild.data
-and elem.firstChild.nodeType == elem.TEXT_NODE]
+for elem in elems
+if elem.firstChild is not None and elem.firstChild.nodeType == elem.TEXT_NODE
+]
 return jids
 ### XMLUI Elements ###
 class Element(object):
 """ Base XMLUI element """
 type = None
 def __init__(self, xmlui, parent=None):
 """Create a container element
 @param xmlui: XMLUI instance
 @parent: parent element
 """
 assert self.type is not None
 self.children = []
-if not hasattr(self, 'elem'):
+if not hasattr(self, "elem"):
 self.elem = parent.xmlui.doc.createElement(self.type)
 self.xmlui = xmlui
 if parent is not None:
 parent.append(self)
 self.parent = parent
 return child
 class TopElement(Element):
 """ Main XML Element """
-type = 'top'
+type = "top"
 def __init__(self, xmlui):
 self.elem = xmlui.doc.documentElement
 super(TopElement, self).__init__(xmlui)
 class TabElement(Element):
 """ Used by TabsContainer to give name and label to tabs."""
-type = 'tab'
+type = "tab"
 def __init__(self, parent, name, label, selected=False):
 """
 @param parent (TabsContainer): parent container
 @param selected (bool): set to True to select this tab
 """
 if not isinstance(parent, TabsContainer):
 raise exceptions.DataError(_("TabElement must be a child of TabsContainer"))
 super(TabElement, self).__init__(parent.xmlui, parent)
-self.elem.setAttribute('name', name)
+self.elem.setAttribute("name", name)
-self.elem.setAttribute('label', label)
+self.elem.setAttribute("label", label)
 if selected:
 self.setSelected(selected)
 def setSelected(self, selected=False):
 """Set the tab selected.
 @param selected (bool): set to True to select this tab
 """
-self.elem.setAttribute('selected', 'true' if selected else 'false')
+self.elem.setAttribute("selected", "true" if selected else "false")
 class FieldBackElement(Element):
 """ Used by ButtonWidget to indicate which field have to be sent back """
-type = 'field_back'
+type = "field_back"
 def __init__(self, parent, name):
 assert isinstance(parent, ButtonWidget)
 super(FieldBackElement, self).__init__(parent.xmlui, parent)
-self.elem.setAttribute('name', name)
+self.elem.setAttribute("name", name)
 class InternalFieldElement(Element):
 """ Used by internal callbacks to indicate which fields are manipulated """
-type = 'internal_field'
+type = "internal_field"
 def __init__(self, parent, name):
 super(InternalFieldElement, self).__init__(parent.xmlui, parent)
-self.elem.setAttribute('name', name)
+self.elem.setAttribute("name", name)
 class InternalDataElement(Element):
 """ Used by internal callbacks to retrieve extra data """
-type = 'internal_data'
+type = "internal_data"
 def __init__(self, parent, children):
 super(InternalDataElement, self).__init__(parent.xmlui, parent)
 assert isinstance(children, list)
 for child in children:
 self.elem.childNodes.append(child)
 class OptionElement(Element):
 """" Used by ListWidget to specify options """
-type = 'option'
+type = "option"
 def __init__(self, parent, option, selected=False):
 """
 @param parent
 value, label = option, option
 elif isinstance(option, tuple):
 value, label = option
 else:
 raise NotImplementedError
-self.elem.setAttribute('value', value)
+self.elem.setAttribute("value", value)
-self.elem.setAttribute('label', label)
+self.elem.setAttribute("label", label)
 if selected:
-self.elem.setAttribute('selected', 'true')
+self.elem.setAttribute("selected", "true")
 class JidElement(Element):
 """" Used by JidsListWidget to specify jids"""
-type = 'jid'
+type = "jid"
 def __init__(self, parent, jid_):
 """
 @param jid_(jid.JID, unicode): jid to append
 """
 self.elem.appendChild(jid_txt)
 class RowElement(Element):
 """" Used by AdvancedListContainer """
-type = 'row'
+type = "row"
 def __init__(self, parent):
 assert isinstance(parent, AdvancedListContainer)
 super(RowElement, self).__init__(parent.xmlui, parent)
 if parent.next_row_idx is not None:
 if parent.auto_index:
 raise exceptions.DataError(_("Can't set row index if auto_index is True"))
-self.elem.setAttribute('index', parent.next_row_idx)
+self.elem.setAttribute("index", parent.next_row_idx)
 parent.next_row_idx = None
 class HeaderElement(Element):
 """" Used by AdvancedListContainer """
-type = 'header'
+type = "header"
 def __init__(self, parent, name=None, label=None, description=None):
 """
 @param parent: AdvancedListContainer instance
 @param name: name of the container
 @param description: long descriptive text
 """
 assert isinstance(parent, AdvancedListContainer)
 super(HeaderElement, self).__init__(parent.xmlui, parent)
 if name:
-self.elem.setAttribute('name', name)
+self.elem.setAttribute("name", name)
 if label:
-self.elem.setAttribute('label', label)
+self.elem.setAttribute("label", label)
 if description:
-self.elem.setAttribute('description', description)
+self.elem.setAttribute("description", description)
 ## Containers ##
 class Container(Element):
 """ And Element which contains other ones and has a layout """
 type = None
 def __init__(self, xmlui, parent=None):
 """Create a container element
 @param xmlui: XMLUI instance
 @parent: parent element or None
 """
-self.elem = xmlui.doc.createElement('container')
+self.elem = xmlui.doc.createElement("container")
 super(Container, self).__init__(xmlui, parent)
-self.elem.setAttribute('type', self.type)
+self.elem.setAttribute("type", self.type)
 def getParentContainer(self):
 """ Return first parent container
 @return: parent container or None
 """
 current = self.parent
-while(not isinstance(current, (Container)) and
+while not isinstance(current, (Container)) and current is not None:
-current is not None):
 current = current.parent
 return current
 class VerticalContainer(Container):
 self.xmlui.changeContainer(parent_container)
 class AdvancedListContainer(Container):
 """A list which can contain other widgets, headers, etc"""
 type = "advanced_list"
-def __init__(self, xmlui, callback_id=None, name=None, headers=None, items=None, columns=None, selectable='no', auto_index=False, parent=None):
+def __init__(
+self,
+xmlui,
+callback_id=None,
+name=None,
+headers=None,
+items=None,
+columns=None,
+selectable="no",
+auto_index=False,
+parent=None,
+):
 """Create an advanced list
 @param headers: optional headers information
 @param callback_id: id of the method to call when selection is done
 @param items: list of widgets to add (just the first row)
 'no': nothing is done
 'single': one row can be selected
 @param auto_index: if True, indexes will be generated by frontends, starting from 0
 @return: created element
 """
-assert selectable in ('no', 'single')
+assert selectable in ("no", "single")
 if not items and columns is None:
 raise exceptions.DataError(_("either items or columns need do be filled"))
 if headers is None:
 headers = []
 if items is None:
 self._columns = columns
 self._item_idx = 0
 self.current_row = None
 if headers:
 if len(headers) != self._columns:
-raise exceptions.DataError(_("Headers lenght doesn't correspond to columns"))
+raise exceptions.DataError(
+_("Headers lenght doesn't correspond to columns")
+)
 self.addHeaders(headers)
 if items:
 self.addItems(items)
-self.elem.setAttribute('columns', str(self._columns))
+self.elem.setAttribute("columns", str(self._columns))
 if callback_id is not None:
-self.elem.setAttribute('callback', callback_id)
+self.elem.setAttribute("callback", callback_id)
-self.elem.setAttribute('selectable', selectable)
+self.elem.setAttribute("selectable", selectable)
 self.auto_index = auto_index
 if auto_index:
-self.elem.setAttribute('auto_index', 'true')
+self.elem.setAttribute("auto_index", "true")
 self.next_row_idx = None
 def addHeaders(self, headers):
 for header in headers:
 self.addHeader(header)
 @param xmlui: XMLUI instance
 @param name: name of the element or None
 @param parent: parent element or None
 """
-self.elem = xmlui.doc.createElement('widget')
+self.elem = xmlui.doc.createElement("widget")
 super(Widget, self).__init__(xmlui, parent)
 if name:
-self.elem.setAttribute('name', 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(name=name))
+raise exceptions.ConflictError(
+_(u'A widget with the name "{name}" already exists.').format(
+name=name
+)
+)
 xmlui.named_widgets[name] = self
-self.elem.setAttribute('type', self.type)
+self.elem.setAttribute("type", self.type)
 def setInternalCallback(self, callback, fields, data_elts=None):
 """Set an internal UI callback when the widget value is changed.
 The internal callbacks are NO callback ids, they are strings from
 to which the JID selected in A belongs.
 - more operation to be added when necessary...
 @param fields (list): a list of widget names (string)
 @param data_elts (list[Element]): extra data elements
 """
-self.elem.setAttribute('internal_callback', callback)
+self.elem.setAttribute("internal_callback", callback)
 if fields:
 for field in fields:
 InternalFieldElement(self, field)
 if data_elts:
 InternalDataElement(self, data_elts)
 class EmptyWidget(Widget):
 """Place holder widget"""
-type = 'empty'
+type = "empty"
 class TextWidget(Widget):
 """Used for blob of text"""
-type = 'text'
+type = "text"
 def __init__(self, xmlui, value, name=None, parent=None):
 super(TextWidget, self).__init__(xmlui, name, parent)
-value_elt = self.xmlui.doc.createElement('value')
+value_elt = self.xmlui.doc.createElement("value")
 text = self.xmlui.doc.createTextNode(value)
 value_elt.appendChild(text)
 self.elem.appendChild(value_elt)
 @property
 class LabelWidget(Widget):
 """One line blob of text
 used most of time to display the desciption or name of the next widget
 """
-type = 'label'
+type = "label"
 def __init__(self, xmlui, label, name=None, parent=None):
 super(LabelWidget, self).__init__(xmlui, name, parent)
-self.elem.setAttribute('value', label)
+self.elem.setAttribute("value", label)
 class JidWidget(Widget):
 """Used to display a Jabber ID, some specific methods can be added"""
-type = 'jid'
+type = "jid"
 def __init__(self, xmlui, jid, name=None, parent=None):
 super(JidWidget, self).__init__(xmlui, name, parent)
 try:
-self.elem.setAttribute('value', jid.full())
+self.elem.setAttribute("value", jid.full())
 except AttributeError:
-self.elem.setAttribute('value', unicode(jid))
+self.elem.setAttribute("value", unicode(jid))
 class DividerWidget(Widget):
-type = 'divider'
+type = "divider"
-def __init__(self, xmlui, style='line', name=None, parent=None):
+def __init__(self, xmlui, style="line", name=None, parent=None):
 """ Create a divider
 @param xmlui: XMLUI instance
 @param style: one of:
 - line: a simple line
 @param name: name of the widget
 @param parent: parent container
 """
 super(DividerWidget, self).__init__(xmlui, name, parent)
-self.elem.setAttribute('style', style)
+self.elem.setAttribute("style", style)
 ### Inputs ###
 class InputWidget(Widget):
 """Widget which can accept user inputs
 used mainly in forms
 """
 def __init__(self, xmlui, name=None, parent=None, read_only=False):
 super(InputWidget, self).__init__(xmlui, name, parent)
 if read_only:
-self.elem.setAttribute('read_only', 'true')
+self.elem.setAttribute("read_only", "true")
 class StringWidget(InputWidget):
-type = 'string'
+type = "string"
 def __init__(self, xmlui, value=None, name=None, parent=None, read_only=False):
 super(StringWidget, self).__init__(xmlui, name, parent, read_only=read_only)
 if value:
-value_elt = self.xmlui.doc.createElement('value')
+value_elt = self.xmlui.doc.createElement("value")
 text = self.xmlui.doc.createTextNode(value)
 value_elt.appendChild(text)
 self.elem.appendChild(value_elt)
 @property
 def value(self):
 return self.elem.firstChild.firstChild.wholeText
 class PasswordWidget(StringWidget):
-type = 'password'
+type = "password"
 class TextBoxWidget(StringWidget):
-type = 'textbox'
+type = "textbox"
 class JidInputWidget(StringWidget):
-type = 'jid_input'
+type = "jid_input"
 # TODO handle min and max values
 class IntWidget(StringWidget):
-type = 'int'
+type = "int"
 def __init__(self, xmlui, value=0, name=None, parent=None, read_only=False):
 try:
 int(value)
 except ValueError:
 raise exceptions.DataError(_("Value must be an integer"))
 super(IntWidget, self).__init__(xmlui, value, name, parent, read_only=read_only)
 class BoolWidget(InputWidget):
-type = 'bool'
+type = "bool"
-def __init__(self, xmlui, value='false', name=None, parent=None, read_only=False):
+def __init__(self, xmlui, value="false", name=None, parent=None, read_only=False):
 if isinstance(value, bool):
-value = 'true' if value else 'false'
+value = "true" if value else "false"
-elif value == '0':
+elif value == "0":
-value = 'false'
+value = "false"
-elif value == '1':
+elif value == "1":
-value = 'true'
+value = "true"
-if value not in ('true', 'false'):
+if value not in ("true", "false"):
 raise exceptions.DataError(_("Value must be 0, 1, false or true"))
 super(BoolWidget, self).__init__(xmlui, name, parent, read_only=read_only)
-self.elem.setAttribute('value', value)
+self.elem.setAttribute("value", value)
 class ButtonWidget(Widget):
-type = 'button'
+type = "button"
-def __init__(self, xmlui, callback_id, value=None, fields_back=None, name=None, parent=None):
+def __init__(
+self, xmlui, callback_id, value=None, fields_back=None, name=None, parent=None
+):
 """Add a button
 @param callback_id: callback which will be called if button is pressed
 @param value: label of the button
 @param fields_back: list of names of field to give back when pushing the button
 @param parent: parent container
 """
 if fields_back is None:
 fields_back = []
 super(ButtonWidget, self).__init__(xmlui, name, parent)
-self.elem.setAttribute('callback', callback_id)
+self.elem.setAttribute("callback", callback_id)
 if value:
-self.elem.setAttribute('value', value)
+self.elem.setAttribute("value", value)
 for field in fields_back:
 FieldBackElement(self, field)
 class ListWidget(InputWidget):
-type = 'list'
+type = "list"
-STYLES = (u'multi', u'noselect', u'extensible', u'reducible', u'inline')
+STYLES = (u"multi", u"noselect", u"extensible", u"reducible", u"inline")
-def __init__(self, xmlui, options, selected=None, styles=None, name=None, parent=None):
+def __init__(
+self, xmlui, options, selected=None, styles=None, name=None, parent=None
+):
 """
 @param xmlui
 @param options (list[option]): each option can be given as:
 - a single string if the label and the value are the same
 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 u"noselect" in styles and (u"multi" in styles or selected):
-raise exceptions.DataError(_(u'"multi" flag and "selected" option are not compatible with "noselect" flag'))
+raise exceptions.DataError(
+_(
+u'"multi" flag and "selected" option are not compatible with "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,
 # because we would not have the labels
 log.warning(_('empty "options" list'))
 def setStyles(self, styles):
 if not styles.issubset(self.STYLES):
 raise exceptions.DataError(_(u"invalid styles"))
 for style in styles:
-self.elem.setAttribute(style, 'yes')
+self.elem.setAttribute(style, "yes")
 # TODO: check flags incompatibily (noselect and multi) like in __init__
 def setStyle(self, style):
 self.setStyles([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 == u"option" and child.getAttribute(u"selected") == u"true":
-return child.getAttribute(u'value')
+return child.getAttribute(u"value")
-return u''
+return u""
 class JidsListWidget(InputWidget):
 """A list of text or jids where elements can be added/removed or modified"""
-type = 'jids_list'
+type = "jids_list"
 def __init__(self, xmlui, jids, styles=None, name=None, parent=None):
 """
 @param xmlui
 @param name (string)
 @param parent
 """
 super(JidsListWidget, self).__init__(xmlui, name, parent)
 styles = set() if styles is None else set(styles)
-if not styles.issubset([]): # TODO
+if not styles.issubset([]):  # TODO
 raise exceptions.DataError(_("invalid styles"))
 for style in styles:
-self.elem.setAttribute(style, 'yes')
+self.elem.setAttribute(style, "yes")
 if not jids:
-log.debug('empty jids list')
+log.debug("empty jids list")
 else:
 self.addJids(jids)
 def addJids(self, jids):
 for jid_ in jids:
 ## Dialog Elements ##
 class DialogElement(Element):
 """Main dialog element """
-type = 'dialog'
+type = "dialog"
 def __init__(self, parent, type_, level=None):
 if not isinstance(parent, TopElement):
-raise exceptions.DataError(_("DialogElement must be a direct child of TopElement"))
+raise exceptions.DataError(
+_("DialogElement must be a direct child of TopElement")
+)
 super(DialogElement, self).__init__(parent.xmlui, parent)
 self.elem.setAttribute(C.XMLUI_DATA_TYPE, type_)
 self.elem.setAttribute(C.XMLUI_DATA_LVL, level or C.XMLUI_DATA_LVL_DEFAULT)
 class MessageElement(Element):
 """Element with the instruction message"""
 type = C.XMLUI_DATA_MESS
 def __init__(self, parent, message):
 if not isinstance(parent, DialogElement):
-raise exceptions.DataError(_("MessageElement must be a direct child of DialogElement"))
+raise exceptions.DataError(
+_("MessageElement must be a direct child of DialogElement")
+)
 super(MessageElement, self).__init__(parent.xmlui, parent)
 message_txt = self.xmlui.doc.createTextNode(message)
 self.elem.appendChild(message_txt)
 class ButtonsElement(Element):
 """Buttons element which indicate which set to use"""
-type = 'buttons'
+type = "buttons"
 def __init__(self, parent, set_):
 if not isinstance(parent, DialogElement):
-raise exceptions.DataError(_("ButtonsElement must be a direct child of DialogElement"))
+raise exceptions.DataError(
+_("ButtonsElement must be a direct child of DialogElement")
+)
 super(ButtonsElement, self).__init__(parent.xmlui, parent)
-self.elem.setAttribute('set', set_)
+self.elem.setAttribute("set", set_)
 class FileElement(Element):
 """File element used for FileDialog"""
-type = 'file'
+type = "file"
 def __init__(self, parent, type_):
 if not isinstance(parent, DialogElement):
-raise exceptions.DataError(_("FileElement must be a direct child of DialogElement"))
+raise exceptions.DataError(
+_("FileElement must be a direct child of DialogElement")
+)
 super(FileElement, self).__init__(parent.xmlui, parent)
-self.elem.setAttribute('type', type_)
+self.elem.setAttribute("type", type_)
 ## XMLUI main class
 class XMLUI(object):
 """This class is used to create a user interface (form/window/parameters/etc) using SàT XML"""
-def __init__(self, panel_type="window", container="vertical", dialog_opt=None, title=None, submit_id=None, session_id=None):
+def __init__(
+self,
+panel_type="window",
+container="vertical",
+dialog_opt=None,
+title=None,
+submit_id=None,
+session_id=None,
+):
 """Init SàT XML Panel
 @param panel_type: one of
 - C.XMLUI_WINDOW (new window)
 - C.XMLUI_POPUP
 @param title: title or default if None
 @param submit_id: callback id to call for panel_type we can submit (form, param, dialog)
 @param session_id: use to keep a session attached to the dialog, must be returned by frontends
 @attribute named_widgets(dict): map from name to widget
 """
-self._introspect() # FIXME: why doing that on each XMLUI ? should be done once
+self._introspect()  # FIXME: why doing that on each XMLUI ? should be done once
-if panel_type not in [C.XMLUI_WINDOW, C.XMLUI_FORM, C.XMLUI_PARAM, C.XMLUI_POPUP, C.XMLUI_DIALOG]:
+if panel_type not in [
+C.XMLUI_WINDOW,
+C.XMLUI_FORM,
+C.XMLUI_PARAM,
+C.XMLUI_POPUP,
+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):
 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"))
+raise exceptions.DataError(
+_("dialog_opt can only be used with dialog panels")
+)
 self.type = panel_type
 impl = minidom.getDOMImplementation()
 self.doc = impl.createDocument(None, "sat_xmlui", None)
 top_element = self.doc.documentElement
 self._containers = {}
 self._widgets = {}
 for obj in globals().values():
 try:
 if issubclass(obj, Widget):
-if obj.__name__ == 'Widget':
+if obj.__name__ == "Widget":
 continue
 self._widgets[obj.type] = obj
 elif issubclass(obj, Container):
-if obj.__name__ == 'Container':
+if obj.__name__ == "Container":
 continue
 self._containers[obj.type] = obj
 except TypeError:
 pass
 def __del__(self):
 self.doc.unlink()
 def __getattr__(self, name):
-if name.startswith("add") and name not in ('addWidget',):  # addWidgetName(...) create an instance of WidgetName
+if name.startswith("add") and name not in (
+"addWidget",
+):  # addWidgetName(...) create an instance of WidgetName
 if self.type == C.XMLUI_DIALOG:
 raise exceptions.InternalError(_("addXXX can't be used with dialogs"))
 class_name = name[3:] + "Widget"
 if class_name in globals():
 cls = globals()[class_name]
 if issubclass(cls, Widget):
 def createWidget(*args, **kwargs):
 if "parent" not in kwargs:
 kwargs["parent"] = self.current_container
-if "name" not in kwargs and issubclass(cls, InputWidget):  # name can be given as first argument or in keyword arguments for InputWidgets
+if "name" not in kwargs and issubclass(
+cls, InputWidget
+):  # name can be given as first argument or in keyword arguments for InputWidgets
 args = list(args)
 kwargs["name"] = args.pop(0)
 return cls(self, *args, **kwargs)
 return createWidget
 return object.__getattribute__(self, name)
 @property
 def submit_id(self):
 else:
 raise exceptions.DataError("session_id can't be empty")
 def _createDialog(self, dialog_opt):
 dialog_type = dialog_opt.setdefault(C.XMLUI_DATA_TYPE, C.XMLUI_DIALOG_MESSAGE)
-if dialog_type in [C.XMLUI_DIALOG_CONFIRM, C.XMLUI_DIALOG_FILE] and self.submit_id is None:
+if (
-raise exceptions.InternalError(_("Submit ID must be filled for this kind of dialog"))
+dialog_type in [C.XMLUI_DIALOG_CONFIRM, C.XMLUI_DIALOG_FILE]
+and self.submit_id is None
+):
+raise exceptions.InternalError(
+_("Submit ID must be filled for this kind of dialog")
+)
 top_element = TopElement(self)
 level = dialog_opt.get(C.XMLUI_DATA_LVL)
 dialog_elt = DialogElement(top_element, dialog_type, level)
 try:
 """Change the current container
 @param container: either container type (container it then created),
 or an Container instance"""
 if isinstance(container, basestring):
-self.current_container = self._createContainer(container, self.current_container.getParentContainer() or self.main_container, **kwargs)
+self.current_container = self._createContainer(
+container,
+self.current_container.getParentContainer() or self.main_container,
+**kwargs
+)
 else:
-self.current_container = self.main_container if container is None else container
+self.current_container = (
+self.main_container if container is None else container
+)
 assert isinstance(self.current_container, Container)
 return self.current_container
 def addWidget(self, type_, *args, **kwargs):
 """Convenience method to add an element"""
 return self.doc.toxml()
 # Some sugar for XMLUI dialogs
-def note(message, title='', level=C.XMLUI_DATA_LVL_INFO):
+def note(message, title="", level=C.XMLUI_DATA_LVL_INFO):
 """sugar to easily create a Note Dialog
 @param message(unicode): body of the note
 @param title(unicode): title of the note
 @param level(unicode): one of C.XMLUI_DATA_LVL_*
 @return(XMLUI): instance of XMLUI
 """
-note_xmlui = XMLUI(C.XMLUI_DIALOG, dialog_opt={
+note_xmlui = XMLUI(
-C.XMLUI_DATA_TYPE: C.XMLUI_DIALOG_NOTE,
+C.XMLUI_DIALOG,
-C.XMLUI_DATA_MESS: message,
+dialog_opt={
-C.XMLUI_DATA_LVL: level},
+C.XMLUI_DATA_TYPE: C.XMLUI_DIALOG_NOTE,
-title=title
+C.XMLUI_DATA_MESS: message,
-)
+C.XMLUI_DATA_LVL: level,
+},
+title=title,
+)
 return note_xmlui
-def quickNote(host, client, message, title='', level=C.XMLUI_DATA_LVL_INFO):
+def quickNote(host, client, message, title="", level=C.XMLUI_DATA_LVL_INFO):
 """more sugar to do the whole note process"""
 note_ui = note(message, title, level)
-host.actionNew({'xmlui': note_ui.toXml()}, profile=client.profile)
+host.actionNew({"xmlui": note_ui.toXml()}, profile=client.profile)
 def deferredUI(host, xmlui, chained=False):
 """create a deferred linked to XMLUI
 Must be an XMLUI that you can submit, with submit_id set to ''
 @param chained(bool): True if the Deferred result must be returned to the frontend
 useful when backend is in a series of dialogs with an ui
 @return (D(data)): a deferred which fire the data
 """
-assert xmlui.submit_id == ''
+assert xmlui.submit_id == ""
 xmlui_d = defer.Deferred()
 def onSubmit(data, profile):
 xmlui_d.callback(data)
 return xmlui_d if chained else {}
 xmlui.submit_id = host.registerCallback(onSubmit, with_data=True, one_shot=True)
 return xmlui_d
-def deferXMLUI(host, xmlui, action_extra=None, security_limit=C.NO_SECURITY_LIMIT, chained=False, profile=C.PROF_KEY_NONE):
+def deferXMLUI(
+host,
+xmlui,
+action_extra=None,
+security_limit=C.NO_SECURITY_LIMIT,
+chained=False,
+profile=C.PROF_KEY_NONE,
+):
 """Create a deferred linked to XMLUI
 @param xmlui(XMLUI): instance of the XMLUI
 Must be an XMLUI that you can submit, with submit_id set to ''
 @param profile: %(doc_profile)s
 @param chained(bool): True if the Deferred result must be returned to the frontend
 useful when backend is in a series of dialogs with an ui
 @return (data): a deferred which fire the data
 """
 xmlui_d = deferredUI(host, xmlui, chained)
-action_data = {'xmlui': xmlui.toXml()}
+action_data = {"xmlui": xmlui.toXml()}
 if action_extra is not None:
 action_data.update(action_extra)
-host.actionNew(action_data, security_limit=security_limit, keep_id=xmlui.submit_id, profile=profile)
+host.actionNew(
+action_data,
+security_limit=security_limit,
+keep_id=xmlui.submit_id,
+profile=profile,
+)
 return xmlui_d
-def deferDialog(host, message, title=u'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):
+def deferDialog(
+host,
+message,
+title=u"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
 @param title(unicode): title of the dialog
 @param type(unicode): dialog type (C.XMLUI_DIALOG_*)
 useful when backend is in a series of dialogs with an ui
 @param profile: %(doc_profile)s
 @return (dict): Deferred dict
 """
 assert profile is not None
-dialog_opt = {'type': type_, 'message': message}
+dialog_opt = {"type": type_, "message": message}
 if options is not None:
 dialog_opt.update(options)
-dialog = XMLUI(C.XMLUI_DIALOG, title=title, dialog_opt=dialog_opt, submit_id='')
+dialog = XMLUI(C.XMLUI_DIALOG, title=title, dialog_opt=dialog_opt, submit_id="")
 return deferXMLUI(host, dialog, action_extra, security_limit, chained, profile)
 def deferConfirm(*args, **kwargs):
 """call deferDialog and return a boolean instead of the whole data dict"""
 d = deferDialog(*args, **kwargs)
-d.addCallback(lambda data: C.bool(data['answer']))
+d.addCallback(lambda data: C.bool(data["answer"]))
 return d
 # Misc other funtions
 class ElementParser(object):
 """callable class to parse XML string into Element"""
 # XXX: Found at http://stackoverflow.com/questions/2093400/how-to-create-twisted-words-xish-domish-element-entirely-from-raw-xml/2095942#2095942
 def _escapeHTML(self, matchobj):
 entity = matchobj.group(1)
 if entity in XML_ENTITIES:
 else:
 try:
 return unichr(htmlentitydefs.name2codepoint[entity])
 except KeyError:
 log.warning(u"removing unknown entity {}".format(entity))
-return u''
+return u""
 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' with ' '.
 parser.DocumentStartEvent = onStart
 parser.ElementEvent = onElement
 parser.DocumentEndEvent = onEnd
 tmp = domish.Element((None, "s"))
 if force_spaces:
-raw_xml = raw_xml.replace('\n', ' ').replace('\t', ' ')
+raw_xml = raw_xml.replace("\n", " ").replace("\t", " ")
 tmp.addRawXml(raw_xml)
-parser.parse(tmp.toXml().encode('utf-8'))
+parser.parse(tmp.toXml().encode("utf-8"))
 top_elt = self.result.firstChildElement()
 # we now can check if there was a unique element on the top
 # and remove our wrapping <div/> is this was the case
 if len(top_elt.children) == 1 and domish.IElement.providedBy(top_elt.children[0]):
 top_elt = top_elt.firstChildElement()
 for child in node.childNodes:
 if child.nodeType == child.TEXT_NODE:
 data.append(child.wholeText)
 return u"".join(data)
-def findAll(elt, namespaces=None, names=None, ):
+def findAll(elt, namespaces=None, names=None):
 """Find child element at any depth matching criteria
 @param elt(domish.Element): top parent of the elements to find
 @param names(iterable[unicode], basestring, None): names to match
 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):
-namespaces=tuple((namespaces,))
+namespaces = tuple((namespaces,))
 if isinstance(names, basestring):
-names=tuple((names,))
+names = tuple((names,))
 for child in elt.elements():
-if (domish.IElement.providedBy(child) and
+if (
-(not names or child.name in names) and
+domish.IElement.providedBy(child)
-(not namespaces or child.uri in namespaces)):
+and (not names or child.name in names)
+and (not namespaces or child.uri in namespaces)
+):
 yield child
 for found in findAll(child, namespaces, names):
 yield found

Mercurial > libervia-backend

comparison sat/tools/xml_tools.py @ 2624:56f94936df1e