lxml 5.2.0__cp310-cp310-win32.whl → 5.2.2__cp310-cp310-win32.whl

lxml/html/formfill.py

@@ -1,299 +1,299 @@
-from lxml.etree import XPath, ElementBase
-from lxml.html import fromstring, XHTML_NAMESPACE
-from lxml.html import _forms_xpath, _options_xpath, _nons, _transform_result
-from lxml.html import defs
-import copy
-
-try:
-    basestring
-except NameError:
-    # Python 3
-    basestring = str
-
-__all__ = ['FormNotFound', 'fill_form', 'fill_form_html',
-           'insert_errors', 'insert_errors_html',
-           'DefaultErrorCreator']
-
-class FormNotFound(LookupError):
-    """
-    Raised when no form can be found
-    """
-
-_form_name_xpath = XPath('descendant-or-self::form[name=$name]|descendant-or-self::x:form[name=$name]', namespaces={'x':XHTML_NAMESPACE})
-_input_xpath = XPath('|'.join(['descendant-or-self::'+_tag for _tag in ('input','select','textarea','x:input','x:select','x:textarea')]),
-                               namespaces={'x':XHTML_NAMESPACE})
-_label_for_xpath = XPath('//label[@for=$for_id]|//x:label[@for=$for_id]',
-                               namespaces={'x':XHTML_NAMESPACE})
-_name_xpath = XPath('descendant-or-self::*[@name=$name]')
-
-def fill_form(
-    el,
-    values,
-    form_id=None,
-    form_index=None,
-    ):
-    el = _find_form(el, form_id=form_id, form_index=form_index)
-    _fill_form(el, values)
-
-def fill_form_html(html, values, form_id=None, form_index=None):
-    result_type = type(html)
-    if isinstance(html, basestring):
-        doc = fromstring(html)
-    else:
-        doc = copy.deepcopy(html)
-    fill_form(doc, values, form_id=form_id, form_index=form_index)
-    return _transform_result(result_type, doc)
-
-def _fill_form(el, values):
-    counts = {}
-    if hasattr(values, 'mixed'):
-        # For Paste request parameters
-        values = values.mixed()
-    inputs = _input_xpath(el)
-    for input in inputs:
-        name = input.get('name')
-        if not name:
-            continue
-        if _takes_multiple(input):
-            value = values.get(name, [])
-            if not isinstance(value, (list, tuple)):
-                value = [value]
-            _fill_multiple(input, value)
-        elif name not in values:
-            continue
-        else:
-            index = counts.get(name, 0)
-            counts[name] = index + 1
-            value = values[name]
-            if isinstance(value, (list, tuple)):
-                try:
-                    value = value[index]
-                except IndexError:
-                    continue
-            elif index > 0:
-                continue
-            _fill_single(input, value)
-
-def _takes_multiple(input):
-    if _nons(input.tag) == 'select' and input.get('multiple'):
-        # FIXME: multiple="0"?
-        return True
-    type = input.get('type', '').lower()
-    if type in ('radio', 'checkbox'):
-        return True
-    return False
-
-def _fill_multiple(input, value):
-    type = input.get('type', '').lower()
-    if type == 'checkbox':
-        v = input.get('value')
-        if v is None:
-            if not value:
-                result = False
-            else:
-                result = value[0]
-                if isinstance(value, basestring):
-                    # The only valid "on" value for an unnamed checkbox is 'on'
-                    result = result == 'on'
-            _check(input, result)
-        else:
-            _check(input, v in value)
-    elif type == 'radio':
-        v = input.get('value')
-        _check(input, v in value)
-    else:
-        assert _nons(input.tag) == 'select'
-        for option in _options_xpath(input):
-            v = option.get('value')
-            if v is None:
-                # This seems to be the default, at least on IE
-                # FIXME: but I'm not sure
-                v = option.text_content()
-            _select(option, v in value)
-
-def _check(el, check):
-    if check:
-        el.set('checked', '')
-    else:
-        if 'checked' in el.attrib:
-            del el.attrib['checked']
-
-def _select(el, select):
-    if select:
-        el.set('selected', '')
-    else:
-        if 'selected' in el.attrib:
-            del el.attrib['selected']
-
-def _fill_single(input, value):
-    if _nons(input.tag) == 'textarea':
-        input.text = value
-    else:
-        input.set('value', value)
-
-def _find_form(el, form_id=None, form_index=None):
-    if form_id is None and form_index is None:
-        forms = _forms_xpath(el)
-        for form in forms:
-            return form
-        raise FormNotFound(
-            "No forms in page")
-    if form_id is not None:
-        form = el.get_element_by_id(form_id)
-        if form is not None:
-            return form
-        forms = _form_name_xpath(el, name=form_id)
-        if forms:
-            return forms[0]
-        else:
-            raise FormNotFound(
-                "No form with the name or id of %r (forms: %s)"
-                % (id, ', '.join(_find_form_ids(el))))               
-    if form_index is not None:
-        forms = _forms_xpath(el)
-        try:
-            return forms[form_index]
-        except IndexError:
-            raise FormNotFound(
-                "There is no form with the index %r (%i forms found)"
-                % (form_index, len(forms)))
-
-def _find_form_ids(el):
-    forms = _forms_xpath(el)
-    if not forms:
-        yield '(no forms)'
-        return
-    for index, form in enumerate(forms):
-        if form.get('id'):
-            if form.get('name'):
-                yield '%s or %s' % (form.get('id'),
-                                     form.get('name'))
-            else:
-                yield form.get('id')
-        elif form.get('name'):
-            yield form.get('name')
-        else:
-            yield '(unnamed form %s)' % index
-
-############################################################
-## Error filling
-############################################################
-
-class DefaultErrorCreator:
-    insert_before = True
-    block_inside = True
-    error_container_tag = 'div'
-    error_message_class = 'error-message'
-    error_block_class = 'error-block'
-    default_message = "Invalid"
-
-    def __init__(self, **kw):
-        for name, value in kw.items():
-            if not hasattr(self, name):
-                raise TypeError(
-                    "Unexpected keyword argument: %s" % name)
-            setattr(self, name, value)
-
-    def __call__(self, el, is_block, message):
-        error_el = el.makeelement(self.error_container_tag)
-        if self.error_message_class:
-            error_el.set('class', self.error_message_class)
-        if is_block and self.error_block_class:
-            error_el.set('class', error_el.get('class', '')+' '+self.error_block_class)
-        if message is None or message == '':
-            message = self.default_message
-        if isinstance(message, ElementBase):
-            error_el.append(message)
-        else:
-            assert isinstance(message, basestring), (
-                "Bad message; should be a string or element: %r" % message)
-            error_el.text = message or self.default_message
-        if is_block and self.block_inside:
-            if self.insert_before:
-                error_el.tail = el.text
-                el.text = None
-                el.insert(0, error_el)
-            else:
-                el.append(error_el)
-        else:
-            parent = el.getparent()
-            pos = parent.index(el)
-            if self.insert_before:
-                parent.insert(pos, error_el)
-            else:
-                error_el.tail = el.tail
-                el.tail = None
-                parent.insert(pos+1, error_el)
-
-default_error_creator = DefaultErrorCreator()
-    
-
-def insert_errors(
-    el,
-    errors,
-    form_id=None,
-    form_index=None,
-    error_class="error",
-    error_creator=default_error_creator,
-    ):
-    el = _find_form(el, form_id=form_id, form_index=form_index)
-    for name, error in errors.items():
-        if error is None:
-            continue
-        for error_el, message in _find_elements_for_name(el, name, error):
-            assert isinstance(message, (basestring, type(None), ElementBase)), (
-                "Bad message: %r" % message)
-            _insert_error(error_el, message, error_class, error_creator)
-
-def insert_errors_html(html, values, **kw):
-    result_type = type(html)
-    if isinstance(html, basestring):
-        doc = fromstring(html)
-    else:
-        doc = copy.deepcopy(html)
-    insert_errors(doc, values, **kw)
-    return _transform_result(result_type, doc)
-
-def _insert_error(el, error, error_class, error_creator):
-    if _nons(el.tag) in defs.empty_tags or _nons(el.tag) == 'textarea':
-        is_block = False
-    else:
-        is_block = True
-    if _nons(el.tag) != 'form' and error_class:
-        _add_class(el, error_class)
-    if el.get('id'):
-        labels = _label_for_xpath(el, for_id=el.get('id'))
-        if labels:
-            for label in labels:
-                _add_class(label, error_class)
-    error_creator(el, is_block, error)
-
-def _add_class(el, class_name):
-    if el.get('class'):
-        el.set('class', el.get('class')+' '+class_name)
-    else:
-        el.set('class', class_name)
-
-def _find_elements_for_name(form, name, error):
-    if name is None:
-        # An error for the entire form
-        yield form, error
-        return
-    if name.startswith('#'):
-        # By id
-        el = form.get_element_by_id(name[1:])
-        if el is not None:
-            yield el, error
-        return
-    els = _name_xpath(form, name=name)
-    if not els:
-        # FIXME: should this raise an exception?
-        return
-    if not isinstance(error, (list, tuple)):
-        yield els[0], error
-        return
-    # FIXME: if error is longer than els, should it raise an error?
-    for el, err in zip(els, error):
-        if err is None:
-            continue
-        yield el, err
+from lxml.etree import XPath, ElementBase
+from lxml.html import fromstring, XHTML_NAMESPACE
+from lxml.html import _forms_xpath, _options_xpath, _nons, _transform_result
+from lxml.html import defs
+import copy
+
+try:
+    basestring
+except NameError:
+    # Python 3
+    basestring = str
+
+__all__ = ['FormNotFound', 'fill_form', 'fill_form_html',
+           'insert_errors', 'insert_errors_html',
+           'DefaultErrorCreator']
+
+class FormNotFound(LookupError):
+    """
+    Raised when no form can be found
+    """
+
+_form_name_xpath = XPath('descendant-or-self::form[name=$name]|descendant-or-self::x:form[name=$name]', namespaces={'x':XHTML_NAMESPACE})
+_input_xpath = XPath('|'.join(['descendant-or-self::'+_tag for _tag in ('input','select','textarea','x:input','x:select','x:textarea')]),
+                               namespaces={'x':XHTML_NAMESPACE})
+_label_for_xpath = XPath('//label[@for=$for_id]|//x:label[@for=$for_id]',
+                               namespaces={'x':XHTML_NAMESPACE})
+_name_xpath = XPath('descendant-or-self::*[@name=$name]')
+
+def fill_form(
+    el,
+    values,
+    form_id=None,
+    form_index=None,
+    ):
+    el = _find_form(el, form_id=form_id, form_index=form_index)
+    _fill_form(el, values)
+
+def fill_form_html(html, values, form_id=None, form_index=None):
+    result_type = type(html)
+    if isinstance(html, basestring):
+        doc = fromstring(html)
+    else:
+        doc = copy.deepcopy(html)
+    fill_form(doc, values, form_id=form_id, form_index=form_index)
+    return _transform_result(result_type, doc)
+
+def _fill_form(el, values):
+    counts = {}
+    if hasattr(values, 'mixed'):
+        # For Paste request parameters
+        values = values.mixed()
+    inputs = _input_xpath(el)
+    for input in inputs:
+        name = input.get('name')
+        if not name:
+            continue
+        if _takes_multiple(input):
+            value = values.get(name, [])
+            if not isinstance(value, (list, tuple)):
+                value = [value]
+            _fill_multiple(input, value)
+        elif name not in values:
+            continue
+        else:
+            index = counts.get(name, 0)
+            counts[name] = index + 1
+            value = values[name]
+            if isinstance(value, (list, tuple)):
+                try:
+                    value = value[index]
+                except IndexError:
+                    continue
+            elif index > 0:
+                continue
+            _fill_single(input, value)
+
+def _takes_multiple(input):
+    if _nons(input.tag) == 'select' and input.get('multiple'):
+        # FIXME: multiple="0"?
+        return True
+    type = input.get('type', '').lower()
+    if type in ('radio', 'checkbox'):
+        return True
+    return False
+
+def _fill_multiple(input, value):
+    type = input.get('type', '').lower()
+    if type == 'checkbox':
+        v = input.get('value')
+        if v is None:
+            if not value:
+                result = False
+            else:
+                result = value[0]
+                if isinstance(value, basestring):
+                    # The only valid "on" value for an unnamed checkbox is 'on'
+                    result = result == 'on'
+            _check(input, result)
+        else:
+            _check(input, v in value)
+    elif type == 'radio':
+        v = input.get('value')
+        _check(input, v in value)
+    else:
+        assert _nons(input.tag) == 'select'
+        for option in _options_xpath(input):
+            v = option.get('value')
+            if v is None:
+                # This seems to be the default, at least on IE
+                # FIXME: but I'm not sure
+                v = option.text_content()
+            _select(option, v in value)
+
+def _check(el, check):
+    if check:
+        el.set('checked', '')
+    else:
+        if 'checked' in el.attrib:
+            del el.attrib['checked']
+
+def _select(el, select):
+    if select:
+        el.set('selected', '')
+    else:
+        if 'selected' in el.attrib:
+            del el.attrib['selected']
+
+def _fill_single(input, value):
+    if _nons(input.tag) == 'textarea':
+        input.text = value
+    else:
+        input.set('value', value)
+
+def _find_form(el, form_id=None, form_index=None):
+    if form_id is None and form_index is None:
+        forms = _forms_xpath(el)
+        for form in forms:
+            return form
+        raise FormNotFound(
+            "No forms in page")
+    if form_id is not None:
+        form = el.get_element_by_id(form_id)
+        if form is not None:
+            return form
+        forms = _form_name_xpath(el, name=form_id)
+        if forms:
+            return forms[0]
+        else:
+            raise FormNotFound(
+                "No form with the name or id of %r (forms: %s)"
+                % (id, ', '.join(_find_form_ids(el))))               
+    if form_index is not None:
+        forms = _forms_xpath(el)
+        try:
+            return forms[form_index]
+        except IndexError:
+            raise FormNotFound(
+                "There is no form with the index %r (%i forms found)"
+                % (form_index, len(forms)))
+
+def _find_form_ids(el):
+    forms = _forms_xpath(el)
+    if not forms:
+        yield '(no forms)'
+        return
+    for index, form in enumerate(forms):
+        if form.get('id'):
+            if form.get('name'):
+                yield '%s or %s' % (form.get('id'),
+                                     form.get('name'))
+            else:
+                yield form.get('id')
+        elif form.get('name'):
+            yield form.get('name')
+        else:
+            yield '(unnamed form %s)' % index
+
+############################################################
+## Error filling
+############################################################
+
+class DefaultErrorCreator:
+    insert_before = True
+    block_inside = True
+    error_container_tag = 'div'
+    error_message_class = 'error-message'
+    error_block_class = 'error-block'
+    default_message = "Invalid"
+
+    def __init__(self, **kw):
+        for name, value in kw.items():
+            if not hasattr(self, name):
+                raise TypeError(
+                    "Unexpected keyword argument: %s" % name)
+            setattr(self, name, value)
+
+    def __call__(self, el, is_block, message):
+        error_el = el.makeelement(self.error_container_tag)
+        if self.error_message_class:
+            error_el.set('class', self.error_message_class)
+        if is_block and self.error_block_class:
+            error_el.set('class', error_el.get('class', '')+' '+self.error_block_class)
+        if message is None or message == '':
+            message = self.default_message
+        if isinstance(message, ElementBase):
+            error_el.append(message)
+        else:
+            assert isinstance(message, basestring), (
+                "Bad message; should be a string or element: %r" % message)
+            error_el.text = message or self.default_message
+        if is_block and self.block_inside:
+            if self.insert_before:
+                error_el.tail = el.text
+                el.text = None
+                el.insert(0, error_el)
+            else:
+                el.append(error_el)
+        else:
+            parent = el.getparent()
+            pos = parent.index(el)
+            if self.insert_before:
+                parent.insert(pos, error_el)
+            else:
+                error_el.tail = el.tail
+                el.tail = None
+                parent.insert(pos+1, error_el)
+
+default_error_creator = DefaultErrorCreator()
+    
+
+def insert_errors(
+    el,
+    errors,
+    form_id=None,
+    form_index=None,
+    error_class="error",
+    error_creator=default_error_creator,
+    ):
+    el = _find_form(el, form_id=form_id, form_index=form_index)
+    for name, error in errors.items():
+        if error is None:
+            continue
+        for error_el, message in _find_elements_for_name(el, name, error):
+            assert isinstance(message, (basestring, type(None), ElementBase)), (
+                "Bad message: %r" % message)
+            _insert_error(error_el, message, error_class, error_creator)
+
+def insert_errors_html(html, values, **kw):
+    result_type = type(html)
+    if isinstance(html, basestring):
+        doc = fromstring(html)
+    else:
+        doc = copy.deepcopy(html)
+    insert_errors(doc, values, **kw)
+    return _transform_result(result_type, doc)
+
+def _insert_error(el, error, error_class, error_creator):
+    if _nons(el.tag) in defs.empty_tags or _nons(el.tag) == 'textarea':
+        is_block = False
+    else:
+        is_block = True
+    if _nons(el.tag) != 'form' and error_class:
+        _add_class(el, error_class)
+    if el.get('id'):
+        labels = _label_for_xpath(el, for_id=el.get('id'))
+        if labels:
+            for label in labels:
+                _add_class(label, error_class)
+    error_creator(el, is_block, error)
+
+def _add_class(el, class_name):
+    if el.get('class'):
+        el.set('class', el.get('class')+' '+class_name)
+    else:
+        el.set('class', class_name)
+
+def _find_elements_for_name(form, name, error):
+    if name is None:
+        # An error for the entire form
+        yield form, error
+        return
+    if name.startswith('#'):
+        # By id
+        el = form.get_element_by_id(name[1:])
+        if el is not None:
+            yield el, error
+        return
+    els = _name_xpath(form, name=name)
+    if not els:
+        # FIXME: should this raise an exception?
+        return
+    if not isinstance(error, (list, tuple)):
+        yield els[0], error
+        return
+    # FIXME: if error is longer than els, should it raise an error?
+    for el, err in zip(els, error):
+        if err is None:
+            continue
+        yield el, err