libervia-backend: libervia/backend/tools/xml

comparison libervia/backend/tools/xml_tools.py @ 4270:0d7bb4df2343

Reformatted code base using black.

author	Goffi <goffi@goffi.org>
date	Wed, 19 Jun 2024 18:44:57 +0200
parents	b274f0d5c138
children	d2deddd6df44

comparison

equal deleted inserted replaced

-:64a85ce8be70
+:0d7bb4df2343
 widget_type = "textbox"
 widget_args[0] = element.toXml()
 widget_kwargs["read_only"] = read_only
 else:
-raise exceptions.DataError("unknown extended type {ext_type}".format(
+raise exceptions.DataError(
-ext_type = field.ext_type))
+"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:
 widget_type = "list"
 widget_kwargs["options"] = [
 (option.value, option.label or option.value) for option in field.options
 ]
 widget_kwargs["selected"] = widget_args
-widget_kwargs["styles"] =  ["multi"]
+widget_kwargs["styles"] = ["multi"]
 widget_args = []
 else:
 log.error(
 "FIXME FIXME FIXME: Type [%s] is not managed yet by SàT" % field.fieldType
 )
 if field.var:
 widget_kwargs["name"] = field.var
 return widget_type, widget_args, widget_kwargs
 def data_form_2_widgets(form_ui, form, read_only=False, prepend=None, filters=None):
 """Complete an existing XMLUI with widget converted from XEP-0004 data forms.
 @param form_ui (XMLUI): XMLUI instance
 """Convert data form to a simple dict, easily serialisable
 see data_dict_2_data_form for a description of the format
 """
 fields = []
-data_dict = {
+data_dict = {"fields": fields}
-"fields": fields
-}
 if form.formNamespace:
 data_dict["namespace"] = form.formNamespace
 for form_field in form.fieldList:
 field = {"type": form_field.fieldType}
 fields.append(field)
 for src_name, dest_name in (
-('var', 'name'),
+("var", "name"),
-('label', 'label'),
+("label", "label"),
-('value', 'value'),
+("value", "value"),
 # FIXME: we probably should have only "values"
-('values', 'values')
+("values", "values"),
 ):
 value = getattr(form_field, src_name, None)
 if value:
 field[dest_name] = value
 if form_field.options:
 opt["label"] = form_opt.label
 options.append(opt)
 if form_field.fieldType is None and form_field.ext_type == "xml":
 if isinstance(form_field.value, domish.Element):
-if ((form_field.value.uri == C.NS_XHTML
+if form_field.value.uri == C.NS_XHTML and form_field.value.name == "div":
-and form_field.value.name == "div")):
 field["type"] = "xhtml"
 if form_field.value.children:
 log.warning(
 "children are not managed for XHTML fields: "
 f"{form_field.value.toXml()}"
 - "required" is the same as data_form.Field.required
 """
 # TODO: describe format
 fields = []
 for field_data in data_dict["fields"]:
-field_type = field_data.get('type', 'text-single')
+field_type = field_data.get("type", "text-single")
 kwargs = {
 "fieldType": field_type,
 "var": field_data["name"],
-"label": field_data.get('label'),
+"label": field_data.get("label"),
 "value": field_data.get("value"),
-"required": field_data.get("required")
+"required": field_data.get("required"),
 }
 if field_type == "xhtml":
-kwargs.update({
+kwargs.update(
-"fieldType": None,
+{
-"ext_type": "xml",
+"fieldType": None,
-})
+"ext_type": "xml",
+}
+)
 if kwargs["value"] is None:
 kwargs["value"] = domish.Element((C.NS_XHTML, "div"))
 elif "options" in field_data:
 kwargs["options"] = [
 data_form.Option(o["value"], o.get("label"))
 for o in field_data["options"]
 ]
 field = data_form.Field(**kwargs)
 fields.append(field)
-return data_form.Form(
+return data_form.Form("form", formNamespace=data_dict.get("namespace"), fields=fields)
-"form",
-formNamespace=data_dict.get("namespace"),
-fields=fields
-)
 def data_form_elt_result_2_xmlui_data(form_xml):
 """Parse a data form result (not parsed by Wokkel's XEP-0004 implementation).
 parsed_form = data_form.Form.fromElement(form_elt)
 data_form_2_widgets(xml_ui, parsed_form, read_only=True)
 return xml_ui
-def data_form_result_2_xmlui(result_form, base_form, session_id=None, prepend=None,
+def data_form_result_2_xmlui(
-filters=None, read_only=True):
+result_form, base_form, session_id=None, prepend=None, filters=None, read_only=True
+):
 """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)
 @return: XMLUI instance
 """
 # we deepcopy the form because _data_form_field_2_xmlui_data 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.items():
 try:
 base_field = base_form.fields[name]
 except KeyError:
 continue
 field.options = base_field.options[:]
 xml_ui = XMLUI("window", "vertical", session_id=session_id)
-data_form_2_widgets(xml_ui, form, read_only=read_only, prepend=prepend, filters=filters)
+data_form_2_widgets(
+xml_ui, form, read_only=read_only, prepend=prepend, filters=filters
+)
 return xml_ui
 def _clean_value(value):
 """Workaround method to avoid DBus types with D-Bus bridge.
 return str(value)
 return value
 def xmlui_result_2_data_form_result(xmlui_data):
-""" Extract form data from a XMLUI return.
+"""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 = {}
 if not key.startswith(SAT_FORM_PREFIX):
 continue
 if isinstance(value, str):
 if "\n" in value:
 # data form expects multi-lines text to be in separated values
-value = value.split('\n')
+value = value.split("\n")
 elif "\t" in value:
 # FIXME: workaround to handle multiple values. Proper serialisation must
 #   be done in XMLUI
 value = value.split("\t")
 ret[key[len(SAT_FORM_PREFIX) :]] = _clean_value(value)
 return "%s%s" % (SAT_FORM_PREFIX, name)
 def is_xmlui_cancelled(raw_xmlui):
 """Tell if an XMLUI has been cancelled by checking raw XML"""
-return C.bool(raw_xmlui.get('cancelled', C.BOOL_FALSE))
+return C.bool(raw_xmlui.get("cancelled", C.BOOL_FALSE))
 def xmlui_result_to_elt(xmlui_data):
 """Construct result domish.Element from XMLUI result.
 ### XMLUI Elements ###
 class Element(object):
-""" Base XMLUI element """
+"""Base XMLUI element"""
 type = None
 def __init__(self, xmlui, parent=None):
 """Create a container element
 self.children.append(child)
 return child
 class TopElement(Element):
-""" Main XML Element """
+"""Main XML Element"""
 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."""
+"""Used by TabsContainer to give name and label to tabs."""
 type = "tab"
 def __init__(self, parent, name, label, selected=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 """
+"""Used by ButtonWidget to indicate which field have to be sent 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)
 class InternalFieldElement(Element):
-""" Used by internal callbacks to indicate which fields are manipulated """
+"""Used by internal callbacks to indicate which fields are manipulated"""
 type = "internal_field"
 def __init__(self, parent, name):
 super(InternalFieldElement, self).__init__(parent.xmlui, parent)
 self.elem.setAttribute("name", name)
 class InternalDataElement(Element):
-""" Used by internal callbacks to retrieve extra data """
+"""Used by internal callbacks to retrieve extra data"""
 type = "internal_data"
 def __init__(self, parent, children):
 super(InternalDataElement, self).__init__(parent.xmlui, parent)
 for child in children:
 self.elem.childNodes.append(child)
 class OptionElement(Element):
-"""" Used by ListWidget to specify options """
+""" " Used by ListWidget to specify options"""
 type = "option"
 def __init__(self, parent, option, selected=False):
 """
 if selected:
 self.elem.setAttribute("selected", "true")
 class JidElement(Element):
-"""" Used by JidsListWidget to specify jids"""
+""" " Used by JidsListWidget to specify jids"""
 type = "jid"
 def __init__(self, parent, jid_):
 """
 jid_txt = self.xmlui.doc.createTextNode(value)
 self.elem.appendChild(jid_txt)
 class RowElement(Element):
-"""" Used by AdvancedListContainer """
+""" " Used by AdvancedListContainer"""
 type = "row"
 def __init__(self, parent):
 assert isinstance(parent, AdvancedListContainer)
 self.elem.setAttribute("index", parent.next_row_idx)
 parent.next_row_idx = None
 class HeaderElement(Element):
-"""" Used by AdvancedListContainer """
+""" " Used by AdvancedListContainer"""
 type = "header"
 def __init__(self, parent, name=None, label=None, description=None):
 """
 ## Containers ##
 class Container(Element):
-""" And Element which contains other ones and has a layout """
+"""And Element which contains other ones and has a layout"""
 type = None
 def __init__(self, xmlui, parent=None):
 """Create a container element
 self.elem = xmlui.doc.createElement("container")
 super(Container, self).__init__(xmlui, parent)
 self.elem.setAttribute("type", self.type)
 def get_parent_container(self):
-""" Return first parent container
+"""Return first parent container
 @return: parent container or None
 """
 current = self.parent
 while not isinstance(current, (Container)) and current is not None:
 type = "horizontal"
 class PairsContainer(Container):
 """Container with series of 2 elements"""
 type = "pairs"
 class LabelContainer(Container):
 """Like PairsContainer, but first element can only be a label"""
 type = "label"
 class TabsContainer(Container):
 type = "tabs"
 tab_elt = TabElement(self, name, label, selected)
 new_container = container(self.xmlui, tab_elt)
 return self.xmlui.change_container(new_container)
 def end(self):
-""" Called when we have finished tabs
+"""Called when we have finished tabs
 change current container to first container parent
 """
 parent_container = self.get_parent_container()
 self.xmlui.change_container(parent_container)
 def add_items(self, items):
 for item in items:
 self.append(item)
 def set_row_index(self, idx):
-""" Set index for next row
+"""Set index for next row
 index are returned when a row is selected, in data's "index" key
 @param idx: string index to associate to the next row
 """
 self.next_row_idx = idx
 self.current_row = RowElement(self)
 self.current_row.append(child)
 self._item_idx += 1
 def end(self):
-""" Called when we have finished list
+"""Called when we have finished list
 change current container to first container parent
 """
 if self._item_idx % self._columns != 0:
 raise exceptions.DataError(_("Incorrect number of items in list"))
 super(Widget, self).__init__(xmlui, parent)
 if name:
 self.elem.setAttribute("name", name)
 if name in xmlui.named_widgets:
 raise exceptions.ConflictError(
-_('A widget with the name "{name}" already exists.').format(
+_('A widget with the name "{name}" already exists.').format(name=name)
-name=name
-)
 )
 xmlui.named_widgets[name] = self
 self.elem.setAttribute("type", self.type)
 def set_internal_callback(self, callback, fields, data_elts=None):
 class LabelWidget(Widget):
 """One line blob of text
 used most of time to display the desciption or name of the next widget
 """
 type = "label"
 def __init__(self, xmlui, label, name=None, parent=None):
 super(LabelWidget, self).__init__(xmlui, name, parent)
 self.elem.setAttribute("value", label)
 class HiddenWidget(Widget):
 """Not displayed widget, frontends will just copy the value(s)"""
 type = "hidden"
 def __init__(self, xmlui, value, name, parent=None):
 super(HiddenWidget, self).__init__(xmlui, name, parent)
 value_elt = self.xmlui.doc.createElement("value")
 class DividerWidget(Widget):
 type = "divider"
 def __init__(self, xmlui, style="line", name=None, parent=None):
-""" Create a divider
+"""Create a divider
 @param xmlui: XMLUI instance
 @param style: one of:
 - line: a simple line
 - dot: a line of dots
 type = "textbox"
 class XHTMLBoxWidget(StringWidget):
 """Specialized textbox to manipulate XHTML"""
 type = "xhtmlbox"
 def __init__(self, xmlui, value, name=None, parent=None, read_only=False, clean=True):
 """
 @param clean(bool): if True, the XHTML is considered insecure and will be cleaned
 Only set to False if you are absolutely sure that the XHTML is safe (in other
 word, set to False only if you made the XHTML yourself)
 """
 if clean:
 if clean_xhtml is None:
-raise exceptions.NotFound(
+raise exceptions.NotFound("No cleaning method set, can't clean the XHTML")
-"No cleaning method set, can't clean the XHTML")
 value = clean_xhtml(value)
 super(XHTMLBoxWidget, self).__init__(
-xmlui, value=value, name=name, parent=parent, read_only=read_only)
+xmlui, value=value, name=name, parent=parent, read_only=read_only
+)
 class JidInputWidget(StringWidget):
 type = "jid_input"
 super(ListWidget, self).__init__(xmlui, name, parent)
 self.add_options(options, selected)
 self.set_styles(styles)
 def add_options(self, options, selected=None):
-"""Add options to a multi-values element (e.g. list) """
+"""Add options to a multi-values element (e.g. list)"""
 if selected:
 if isinstance(selected, str):
 selected = [selected]
 else:
 selected = []
 ## Dialog Elements ##
 class DialogElement(Element):
-"""Main dialog element """
+"""Main dialog element"""
 type = "dialog"
 def __init__(self, parent, type_, level=None):
 if not isinstance(parent, TopElement):
 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,
+def __init__(
-title=None, submit_id=None, session_id=None):
+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
 def creator_wrapper(widget_cls, is_input):
 # TODO: once moved to Python 3, use functools.partialmethod and
 #       remove the creator_wrapper
 def create_widget(self, *args, **kwargs):
 if self.type == C.XMLUI_DIALOG:
-raise exceptions.InternalError(_(
+raise exceptions.InternalError(
-"create_widget can't be used with dialogs"))
+_("create_widget can't be used with dialogs")
+)
 if "parent" not in kwargs:
 kwargs["parent"] = self.current_container
 if "name" not in kwargs and is_input:
 # name can be given as first argument or in keyword
 # arguments for InputWidgets
 args = list(args)
 kwargs["name"] = args.pop(0)
 return widget_cls(self, *args, **kwargs)
 return create_widget
 @classmethod
 def _introspect(cls):
-""" Introspect module to find Widgets and Containers, and create addXXX methods"""
+"""Introspect module to find Widgets and Containers, and create addXXX methods"""
 # FIXME: we can't log anything because this file is used
 #        in bin/sat script then evaluated
 #        bin/sat should be refactored
 # log.debug(u'introspecting XMLUI widgets and containers')
 cls._containers = {}
 if issubclass(obj, Widget):
 if obj.__name__ == "Widget":
 continue
 cls._widgets[obj.type] = obj
 creator_name = "add" + obj.__name__
-if creator_name.endswith('Widget'):
+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}))"
 #     .format(creator_name=creator_name, is_input=is_input))
 or an Container instance"""
 if isinstance(container, str):
 self.current_container = self._create_container(
 container,
 self.current_container.get_parent_container() or self.main_container,
-**kwargs
+**kwargs,
 )
 else:
 self.current_container = (
 self.main_container if container is None else container
 )
 xmlui.submit_id = host.register_callback(on_submit, with_data=True, one_shot=True)
 return xmlui_d
-def defer_xmlui(host, xmlui, action_extra=None, security_limit=C.NO_SECURITY_LIMIT,
+def defer_xmlui(
-chained=False, profile=C.PROF_KEY_NONE):
+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
 type_: str = C.XMLUI_DIALOG_CONFIRM,
 options: Optional[dict] = None,
 action_extra: Optional[dict] = None,
 security_limit: int = C.NO_SECURITY_LIMIT,
 chained: bool = False,
-profile: str = C.PROF_KEY_NONE
+profile: str = C.PROF_KEY_NONE,
 ) -> defer.Deferred:
 """Create a submitable dialog and manage it with a deferred
 @param message: message to display
 @param title: title of the dialog
 return d
 # Misc other funtions
 def element_copy(
-element: domish.Element,
+element: domish.Element, with_parent: bool = True, with_children: bool = True
-with_parent: bool = True,
-with_children: bool = True
 ) -> domish.Element:
 """Make a copy of a domish.Element
 The copy will have its own children list, so other elements
 can be added as direct children without modifying orignal one.
 it will also affect original element.
 @param element: Element to clone
 """
 new_elt = domish.Element(
 (element.uri, element.name),
-defaultUri = element.defaultUri,
+defaultUri=element.defaultUri,
-attribs = element.attributes,
+attribs=element.attributes,
-localPrefixes = element.localPrefixes)
+localPrefixes=element.localPrefixes,
+)
 if with_parent:
 new_elt.parent = element.parent
 if with_children:
 new_elt.children = element.children[:]
 return new_elt
 def is_xhtml_field(field):
 """Check if a data_form.Field is an XHTML one"""
-return (field.fieldType is None and field.ext_type == "xml" and
+return (
-field.value.uri == C.NS_XHTML)
+field.fieldType is None
+and field.ext_type == "xml"
+and field.value.uri == C.NS_XHTML
+)
 class ElementParser:
 """Callable class to parse XML string into Element"""
 for found in find_all(child, namespaces, names):
 yield found
 def find_ancestor(
-elt,
+elt, name: str, namespace: Optional[Union[str, Iterable[str]]] = None
-name: str,
+) -> domish.Element:
-namespace: Optional[Union[str, Iterable[str]]] = None
-) -> domish.Element:
 """Retrieve ancestor of an element
 @param elt: starting element, its parent will be checked recursively until the
 required one if found
 @param name: name of the element to find
 def p_fmt_elt(elt, indent=0, defaultUri=""):
 """Pretty format a domish.Element"""
 strings = []
 for child in elt.children:
 if domish.IElement.providedBy(child):
-strings.append(p_fmt_elt(child, indent+2, defaultUri=elt.defaultUri))
+strings.append(p_fmt_elt(child, indent + 2, defaultUri=elt.defaultUri))
 else:
 strings.append(f"{(indent+2)*' '}{child!s}")
 if elt.children:
 nochild_elt = domish.Element(
 (elt.uri, elt.name), elt.defaultUri, elt.attributes, elt.localPrefixes
 )
 strings.insert(0, f"{indent*' '}{nochild_elt.toXml(defaultUri=defaultUri)[:-2]}>")
 strings.append(f"{indent*' '}</{nochild_elt.name}>")
 else:
 strings.append(f"{indent*' '}{elt.toXml(defaultUri=defaultUri)}")
-return '\n'.join(strings)
+return "\n".join(strings)
 def pp_elt(elt):
 """Pretty print a domish.Element"""
 print(p_fmt_elt(elt))
 # ElementTree
 def et_get_namespace_and_name(et_elt: ET.Element) -> Tuple[Optional[str], str]:
 """Retrieve element namespace and name from ElementTree element
 @param et_elt: ElementTree element
 elif name[0] != "{":
 return None, name
 end_idx = name.find("}")
 if end_idx == -1:
 raise ValueError("Invalid ET name")
-return name[1:end_idx], name[end_idx+1:]
+return name[1:end_idx], name[end_idx + 1 :]
 def et_elt_2_domish_elt(et_elt: Union[ET.Element, etree.Element]) -> domish.Element:
 """Convert ElementTree element to Twisted's domish.Element
 elt.addChild(et_elt_2_domish_elt(child))
 return elt
 @overload
-def domish_elt_2_et_elt(elt: domish.Element, lxml: Literal[False]) -> ET.Element:
+def domish_elt_2_et_elt(elt: domish.Element, lxml: Literal[False]) -> ET.Element: ...
-...
 @overload
-def domish_elt_2_et_elt(elt: domish.Element, lxml: Literal[True]) -> etree.Element:
+def domish_elt_2_et_elt(elt: domish.Element, lxml: Literal[True]) -> etree.Element: ...
-...
 @overload
 def domish_elt_2_et_elt(
 elt: domish.Element, lxml: bool
-) -> Union[ET.Element, etree.Element]:
+) -> Union[ET.Element, etree.Element]: ...
-...
-def domish_elt_2_et_elt(elt, lxml = False):
+def domish_elt_2_et_elt(elt, lxml=False):
 """Convert Twisted's domish.Element to ElementTree equivalent
 Note: this is a naive implementation, adapted to XMPP, and some text content may be
 missing (content put after a tag, i.e. what would go to the "tail" attribute of ET
 Element)

Mercurial > libervia-backend

comparison libervia/backend/tools/xml_tools.py @ 4270:0d7bb4df2343