lxml.html.formfill

1 from lxml.etree import XPath, ElementBase 2 from lxml.html import fromstring, XHTML_NAMESPACE 3 from lxml.html import _forms_xpath, _options_xpath, _nons, _transform_result 4 from lxml.html import defs 5 import copy 6 7 try: 8 basestring 9 except NameError: 10 # Python 3 11 basestring = str 12 13 __all__ = ['FormNotFound', 'fill_form', 'fill_form_html', 14 'insert_errors', 'insert_errors_html', 15 'DefaultErrorCreator'] 16

17 -class FormNotFound(LookupError):

18 """ 19 Raised when no form can be found 20 """

21 22 _form_name_xpath = XPath('descendant-or-self::form[name=$name]|descendant-or-self::x:form[name=$name]', namespaces={'x':XHTML_NAMESPACE}) 23 _input_xpath = XPath('|'.join(['descendant-or-self::'+_tag for _tag in ('input','select','textarea','x:input','x:select','x:textarea')]), 24 namespaces={'x':XHTML_NAMESPACE}) 25 _label_for_xpath = XPath('//label[@for=$for_id]|//x:label[@for=$for_id]', 26 namespaces={'x':XHTML_NAMESPACE}) 27 _name_xpath = XPath('descendant-or-self::*[@name=$name]') 28

29 -def fill_form( 30 el, 31 values, 32 form_id=None, 33 form_index=None, 34 ):

35 el = _find_form(el, form_id=form_id, form_index=form_index) 36 _fill_form(el, values)

37

38 -def fill_form_html(html, values, form_id=None, form_index=None):

39 result_type = type(html) 40 if isinstance(html, basestring): 41 doc = fromstring(html) 42 else: 43 doc = copy.deepcopy(html) 44 fill_form(doc, values, form_id=form_id, form_index=form_index) 45 return _transform_result(result_type, doc)

46

47 -def _fill_form(el, values):

48 counts = {} 49 if hasattr(values, 'mixed'): 50 # For Paste request parameters 51 values = values.mixed() 52 inputs = _input_xpath(el) 53 for input in inputs: 54 name = input.get('name') 55 if not name: 56 continue 57 if _takes_multiple(input): 58 value = values.get(name, []) 59 if not isinstance(value, (list, tuple)): 60 value = [value] 61 _fill_multiple(input, value) 62 elif name not in values: 63 continue 64 else: 65 index = counts.get(name, 0) 66 counts[name] = index + 1 67 value = values[name] 68 if isinstance(value, (list, tuple)): 69 try: 70 value = value[index] 71 except IndexError: 72 continue 73 elif index > 0: 74 continue 75 _fill_single(input, value)

76

77 -def _takes_multiple(input):

78 if _nons(input.tag) == 'select' and input.get('multiple'): 79 # FIXME: multiple="0"? 80 return True 81 type = input.get('type', '').lower() 82 if type in ('radio', 'checkbox'): 83 return True 84 return False

85

86 -def _fill_multiple(input, value):

87 type = input.get('type', '').lower() 88 if type == 'checkbox': 89 v = input.get('value') 90 if v is None: 91 if not value: 92 result = False 93 else: 94 result = value[0] 95 if isinstance(value, basestring): 96 # The only valid "on" value for an unnamed checkbox is 'on' 97 result = result == 'on' 98 _check(input, result) 99 else: 100 _check(input, v in value) 101 elif type == 'radio': 102 v = input.get('value') 103 _check(input, v in value) 104 else: 105 assert _nons(input.tag) == 'select' 106 for option in _options_xpath(input): 107 v = option.get('value') 108 if v is None: 109 # This seems to be the default, at least on IE 110 # FIXME: but I'm not sure 111 v = option.text_content() 112 _select(option, v in value)

113

114 -def _check(el, check):

115 if check: 116 el.set('checked', '') 117 else: 118 if 'checked' in el.attrib: 119 del el.attrib['checked']

120

121 -def _select(el, select):

122 if select: 123 el.set('selected', '') 124 else: 125 if 'selected' in el.attrib: 126 del el.attrib['selected']

127

128 -def _fill_single(input, value):

129 if _nons(input.tag) == 'textarea': 130 input.text = value 131 else: 132 input.set('value', value)

133

134 -def _find_form(el, form_id=None, form_index=None):

135 if form_id is None and form_index is None: 136 forms = _forms_xpath(el) 137 for form in forms: 138 return form 139 raise FormNotFound( 140 "No forms in page") 141 if form_id is not None: 142 form = el.get_element_by_id(form_id) 143 if form is not None: 144 return form 145 forms = _form_name_xpath(el, name=form_id) 146 if forms: 147 return forms[0] 148 else: 149 raise FormNotFound( 150 "No form with the name or id of %r (forms: %s)" 151 % (id, ', '.join(_find_form_ids(el)))) 152 if form_index is not None: 153 forms = _forms_xpath(el) 154 try: 155 return forms[form_index] 156 except IndexError: 157 raise FormNotFound( 158 "There is no form with the index %r (%i forms found)" 159 % (form_index, len(forms)))

160

161 -def _find_form_ids(el):

162 forms = _forms_xpath(el) 163 if not forms: 164 yield '(no forms)' 165 return 166 for index, form in enumerate(forms): 167 if form.get('id'): 168 if form.get('name'): 169 yield '%s or %s' % (form.get('id'), 170 form.get('name')) 171 else: 172 yield form.get('id') 173 elif form.get('name'): 174 yield form.get('name') 175 else: 176 yield '(unnamed form %s)' % index

177 178 ############################################################ 179 ## Error filling 180 ############################################################ 181

182 -class DefaultErrorCreator(object):

183 insert_before = True 184 block_inside = True 185 error_container_tag = 'div' 186 error_message_class = 'error-message' 187 error_block_class = 'error-block' 188 default_message = "Invalid" 189

190 - def __init__(self, **kw):

191 for name, value in kw.items(): 192 if not hasattr(self, name): 193 raise TypeError( 194 "Unexpected keyword argument: %s" % name) 195 setattr(self, name, value)

196

197 - def __call__(self, el, is_block, message):

198 error_el = el.makeelement(self.error_container_tag) 199 if self.error_message_class: 200 error_el.set('class', self.error_message_class) 201 if is_block and self.error_block_class: 202 error_el.set('class', error_el.get('class', '')+' '+self.error_block_class) 203 if message is None or message == '': 204 message = self.default_message 205 if isinstance(message, ElementBase): 206 error_el.append(message) 207 else: 208 assert isinstance(message, basestring), ( 209 "Bad message; should be a string or element: %r" % message) 210 error_el.text = message or self.default_message 211 if is_block and self.block_inside: 212 if self.insert_before: 213 error_el.tail = el.text 214 el.text = None 215 el.insert(0, error_el) 216 else: 217 el.append(error_el) 218 else: 219 parent = el.getparent() 220 pos = parent.index(el) 221 if self.insert_before: 222 parent.insert(pos, error_el) 223 else: 224 error_el.tail = el.tail 225 el.tail = None 226 parent.insert(pos+1, error_el)

227 228 default_error_creator = DefaultErrorCreator() 229 230

231 -def insert_errors( 232 el, 233 errors, 234 form_id=None, 235 form_index=None, 236 error_class="error", 237 error_creator=default_error_creator, 238 ):

239 el = _find_form(el, form_id=form_id, form_index=form_index) 240 for name, error in errors.items(): 241 if error is None: 242 continue 243 for error_el, message in _find_elements_for_name(el, name, error): 244 assert isinstance(message, (basestring, type(None), ElementBase)), ( 245 "Bad message: %r" % message) 246 _insert_error(error_el, message, error_class, error_creator)

247

248 -def insert_errors_html(html, values, **kw):

249 result_type = type(html) 250 if isinstance(html, basestring): 251 doc = fromstring(html) 252 else: 253 doc = copy.deepcopy(html) 254 insert_errors(doc, values, **kw) 255 return _transform_result(result_type, doc)

256

257 -def _insert_error(el, error, error_class, error_creator):

258 if _nons(el.tag) in defs.empty_tags or _nons(el.tag) == 'textarea': 259 is_block = False 260 else: 261 is_block = True 262 if _nons(el.tag) != 'form' and error_class: 263 _add_class(el, error_class) 264 if el.get('id'): 265 labels = _label_for_xpath(el, for_id=el.get('id')) 266 if labels: 267 for label in labels: 268 _add_class(label, error_class) 269 error_creator(el, is_block, error)

270

271 -def _add_class(el, class_name):

272 if el.get('class'): 273 el.set('class', el.get('class')+' '+class_name) 274 else: 275 el.set('class', class_name)

276

277 -def _find_elements_for_name(form, name, error):

278 if name is None: 279 # An error for the entire form 280 yield form, error 281 return 282 if name.startswith('#'): 283 # By id 284 el = form.get_element_by_id(name[1:]) 285 if el is not None: 286 yield el, error 287 return 288 els = _name_xpath(form, name=name) 289 if not els: 290 # FIXME: should this raise an exception? 291 return 292 if not isinstance(error, (list, tuple)): 293 yield els[0], error 294 return 295 # FIXME: if error is longer than els, should it raise an error? 296 for el, err in zip(els, error): 297 if err is None: 298 continue 299 yield el, err

300

Source Code for Module lxml.html.formfill