libervia-backend: sat/tools/xml

comparison sat/tools/xml_tools.py @ 4037:524856bd7b19

massive refactoring to switch from camelCase to snake_case: historically, Libervia (SàT before) was using camelCase as allowed by PEP8 when using a pre-PEP8 code, to use the same coding style as in Twisted. However, snake_case is more readable and it's better to follow PEP8 best practices, so it has been decided to move on full snake_case. Because Libervia has a huge codebase, this ended with a ugly mix of camelCase and snake_case. To fix that, this patch does a big refactoring by renaming every function and method (including bridge) that are not coming from Twisted or Wokkel, to use fully snake_case. This is a massive change, and may result in some bugs.

author	Goffi <goffi@goffi.org>
date	Sat, 08 Apr 2023 13:54:42 +0200
parents	bb211f80c3e6
children	2594e1951cf7

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 html_entity_re = re.compile(r"&([a-zA-Z]+?);")
 XML_ENTITIES = ("quot", "amp", "apos", "lt", "gt")
 # method to clean XHTML, receive raw unsecure XML or HTML, must return cleaned raw XHTML
 # this method must be set during runtime
-cleanXHTML = None
+clean_xhtml = None
 # 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):
+def _data_form_field_2_xmlui_data(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 field (data_form.Field): a field with attributes "value", "fieldType",
 "label" and "var"
 if field.var:
 widget_kwargs["name"] = field.var
 return widget_type, widget_args, widget_kwargs
-def dataForm2Widgets(form_ui, form, read_only=False, prepend=None, filters=None):
+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
 @param form (data_form.Form): Wokkel's implementation of data form
 @param read_only (bool): if True and it makes sense, create a read only input widget
 @param prepend(iterable, None): widgets to prepend to main LabelContainer
-if not None, must be an iterable of *args for addWidget. Those widgets will
+if not None, must be an iterable of *args for add_widget. Those widgets will
 be added first to the container.
 @param filters(dict, None): if not None, a dictionary of callable:
 key is the name of the widget to filter
 the value is a callable, it will get form's XMLUI, widget's type, args and kwargs
 and must return widget's type, args and kwargs (which can be modified)
 if filters is None:
 filters = {}
 if form.instructions:
 form_ui.addText("\n".join(form.instructions), "instructions")
-form_ui.changeContainer("label")
+form_ui.change_container("label")
 if prepend is not None:
 for widget_args in prepend:
-form_ui.addWidget(*widget_args)
+form_ui.add_widget(*widget_args)
 for field in form.fieldList:
-widget_type, widget_args, widget_kwargs = _dataFormField2XMLUIData(
+widget_type, widget_args, widget_kwargs = _data_form_field_2_xmlui_data(
 field, read_only
 )
 try:
 widget_filter = filters[widget_kwargs["name"]]
 except KeyError:
 if label:
 form_ui.addLabel(label)
 else:
 form_ui.addEmpty()
-form_ui.addWidget(widget_type, *widget_args, **widget_kwargs)
+form_ui.add_widget(widget_type, *widget_args, **widget_kwargs)
 return form_ui
-def dataForm2XMLUI(form, submit_id, session_id=None, read_only=False):
+def data_form_2_xmlui(form, submit_id, session_id=None, read_only=False):
 """Take a data form (Wokkel's XEP-0004 implementation) and convert it to a SàT XMLUI.
 @param form (data_form.Form): a Form instance
 @param submit_id (unicode): callback id to call when submitting form
 @param session_id (unicode): session id to return with the data
 @param read_only (bool): if True and it makes sense, create a read only input widget
 @return: XMLUI instance
 """
 form_ui = XMLUI("form", "vertical", submit_id=submit_id, session_id=session_id)
-return dataForm2Widgets(form_ui, form, read_only=read_only)
+return data_form_2_widgets(form_ui, form, read_only=read_only)
-def dataForm2dataDict(form: data_form.Form) -> dict:
+def data_form_2_data_dict(form: data_form.Form) -> dict:
 """Convert data form to a simple dict, easily serialisable
-see dataDict2dataForm for a description of the format
+see data_dict_2_data_form for a description of the format
 """
 fields = []
 data_dict = {
 "fields": fields
 }
 f"{form_field.value.toXml()}"
 )
 return data_dict
-def dataDict2dataForm(data_dict):
+def data_dict_2_data_form(data_dict):
 """Convert serialisable dict of data to a data form
 The format of the dict is as follow:
 - an optional "namespace" key with form namespace
 - a mandatory "fields" key with list of fields as follow:
 formNamespace=data_dict.get("namespace"),
 fields=fields
 )
-def dataFormEltResult2XMLUIData(form_xml):
+def data_form_elt_result_2_xmlui_data(form_xml):
 """Parse a data form result (not parsed by Wokkel's XEP-0004 implementation).
 The raw data form is used because Wokkel doesn't manage result items parsing yet.
 @param form_xml (domish.Element): element of the data form
 @return: a couple (headers, result_list):
 if elt.name != "field":
 log.warning("Unexpected tag (%s)" % elt.name)
 continue
 field = data_form.Field.fromElement(elt)
-xmlui_data.append(_dataFormField2XMLUIData(field))
+xmlui_data.append(_data_form_field_2_xmlui_data(field))
 return headers, xmlui_data
-def XMLUIData2AdvancedList(xmlui, headers, xmlui_data):
+def xmlui_data_2_advanced_list(xmlui, headers, xmlui_data):
 """Take a raw data form result (not parsed by Wokkel's XEP-0004 implementation) and convert it to an advanced list.
 The raw data form is used because Wokkel doesn't manage result items parsing yet.
 @param xmlui (XMLUI): the XMLUI where the AdvancedList will be added
 @param headers (dict{unicode: unicode}): form headers (field labels and types)
 @return: the completed XMLUI instance
 """
 adv_list = AdvancedListContainer(
 xmlui, headers=headers, columns=len(headers), parent=xmlui.current_container
 )
-xmlui.changeContainer(adv_list)
+xmlui.change_container(adv_list)
 for widget_type, widget_args, widget_kwargs in xmlui_data:
-xmlui.addWidget(widget_type, *widget_args, **widget_kwargs)
+xmlui.add_widget(widget_type, *widget_args, **widget_kwargs)
 return xmlui
-def dataFormResult2AdvancedList(xmlui, form_xml):
+def data_form_result_2_advanced_list(xmlui, form_xml):
 """Take a raw data form result (not parsed by Wokkel's XEP-0004 implementation) and convert it to an advanced list.
 The raw data form is used because Wokkel doesn't manage result items parsing yet.
 @param xmlui (XMLUI): the XMLUI where the AdvancedList will be added
 @param form_xml (domish.Element): element of the data form
 @return: the completed XMLUI instance
 """
-headers, xmlui_data = dataFormEltResult2XMLUIData(form_xml)
+headers, xmlui_data = data_form_elt_result_2_xmlui_data(form_xml)
-XMLUIData2AdvancedList(xmlui, headers, xmlui_data)
+xmlui_data_2_advanced_list(xmlui, headers, xmlui_data)
-def dataFormEltResult2XMLUI(form_elt, session_id=None):
+def data_form_elt_result_2_xmlui(form_elt, session_id=None):
 """Take a raw data form (not parsed by XEP-0004) and convert it to a SàT XMLUI.
 The raw data form is used because Wokkel doesn't manage result items parsing yet.
 @param form_elt (domish.Element): element of the data form
 @param session_id (unicode): session id to return with the data
 @return: XMLUI instance
 """
 xml_ui = XMLUI("window", "vertical", session_id=session_id)
 try:
-dataFormResult2AdvancedList(xml_ui, form_elt)
+data_form_result_2_advanced_list(xml_ui, form_elt)
 except exceptions.DataError:
 parsed_form = data_form.Form.fromElement(form_elt)
-dataForm2Widgets(xml_ui, parsed_form, read_only=True)
+data_form_2_widgets(xml_ui, parsed_form, read_only=True)
 return xml_ui
-def dataFormResult2XMLUI(result_form, base_form, session_id=None, prepend=None,
+def data_form_result_2_xmlui(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)
 @param session_id (unicode): session id to return with the data
-@param prepend: same as for [dataForm2Widgets]
+@param prepend: same as for [data_form_2_widgets]
-@param filters: same as for [dataForm2Widgets]
+@param filters: same as for [data_form_2_widgets]
-@param read_only: same as for [dataForm2Widgets]
+@param read_only: same as for [data_form_2_widgets]
 @return: XMLUI instance
 """
-# we deepcopy the form because _dataFormField2XMLUIData can modify the value
+# 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 = result_form
 for name, field in form.fields.items():
 base_field = base_form.fields[name]
 except KeyError:
 continue
 field.options = base_field.options[:]
 xml_ui = XMLUI("window", "vertical", session_id=session_id)
-dataForm2Widgets(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 _cleanValue(value):
+def _clean_value(value):
 """Workaround method to avoid DBus types with D-Bus bridge.
 @param value: value to clean
 @return: value in a non DBus type (only clean string yet)
 """
 if isinstance(value, str):
 return str(value)
 return value
-def XMLUIResult2DataFormResult(xmlui_data):
+def xmlui_result_2_data_form_result(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
 """
 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) :]] = _cleanValue(value)
+ret[key[len(SAT_FORM_PREFIX) :]] = _clean_value(value)
 return ret
-def formEscape(name):
+def form_escape(name):
 """Return escaped name for forms.
 @param name (unicode): form name
 @return: unicode
 """
 return "%s%s" % (SAT_FORM_PREFIX, name)
-def isXMLUICancelled(raw_xmlui):
+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))
-def XMLUIResultToElt(xmlui_data):
+def xmlui_result_to_elt(xmlui_data):
 """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.makeFields(XMLUIResult2DataFormResult(xmlui_data))
+form.makeFields(xmlui_result_2_data_form_result(xmlui_data))
 return form.toElement()
-def tupleList2dataForm(values):
+def tuple_list_2_data_form(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.addField(field)
 return form
-def paramsXML2XMLUI(xml):
+def params_xml_2_xmlui(xml):
 """Convert the XML for parameter to a SàT XML User Interface.
 @param xml (unicode)
 @return: XMLUI
 """
 label = category.getAttribute("label")
 if not category_name:
 raise exceptions.DataError(
 _("INTERNAL ERROR: params categories must have a name")
 )
-tabs_cont.addTab(category_name, label=label, container=LabelContainer)
+tabs_cont.add_tab(category_name, label=label, container=LabelContainer)
 for param in category.getElementsByTagName("param"):
 widget_kwargs = {}
 param_name = param.getAttribute("name")
 param_label = param.getAttribute("label")
 value = param.getAttribute("value") or None
 callback_id = param.getAttribute("callback_id") or None
 if type_ == "list":
-options, selected = _paramsGetListOptions(param)
+options, selected = _params_get_list_options(param)
 widget_kwargs["options"] = options
 widget_kwargs["selected"] = selected
 widget_kwargs["styles"] = ["extensible"]
 elif type_ == "jids_list":
-widget_kwargs["jids"] = _paramsGetListJids(param)
+widget_kwargs["jids"] = _params_get_list_jids(param)
 if type_ in ("button", "text"):
 param_ui.addEmpty()
 value = param_label
 else:
 category_name,
 SAT_PARAM_SEPARATOR,
 param_name,
 )
-param_ui.addWidget(type_, **widget_kwargs)
+param_ui.add_widget(type_, **widget_kwargs)
 return param_ui.toXml()
-def _paramsGetListOptions(param):
+def _params_get_list_options(param):
 """Retrieve the options for list element.
 The <option/> tags must be direct children of <param/>.
 @param param (domish.Element): element
 @return: a tuple (options, selected_value)
 if elem.getAttribute("selected") == "true"
 ]
 return (options, selected)
-def _paramsGetListJids(param):
+def _params_get_list_jids(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
 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("label", label)
 if selected:
-self.setSelected(selected)
+self.set_selected(selected)
-def setSelected(self, selected=False):
+def set_selected(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 = xmlui.doc.createElement("container")
 super(Container, self).__init__(xmlui, parent)
 self.elem.setAttribute("type", self.type)
-def getParentContainer(self):
+def get_parent_container(self):
 """ Return first parent container
 @return: parent container or None
 """
 current = self.parent
 class TabsContainer(Container):
 type = "tabs"
-def addTab(self, name, label=None, selected=None, container=VerticalContainer):
+def add_tab(self, name, label=None, selected=None, container=VerticalContainer):
 """Add a tab.
 @param name (unicode): tab name
 @param label (unicode): tab label
 @param selected (bool): set to True to select this tab
 """
 if not label:
 label = name
 tab_elt = TabElement(self, name, label, selected)
 new_container = container(self.xmlui, tab_elt)
-return self.xmlui.changeContainer(new_container)
+return self.xmlui.change_container(new_container)
 def end(self):
 """ Called when we have finished tabs
 change current container to first container parent
 """
-parent_container = self.getParentContainer()
+parent_container = self.get_parent_container()
-self.xmlui.changeContainer(parent_container)
+self.xmlui.change_container(parent_container)
 class AdvancedListContainer(Container):
 """A list which can contain other widgets, headers, etc"""
 if headers:
 if len(headers) != self._columns:
 raise exceptions.DataError(
 _("Headers lenght doesn't correspond to columns")
 )
-self.addHeaders(headers)
+self.add_headers(headers)
 if items:
-self.addItems(items)
+self.add_items(items)
 self.elem.setAttribute("columns", str(self._columns))
 if callback_id is not None:
 self.elem.setAttribute("callback", callback_id)
 self.elem.setAttribute("selectable", selectable)
 self.auto_index = auto_index
 if auto_index:
 self.elem.setAttribute("auto_index", "true")
 self.next_row_idx = None
-def addHeaders(self, headers):
+def add_headers(self, headers):
 for header in headers:
 self.addHeader(header)
 def addHeader(self, header):
 pass  # TODO
-def addItems(self, items):
+def add_items(self, items):
 for item in items:
 self.append(item)
-def setRowIndex(self, idx):
+def set_row_index(self, idx):
 """ 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
 """
 change current container to first container parent
 """
 if self._item_idx % self._columns != 0:
 raise exceptions.DataError(_("Incorrect number of items in list"))
-parent_container = self.getParentContainer()
+parent_container = self.get_parent_container()
-self.xmlui.changeContainer(parent_container)
+self.xmlui.change_container(parent_container)
 ## Widgets ##
 )
 )
 xmlui.named_widgets[name] = self
 self.elem.setAttribute("type", self.type)
-def setInternalCallback(self, callback, fields, data_elts=None):
+def set_internal_callback(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
 a predefined set of actions that are running in the scope of XMLUI.
 @param callback (string): a value from:
 @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 cleanXHTML is None:
+if clean_xhtml is None:
 raise exceptions.NotFound(
 "No cleaning method set, can't clean the XHTML")
-value = cleanXHTML(value)
+value = clean_xhtml(value)
 super(XHTMLBoxWidget, self).__init__(
 xmlui, value=value, name=name, parent=parent, read_only=read_only)
 # 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'))
 super(ListWidget, self).__init__(xmlui, name, parent)
-self.addOptions(options, selected)
+self.add_options(options, selected)
-self.setStyles(styles)
+self.set_styles(styles)
-def addOptions(self, options, selected=None):
+def add_options(self, options, selected=None):
 """Add options to a multi-values element (e.g. list) """
 if selected:
 if isinstance(selected, str):
 selected = [selected]
 else:
 for option in options:
 assert isinstance(option, str) or isinstance(option, tuple)
 value = option if isinstance(option, str) else option[0]
 OptionElement(self, option, value in selected)
-def setStyles(self, styles):
+def set_styles(self, styles):
 if not styles.issubset(self.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):
-self.setStyles([style])
+self.set_styles([style])
 @property
 def value(self):
 """Return the value of first selected option"""
 for child in self.elem.childNodes:
 for style in styles:
 self.elem.setAttribute(style, "yes")
 if not jids:
 log.debug("empty jids list")
 else:
-self.addJids(jids)
+self.add_jids(jids)
-def addJids(self, jids):
+def add_jids(self, jids):
 for jid_ in jids:
 JidElement(self, jid_)
 ## Dialog Elements ##
 self.submit_id = submit_id
 self.session_id = session_id
 if panel_type == C.XMLUI_DIALOG:
 if dialog_opt is None:
 dialog_opt = {}
-self._createDialog(dialog_opt)
+self._create_dialog(dialog_opt)
 return
-self.main_container = self._createContainer(container, TopElement(self))
+self.main_container = self._create_container(container, TopElement(self))
 self.current_container = self.main_container
 self.named_widgets = {}
 @staticmethod
-def creatorWrapper(widget_cls, is_input):
+def creator_wrapper(widget_cls, is_input):
 # TODO: once moved to Python 3, use functools.partialmethod and
-#       remove the creatorWrapper
+#       remove the creator_wrapper
-def createWidget(self, *args, **kwargs):
+def create_widget(self, *args, **kwargs):
 if self.type == C.XMLUI_DIALOG:
 raise exceptions.InternalError(_(
-"createWidget 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 createWidget
+return create_widget
 @classmethod
 def _introspect(cls):
 """ Introspect module to find Widgets and Containers, and create addXXX methods"""
 # FIXME: we can't log anything because this file is used
 # FIXME: cf. above comment
 # log.debug(u"Adding {creator_name} creator (is_input={is_input}))"
 #     .format(creator_name=creator_name, is_input=is_input))
 assert not hasattr(cls, creator_name)
-# XXX: we need to use creatorWrapper because we are in a loop
+# XXX: we need to use creator_wrapper because we are in a loop
 #      and Python 2 doesn't support default values in kwargs
 #      when using *args, **kwargs
-setattr(cls, creator_name, cls.creatorWrapper(obj, is_input))
+setattr(cls, creator_name, cls.creator_wrapper(obj, is_input))
 elif issubclass(obj, Container):
 if obj.__name__ == "Container":
 continue
 cls._containers[obj.type] = obj
 elif value:
 top_element.setAttribute("session_id", value)
 else:
 raise exceptions.DataError("session_id can't be empty")
-def _createDialog(self, dialog_opt):
+def _create_dialog(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
 ):
 try:
 FileElement(dialog_elt, dialog_opt[C.XMLUI_DATA_FILETYPE])
 except KeyError:
 pass
-def _createContainer(self, container, parent=None, **kwargs):
+def _create_container(self, container, parent=None, **kwargs):
 """Create a container element
 @param type: container type (cf init doc)
 @parent: parent element or None
 """
 raise exceptions.DataError(_("Unknown container type [%s]") % container)
 cls = self._containers[container]
 new_container = cls(self, parent=parent, **kwargs)
 return new_container
-def changeContainer(self, container, **kwargs):
+def change_container(self, container, **kwargs):
 """Change the current container
 @param container: either container type (container it then created),
 or an Container instance"""
 if isinstance(container, str):
-self.current_container = self._createContainer(
+self.current_container = self._create_container(
 container,
-self.current_container.getParentContainer() or self.main_container,
+self.current_container.get_parent_container() or self.main_container,
 **kwargs
 )
 else:
 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):
+def add_widget(self, type_, *args, **kwargs):
 """Convenience method to add an element"""
 if "parent" not in kwargs:
 kwargs["parent"] = self.current_container
 try:
 cls = self._widgets[type_]
 title=title,
 )
 return note_xmlui
-def quickNote(host, client, message, title="", level=C.XMLUI_DATA_LVL_INFO):
+def quick_note(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.action_new({"xmlui": note_ui.toXml()}, profile=client.profile)
-def deferredUI(host, xmlui, chained=False):
+def deferred_ui(host, xmlui, chained=False):
 """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 chained(bool): True if the Deferred result must be returned to the frontend
 @return (D(data)): a deferred which fire the data
 """
 assert xmlui.submit_id == ""
 xmlui_d = defer.Deferred()
-def onSubmit(data, profile):
+def on_submit(data, profile):
 xmlui_d.callback(data)
 return xmlui_d if chained else {}
-xmlui.submit_id = host.registerCallback(onSubmit, with_data=True, one_shot=True)
+xmlui.submit_id = host.register_callback(on_submit, with_data=True, one_shot=True)
 return xmlui_d
-def deferXMLUI(host, xmlui, action_extra=None, security_limit=C.NO_SECURITY_LIMIT,
+def defer_xmlui(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 action_extra(None, dict): extra action to merge with xmlui
-mainly used to add meta informations (see actionNew doc)
+mainly used to add meta informations (see action_new doc)
 @param security_limit: %(doc_security_limit)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)
+xmlui_d = deferred_ui(host, xmlui, chained)
 action_data = {"xmlui": xmlui.toXml()}
 if action_extra is not None:
 action_data.update(action_extra)
-host.actionNew(
+host.action_new(
 action_data,
 security_limit=security_limit,
 keep_id=xmlui.submit_id,
 profile=profile,
 )
 return xmlui_d
-def deferDialog(host, message, title="Please confirm", type_=C.XMLUI_DIALOG_CONFIRM,
+def defer_dialog(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
 @param title(unicode): title of the dialog
 @param type(unicode): dialog type (C.XMLUI_DIALOG_*)
 @param options(None, dict): if not None, will be used to update (extend) dialog_opt
 arguments of XMLUI
 @param action_extra(None, dict): extra action to merge with xmlui
-mainly used to add meta informations (see actionNew doc)
+mainly used to add meta informations (see action_new doc)
 @param security_limit: %(doc_security_limit)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
 @param profile: %(doc_profile)s
 @return (dict): Deferred dict
 assert profile is not None
 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="")
-return deferXMLUI(host, dialog, action_extra, security_limit, chained, profile)
+return defer_xmlui(host, dialog, action_extra, security_limit, chained, profile)
-def deferConfirm(*args, **kwargs):
+def defer_confirm(*args, **kwargs):
-"""call deferDialog and return a boolean instead of the whole data dict"""
+"""call defer_dialog and return a boolean instead of the whole data dict"""
-d = deferDialog(*args, **kwargs)
+d = defer_dialog(*args, **kwargs)
 d.addCallback(lambda data: C.bool(data["answer"]))
 return d
 # Misc other funtions
-def elementCopy(
+def element_copy(
 element: domish.Element,
 with_parent: bool = True,
 with_children: bool = True
 ) -> domish.Element:
 """Make a copy of a domish.Element
 if with_children:
 new_elt.children = element.children[:]
 return new_elt
-def isXHTMLField(field):
+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
 field.value.uri == C.NS_XHTML)
 class ElementParser:
 """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):
+def _escape_html(self, matchobj):
 entity = matchobj.group(1)
 if entity in XML_ENTITIES:
 # we don't escape XML entities
 return matchobj.group(0)
 else:
 raw_xml = "<div xmlns='{}'>{}</div>".format(namespace, raw_xml)
 else:
 raw_xml = "<div>{}</div>".format(raw_xml)
 # avoid ParserError on HTML escaped chars
-raw_xml = html_entity_re.sub(self._escapeHTML, raw_xml)
+raw_xml = html_entity_re.sub(self._escape_html, raw_xml)
 self.result = None
-def onStart(elem):
+def on_start(elem):
 self.result = elem
-def onEnd():
+def on_end():
 pass
 def onElement(elem):
 self.result.addChild(elem)
 parser = domish.elementStream()
-parser.DocumentStartEvent = onStart
+parser.DocumentStartEvent = on_start
 parser.ElementEvent = onElement
-parser.DocumentEndEvent = onEnd
+parser.DocumentEndEvent = on_end
 tmp = domish.Element((None, "s"))
 if force_spaces:
 raw_xml = raw_xml.replace("\n", " ").replace("\t", " ")
 tmp.addRawXml(raw_xml)
 parser.parse(tmp.toXml().encode("utf-8"))
 parse = ElementParser()
-# FIXME: this method is duplicated from frontends.tools.xmlui.getText
+# FIXME: this method is duplicated from frontends.tools.xmlui.get_text
-def getText(node):
+def get_text(node):
 """Get child text nodes of a domish.Element.
 @param node (domish.Element)
 @return: joined unicode text of all nodes
 """
 if child.nodeType == child.TEXT_NODE:
 data.append(child.wholeText)
 return "".join(data)
-def findAll(elt, namespaces=None, names=None):
+def find_all(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
 domish.IElement.providedBy(child)
 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):
+for found in find_all(child, namespaces, names):
 yield found
-def findAncestor(
+def find_ancestor(
 elt,
 name: str,
 namespace: Optional[Union[str, Iterable[str]]] = None
 ) -> domish.Element:
 """Retrieve ancestor of an element
 if current.name == name and (namespace is None or current.uri in namespace):
 return current
 current = current.parent
-def pFmtElt(elt, indent=0, defaultUri=""):
+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(pFmtElt(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
 else:
 strings.append(f"{indent*' '}{elt.toXml(defaultUri=defaultUri)}")
 return '\n'.join(strings)
-def ppElt(elt):
+def pp_elt(elt):
 """Pretty print a domish.Element"""
-print(pFmtElt(elt))
+print(p_fmt_elt(elt))
 # ElementTree
 def et_get_namespace_and_name(et_elt: ET.Element) -> Tuple[Optional[str], str]:

Mercurial > libervia-backend

comparison sat/tools/xml_tools.py @ 4037:524856bd7b19