lxml FAQ - Frequently Asked Questions

Stefan Behnel

pretty_print
findall()
xpath()
findall()
>>> from lxml import etree
+
lxml.etree
lxml.etree
lxml.etree
lxml.objectify
doc
lxml.cssselect
>>> root = etree.XML("<root><tag>text<child/></tag>tail</root>")
+>>> print(etree.tostring(root[0]))
+<tag>text<child/></tag>tail
+
>>> root = etree.Element("test")
+
+>>> root.text = "TEXT"
+>>> print(etree.tostring(root))
+<test>TEXT</test>
+
+>>> root.tail = "TAIL"
+>>> print(etree.tostring(root))
+<test>TEXT</test>TAIL
+
+>>> root.tail = None
+>>> print(etree.tostring(root))
+<test>TEXT</test>
+
.tail
lxml.html
>>> root = etree.XML("<?my PI?><root><!-- empty --></root>")
+
+>>> root.tag
+'root'
+>>> root.getprevious().tag is etree.PI
+True
+>>> root[0].tag is etree.Comment
+True
+
def recursive_dict(element):
+     return element.tag, \
+            dict(map(recursive_dict, element)) or element.text
+
/etc/xml/catalog
lxml.html
tests
src
doc
help()
lxml.etree
import sys
+from lxml import etree
+
+print("%-20s: %s" % ('Python',           sys.version_info))
+print("%-20s: %s" % ('lxml.etree',       etree.LXML_VERSION))
+print("%-20s: %s" % ('libxml used',      etree.LIBXML_VERSION))
+print("%-20s: %s" % ('libxml compiled',  etree.LIBXML_COMPILED_VERSION))
+print("%-20s: %s" % ('libxslt used',     etree.LIBXSLT_VERSION))
+print("%-20s: %s" % ('libxslt compiled', etree.LIBXSLT_COMPILED_VERSION))
+
xmllint
xsltproc
xsltproc
xmllint
.copy()
--without-threading
--without-pthreads
lxml.etree
mod_python
lxml.etree
lxml.etree
setup.py
--without-threading
pretty_print
remove_blank_text
>>> parser = etree.XMLParser(remove_blank_text=True)
+>>> tree = etree.parse(filename, parser)
+
remove_blank_text
<p><b>some</b> <em>text</em></p>
+
for element in root.iter():
+    element.tail = None
+
parse()
<?xml encoding="..."?>
etree.parse(file, parser)
parse()
xsl:output
indent
write()
iterparse()
huge_tree
resolve_entities=False
root.iter(etree.Entity)
iterparse()
def sort_attributes(root):
+    for el in root.iter():
+        attrib = el.attrib
+        if len(attrib) > 1:
+            attributes = sorted(attrib.items())
+            attrib.clear()
+            attrib.update(attributes)
+
findall()
xpath()
findall()
{namespace}tagname
xpath()
xpath()
XPath
XPathEvaluator
findall()
{namespace}tagname
findall()
findall()
root.iter()
nsmap
lxml.etree.LXML_VERSION
LIBXML_VERSION
LIBXSLT_VERSION
>>> from lxml import etree
+
>>> root = etree.Element("root")
+>>> a = etree.SubElement(root, "a")
+>>> b = etree.SubElement(root, "b")
+>>> c = etree.SubElement(root, "c")
+>>> d = etree.SubElement(root, "d")
+>>> e = etree.SubElement(d,    "e")
+>>> b.getparent() == root
+True
+>>> print(b.getnext().tag)
+c
+>>> print(c.getprevious().tag)
+b
+
>>> tree = d.getroottree()
+>>> print(tree.getroot().tag)
+root
+
>>> tree = etree.ElementTree(d)
+>>> print(tree.getroot().tag)
+d
+>>> etree.tostring(tree)
+b'<d><e/></d>'
+
>>> element = tree.getroot()
+>>> print(element.tag)
+d
+>>> print(element.getparent().tag)
+root
+>>> print(element.getroottree().getroot().tag)
+root
+
>>> [ child.tag for child in root ]
+['a', 'b', 'c', 'd']
+
reversed()
element.iter()
>>> [ el.tag for el in root.iter() ]
+['root', 'a', 'b', 'c', 'd', 'e']
+
>>> [ child.tag for child in root.iterchildren() ]
+['a', 'b', 'c', 'd']
+>>> [ child.tag for child in root.iterchildren(reversed=True) ]
+['d', 'c', 'b', 'a']
+>>> [ sibling.tag for sibling in b.itersiblings() ]
+['c', 'd']
+>>> [ sibling.tag for sibling in c.itersiblings(preceding=True) ]
+['b', 'a']
+>>> [ ancestor.tag for ancestor in e.iterancestors() ]
+['d', 'root']
+>>> [ el.tag for el in root.iterdescendants() ]
+['a', 'b', 'c', 'd', 'e']
+
element.iterdescendants()
element.iter()
>>> [ child.tag for child in root.iterchildren('a') ]
+['a']
+>>> [ child.tag for child in d.iterchildren('a') ]
+[]
+>>> [ el.tag for el in root.iterdescendants('d') ]
+['d']
+>>> [ el.tag for el in root.iter('d') ]
+['d']
+>>> [ el.tag for el in root.iter('d', 'a') ]
+['a', 'd']
+
.iter()
collections.deque
>>> root = etree.XML('<root><a><b/><c/></a><d><e/></d></root>')
+>>> print(etree.tostring(root, pretty_print=True, encoding='unicode'))
+<root>
+  <a>
+    <b/>
+    <c/>
+  </a>
+  <d>
+    <e/>
+  </d>
+</root>
+
+>>> queue = deque([root])
+>>> while queue:
+...    el = queue.popleft()  # pop next element
+...    queue.extend(el)      # append its children
+...    print(el.tag)
+root
+a
+d
+b
+c
+e
+
iterparse()
iterwalk()
error_log
>>> etree.clear_error_log()
+>>> broken_xml = '''
+... <root>
+...   <a>
+... </root>
+... '''
+>>> try:
+...   etree.parse(StringIO(broken_xml))
+... except etree.XMLSyntaxError, e:
+...   pass # just put the exception into e
+
error_log
>>> log = e.error_log.filter_from_level(etree.ErrorLevels.FATAL)
+>>> print(log[0])
+<string>:4:8:FATAL:PARSER:ERR_TAG_NAME_MISMATCH: Opening and ending tag mismatch: a line 3 and root
+
lxml.etree.ErrorDomains
>>> entry = log[0]
+>>> print(entry.domain_name)
+PARSER
+>>> print(entry.type_name)
+ERR_TAG_NAME_MISMATCH
+>>> print(entry.filename)
+<string>
+
error_log.last_error
etree.PyErrorLog
etree.useGlobalPythonLog
etree.PyErrorLog
ElementTree.write()
tostring()
method="c14n"
method="c14n2"
etree.canonicalize()
>>> c14n_xml = etree.canonicalize("<root><test z='1' y='2'/></root>")
+>>> print(c14n_xml)
+<root><test y="2" z="1"></test></root>
+
ElementTree.write()
tostring()
>>> root = etree.XML("<root><test/></root>")
+>>> etree.tostring(root)
+b'<root><test/></root>'
+
+>>> print(etree.tostring(root, pretty_print=True))
+<root>
+  <test/>
+</root>
+
>>> unicode_root = etree.Element( u"t\u3120st" )
+>>> unicode_root.text = u"t\u0A0Ast"
+>>> etree.tostring(unicode_root, encoding="utf-8")
+b'<t\xe3\x84\xa0st>t\xe0\xa8\x8ast</t\xe3\x84\xa0st>'
+
+>>> print(etree.tostring(unicode_root, encoding="iso-8859-1"))
+<?xml version='1.0' encoding='iso-8859-1'?>
+<t&#12576;st>t&#2570;st</t&#12576;st>
+
>>> print(etree.tostring(root, xml_declaration=True))
+<?xml version='1.0' encoding='ASCII'?>
+<root><test/></root>
+
+>>> unicode_root.clear()
+>>> etree.tostring(unicode_root, encoding="UTF-16LE",
+...                              xml_declaration=False)
+b'<\x00t\x00 1s\x00t\x00/\x00>\x00'
+
>>> notxml = etree.tostring(unicode_root, encoding="UTF-16LE",
+...                                       xml_declaration=False)
+>>> root = etree.XML(notxml)        #doctest: +ELLIPSIS
+Traceback (most recent call last):
+  ...
+lxml.etree.XMLSyntaxError: ...
+
>>> xml = '<!DOCTYPE root>\n<root/>'
+>>> tree = etree.parse(StringIO(xml))
+
+>>> print(etree.tostring(tree))
+<!DOCTYPE root>
+<root/>
+
+>>> print(etree.tostring(tree,
+...     doctype='<!DOCTYPE root SYSTEM "/tmp/test.dtd">'))
+<!DOCTYPE root SYSTEM "/tmp/test.dtd">
+<root/>
+
xmlfile
with
htmlfile
io.BytesIO()
+>>> f = BytesIO()
+>>> with etree.xmlfile(f) as xf:
+...     with xf.element('abc'):
+...         xf.write('text')
+
+>>> print(f.getvalue().decode('utf-8'))
+<abc>text</abc>
+
xmlfile()
close=True
.close()
write()
+>>> f = BytesIO()
+>>> with etree.xmlfile(f) as xf:
+...     with xf.element('abc'):
+...         with xf.element('in'):
+...
+...             for value in '123':
+...                 # construct a really complex XML tree
+...                 el = etree.Element('xyz', attr=value)
+...
+...                 xf.write(el)
+...
+...                 # no longer needed, discard it right away!
+...                 el = None
+
+>>> print(f.getvalue().decode('utf-8'))
+<abc><in><xyz attr="1"/><xyz attr="2"/><xyz attr="3"/></in></abc>
+
element()
+def writer(out_stream):
+    with xmlfile(out_stream) as xf:
+        with xf.element('{http://etherx.jabber.org/streams}stream'):
+            while True:
+                el = (yield)
+                xf.write(el)
+                xf.flush()
+
+w = writer(stream)
+next(w)   # start writing (run up to 'yield')
+
+w.send(element)
+
+w.close()
+
xf.flush()
buffered=False
xmlfile()
async def write(self, data)
async def close(self)
+async def writer(out_stream, xml_messages):
+    async with xmlfile(out_stream) as xf:
+        async with xf.element('{http://etherx.jabber.org/streams}stream'):
+             async for el in xml_messages:
+                  await xf.write(el)
+                  await xf.flush()
+
+
+class DummyAsyncOut(object):
+    async def write(self, data):
+        print(data.decode('utf8'))
+
+    async def close(self):
+         pass
+
+stream = DummyAsyncOut()
+async_writer = writer(stream, async_message_stream)
+
>>> parser = etree.XMLParser(strip_cdata=False)
+>>> root = etree.XML('<root><![CDATA[test]]></root>', parser)
+>>> root.text
+'test'
+
+>>> etree.tostring(root)
+b'<root><![CDATA[test]]></root>'
+
.text
CDATA()
>>> root.text = 'test'
+
+>>> root.text
+'test'
+>>> etree.tostring(root)
+b'<root>test</root>'
+
+>>> root.text = etree.CDATA(root.text)
+
+>>> root.text
+'test'
+>>> etree.tostring(root)
+b'<root><![CDATA[test]]></root>'
+
>>> data = StringIO('''\
+... <doc xmlns:xi="http://www.w3.org/2001/XInclude">
+... <foo/>
+... <xi:include href="doc/test.xml" />
+... </doc>''')
+
+>>> tree = etree.parse(data)
+>>> tree.xinclude()
+>>> print(etree.tostring(tree.getroot()))
+<doc xmlns:xi="http://www.w3.org/2001/XInclude">
+<foo/>
+<a xml:base="doc/test.xml"/>
+</doc>
+
lxml.ElementInclude
+object --+    
+         |    
+      type --+
+             |
+            ABCMeta
+
<select multiple>
<input>
<label>
<select>
.name
<textarea>
.name
.value
<input>
<select>
.name
<textarea>
.name
.value
<select multiple>
<select multiple>
Element.attrib
<input>
<label>
<select>
.name
<textarea>
.name
.value
<input type=checkbox>
<input type=radio>
+              object --+        
+                       |        
+exceptions.BaseException --+    
+                           |    
+        exceptions.Exception --+
+                               |
+                              SelectorError
+
+Common parent for :class:`SelectorSyntaxError` and
+:class:`ExpressionError`.
+
+You can just use ``except SelectorError:`` when calling
+:meth:`~GenericTranslator.css_to_xpath` and handle both exceptions types.
+
+
+                  object --+            
+                           |            
+    exceptions.BaseException --+        
+                               |        
+            exceptions.Exception --+    
+                                   |    
+                       SelectorError --+
+                                       |
+              object --+               |
+                       |               |
+exceptions.BaseException --+           |
+                           |           |
+        exceptions.Exception --+       |
+                               |       |
+        exceptions.StandardError --+   |
+                                   |   |
+              exceptions.SyntaxError --+
+                                       |
+                                      SelectorSyntaxError
+
+                  object --+            
+                           |            
+    exceptions.BaseException --+        
+                               |        
+            exceptions.Exception --+    
+                                   |    
+                parser.SelectorError --+
+                                       |
+              object --+               |
+                       |               |
+exceptions.BaseException --+           |
+                           |           |
+        exceptions.Exception --+       |
+                               |       |
+        exceptions.StandardError --+   |
+                                   |   |
+             exceptions.RuntimeError --+
+                                       |
+                                      ExpressionError
+
+object --+
+         |
+        XPathExpr
+
parser.set_element_class_lookup(lookup)
list(element)
element.iter()
tree.iter()
tostring(el, encoding='unicode')
+   object --+            
+            |            
+BaseException --+        
+                |        
+        Exception --+    
+                    |    
+        StandardError --+
+                        |
+                       AssertionError
+
E
lxml.etree
lxml.html
lxml.isoschematron
lxml.objectify
+ 1  # this is a package 
+ 2   
+ 3 -def get_include(): 
+
 4      """ 
+ 5      Returns a list of header include paths (for lxml itself, libxml2 
+ 6      and libxslt) needed to compile C code against lxml if it was built 
+ 7      with statically linked libraries. 
+ 8      """ 
+ 9      import os 
+10      lxml_path = __path__[0] 
+11      include_path = os.path.join(lxml_path, 'includes') 
+12      includes = [include_path, lxml_path] 
+13   
+14      for name in os.listdir(include_path): 
+15          path = os.path.join(include_path, name) 
+16          if os.path.isdir(path): 
+17              includes.append(path) 
+18   
+19      return includes 
+
20   
+
+  1  # 
+  2  # ElementTree 
+  3  # $Id: ElementInclude.py 1862 2004-06-18 07:31:02Z Fredrik $ 
+  4  # 
+  5  # limited xinclude support for element trees 
+  6  # 
+  7  # history: 
+  8  # 2003-08-15 fl   created 
+  9  # 2003-11-14 fl   fixed default loader 
+ 10  # 
+ 11  # Copyright (c) 2003-2004 by Fredrik Lundh.  All rights reserved. 
+ 12  # 
+ 13  # fredrik@pythonware.com 
+ 14  # http://www.pythonware.com 
+ 15  # 
+ 16  # -------------------------------------------------------------------- 
+ 17  # The ElementTree toolkit is 
+ 18  # 
+ 19  # Copyright (c) 1999-2004 by Fredrik Lundh 
+ 20  # 
+ 21  # By obtaining, using, and/or copying this software and/or its 
+ 22  # associated documentation, you agree that you have read, understood, 
+ 23  # and will comply with the following terms and conditions: 
+ 24  # 
+ 25  # Permission to use, copy, modify, and distribute this software and 
+ 26  # its associated documentation for any purpose and without fee is 
+ 27  # hereby granted, provided that the above copyright notice appears in 
+ 28  # all copies, and that both that copyright notice and this permission 
+ 29  # notice appear in supporting documentation, and that the name of 
+ 30  # Secret Labs AB or the author not be used in advertising or publicity 
+ 31  # pertaining to distribution of the software without specific, written 
+ 32  # prior permission. 
+ 33  # 
+ 34  # SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD 
+ 35  # TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- 
+ 36  # ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR 
+ 37  # BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 
+ 38  # DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 
+ 39  # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 
+ 40  # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+ 41  # OF THIS SOFTWARE. 
+ 42  # -------------------------------------------------------------------- 
+ 43   
+ 44  """ 
+ 45  Limited XInclude support for the ElementTree package. 
+ 46   
+ 47  While lxml.etree has full support for XInclude (see 
+ 48  `etree.ElementTree.xinclude()`), this module provides a simpler, pure 
+ 49  Python, ElementTree compatible implementation that supports a simple 
+ 50  form of custom URL resolvers. 
+ 51  """ 
+ 52   
+ 53  from lxml import etree 
+ 54  try: 
+ 55      from urlparse import urljoin 
+ 56      from urllib2 import urlopen 
+ 57  except ImportError: 
+ 58      # Python 3 
+ 59      from urllib.parse import urljoin 
+ 60      from urllib.request import urlopen 
+ 61   
+ 62  XINCLUDE = "{http://www.w3.org/2001/XInclude}" 
+ 63   
+ 64  XINCLUDE_INCLUDE = XINCLUDE + "include" 
+ 65  XINCLUDE_FALLBACK = XINCLUDE + "fallback" 
+ 66  XINCLUDE_ITER_TAG = XINCLUDE + "*" 
+ 67   
+ 68  # For security reasons, the inclusion depth is limited to this read-only value by default. 
+ 69  DEFAULT_MAX_INCLUSION_DEPTH = 6 
+ 70   
+ 71   
+ 72  ## 
+ 73  # Fatal include error. 
+ 74   
+ 75 -class FatalIncludeError(etree.LxmlSyntaxError): 
+
 76      pass 
+
 77   
+ 78   
+ 79 -class LimitedRecursiveIncludeError(FatalIncludeError): 
+
 80      pass 
+
 81   
+ 82   
+ 83  ## 
+ 84  # ET compatible default loader. 
+ 85  # This loader reads an included resource from disk. 
+ 86  # 
+ 87  # @param href Resource reference. 
+ 88  # @param parse Parse mode.  Either "xml" or "text". 
+ 89  # @param encoding Optional text encoding. 
+ 90  # @return The expanded resource.  If the parse mode is "xml", this 
+ 91  #    is an ElementTree instance.  If the parse mode is "text", this 
+ 92  #    is a Unicode string.  If the loader fails, it can return None 
+ 93  #    or raise an IOError exception. 
+ 94  # @throws IOError If the loader fails to load the resource. 
+ 95   
+ 96 -def default_loader(href, parse, encoding=None): 
+
 97      file = open(href, 'rb') 
+ 98      if parse == "xml": 
+ 99          data = etree.parse(file).getroot() 
+100      else: 
+101          data = file.read() 
+102          if not encoding: 
+103              encoding = 'utf-8' 
+104          data = data.decode(encoding) 
+105      file.close() 
+106      return data 
+
107   
+108   
+109  ## 
+110  # Default loader used by lxml.etree - handles custom resolvers properly 
+111  #  
+112   
+113 -def _lxml_default_loader(href, parse, encoding=None, parser=None): 
+
114      if parse == "xml": 
+115          data = etree.parse(href, parser).getroot() 
+116      else: 
+117          if "://" in href: 
+118              f = urlopen(href) 
+119          else: 
+120              f = open(href, 'rb') 
+121          data = f.read() 
+122          f.close() 
+123          if not encoding: 
+124              encoding = 'utf-8' 
+125          data = data.decode(encoding) 
+126      return data 
+
127   
+128   
+129  ## 
+130  # Wrapper for ET compatibility - drops the parser 
+131   
+132 -def _wrap_et_loader(loader): 
+
133      def load(href, parse, encoding=None, parser=None): 
+134          return loader(href, parse, encoding) 
+
135      return load 
+136   
+137   
+138  ## 
+139  # Expand XInclude directives. 
+140  # 
+141  # @param elem Root element. 
+142  # @param loader Optional resource loader.  If omitted, it defaults 
+143  #     to {@link default_loader}.  If given, it should be a callable 
+144  #     that implements the same interface as <b>default_loader</b>. 
+145  # @param base_url The base URL of the original file, to resolve 
+146  #     relative include file references. 
+147  # @param max_depth The maximum number of recursive inclusions. 
+148  #     Limited to reduce the risk of malicious content explosion. 
+149  #     Pass None to disable the limitation. 
+150  # @throws LimitedRecursiveIncludeError If the {@link max_depth} was exceeded. 
+151  # @throws FatalIncludeError If the function fails to include a given 
+152  #     resource, or if the tree contains malformed XInclude elements. 
+153  # @throws IOError If the function fails to load a given resource. 
+154  # @returns the node or its replacement if it was an XInclude node 
+155   
+156 -def include(elem, loader=None, base_url=None, 
+157              max_depth=DEFAULT_MAX_INCLUSION_DEPTH): 
+
158      if max_depth is None: 
+159          max_depth = -1 
+160      elif max_depth < 0: 
+161          raise ValueError("expected non-negative depth or None for 'max_depth', got %r" % max_depth) 
+162   
+163      if base_url is None: 
+164          if hasattr(elem, 'getroot'): 
+165              tree = elem 
+166              elem = elem.getroot() 
+167          else: 
+168              tree = elem.getroottree() 
+169          if hasattr(tree, 'docinfo'): 
+170              base_url = tree.docinfo.URL 
+171      elif hasattr(elem, 'getroot'): 
+172          elem = elem.getroot() 
+173      _include(elem, loader, base_url, max_depth) 
+
174   
+175   
+176 -def _include(elem, loader=None, base_url=None, 
+177               max_depth=DEFAULT_MAX_INCLUSION_DEPTH, _parent_hrefs=None): 
+
178      if loader is not None: 
+179          load_include = _wrap_et_loader(loader) 
+180      else: 
+181          load_include = _lxml_default_loader 
+182   
+183      if _parent_hrefs is None: 
+184          _parent_hrefs = set() 
+185   
+186      parser = elem.getroottree().parser 
+187   
+188      include_elements = list( 
+189          elem.iter(XINCLUDE_ITER_TAG)) 
+190   
+191      for e in include_elements: 
+192          if e.tag == XINCLUDE_INCLUDE: 
+193              # process xinclude directive 
+194              href = urljoin(base_url, e.get("href")) 
+195              parse = e.get("parse", "xml") 
+196              parent = e.getparent() 
+197              if parse == "xml": 
+198                  if href in _parent_hrefs: 
+199                      raise FatalIncludeError( 
+200                          "recursive include of %r detected" % href 
+201                          ) 
+202                  if max_depth == 0: 
+203                      raise LimitedRecursiveIncludeError( 
+204                          "maximum xinclude depth reached when including file %s" % href) 
+205                  node = load_include(href, parse, parser=parser) 
+206                  if node is None: 
+207                      raise FatalIncludeError( 
+208                          "cannot load %r as %r" % (href, parse) 
+209                          ) 
+210                  node = _include(node, loader, href, max_depth - 1, {href} | _parent_hrefs) 
+211                  if e.tail: 
+212                      node.tail = (node.tail or "") + e.tail 
+213                  if parent is None: 
+214                      return node # replaced the root node! 
+215                  parent.replace(e, node) 
+216              elif parse == "text": 
+217                  text = load_include(href, parse, encoding=e.get("encoding")) 
+218                  if text is None: 
+219                      raise FatalIncludeError( 
+220                          "cannot load %r as %r" % (href, parse) 
+221                          ) 
+222                  predecessor = e.getprevious() 
+223                  if predecessor is not None: 
+224                      predecessor.tail = (predecessor.tail or "") + text 
+225                  elif parent is None: 
+226                      return text # replaced the root node! 
+227                  else: 
+228                      parent.text = (parent.text or "") + text + (e.tail or "") 
+229                  parent.remove(e) 
+230              else: 
+231                  raise FatalIncludeError( 
+232                      "unknown parse type in xi:include tag (%r)" % parse 
+233                  ) 
+234          elif e.tag == XINCLUDE_FALLBACK: 
+235              parent = e.getparent() 
+236              if parent is not None and parent.tag != XINCLUDE_INCLUDE: 
+237                  raise FatalIncludeError( 
+238                      "xi:fallback tag must be child of xi:include (%r)" % e.tag 
+239                      ) 
+240          else: 
+241              raise FatalIncludeError( 
+242                  "Invalid element found in XInclude namespace (%r)" % e.tag 
+243                  ) 
+244      return elem 
+
245   
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                     etree.Error --+        
+                                   |        
+                     etree.LxmlError --+    
+                                       |    
+              object --+               |    
+                       |               |    
+exceptions.BaseException --+           |    
+                           |           |    
+        exceptions.Exception --+       |    
+                               |       |    
+        exceptions.StandardError --+   |    
+                                   |   |    
+              exceptions.SyntaxError --+    
+                                       |    
+                   etree.LxmlSyntaxError --+
+                                           |
+                                          FatalIncludeError
+
+              object --+                        
+                       |                        
+exceptions.BaseException --+                    
+                           |                    
+        exceptions.Exception --+                
+                               |                
+                     etree.Error --+            
+                                   |            
+                     etree.LxmlError --+        
+                                       |        
+              object --+               |        
+                       |               |        
+exceptions.BaseException --+           |        
+                           |           |        
+        exceptions.Exception --+       |        
+                               |       |        
+        exceptions.StandardError --+   |        
+                                   |   |        
+              exceptions.SyntaxError --+        
+                                       |        
+                   etree.LxmlSyntaxError --+    
+                                           |    
+                           FatalIncludeError --+
+                                               |
+                                              LimitedRecursiveIncludeError
+
E
+{'ET': <capsule object "PyObject *" at 0x7f4dd2fc6a50>,
+ 'partial': <capsule object "PyObject *" at 0x7f4dd2fc6a80>}
+
+  1  # cython: language_level=2 
+  2   
+  3  # 
+  4  # Element generator factory by Fredrik Lundh. 
+  5  # 
+  6  # Source: 
+  7  #    http://online.effbot.org/2006_11_01_archive.htm#et-builder 
+  8  #    http://effbot.python-hosting.com/file/stuff/sandbox/elementlib/builder.py 
+  9  # 
+ 10  # -------------------------------------------------------------------- 
+ 11  # The ElementTree toolkit is 
+ 12  # 
+ 13  # Copyright (c) 1999-2004 by Fredrik Lundh 
+ 14  # 
+ 15  # By obtaining, using, and/or copying this software and/or its 
+ 16  # associated documentation, you agree that you have read, understood, 
+ 17  # and will comply with the following terms and conditions: 
+ 18  # 
+ 19  # Permission to use, copy, modify, and distribute this software and 
+ 20  # its associated documentation for any purpose and without fee is 
+ 21  # hereby granted, provided that the above copyright notice appears in 
+ 22  # all copies, and that both that copyright notice and this permission 
+ 23  # notice appear in supporting documentation, and that the name of 
+ 24  # Secret Labs AB or the author not be used in advertising or publicity 
+ 25  # pertaining to distribution of the software without specific, written 
+ 26  # prior permission. 
+ 27  # 
+ 28  # SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD 
+ 29  # TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- 
+ 30  # ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR 
+ 31  # BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 
+ 32  # DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 
+ 33  # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 
+ 34  # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+ 35  # OF THIS SOFTWARE. 
+ 36  # -------------------------------------------------------------------- 
+ 37   
+ 38  """ 
+ 39  The ``E`` Element factory for generating XML documents. 
+ 40  """ 
+ 41   
+ 42  from __future__ import absolute_import 
+ 43   
+ 44  import lxml.etree as ET 
+ 45   
+ 46  from functools import partial 
+ 47   
+ 48  try: 
+ 49      basestring 
+ 50  except NameError: 
+ 51      basestring = str 
+ 52   
+ 53  try: 
+ 54      unicode 
+ 55  except NameError: 
+ 56      unicode = str 
+ 57   
+ 58   
+ 59 -class ElementMaker(object): 
+
 60      """Element generator factory. 
+ 61   
+ 62      Unlike the ordinary Element factory, the E factory allows you to pass in 
+ 63      more than just a tag and some optional attributes; you can also pass in 
+ 64      text and other elements.  The text is added as either text or tail 
+ 65      attributes, and elements are inserted at the right spot.  Some small 
+ 66      examples:: 
+ 67   
+ 68          >>> from lxml import etree as ET 
+ 69          >>> from lxml.builder import E 
+ 70   
+ 71          >>> ET.tostring(E("tag")) 
+ 72          '<tag/>' 
+ 73          >>> ET.tostring(E("tag", "text")) 
+ 74          '<tag>text</tag>' 
+ 75          >>> ET.tostring(E("tag", "text", key="value")) 
+ 76          '<tag key="value">text</tag>' 
+ 77          >>> ET.tostring(E("tag", E("subtag", "text"), "tail")) 
+ 78          '<tag><subtag>text</subtag>tail</tag>' 
+ 79   
+ 80      For simple tags, the factory also allows you to write ``E.tag(...)`` instead 
+ 81      of ``E('tag', ...)``:: 
+ 82   
+ 83          >>> ET.tostring(E.tag()) 
+ 84          '<tag/>' 
+ 85          >>> ET.tostring(E.tag("text")) 
+ 86          '<tag>text</tag>' 
+ 87          >>> ET.tostring(E.tag(E.subtag("text"), "tail")) 
+ 88          '<tag><subtag>text</subtag>tail</tag>' 
+ 89   
+ 90      Here's a somewhat larger example; this shows how to generate HTML 
+ 91      documents, using a mix of prepared factory functions for inline elements, 
+ 92      nested ``E.tag`` calls, and embedded XHTML fragments:: 
+ 93   
+ 94          # some common inline elements 
+ 95          A = E.a 
+ 96          I = E.i 
+ 97          B = E.b 
+ 98   
+ 99          def CLASS(v): 
+100              # helper function, 'class' is a reserved word 
+101              return {'class': v} 
+102   
+103          page = ( 
+104              E.html( 
+105                  E.head( 
+106                      E.title("This is a sample document") 
+107                  ), 
+108                  E.body( 
+109                      E.h1("Hello!", CLASS("title")), 
+110                      E.p("This is a paragraph with ", B("bold"), " text in it!"), 
+111                      E.p("This is another paragraph, with a ", 
+112                          A("link", href="http://www.python.org"), "."), 
+113                      E.p("Here are some reserved characters: <spam&egg>."), 
+114                      ET.XML("<p>And finally, here is an embedded XHTML fragment.</p>"), 
+115                  ) 
+116              ) 
+117          ) 
+118   
+119          print ET.tostring(page) 
+120   
+121      Here's a prettyprinted version of the output from the above script:: 
+122   
+123          <html> 
+124            <head> 
+125              <title>This is a sample document</title> 
+126            </head> 
+127            <body> 
+128              <h1 class="title">Hello!</h1> 
+129              <p>This is a paragraph with <b>bold</b> text in it!</p> 
+130              <p>This is another paragraph, with <a href="http://www.python.org">link</a>.</p> 
+131              <p>Here are some reserved characters: &lt;spam&amp;egg&gt;.</p> 
+132              <p>And finally, here is an embedded XHTML fragment.</p> 
+133            </body> 
+134          </html> 
+135   
+136      For namespace support, you can pass a namespace map (``nsmap``) 
+137      and/or a specific target ``namespace`` to the ElementMaker class:: 
+138   
+139          >>> E = ElementMaker(namespace="http://my.ns/") 
+140          >>> print(ET.tostring( E.test )) 
+141          <test xmlns="http://my.ns/"/> 
+142   
+143          >>> E = ElementMaker(namespace="http://my.ns/", nsmap={'p':'http://my.ns/'}) 
+144          >>> print(ET.tostring( E.test )) 
+145          <p:test xmlns:p="http://my.ns/"/> 
+146      """ 
+147   
+148 -    def __init__(self, typemap=None, 
+149                   namespace=None, nsmap=None, makeelement=None): 
+
150          if namespace is not None: 
+151              self._namespace = '{' + namespace + '}' 
+152          else: 
+153              self._namespace = None 
+154   
+155          if nsmap: 
+156              self._nsmap = dict(nsmap) 
+157          else: 
+158              self._nsmap = None 
+159   
+160          if makeelement is not None: 
+161              assert callable(makeelement) 
+162              self._makeelement = makeelement 
+163          else: 
+164              self._makeelement = ET.Element 
+165   
+166          # initialize type map for this element factory 
+167   
+168          if typemap: 
+169              typemap = dict(typemap) 
+170          else: 
+171              typemap = {} 
+172   
+173          def add_text(elem, item): 
+174              try: 
+175                  elem[-1].tail = (elem[-1].tail or "") + item 
+176              except IndexError: 
+177                  elem.text = (elem.text or "") + item 
+
178   
+179          def add_cdata(elem, cdata): 
+180              if elem.text: 
+181                  raise ValueError("Can't add a CDATA section. Element already has some text: %r" % elem.text) 
+182              elem.text = cdata 
+
183   
+184          if str not in typemap: 
+185              typemap[str] = add_text 
+186          if unicode not in typemap: 
+187              typemap[unicode] = add_text 
+188          if ET.CDATA not in typemap: 
+189              typemap[ET.CDATA] = add_cdata 
+190   
+191          def add_dict(elem, item): 
+192              attrib = elem.attrib 
+193              for k, v in item.items(): 
+194                  if isinstance(v, basestring): 
+195                      attrib[k] = v 
+196                  else: 
+197                      attrib[k] = typemap[type(v)](None, v) 
+198          if dict not in typemap: 
+199              typemap[dict] = add_dict 
+200   
+201          self._typemap = typemap 
+202   
+203 -    def __call__(self, tag, *children, **attrib): 
+
204          typemap = self._typemap 
+205   
+206          if self._namespace is not None and tag[0] != '{': 
+207              tag = self._namespace + tag 
+208          elem = self._makeelement(tag, nsmap=self._nsmap) 
+209          if attrib: 
+210              typemap[dict](elem, attrib) 
+211   
+212          for item in children: 
+213              if callable(item): 
+214                  item = item() 
+215              t = typemap.get(type(item)) 
+216              if t is None: 
+217                  if ET.iselement(item): 
+218                      elem.append(item) 
+219                      continue 
+220                  for basetype in type(item).__mro__: 
+221                      # See if the typemap knows of any of this type's bases. 
+222                      t = typemap.get(basetype) 
+223                      if t is not None: 
+224                          break 
+225                  else: 
+226                      raise TypeError("bad argument type: %s(%r)" % 
+227                                      (type(item).__name__, item)) 
+228              v = t(elem, item) 
+229              if v: 
+230                  typemap.get(type(v))(elem, v) 
+231   
+232          return elem 
+
233   
+234 -    def __getattr__(self, tag): 
+
235          return partial(self, tag) 
+
236   
+237   
+238  # create factory object 
+239  E = ElementMaker() 
+240   
+
+object --+
+         |
+        ElementMaker
+
+>>> from lxml import etree as ET
+>>> from lxml.builder import E
+
+>>> ET.tostring(E("tag"))
+'<tag/>'
+>>> ET.tostring(E("tag", "text"))
+'<tag>text</tag>'
+>>> ET.tostring(E("tag", "text", key="value"))
+'<tag key="value">text</tag>'
+>>> ET.tostring(E("tag", E("subtag", "text"), "tail"))
+'<tag><subtag>text</subtag>tail</tag>'
+
E.tag(...)
E('tag', ...)
+>>> ET.tostring(E.tag())
+'<tag/>'
+>>> ET.tostring(E.tag("text"))
+'<tag>text</tag>'
+>>> ET.tostring(E.tag(E.subtag("text"), "tail"))
+'<tag><subtag>text</subtag>tail</tag>'
+
E.tag
+# some common inline elements
+A = E.a
+I = E.i
+B = E.b
+
+def CLASS(v):
+    # helper function, 'class' is a reserved word
+    return {'class': v}
+
+page = (
+    E.html(
+        E.head(
+            E.title("This is a sample document")
+        ),
+        E.body(
+            E.h1("Hello!", CLASS("title")),
+            E.p("This is a paragraph with ", B("bold"), " text in it!"),
+            E.p("This is another paragraph, with a ",
+                A("link", href="http://www.python.org"), "."),
+            E.p("Here are some reserved characters: <spam&egg>."),
+            ET.XML("<p>And finally, here is an embedded XHTML fragment.</p>"),
+        )
+    )
+)
+
+print ET.tostring(page)
+
+<html>
+  <head>
+    <title>This is a sample document</title>
+  </head>
+  <body>
+    <h1 class="title">Hello!</h1>
+    <p>This is a paragraph with <b>bold</b> text in it!</p>
+    <p>This is another paragraph, with <a href="http://www.python.org">link</a>.</p>
+    <p>Here are some reserved characters: &lt;spam&amp;egg&gt;.</p>
+    <p>And finally, here is an embedded XHTML fragment.</p>
+  </body>
+</html>
+
nsmap
namespace
+>>> E = ElementMaker(namespace="http://my.ns/")
+>>> print(ET.tostring( E.test ))
+<test xmlns="http://my.ns/"/>
+
+>>> E = ElementMaker(namespace="http://my.ns/", nsmap={'p':'http://my.ns/'})
+>>> print(ET.tostring( E.test ))
+<p:test xmlns:p="http://my.ns/"/>
+
+  1  """CSS Selectors based on XPath. 
+  2   
+  3  This module supports selecting XML/HTML tags based on CSS selectors. 
+  4  See the `CSSSelector` class for details. 
+  5   
+  6  This is a thin wrapper around cssselect 0.7 or later. 
+  7  """ 
+  8   
+  9  from __future__ import absolute_import 
+ 10   
+ 11  from . import etree 
+ 12  try: 
+ 13      import cssselect as external_cssselect 
+ 14  except ImportError: 
+ 15      raise ImportError( 
+ 16          'cssselect does not seem to be installed. ' 
+ 17          'See http://packages.python.org/cssselect/') 
+ 18   
+ 19   
+ 20  SelectorSyntaxError = external_cssselect.SelectorSyntaxError 
+ 21  ExpressionError = external_cssselect.ExpressionError 
+ 22  SelectorError = external_cssselect.SelectorError 
+ 23   
+ 24   
+ 25  __all__ = ['SelectorSyntaxError', 'ExpressionError', 'SelectorError', 
+ 26             'CSSSelector'] 
+ 27   
+ 28   
+ 29 -class LxmlTranslator(external_cssselect.GenericTranslator): 
+
 30      """ 
+ 31      A custom CSS selector to XPath translator with lxml-specific extensions. 
+ 32      """ 
+ 33 -    def xpath_contains_function(self, xpath, function): 
+
 34          # Defined there, removed in later drafts: 
+ 35          # http://www.w3.org/TR/2001/CR-css3-selectors-20011113/#content-selectors 
+ 36          if function.argument_types() not in (['STRING'], ['IDENT']): 
+ 37              raise ExpressionError( 
+ 38                  "Expected a single string or ident for :contains(), got %r" 
+ 39                  % function.arguments) 
+ 40          value = function.arguments[0].value 
+ 41          return xpath.add_condition( 
+ 42              'contains(__lxml_internal_css:lower-case(string(.)), %s)' 
+ 43              % self.xpath_literal(value.lower())) 
+
 44   
+ 45   
+ 46 -class LxmlHTMLTranslator(LxmlTranslator, external_cssselect.HTMLTranslator): 
+
 47      """ 
+ 48      lxml extensions + HTML support. 
+ 49      """ 
+
 50   
+ 51   
+ 52 -def _make_lower_case(context, s): 
+
 53      return s.lower() 
+
 54   
+ 55  ns = etree.FunctionNamespace('http://codespeak.net/lxml/css/') 
+ 56  ns.prefix = '__lxml_internal_css' 
+ 57  ns['lower-case'] = _make_lower_case 
+ 58   
+ 59   
+ 60 -class CSSSelector(etree.XPath): 
+
 61      """A CSS selector. 
+ 62   
+ 63      Usage:: 
+ 64   
+ 65          >>> from lxml import etree, cssselect 
+ 66          >>> select = cssselect.CSSSelector("a tag > child") 
+ 67   
+ 68          >>> root = etree.XML("<a><b><c/><tag><child>TEXT</child></tag></b></a>") 
+ 69          >>> [ el.tag for el in select(root) ] 
+ 70          ['child'] 
+ 71   
+ 72      To use CSS namespaces, you need to pass a prefix-to-namespace 
+ 73      mapping as ``namespaces`` keyword argument:: 
+ 74   
+ 75          >>> rdfns = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' 
+ 76          >>> select_ns = cssselect.CSSSelector('root > rdf|Description', 
+ 77          ...                                   namespaces={'rdf': rdfns}) 
+ 78   
+ 79          >>> rdf = etree.XML(( 
+ 80          ...     '<root xmlns:rdf="%s">' 
+ 81          ...       '<rdf:Description>blah</rdf:Description>' 
+ 82          ...     '</root>') % rdfns) 
+ 83          >>> [(el.tag, el.text) for el in select_ns(rdf)] 
+ 84          [('{http://www.w3.org/1999/02/22-rdf-syntax-ns#}Description', 'blah')] 
+ 85   
+ 86      """ 
+ 87 -    def __init__(self, css, namespaces=None, translator='xml'): 
+
 88          if translator == 'xml': 
+ 89              translator = LxmlTranslator() 
+ 90          elif translator == 'html': 
+ 91              translator = LxmlHTMLTranslator() 
+ 92          elif translator == 'xhtml': 
+ 93              translator = LxmlHTMLTranslator(xhtml=True) 
+ 94          path = translator.css_to_xpath(css) 
+ 95          etree.XPath.__init__(self, path, namespaces=namespaces) 
+ 96          self.css = css 
+
 97   
+ 98 -    def __repr__(self): 
+
 99          return '<%s %s for %r>' % ( 
+100              self.__class__.__name__, 
+101              hex(abs(id(self)))[2:], 
+102              self.css) 
+
103   
+
+               object --+        
+                        |        
+etree._XPathEvaluatorBase --+    
+                            |    
+                  etree.XPath --+
+                                |
+                               CSSSelector
+
+>>> from lxml import etree, cssselect
+>>> select = cssselect.CSSSelector("a tag > child")
+
+>>> root = etree.XML("<a><b><c/><tag><child>TEXT</child></tag></b></a>")
+>>> [ el.tag for el in select(root) ]
+['child']
+
namespaces
+>>> rdfns = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+>>> select_ns = cssselect.CSSSelector('root > rdf|Description',
+...                                   namespaces={'rdf': rdfns})
+
+>>> rdf = etree.XML((
+...     '<root xmlns:rdf="%s">'
+...       '<rdf:Description>blah</rdf:Description>'
+...     '</root>') % rdfns)
+>>> [(el.tag, el.text) for el in select_ns(rdf)]
+[('{http://www.w3.org/1999/02/22-rdf-syntax-ns#}Description', 'blah')]
+
+                       object --+        
+                                |        
+cssselect.xpath.GenericTranslator --+    
+                                    |    
+                       LxmlTranslator --+
+                                        |
+                       object --+       |
+                                |       |
+cssselect.xpath.GenericTranslator --+   |
+                                    |   |
+       cssselect.xpath.HTMLTranslator --+
+                                        |
+                                       LxmlHTMLTranslator
+
+                       object --+    
+                                |    
+cssselect.xpath.GenericTranslator --+
+                                    |
+                                   LxmlTranslator
+
+>>> import lxml.usedoctest # for XML output
+
+>>> import lxml.html.usedoctest # for HTML output
+
lxmldoctest.install()
<
<html
PARSE_HTML
PARSE_XML
...
<any>
any
any
+
-
# doctest:+NOPARSE_MARKUP
+{'basic': '''
+    >>> temp_install()
+    >>> print """<xml a="1" b="2">stuff</xml>"""
+    <xml b="2" a="1">...</xml>
+    >>> print """<xml xmlns="http://example.com"><tag   attr="bar"   /
+></xml>"""
+    <xml xmlns="...">
+      <tag attr="..." />
+...
+
+  1  """ 
+  2  lxml-based doctest output comparison. 
+  3   
+  4  Note: normally, you should just import the `lxml.usedoctest` and 
+  5  `lxml.html.usedoctest` modules from within a doctest, instead of this 
+  6  one:: 
+  7   
+  8      >>> import lxml.usedoctest # for XML output 
+  9   
+ 10      >>> import lxml.html.usedoctest # for HTML output 
+ 11   
+ 12  To use this module directly, you must call ``lxmldoctest.install()``, 
+ 13  which will cause doctest to use this in all subsequent calls. 
+ 14   
+ 15  This changes the way output is checked and comparisons are made for 
+ 16  XML or HTML-like content. 
+ 17   
+ 18  XML or HTML content is noticed because the example starts with ``<`` 
+ 19  (it's HTML if it starts with ``<html``).  You can also use the 
+ 20  ``PARSE_HTML`` and ``PARSE_XML`` flags to force parsing. 
+ 21   
+ 22  Some rough wildcard-like things are allowed.  Whitespace is generally 
+ 23  ignored (except in attributes).  In text (attributes and text in the 
+ 24  body) you can use ``...`` as a wildcard.  In an example it also 
+ 25  matches any trailing tags in the element, though it does not match 
+ 26  leading tags.  You may create a tag ``<any>`` or include an ``any`` 
+ 27  attribute in the tag.  An ``any`` tag matches any tag, while the 
+ 28  attribute matches any and all attributes. 
+ 29   
+ 30  When a match fails, the reformatted example and gotten text is 
+ 31  displayed (indented), and a rough diff-like output is given.  Anything 
+ 32  marked with ``+`` is in the output but wasn't supposed to be, and 
+ 33  similarly ``-`` means its in the example but wasn't in the output. 
+ 34   
+ 35  You can disable parsing on one line with ``# doctest:+NOPARSE_MARKUP`` 
+ 36  """ 
+ 37   
+ 38  from lxml import etree 
+ 39  import sys 
+ 40  import re 
+ 41  import doctest 
+ 42  try: 
+ 43      from html import escape as html_escape 
+ 44  except ImportError: 
+ 45      from cgi import escape as html_escape 
+ 46   
+ 47  __all__ = ['PARSE_HTML', 'PARSE_XML', 'NOPARSE_MARKUP', 'LXMLOutputChecker', 
+ 48             'LHTMLOutputChecker', 'install', 'temp_install'] 
+ 49   
+ 50  try: 
+ 51      _basestring = basestring 
+ 52  except NameError: 
+ 53      _basestring = (str, bytes) 
+ 54   
+ 55  _IS_PYTHON_3 = sys.version_info[0] >= 3 
+ 56   
+ 57  PARSE_HTML = doctest.register_optionflag('PARSE_HTML') 
+ 58  PARSE_XML = doctest.register_optionflag('PARSE_XML') 
+ 59  NOPARSE_MARKUP = doctest.register_optionflag('NOPARSE_MARKUP') 
+ 60   
+ 61  OutputChecker = doctest.OutputChecker 
+ 62   
+ 63 -def strip(v): 
+
 64      if v is None: 
+ 65          return None 
+ 66      else: 
+ 67          return v.strip() 
+
 68   
+ 69 -def norm_whitespace(v): 
+
 70      return _norm_whitespace_re.sub(' ', v) 
+
 71   
+ 72  _html_parser = etree.HTMLParser(recover=False, remove_blank_text=True) 
+ 73   
+ 74 -def html_fromstring(html): 
+
 75      return etree.fromstring(html, _html_parser) 
+
 76   
+ 77  # We use this to distinguish repr()s from elements: 
+ 78  _repr_re = re.compile(r'^<[^>]+ (at|object) ') 
+ 79  _norm_whitespace_re = re.compile(r'[ \t\n][ \t\n]+') 
+ 80   
+ 81 -class LXMLOutputChecker(OutputChecker): 
+
 82   
+ 83      empty_tags = ( 
+ 84          'param', 'img', 'area', 'br', 'basefont', 'input', 
+ 85          'base', 'meta', 'link', 'col') 
+ 86   
+ 87 -    def get_default_parser(self): 
+
 88          return etree.XML 
+
 89   
+ 90 -    def check_output(self, want, got, optionflags): 
+
 91          alt_self = getattr(self, '_temp_override_self', None) 
+ 92          if alt_self is not None: 
+ 93              super_method = self._temp_call_super_check_output 
+ 94              self = alt_self 
+ 95          else: 
+ 96              super_method = OutputChecker.check_output 
+ 97          parser = self.get_parser(want, got, optionflags) 
+ 98          if not parser: 
+ 99              return super_method( 
+100                  self, want, got, optionflags) 
+101          try: 
+102              want_doc = parser(want) 
+103          except etree.XMLSyntaxError: 
+104              return False 
+105          try: 
+106              got_doc = parser(got) 
+107          except etree.XMLSyntaxError: 
+108              return False 
+109          return self.compare_docs(want_doc, got_doc) 
+
110   
+111 -    def get_parser(self, want, got, optionflags): 
+
112          parser = None 
+113          if NOPARSE_MARKUP & optionflags: 
+114              return None 
+115          if PARSE_HTML & optionflags: 
+116              parser = html_fromstring 
+117          elif PARSE_XML & optionflags: 
+118              parser = etree.XML 
+119          elif (want.strip().lower().startswith('<html') 
+120                and got.strip().startswith('<html')): 
+121              parser = html_fromstring 
+122          elif (self._looks_like_markup(want) 
+123                and self._looks_like_markup(got)): 
+124              parser = self.get_default_parser() 
+125          return parser 
+
126   
+127 -    def _looks_like_markup(self, s): 
+
128          s = s.strip() 
+129          return (s.startswith('<') 
+130                  and not _repr_re.search(s)) 
+
131   
+132 -    def compare_docs(self, want, got): 
+
133          if not self.tag_compare(want.tag, got.tag): 
+134              return False 
+135          if not self.text_compare(want.text, got.text, True): 
+136              return False 
+137          if not self.text_compare(want.tail, got.tail, True): 
+138              return False 
+139          if 'any' not in want.attrib: 
+140              want_keys = sorted(want.attrib.keys()) 
+141              got_keys = sorted(got.attrib.keys()) 
+142              if want_keys != got_keys: 
+143                  return False 
+144              for key in want_keys: 
+145                  if not self.text_compare(want.attrib[key], got.attrib[key], False): 
+146                      return False 
+147          if want.text != '...' or len(want): 
+148              want_children = list(want) 
+149              got_children = list(got) 
+150              while want_children or got_children: 
+151                  if not want_children or not got_children: 
+152                      return False 
+153                  want_first = want_children.pop(0) 
+154                  got_first = got_children.pop(0) 
+155                  if not self.compare_docs(want_first, got_first): 
+156                      return False 
+157                  if not got_children and want_first.tail == '...': 
+158                      break 
+159          return True 
+
160   
+161 -    def text_compare(self, want, got, strip): 
+
162          want = want or '' 
+163          got = got or '' 
+164          if strip: 
+165              want = norm_whitespace(want).strip() 
+166              got = norm_whitespace(got).strip() 
+167          want = '^%s$' % re.escape(want) 
+168          want = want.replace(r'\.\.\.', '.*') 
+169          if re.search(want, got): 
+170              return True 
+171          else: 
+172              return False 
+
173   
+174 -    def tag_compare(self, want, got): 
+
175          if want == 'any': 
+176              return True 
+177          if (not isinstance(want, _basestring) 
+178              or not isinstance(got, _basestring)): 
+179              return want == got 
+180          want = want or '' 
+181          got = got or '' 
+182          if want.startswith('{...}'): 
+183              # Ellipsis on the namespace 
+184              return want.split('}')[-1] == got.split('}')[-1] 
+185          else: 
+186              return want == got 
+
187   
+188 -    def output_difference(self, example, got, optionflags): 
+
189          want = example.want 
+190          parser = self.get_parser(want, got, optionflags) 
+191          errors = [] 
+192          if parser is not None: 
+193              try: 
+194                  want_doc = parser(want) 
+195              except etree.XMLSyntaxError: 
+196                  e = sys.exc_info()[1] 
+197                  errors.append('In example: %s' % e) 
+198              try: 
+199                  got_doc = parser(got) 
+200              except etree.XMLSyntaxError: 
+201                  e = sys.exc_info()[1] 
+202                  errors.append('In actual output: %s' % e) 
+203          if parser is None or errors: 
+204              value = OutputChecker.output_difference( 
+205                  self, example, got, optionflags) 
+206              if errors: 
+207                  errors.append(value) 
+208                  return '\n'.join(errors) 
+209              else: 
+210                  return value 
+211          html = parser is html_fromstring 
+212          diff_parts = ['Expected:', 
+213                        self.format_doc(want_doc, html, 2), 
+214                        'Got:', 
+215                        self.format_doc(got_doc, html, 2), 
+216                        'Diff:', 
+217                        self.collect_diff(want_doc, got_doc, html, 2)] 
+218          return '\n'.join(diff_parts) 
+
219   
+220 -    def html_empty_tag(self, el, html=True): 
+
221          if not html: 
+222              return False 
+223          if el.tag not in self.empty_tags: 
+224              return False 
+225          if el.text or len(el): 
+226              # This shouldn't happen (contents in an empty tag) 
+227              return False 
+228          return True 
+
229   
+230 -    def format_doc(self, doc, html, indent, prefix=''): 
+
231          parts = [] 
+232          if not len(doc): 
+233              # No children... 
+234              parts.append(' '*indent) 
+235              parts.append(prefix) 
+236              parts.append(self.format_tag(doc)) 
+237              if not self.html_empty_tag(doc, html): 
+238                  if strip(doc.text): 
+239                      parts.append(self.format_text(doc.text)) 
+240                  parts.append(self.format_end_tag(doc)) 
+241              if strip(doc.tail): 
+242                  parts.append(self.format_text(doc.tail)) 
+243              parts.append('\n') 
+244              return ''.join(parts) 
+245          parts.append(' '*indent) 
+246          parts.append(prefix) 
+247          parts.append(self.format_tag(doc)) 
+248          if not self.html_empty_tag(doc, html): 
+249              parts.append('\n') 
+250              if strip(doc.text): 
+251                  parts.append(' '*indent) 
+252                  parts.append(self.format_text(doc.text)) 
+253                  parts.append('\n') 
+254              for el in doc: 
+255                  parts.append(self.format_doc(el, html, indent+2)) 
+256              parts.append(' '*indent) 
+257              parts.append(self.format_end_tag(doc)) 
+258              parts.append('\n') 
+259          if strip(doc.tail): 
+260              parts.append(' '*indent) 
+261              parts.append(self.format_text(doc.tail)) 
+262              parts.append('\n') 
+263          return ''.join(parts) 
+
264   
+265 -    def format_text(self, text, strip=True): 
+
266          if text is None: 
+267              return '' 
+268          if strip: 
+269              text = text.strip() 
+270          return html_escape(text, 1) 
+
271   
+272 -    def format_tag(self, el): 
+
273          attrs = [] 
+274          if isinstance(el, etree.CommentBase): 
+275              # FIXME: probably PIs should be handled specially too? 
+276              return '<!--' 
+277          for name, value in sorted(el.attrib.items()): 
+278              attrs.append('%s="%s"' % (name, self.format_text(value, False))) 
+279          if not attrs: 
+280              return '<%s>' % el.tag 
+281          return '<%s %s>' % (el.tag, ' '.join(attrs)) 
+
282       
+283 -    def format_end_tag(self, el): 
+
284          if isinstance(el, etree.CommentBase): 
+285              # FIXME: probably PIs should be handled specially too? 
+286              return '-->' 
+287          return '</%s>' % el.tag 
+
288   
+289 -    def collect_diff(self, want, got, html, indent): 
+
290          parts = [] 
+291          if not len(want) and not len(got): 
+292              parts.append(' '*indent) 
+293              parts.append(self.collect_diff_tag(want, got)) 
+294              if not self.html_empty_tag(got, html): 
+295                  parts.append(self.collect_diff_text(want.text, got.text)) 
+296                  parts.append(self.collect_diff_end_tag(want, got)) 
+297              parts.append(self.collect_diff_text(want.tail, got.tail)) 
+298              parts.append('\n') 
+299              return ''.join(parts) 
+300          parts.append(' '*indent) 
+301          parts.append(self.collect_diff_tag(want, got)) 
+302          parts.append('\n') 
+303          if strip(want.text) or strip(got.text): 
+304              parts.append(' '*indent) 
+305              parts.append(self.collect_diff_text(want.text, got.text)) 
+306              parts.append('\n') 
+307          want_children = list(want) 
+308          got_children = list(got) 
+309          while want_children or got_children: 
+310              if not want_children: 
+311                  parts.append(self.format_doc(got_children.pop(0), html, indent+2, '+')) 
+312                  continue 
+313              if not got_children: 
+314                  parts.append(self.format_doc(want_children.pop(0), html, indent+2, '-')) 
+315                  continue 
+316              parts.append(self.collect_diff( 
+317                  want_children.pop(0), got_children.pop(0), html, indent+2)) 
+318          parts.append(' '*indent) 
+319          parts.append(self.collect_diff_end_tag(want, got)) 
+320          parts.append('\n') 
+321          if strip(want.tail) or strip(got.tail): 
+322              parts.append(' '*indent) 
+323              parts.append(self.collect_diff_text(want.tail, got.tail)) 
+324              parts.append('\n') 
+325          return ''.join(parts) 
+
326   
+327 -    def collect_diff_tag(self, want, got): 
+
328          if not self.tag_compare(want.tag, got.tag): 
+329              tag = '%s (got: %s)' % (want.tag, got.tag) 
+330          else: 
+331              tag = got.tag 
+332          attrs = [] 
+333          any = want.tag == 'any' or 'any' in want.attrib 
+334          for name, value in sorted(got.attrib.items()): 
+335              if name not in want.attrib and not any: 
+336                  attrs.append('+%s="%s"' % (name, self.format_text(value, False))) 
+337              else: 
+338                  if name in want.attrib: 
+339                      text = self.collect_diff_text(want.attrib[name], value, False) 
+340                  else: 
+341                      text = self.format_text(value, False) 
+342                  attrs.append('%s="%s"' % (name, text)) 
+343          if not any: 
+344              for name, value in sorted(want.attrib.items()): 
+345                  if name in got.attrib: 
+346                      continue 
+347                  attrs.append('-%s="%s"' % (name, self.format_text(value, False))) 
+348          if attrs: 
+349              tag = '<%s %s>' % (tag, ' '.join(attrs)) 
+350          else: 
+351              tag = '<%s>' % tag 
+352          return tag 
+
353   
+354 -    def collect_diff_end_tag(self, want, got): 
+
355          if want.tag != got.tag: 
+356              tag = '%s (got: %s)' % (want.tag, got.tag) 
+357          else: 
+358              tag = got.tag 
+359          return '</%s>' % tag 
+
360   
+361 -    def collect_diff_text(self, want, got, strip=True): 
+
362          if self.text_compare(want, got, strip): 
+363              if not got: 
+364                  return '' 
+365              return self.format_text(got, strip) 
+366          text = '%s (got: %s)' % (want, got) 
+367          return self.format_text(text, strip) 
+
368   
+369 -class LHTMLOutputChecker(LXMLOutputChecker): 
+
370 -    def get_default_parser(self): 
+
371          return html_fromstring 
+
372       
+373 -def install(html=False): 
+
374      """ 
+375      Install doctestcompare for all future doctests. 
+376   
+377      If html is true, then by default the HTML parser will be used; 
+378      otherwise the XML parser is used. 
+379      """ 
+380      if html: 
+381          doctest.OutputChecker = LHTMLOutputChecker 
+382      else: 
+383          doctest.OutputChecker = LXMLOutputChecker 
+
384   
+385 -def temp_install(html=False, del_module=None): 
+
386      """ 
+387      Use this *inside* a doctest to enable this checker for this 
+388      doctest only. 
+389   
+390      If html is true, then by default the HTML parser will be used; 
+391      otherwise the XML parser is used. 
+392      """ 
+393      if html: 
+394          Checker = LHTMLOutputChecker 
+395      else: 
+396          Checker = LXMLOutputChecker 
+397      frame = _find_doctest_frame() 
+398      dt_self = frame.f_locals['self'] 
+399      checker = Checker() 
+400      old_checker = dt_self._checker 
+401      dt_self._checker = checker 
+402      # The unfortunate thing is that there is a local variable 'check' 
+403      # in the function that runs the doctests, that is a bound method 
+404      # into the output checker.  We have to update that.  We can't 
+405      # modify the frame, so we have to modify the object in place.  The 
+406      # only way to do this is to actually change the func_code 
+407      # attribute of the method.  We change it, and then wait for 
+408      # __record_outcome to be run, which signals the end of the __run 
+409      # method, at which point we restore the previous check_output 
+410      # implementation. 
+411      if _IS_PYTHON_3: 
+412          check_func = frame.f_locals['check'].__func__ 
+413          checker_check_func = checker.check_output.__func__ 
+414      else: 
+415          check_func = frame.f_locals['check'].im_func 
+416          checker_check_func = checker.check_output.im_func 
+417      # Because we can't patch up func_globals, this is the only global 
+418      # in check_output that we care about: 
+419      doctest.etree = etree 
+420      _RestoreChecker(dt_self, old_checker, checker, 
+421                      check_func, checker_check_func, 
+422                      del_module) 
+
423   
+424 -class _RestoreChecker(object): 
+
425 -    def __init__(self, dt_self, old_checker, new_checker, check_func, clone_func, 
+426                   del_module): 
+
427          self.dt_self = dt_self 
+428          self.checker = old_checker 
+429          self.checker._temp_call_super_check_output = self.call_super 
+430          self.checker._temp_override_self = new_checker 
+431          self.check_func = check_func 
+432          self.clone_func = clone_func 
+433          self.del_module = del_module 
+434          self.install_clone() 
+435          self.install_dt_self() 
+
436 -    def install_clone(self): 
+
437          if _IS_PYTHON_3: 
+438              self.func_code = self.check_func.__code__ 
+439              self.func_globals = self.check_func.__globals__ 
+440              self.check_func.__code__ = self.clone_func.__code__ 
+441          else: 
+442              self.func_code = self.check_func.func_code 
+443              self.func_globals = self.check_func.func_globals 
+444              self.check_func.func_code = self.clone_func.func_code 
+
445 -    def uninstall_clone(self): 
+
446          if _IS_PYTHON_3: 
+447              self.check_func.__code__ = self.func_code 
+448          else: 
+449              self.check_func.func_code = self.func_code 
+
450 -    def install_dt_self(self): 
+
451          self.prev_func = self.dt_self._DocTestRunner__record_outcome 
+452          self.dt_self._DocTestRunner__record_outcome = self 
+
453 -    def uninstall_dt_self(self): 
+
454          self.dt_self._DocTestRunner__record_outcome = self.prev_func 
+
455 -    def uninstall_module(self): 
+
456          if self.del_module: 
+457              import sys 
+458              del sys.modules[self.del_module] 
+459              if '.' in self.del_module: 
+460                  package, module = self.del_module.rsplit('.', 1) 
+461                  package_mod = sys.modules[package] 
+462                  delattr(package_mod, module) 
+
463 -    def __call__(self, *args, **kw): 
+
464          self.uninstall_clone() 
+465          self.uninstall_dt_self() 
+466          del self.checker._temp_override_self 
+467          del self.checker._temp_call_super_check_output 
+468          result = self.prev_func(*args, **kw) 
+469          self.uninstall_module() 
+470          return result 
+
471 -    def call_super(self, *args, **kw): 
+
472          self.uninstall_clone() 
+473          try: 
+474              return self.check_func(*args, **kw) 
+475          finally: 
+476              self.install_clone() 
+
477               
+478 -def _find_doctest_frame(): 
+
479      import sys 
+480      frame = sys._getframe(1) 
+481      while frame: 
+482          l = frame.f_locals 
+483          if 'BOOM' in l: 
+484              # Sign of doctest 
+485              return frame 
+486          frame = frame.f_back 
+487      raise LookupError( 
+488          "Could not find doctest (only use this function *inside* a doctest)") 
+
489       
+490  __test__ = { 
+491      'basic': ''' 
+492      >>> temp_install() 
+493      >>> print """<xml a="1" b="2">stuff</xml>""" 
+494      <xml b="2" a="1">...</xml> 
+495      >>> print """<xml xmlns="http://example.com"><tag   attr="bar"   /></xml>""" 
+496      <xml xmlns="..."> 
+497        <tag attr="..." /> 
+498      </xml> 
+499      >>> print """<xml>blahblahblah<foo /></xml>""" # doctest: +NOPARSE_MARKUP, +ELLIPSIS 
+500      <xml>...foo /></xml> 
+501      '''} 
+502   
+503  if __name__ == '__main__': 
+504      import doctest 
+505      doctest.testmod() 
+506   
+
+doctest.OutputChecker --+    
+                        |    
+        LXMLOutputChecker --+
+                            |
+                           LHTMLOutputChecker
+
+doctest.OutputChecker --+
+                        |
+                       LXMLOutputChecker
+
+('param',
+ 'img',
+ 'area',
+ 'br',
+ 'basefont',
+ 'input',
+ 'base',
+ 'meta',
+...
+
+object --+
+         |
+        _RestoreChecker
+
lxml.etree
Element.attrib
with_tail
ns
+>>> ns_functions = FunctionNamespace("http://schema.org/Movie")
+>>> @ns_functions  # uses function name
+... def add2(x):
+...     return x + 2
+>>> @ns_functions("add3")  # uses explicit name
+... def add_three(x):
+...     return x + 3
HTMLParser
parser
base_url
+>>> root = XML("<root><test/></root>")
+>>> print(root.tag)
+root
XMLParser
parser
base_url
smart_strings=False
parser
"libxml2:xmlDoc"
xmlDoc*
strcmp()
"destructor:xmlFreeDoc"
xmlFreeDoc()
.write()
C14NWriterTarget
parser
base_url
parser
source
fromstring()
base_url
+strip_attributes(root_element,
+                 'simpleattr',
+                 '{http://some/ns}attrname',
+                 '{http://other/ns}*')
+
with_tail
+strip_elements(some_element,
+    'simpletagname',             # non-namespaced tag
+    '{http://some/ns}tagname',   # namespaced tag
+    '{http://some/other/ns}*'    # any tag from a namespace
+    lxml.etree.Comment           # comments
+    )
+
+strip_tags(some_element,
+    'simpletagname',             # non-namespaced tag
+    '{http://some/ns}tagname',   # namespaced tag
+    '{http://some/other/ns}*'    # any tag from a namespace
+    Comment                      # comments (including their text!)
+    )
+
'unicode'
str
unicode
method="c14n"
exclusive
with_comments
inclusive_ns_prefixes
method="c14n2"
with_comments
strip_text
standalone
standalone
doctype
with_tail
with_tail
tostring(el, encoding='unicode')
+{'adoptExternalDocument': <capsule object "struct LxmlElementTree *(xm
+lDoc *, PyObject *, int)" at 0x7f4dd3ff67b0>,
+ 'appendChild': <capsule object "void (struct LxmlElement *, struct Lx
+mlElement *)" at 0x7f4dd3ff6f90>,
+ 'appendChildToElement': <capsule object "int (struct LxmlElement *, s
+truct LxmlElement *)" at 0x7f4dd3ff6fc0>,
+ 'attributeValue': <capsule object "PyObject *(xmlNode *, xmlAttr *)" 
+at 0x7f4dd3ff6c60>,
+...
+
+{u'FunctionNamespace (line 207)': u'''FunctionNamespace(ns_uri)
+
+    Retrieve the function namespace object associated with the given
+    URI.
+
+    Creates a new one if it does not yet exist. A function namespace
+    can only be used to register extension functions.
+
+...
+
+           object --+    
+                    |    
+_ElementMatchIterator --+
+                        |
+                       AncestorsIterator
+
+            object --+        
+                     |        
+    ElementClassLookup --+    
+                         |    
+FallbackElementClassLookup --+
+                             |
+                            AttributeBasedElementClassLookup
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      C14NError
+
+object --+
+         |
+        C14NWriterTarget
+
+object --+
+         |
+        CDATA
+
+>>> el = Element('content')
+>>> el.text = CDATA('a string')
+
+>>> print(el.text)
+a string
+>>> print(tostring(el, encoding="unicode"))
+<content><![CDATA[a string]]></content>
+
+         object --+            
+                  |            
+           _Element --+        
+                      |        
+??.__ContentOnlyElement --+    
+                          |    
+                   _Comment --+
+                              |
+                             CommentBase
+
Comment()
_init(self)
+            object --+        
+                     |        
+    ElementClassLookup --+    
+                         |    
+FallbackElementClassLookup --+
+                             |
+                            CustomElementClassLookup
+
+lookup(self, type, doc, namespace, name)
+
+object --+    
+         |    
+_Validator --+
+             |
+            DTD
+
external_id
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      DTDError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                                DTDError --+
+                                           |
+                                          DTDParseError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                                DTDError --+
+                                           |
+                                          DTDValidateError
+
+object --+
+         |
+        DocInfo
+
standalone='yes'
standalone='no'
standalone
'yes'
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      DocumentInvalid
+
assertValid(tree)
+    object --+            
+             |            
+??._BaseParser --+        
+                 |        
+       _FeedParser --+    
+                     |    
+             XMLParser --+
+                         |
+                        ETCompatXMLParser
+
remove_comments
remove_pis
+         object --+        
+                  |        
+_XPathEvaluatorBase --+    
+                      |    
+                  XPath --+
+                          |
+                         ETXPath
+
namespace
smart_strings=False
+object --+    
+         |    
+  _Element --+
+             |
+            ElementBase
+
_init(self)
+           object --+    
+                    |    
+_ElementMatchIterator --+
+                        |
+                       ElementChildIterator
+
+object --+
+         |
+        ElementClassLookup
+
+        object --+    
+                 |    
+ElementClassLookup --+
+                     |
+                    ElementDefaultClassLookup
+
element
comment
pi
entity
+object --+
+         |
+        ElementDepthFirstIterator
+
tag
Element
tag
tag
+            object --+        
+                     |        
+    ElementClassLookup --+    
+                         |    
+FallbackElementClassLookup --+
+                             |
+                            ElementNamespaceClassLookup
+
+>>> lookup = ElementNamespaceClassLookup()
+>>> ns_elements = lookup.get_namespace("http://schema.org/Movie")
+>>> @ns_elements
+... class movie(ElementBase):
+...     "Element implementation for 'movie' tag (using class name) in schema namespace."
+>>> @ns_elements("movie")
+... class MovieElement(ElementBase):
+...     "Element implementation for 'movie' tag (explicit tag name) in schema namespace."
+object --+
+         |
+        ElementTextIterator
+
tag
with_tail
False
+         object --+            
+                  |            
+           _Element --+        
+                      |        
+??.__ContentOnlyElement --+    
+                          |    
+                    _Entity --+
+                              |
+                             EntityBase
+
Entity()
_init(self)
+              object --+        
+                       |        
+exceptions.BaseException --+    
+                           |    
+        exceptions.Exception --+
+                               |
+                              Error
+
+object --+
+         |
+        ErrorDomains
+
+{0: 'NONE',
+ 1: 'PARSER',
+ 2: 'TREE',
+ 3: 'NAMESPACE',
+ 4: 'DTD',
+ 5: 'HTML',
+ 6: 'MEMORY',
+ 7: 'OUTPUT',
+...
+
+object --+
+         |
+        ErrorLevels
+
+object --+
+         |
+        ErrorTypes
+
+{0: 'ERR_OK',
+ 1: 'ERR_INTERNAL_ERROR',
+ 2: 'ERR_NO_MEMORY',
+ 3: 'ERR_DOCUMENT_START',
+ 4: 'ERR_DOCUMENT_EMPTY',
+ 5: 'ERR_DOCUMENT_END',
+ 6: 'ERR_INVALID_HEX_CHARREF',
+ 7: 'ERR_INVALID_DEC_CHARREF',
+...
+
+        object --+    
+                 |    
+ElementClassLookup --+
+                     |
+                    FallbackElementClassLookup
+
+    object --+        
+             |        
+??._BaseParser --+    
+                 |    
+       _FeedParser --+
+                     |
+                    HTMLParser
+
+    object --+            
+             |            
+??._BaseParser --+        
+                 |        
+       _FeedParser --+    
+                     |    
+            HTMLParser --+
+                         |
+                        HTMLPullParser
+
events
'start'
'end'
'start-ns'
'end-ns'
'comment'
'pi'
base_url
+              object --+            
+                       |            
+exceptions.BaseException --+        
+                           |        
+        exceptions.Exception --+    
+                               |    
+                           Error --+
+                                   |
+                                  LxmlError
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      LxmlRegistryError
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+              object --+               |
+                       |               |
+exceptions.BaseException --+           |
+                           |           |
+        exceptions.Exception --+       |
+                               |       |
+        exceptions.StandardError --+   |
+                                   |   |
+              exceptions.SyntaxError --+
+                                       |
+                                      LxmlSyntaxError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                       LxmlRegistryError --+
+                                           |
+                                          NamespaceRegistryError
+
+         object --+            
+                  |            
+           _Element --+        
+                      |        
+??.__ContentOnlyElement --+    
+                          |    
+     _ProcessingInstruction --+
+                              |
+                             PIBase
+
PI()
_init(self)
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+              object --+               |    
+                       |               |    
+exceptions.BaseException --+           |    
+                           |           |    
+        exceptions.Exception --+       |    
+                               |       |    
+        exceptions.StandardError --+   |    
+                                   |   |    
+              exceptions.SyntaxError --+    
+                                       |    
+                         LxmlSyntaxError --+
+                                           |
+                                          ParseError
+
+            object --+        
+                     |        
+    ElementClassLookup --+    
+                         |    
+FallbackElementClassLookup --+
+                             |
+                            ParserBasedElementClassLookup
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      ParserError
+
+   object --+    
+            |    
+_BaseErrorLog --+
+                |
+               PyErrorLog
+
+ErrorLevels.WARNING = logging.WARNING
+ErrorLevels.ERROR   = logging.ERROR
+ErrorLevels.FATAL   = logging.CRITICAL
+
receive()
self.log(log_entry, format_string, arg1, arg2, ...)
message
args
+self.log(log_entry, repr(log_entry))
+
+            object --+        
+                     |        
+    ElementClassLookup --+    
+                         |    
+FallbackElementClassLookup --+
+                             |
+                            PythonElementClassLookup
+
lookup(self, doc,
+root)
+from lxml import etree, pyclasslookup
+
+class MyElementClass(etree.ElementBase):
+    honkey = True
+
+class MyLookup(pyclasslookup.PythonElementClassLookup):
+    def lookup(self, doc, root):
+        if root.tag == "sometag":
+            return MyElementClass
+        else:
+            for child in root:
+                if child.tag == "someothertag":
+                    return MyElementClass
+        # delegate to default
+        return None
+
+object --+
+         |
+        QName
+
None
text
{namespace}tagname
namespace
localname
+object --+    
+         |    
+_Validator --+
+             |
+            RelaxNG
+
file
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      RelaxNGError
+
+object --+
+         |
+        RelaxNGErrorTypes
+
+{0: 'RELAXNG_OK',
+ 1: 'RELAXNG_ERR_MEMORY',
+ 2: 'RELAXNG_ERR_TYPE',
+ 3: 'RELAXNG_ERR_TYPEVAL',
+ 4: 'RELAXNG_ERR_DUPID',
+ 5: 'RELAXNG_ERR_TYPECMP',
+ 6: 'RELAXNG_ERR_NOSTATE',
+ 7: 'RELAXNG_ERR_NODEFINE',
+...
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                            RelaxNGError --+
+                                           |
+                                          RelaxNGParseError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                            RelaxNGError --+
+                                           |
+                                          RelaxNGValidateError
+
+object --+
+         |
+        Resolver
+
system_url
public_id
system_url
public_id
resolve_*()
base_url
close
.resolve_filename()
base_url
+object --+    
+         |    
+_Validator --+
+             |
+            Schematron
+
+>>> schematron = Schematron(XML('''
+... <schema xmlns="http://www.ascc.net/xml/schematron" >
+...   <pattern name="id is the only permited attribute name">
+...     <rule context="*">
+...       <report test="@*[not(name()='id')]">Attribute
+...         <name path="@*[not(name()='id')]"/> is forbidden<name/>
+...       </report>
+...     </rule>
+...   </pattern>
+... </schema>
+... '''))
+
+>>> xml = XML('''
+... <AAA name="aaa">
+...   <BBB id="bbb"/>
+...   <CCC color="ccc"/>
+... </AAA>
+... ''')
+
+>>> schematron.validate(xml)
+0
+
+>>> xml = XML('''
+... <AAA id="aaa">
+...   <BBB id="bbb"/>
+...   <CCC/>
+... </AAA>
+... ''')
+
+>>> schematron.validate(xml)
+1
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      SchematronError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                         SchematronError --+
+                                           |
+                                          SchematronParseError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                         SchematronError --+
+                                           |
+                                          SchematronValidateError
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      SerialisationError
+
+           object --+    
+                    |    
+_ElementMatchIterator --+
+                        |
+                       SiblingsIterator
+
preceding
+      object --+    
+               |    
+_SaxParserTarget --+
+                   |
+                  TreeBuilder
+
close()
+object --+
+         |
+        XInclude
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      XIncludeError
+
+    object --+        
+             |        
+??._BaseParser --+    
+                 |    
+       _FeedParser --+
+                     |
+                    XMLParser
+
+    object --+            
+             |            
+??._BaseParser --+        
+                 |        
+       _FeedParser --+    
+                     |    
+             XMLParser --+
+                         |
+                        XMLPullParser
+
events
'start'
'end'
'start-ns'
'end-ns'
'comment'
'pi'
base_url
+object --+    
+         |    
+_Validator --+
+             |
+            XMLSchema
+
file
attribute_defaults
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      XMLSchemaError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                          XMLSchemaError --+
+                                           |
+                                          XMLSchemaParseError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                          XMLSchemaError --+
+                                           |
+                                          XMLSchemaValidateError
+
+              object --+                        
+                       |                        
+exceptions.BaseException --+                    
+                           |                    
+        exceptions.Exception --+                
+                               |                
+                           Error --+            
+                                   |            
+                           LxmlError --+        
+                                       |        
+              object --+               |        
+                       |               |        
+exceptions.BaseException --+           |        
+                           |           |        
+        exceptions.Exception --+       |        
+                               |       |        
+        exceptions.StandardError --+   |        
+                                   |   |        
+              exceptions.SyntaxError --+        
+                                       |        
+                         LxmlSyntaxError --+    
+                                           |    
+                                  ParseError --+
+                                               |
+                                              XMLSyntaxError
+
+         object --+    
+                  |    
+_XPathEvaluatorBase --+
+                      |
+                     XPath
+
namespaces
extensions
smart_strings=False
+         object --+        
+                  |        
+_XPathEvaluatorBase --+    
+                      |    
+  XPathElementEvaluator --+
+                          |
+                         XPathDocumentEvaluator
+
smart_strings=False
+         object --+    
+                  |    
+_XPathEvaluatorBase --+
+                      |
+                     XPathElementEvaluator
+
smart_strings=False
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      XPathError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                              XPathError --+
+                                           |
+                                          XPathEvalError
+
+              object --+                        
+                       |                        
+exceptions.BaseException --+                    
+                           |                    
+        exceptions.Exception --+                
+                               |                
+                           Error --+            
+                                   |            
+                           LxmlError --+        
+                                       |        
+                              XPathError --+    
+                                           |    
+                              XPathEvalError --+
+                                               |
+                                              XPathFunctionError
+
+              object --+                        
+                       |                        
+exceptions.BaseException --+                    
+                           |                    
+        exceptions.Exception --+                
+                               |                
+                           Error --+            
+                                   |            
+                           LxmlError --+        
+                                       |        
+                              XPathError --+    
+                                           |    
+                              XPathEvalError --+
+                                               |
+                                              XPathResultError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+              object --+               |    
+                       |               |    
+exceptions.BaseException --+           |    
+                           |           |    
+        exceptions.Exception --+       |    
+                               |       |    
+        exceptions.StandardError --+   |    
+                                   |   |    
+              exceptions.SyntaxError --+    
+                                       |    
+                         LxmlSyntaxError --+
+                                           |
+              object --+                   |
+                       |                   |
+exceptions.BaseException --+               |
+                           |               |
+        exceptions.Exception --+           |
+                               |           |
+                           Error --+       |
+                                   |       |
+                           LxmlError --+   |
+                                       |   |
+                              XPathError --+
+                                           |
+                                          XPathSyntaxError
+
+object --+
+         |
+        XSLT
+
+transform = etree.XSLT(xsl_tree)
+result = transform(xml_tree)
+
(namespace, name)
profile_run
+XSLT.set_global_max_depth(5000)
+
+result = transform(doc, some_strval = XSLT.strparam(
+    '''it's "Monty Python's" ...'''))
+
+object --+
+         |
+        XSLTAccessControl
+
+XSLTAccessControl(create_dir=False, read_file=False, read_network=Fals
+e, write_file=False, write_network=False)
+
+XSLTAccessControl(create_dir=False, read_file=True, read_network=True,
+ write_file=False, write_network=False)
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                               XSLTError --+
+                                           |
+                                          XSLTApplyError
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                           Error --+    
+                                   |    
+                           LxmlError --+
+                                       |
+                                      XSLTError
+
+object --+
+         |
+        XSLTExtension
+
elements_only=True
remove_blank_text=True
elements_only=True
remove_blank_text=True
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                               XSLTError --+
+                                           |
+                                          XSLTExtensionError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                               XSLTError --+
+                                           |
+                                          XSLTParseError
+
+              object --+                    
+                       |                    
+exceptions.BaseException --+                
+                           |                
+        exceptions.Exception --+            
+                               |            
+                           Error --+        
+                                   |        
+                           LxmlError --+    
+                                       |    
+                               XSLTError --+
+                                           |
+              object --+                   |
+                       |                   |
+exceptions.BaseException --+               |
+                           |               |
+        exceptions.Exception --+           |
+                               |           |
+                           Error --+       |
+                                   |       |
+                           LxmlError --+   |
+                                       |   |
+                      SerialisationError --+
+                                           |
+                                          XSLTSaveError
+
+object --+
+         |
+        _Attrib
+
Element.attrib
+object --+
+         |
+        _BaseErrorLog
+
+         object --+        
+                  |        
+           _Element --+    
+                      |    
+??.__ContentOnlyElement --+
+                          |
+                         _Comment
+
+object --+
+         |
+        _Document
+
+   object --+            
+            |            
+_BaseErrorLog --+        
+                |        
+    _ListErrorLog --+    
+                    |    
+            _ErrorLog --+
+                        |
+                       _DomainErrorLog
+
+object --+
+         |
+        _Element
+
keep_tail=True
namespaces
namespaces
namespaces
list(element)
element.iter()
"{ns}localname"
ns
localname
*
ns
"localname"
"{}localname"
"*"
"{*}*"
"{}*"
el.iter()
namespaces
with_tail
False
+        object --+    
+                 |    
+_ElementTagMatcher --+
+                     |
+                    _ElementIterator
+
+object --+
+         |
+        _ElementMatchIterator
+
+object --+        
+         |        
+basestring --+    
+             |    
+           str --+
+                 |
+                _ElementStringResult
+
+object --+
+         |
+        _ElementTagMatcher
+
+object --+
+         |
+        _ElementTree
+
tree.getroot().find(path)
tree.getroot().find(path)
namespaces
namespaces
namespaces
tree.iter()
namespaces
method="c14n"
exclusive
with_comments
inclusive_ns_prefixes
method="c14n2"
with_comments
strip_text
standalone
standalone
doctype
compression
inclusive_ns_prefixes
compression
inclusive_ns_prefixes
.write(f, method="c14n")
namespaces
extensions
+object --+        
+         |        
+basestring --+    
+             |    
+       unicode --+
+                 |
+                _ElementUnicodeResult
+
+         object --+        
+                  |        
+           _Element --+    
+                      |    
+??.__ContentOnlyElement --+
+                          |
+                         _Entity
+
+   object --+        
+            |        
+_BaseErrorLog --+    
+                |    
+    _ListErrorLog --+
+                    |
+                   _ErrorLog
+
+    object --+    
+             |    
+??._BaseParser --+
+                 |
+                _FeedParser
+
feed()
close()
close()
parse()
error_log
+object --+
+         |
+        _IDDict
+
+   object --+    
+            |    
+_BaseErrorLog --+
+                |
+               _ListErrorLog
+
+object --+
+         |
+        _LogEntry
+
+         object --+        
+                  |        
+           _Element --+    
+                      |    
+??.__ContentOnlyElement --+
+                          |
+                         _ProcessingInstruction
+
+   object --+            
+            |            
+_BaseErrorLog --+        
+                |        
+    _ListErrorLog --+    
+                    |    
+            _ErrorLog --+
+                        |
+                       _RotatingErrorLog
+
+object --+
+         |
+        _SaxParserTarget
+
+              object --+        
+                       |        
+exceptions.BaseException --+    
+                           |    
+        exceptions.Exception --+
+                               |
+                              _TargetParserResult
+
+object --+
+         |
+        _Validator
+
+object --+
+         |
+        _XPathEvaluatorBase
+
+         object --+                
+                  |                
+           _Element --+            
+                      |            
+??.__ContentOnlyElement --+        
+                          |        
+     _ProcessingInstruction --+    
+                              |    
+                         PIBase --+
+                                  |
+                                 _XSLTProcessingInstruction
+
parser
+  object --+    
+           |    
+_ElementTree --+
+               |
+              _XSLTResultTree
+
str()
bytes()
unicode()
.write_output()
.write()
.write_output()
<xsl:output>
+object --+    
+         |    
+   xmlfile --+
+             |
+            htmlfile
+
+object --+
+         |
+        iterparse
+
event
element
events
tag
tag
+object --+
+         |
+        iterwalk
+
iterparse()
iterparse()
tag
skip_subtree()
+object --+
+         |
+        xmlfile
+
+with xmlfile("somefile.xml", encoding='utf-8') as xf:
+    xf.write_declaration(standalone=True)
+    xf.write_doctype('<!DOCTYPE root SYSTEM "some.dtd">')
+
+    # generate an element (the root element)
+    with xf.element('root'):
+         # write a complete Element into the open root element
+         xf.write(etree.Element('test'))
+
+         # generate and write more Elements, e.g. through iterparse
+         for element in generate_some_elements():
+             # serialise generated elements into the XML file
+             xf.write(element)
+
+         # or write multiple Elements or strings at once
+         xf.write(etree.Element('start'), "text", etree.Element('end'))
+
close=True
buffered=False
xf.element()
xf.write()
xf.flush()
lxml.html
<input type=checkbox>
<input>
<label>
<select multiple>
<input type=radio>
<select>
.name
<textarea>
.name
.value
parse(...).getroot()
urllib.urlopen()
.geturl()
create_parent
base_url
base_url
parse(...).getroot()
base_url
urllib.urlopen()
.geturl()
+form = doc.forms[0]
+form.inputs['foo'].value = 'bar' # etc
+response = form.submit()
+doc = parse(response)
+doc.make_links_absolute(response.geturl())
+
open_http
+open_http(method, URL, values)
+
(name, value)
<meta http-equiv="Content-Type" ...>
<meta http-equiv="Content-Type" ...>
encoding
'unicode'
encoding
method
with_tail=False
doctype
+>>> from lxml import html
+>>> root = html.fragment_fromstring('<p>Hello<br>world!</p>')
+
+>>> html.tostring(root)
+'<p>Hello<br>world!</p>'
+>>> html.tostring(root, method='html')
+'<p>Hello<br>world!</p>'
+
+>>> html.tostring(root, method='xml')
+'<p>Hello<br/>world!</p>'
+
+>>> html.tostring(root, method='text')
+'Helloworld!'
+
+>>> html.tostring(root, method='text', encoding='unicode')
+u'Helloworld!'
+
+>>> root = html.fragment_fromstring('<div><p>Hello<br>world!</p>TAIL</div>')
+>>> html.tostring(root[0], method='text', encoding='unicode')
+u'Helloworld!TAIL'
+
+>>> html.tostring(root[0], method='text', encoding='unicode', with_tail=False)
+u'Helloworld!'
+
+>>> doc = html.document_fromstring('<p>Hello<br>world!</p>')
+>>> html.tostring(doc, method='html', encoding='unicode')
+u'<html><body><p>Hello<br>world!</p></body></html>'
+
+>>> print(html.tostring(doc, method='html', encoding='unicode',
+...          doctype='<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"'
+...                  ' "http://www.w3.org/TR/html4/strict.dtd">'))
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html><body><p>Hello<br>world!</p></body></html>
+
+descendant-or-self::*[@class and contains(concat(' ', normalize-space(
+@class), ' '), concat(' ', $class_name, ' '))]
+
+descendant-or-self::form|descendant-or-self::x:form
+
+descendant-or-self::option|descendant-or-self::x:option
+
+descendant-or-self::a[@rel]|descendant-or-self::x:a[@rel]
+
+   1  # Copyright (c) 2004 Ian Bicking. All rights reserved. 
+   2  # 
+   3  # Redistribution and use in source and binary forms, with or without 
+   4  # modification, are permitted provided that the following conditions are 
+   5  # met: 
+   6  # 
+   7  # 1. Redistributions of source code must retain the above copyright 
+   8  # notice, this list of conditions and the following disclaimer. 
+   9  # 
+  10  # 2. Redistributions in binary form must reproduce the above copyright 
+  11  # notice, this list of conditions and the following disclaimer in 
+  12  # the documentation and/or other materials provided with the 
+  13  # distribution. 
+  14  # 
+  15  # 3. Neither the name of Ian Bicking nor the names of its contributors may 
+  16  # be used to endorse or promote products derived from this software 
+  17  # without specific prior written permission. 
+  18  # 
+  19  # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+  20  # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+  21  # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+  22  # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IAN BICKING OR 
+  23  # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+  24  # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
+  25  # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+  26  # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
+  27  # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+  28  # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+  29  # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+  30   
+  31  """The ``lxml.html`` tool set for HTML handling. 
+  32  """ 
+  33   
+  34  from __future__ import absolute_import 
+  35   
+  36  __all__ = [ 
+  37      'document_fromstring', 'fragment_fromstring', 'fragments_fromstring', 'fromstring', 
+  38      'tostring', 'Element', 'defs', 'open_in_browser', 'submit_form', 
+  39      'find_rel_links', 'find_class', 'make_links_absolute', 
+  40      'resolve_base_href', 'iterlinks', 'rewrite_links', 'open_in_browser', 'parse'] 
+  41   
+  42   
+  43  import copy 
+  44  import sys 
+  45  import re 
+  46  from functools import partial 
+  47   
+  48  try: 
+  49      from collections.abc import MutableMapping, MutableSet 
+  50  except ImportError: 
+  51      from collections import MutableMapping, MutableSet 
+  52   
+  53  from .. import etree 
+  54  from . import defs 
+  55  from ._setmixin import SetMixin 
+  56   
+  57  try: 
+  58      from urlparse import urljoin 
+  59  except ImportError: 
+  60      # Python 3 
+  61      from urllib.parse import urljoin 
+  62   
+  63  try: 
+  64      unicode 
+  65  except NameError: 
+  66      # Python 3 
+  67      unicode = str 
+  68  try: 
+  69      basestring 
+  70  except NameError: 
+  71      # Python 3 
+  72      basestring = (str, bytes) 
+  73   
+  74   
+  75 -def __fix_docstring(s): 
+
  76      if not s: 
+  77          return s 
+  78      if sys.version_info[0] >= 3: 
+  79          sub = re.compile(r"^(\s*)u'", re.M).sub 
+  80      else: 
+  81          sub = re.compile(r"^(\s*)b'", re.M).sub 
+  82      return sub(r"\1'", s) 
+
  83   
+  84   
+  85  XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml" 
+  86   
+  87  _rel_links_xpath = etree.XPath("descendant-or-self::a[@rel]|descendant-or-self::x:a[@rel]", 
+  88                                 namespaces={'x':XHTML_NAMESPACE}) 
+  89  _options_xpath = etree.XPath("descendant-or-self::option|descendant-or-self::x:option", 
+  90                               namespaces={'x':XHTML_NAMESPACE}) 
+  91  _forms_xpath = etree.XPath("descendant-or-self::form|descendant-or-self::x:form", 
+  92                             namespaces={'x':XHTML_NAMESPACE}) 
+  93  #_class_xpath = etree.XPath(r"descendant-or-self::*[regexp:match(@class, concat('\b', $class_name, '\b'))]", {'regexp': 'http://exslt.org/regular-expressions'}) 
+  94  _class_xpath = etree.XPath("descendant-or-self::*[@class and contains(concat(' ', normalize-space(@class), ' '), concat(' ', $class_name, ' '))]") 
+  95  _id_xpath = etree.XPath("descendant-or-self::*[@id=$id]") 
+  96  _collect_string_content = etree.XPath("string()") 
+  97  _iter_css_urls = re.compile(r'url\(('+'["][^"]*["]|'+"['][^']*[']|"+r'[^)]*)\)', re.I).finditer 
+  98  _iter_css_imports = re.compile(r'@import "(.*?)"').finditer 
+  99  _label_xpath = etree.XPath("//label[@for=$id]|//x:label[@for=$id]", 
+ 100                             namespaces={'x':XHTML_NAMESPACE}) 
+ 101  _archive_re = re.compile(r'[^ ]+') 
+ 102  _parse_meta_refresh_url = re.compile( 
+ 103      r'[^;=]*;\s*(?:url\s*=\s*)?(?P<url>.*)$', re.I).search 
+ 104   
+ 105   
+ 106 -def _unquote_match(s, pos): 
+
 107      if s[:1] == '"' and s[-1:] == '"' or s[:1] == "'" and s[-1:] == "'": 
+ 108          return s[1:-1], pos+1 
+ 109      else: 
+ 110          return s,pos 
+
 111   
+ 112   
+ 113 -def _transform_result(typ, result): 
+
 114      """Convert the result back into the input type. 
+ 115      """ 
+ 116      if issubclass(typ, bytes): 
+ 117          return tostring(result, encoding='utf-8') 
+ 118      elif issubclass(typ, unicode): 
+ 119          return tostring(result, encoding='unicode') 
+ 120      else: 
+ 121          return result 
+
 122   
+ 123   
+ 124 -def _nons(tag): 
+
 125      if isinstance(tag, basestring): 
+ 126          if tag[0] == '{' and tag[1:len(XHTML_NAMESPACE)+1] == XHTML_NAMESPACE: 
+ 127              return tag.split('}')[-1] 
+ 128      return tag 
+
 129   
+ 130   
+ 131 -class Classes(MutableSet): 
+
 132      """Provides access to an element's class attribute as a set-like collection. 
+ 133      Usage:: 
+ 134   
+ 135          >>> el = fromstring('<p class="hidden large">Text</p>') 
+ 136          >>> classes = el.classes  # or: classes = Classes(el.attrib) 
+ 137          >>> classes |= ['block', 'paragraph'] 
+ 138          >>> el.get('class') 
+ 139          'hidden large block paragraph' 
+ 140          >>> classes.toggle('hidden') 
+ 141          False 
+ 142          >>> el.get('class') 
+ 143          'large block paragraph' 
+ 144          >>> classes -= ('some', 'classes', 'block') 
+ 145          >>> el.get('class') 
+ 146          'large paragraph' 
+ 147      """ 
+ 148 -    def __init__(self, attributes): 
+
 149          self._attributes = attributes 
+ 150          self._get_class_value = partial(attributes.get, 'class', '') 
+
 151   
+ 152 -    def add(self, value): 
+
 153          """ 
+ 154          Add a class. 
+ 155   
+ 156          This has no effect if the class is already present. 
+ 157          """ 
+ 158          if not value or re.search(r'\s', value): 
+ 159              raise ValueError("Invalid class name: %r" % value) 
+ 160          classes = self._get_class_value().split() 
+ 161          if value in classes: 
+ 162              return 
+ 163          classes.append(value) 
+ 164          self._attributes['class'] = ' '.join(classes) 
+
 165   
+ 166 -    def discard(self, value): 
+
 167          """ 
+ 168          Remove a class if it is currently present. 
+ 169   
+ 170          If the class is not present, do nothing. 
+ 171          """ 
+ 172          if not value or re.search(r'\s', value): 
+ 173              raise ValueError("Invalid class name: %r" % value) 
+ 174          classes = [name for name in self._get_class_value().split() 
+ 175                     if name != value] 
+ 176          if classes: 
+ 177              self._attributes['class'] = ' '.join(classes) 
+ 178          elif 'class' in self._attributes: 
+ 179              del self._attributes['class'] 
+
 180   
+ 181 -    def remove(self, value): 
+
 182          """ 
+ 183          Remove a class; it must currently be present. 
+ 184   
+ 185          If the class is not present, raise a KeyError. 
+ 186          """ 
+ 187          if not value or re.search(r'\s', value): 
+ 188              raise ValueError("Invalid class name: %r" % value) 
+ 189          super(Classes, self).remove(value) 
+
 190   
+ 191 -    def __contains__(self, name): 
+
 192          classes = self._get_class_value() 
+ 193          return name in classes and name in classes.split() 
+
 194   
+ 195 -    def __iter__(self): 
+
 196          return iter(self._get_class_value().split()) 
+
 197   
+ 198 -    def __len__(self): 
+
 199          return len(self._get_class_value().split()) 
+
 200   
+ 201      # non-standard methods 
+ 202   
+ 203 -    def update(self, values): 
+
 204          """ 
+ 205          Add all names from 'values'. 
+ 206          """ 
+ 207          classes = self._get_class_value().split() 
+ 208          extended = False 
+ 209          for value in values: 
+ 210              if value not in classes: 
+ 211                  classes.append(value) 
+ 212                  extended = True 
+ 213          if extended: 
+ 214              self._attributes['class'] = ' '.join(classes) 
+
 215   
+ 216 -    def toggle(self, value): 
+
 217          """ 
+ 218          Add a class name if it isn't there yet, or remove it if it exists. 
+ 219   
+ 220          Returns true if the class was added (and is now enabled) and 
+ 221          false if it was removed (and is now disabled). 
+ 222          """ 
+ 223          if not value or re.search(r'\s', value): 
+ 224              raise ValueError("Invalid class name: %r" % value) 
+ 225          classes = self._get_class_value().split() 
+ 226          try: 
+ 227              classes.remove(value) 
+ 228              enabled = False 
+ 229          except ValueError: 
+ 230              classes.append(value) 
+ 231              enabled = True 
+ 232          if classes: 
+ 233              self._attributes['class'] = ' '.join(classes) 
+ 234          else: 
+ 235              del self._attributes['class'] 
+ 236          return enabled 
+
 237   
+ 238   
+ 239 -class HtmlMixin(object): 
+
 240   
+ 241 -    def set(self, key, value=None): 
+
 242          """set(self, key, value=None) 
+ 243   
+ 244          Sets an element attribute.  If no value is provided, or if the value is None, 
+ 245          creates a 'boolean' attribute without value, e.g. "<form novalidate></form>" 
+ 246          for ``form.set('novalidate')``. 
+ 247          """ 
+ 248          super(HtmlElement, self).set(key, value) 
+
 249   
+ 250      @property 
+ 251 -    def classes(self): 
+
 252          """ 
+ 253          A set-like wrapper around the 'class' attribute. 
+ 254          """ 
+ 255          return Classes(self.attrib) 
+
 256   
+ 257      @classes.setter 
+ 258 -    def classes(self, classes): 
+
 259          assert isinstance(classes, Classes)  # only allow "el.classes |= ..." etc. 
+ 260          value = classes._get_class_value() 
+ 261          if value: 
+ 262              self.set('class', value) 
+ 263          elif self.get('class') is not None: 
+ 264              del self.attrib['class'] 
+
 265   
+ 266      @property 
+ 267 -    def base_url(self): 
+
 268          """ 
+ 269          Returns the base URL, given when the page was parsed. 
+ 270   
+ 271          Use with ``urlparse.urljoin(el.base_url, href)`` to get 
+ 272          absolute URLs. 
+ 273          """ 
+ 274          return self.getroottree().docinfo.URL 
+
 275   
+ 276      @property 
+ 277 -    def forms(self): 
+
 278          """ 
+ 279          Return a list of all the forms 
+ 280          """ 
+ 281          return _forms_xpath(self) 
+
 282   
+ 283      @property 
+ 284 -    def body(self): 
+
 285          """ 
+ 286          Return the <body> element.  Can be called from a child element 
+ 287          to get the document's head. 
+ 288          """ 
+ 289          return self.xpath('//body|//x:body', namespaces={'x':XHTML_NAMESPACE})[0] 
+
 290   
+ 291      @property 
+ 292 -    def head(self): 
+
 293          """ 
+ 294          Returns the <head> element.  Can be called from a child 
+ 295          element to get the document's head. 
+ 296          """ 
+ 297          return self.xpath('//head|//x:head', namespaces={'x':XHTML_NAMESPACE})[0] 
+
 298   
+ 299      @property 
+ 300 -    def label(self): 
+
 301          """ 
+ 302          Get or set any <label> element associated with this element. 
+ 303          """ 
+ 304          id = self.get('id') 
+ 305          if not id: 
+ 306              return None 
+ 307          result = _label_xpath(self, id=id) 
+ 308          if not result: 
+ 309              return None 
+ 310          else: 
+ 311              return result[0] 
+
 312   
+ 313      @label.setter 
+ 314 -    def label(self, label): 
+
 315          id = self.get('id') 
+ 316          if not id: 
+ 317              raise TypeError( 
+ 318                  "You cannot set a label for an element (%r) that has no id" 
+ 319                  % self) 
+ 320          if _nons(label.tag) != 'label': 
+ 321              raise TypeError( 
+ 322                  "You can only assign label to a label element (not %r)" 
+ 323                  % label) 
+ 324          label.set('for', id) 
+
 325   
+ 326      @label.deleter 
+ 327 -    def label(self): 
+
 328          label = self.label 
+ 329          if label is not None: 
+ 330              del label.attrib['for'] 
+
 331   
+ 332 -    def drop_tree(self): 
+
 333          """ 
+ 334          Removes this element from the tree, including its children and 
+ 335          text.  The tail text is joined to the previous element or 
+ 336          parent. 
+ 337          """ 
+ 338          parent = self.getparent() 
+ 339          assert parent is not None 
+ 340          if self.tail: 
+ 341              previous = self.getprevious() 
+ 342              if previous is None: 
+ 343                  parent.text = (parent.text or '') + self.tail 
+ 344              else: 
+ 345                  previous.tail = (previous.tail or '') + self.tail 
+ 346          parent.remove(self) 
+
 347   
+ 348 -    def drop_tag(self): 
+
 349          """ 
+ 350          Remove the tag, but not its children or text.  The children and text 
+ 351          are merged into the parent. 
+ 352   
+ 353          Example:: 
+ 354   
+ 355              >>> h = fragment_fromstring('<div>Hello <b>World!</b></div>') 
+ 356              >>> h.find('.//b').drop_tag() 
+ 357              >>> print(tostring(h, encoding='unicode')) 
+ 358              <div>Hello World!</div> 
+ 359          """ 
+ 360          parent = self.getparent() 
+ 361          assert parent is not None 
+ 362          previous = self.getprevious() 
+ 363          if self.text and isinstance(self.tag, basestring): 
+ 364              # not a Comment, etc. 
+ 365              if previous is None: 
+ 366                  parent.text = (parent.text or '') + self.text 
+ 367              else: 
+ 368                  previous.tail = (previous.tail or '') + self.text 
+ 369          if self.tail: 
+ 370              if len(self): 
+ 371                  last = self[-1] 
+ 372                  last.tail = (last.tail or '') + self.tail 
+ 373              elif previous is None: 
+ 374                  parent.text = (parent.text or '') + self.tail 
+ 375              else: 
+ 376                  previous.tail = (previous.tail or '') + self.tail 
+ 377          index = parent.index(self) 
+ 378          parent[index:index+1] = self[:] 
+
 379   
+ 380 -    def find_rel_links(self, rel): 
+
 381          """ 
+ 382          Find any links like ``<a rel="{rel}">...</a>``; returns a list of elements. 
+ 383          """ 
+ 384          rel = rel.lower() 
+ 385          return [el for el in _rel_links_xpath(self) 
+ 386                  if el.get('rel').lower() == rel] 
+
 387   
+ 388 -    def find_class(self, class_name): 
+
 389          """ 
+ 390          Find any elements with the given class name. 
+ 391          """ 
+ 392          return _class_xpath(self, class_name=class_name) 
+
 393   
+ 394 -    def get_element_by_id(self, id, *default): 
+
 395          """ 
+ 396          Get the first element in a document with the given id.  If none is 
+ 397          found, return the default argument if provided or raise KeyError 
+ 398          otherwise. 
+ 399   
+ 400          Note that there can be more than one element with the same id, 
+ 401          and this isn't uncommon in HTML documents found in the wild. 
+ 402          Browsers return only the first match, and this function does 
+ 403          the same. 
+ 404          """ 
+ 405          try: 
+ 406              # FIXME: should this check for multiple matches? 
+ 407              # browsers just return the first one 
+ 408              return _id_xpath(self, id=id)[0] 
+ 409          except IndexError: 
+ 410              if default: 
+ 411                  return default[0] 
+ 412              else: 
+ 413                  raise KeyError(id) 
+
 414   
+ 415 -    def text_content(self): 
+
 416          """ 
+ 417          Return the text content of the tag (and the text in any children). 
+ 418          """ 
+ 419          return _collect_string_content(self) 
+
 420   
+ 421 -    def cssselect(self, expr, translator='html'): 
+
 422          """ 
+ 423          Run the CSS expression on this element and its children, 
+ 424          returning a list of the results. 
+ 425   
+ 426          Equivalent to lxml.cssselect.CSSSelect(expr, translator='html')(self) 
+ 427          -- note that pre-compiling the expression can provide a substantial 
+ 428          speedup. 
+ 429          """ 
+ 430          # Do the import here to make the dependency optional. 
+ 431          from lxml.cssselect import CSSSelector 
+ 432          return CSSSelector(expr, translator=translator)(self) 
+
 433   
+ 434      ######################################## 
+ 435      ## Link functions 
+ 436      ######################################## 
+ 437   
+ 438 -    def make_links_absolute(self, base_url=None, resolve_base_href=True, 
+ 439                              handle_failures=None): 
+
 440          """ 
+ 441          Make all links in the document absolute, given the 
+ 442          ``base_url`` for the document (the full URL where the document 
+ 443          came from), or if no ``base_url`` is given, then the ``.base_url`` 
+ 444          of the document. 
+ 445   
+ 446          If ``resolve_base_href`` is true, then any ``<base href>`` 
+ 447          tags in the document are used *and* removed from the document. 
+ 448          If it is false then any such tag is ignored. 
+ 449   
+ 450          If ``handle_failures`` is None (default), a failure to process 
+ 451          a URL will abort the processing.  If set to 'ignore', errors 
+ 452          are ignored.  If set to 'discard', failing URLs will be removed. 
+ 453          """ 
+ 454          if base_url is None: 
+ 455              base_url = self.base_url 
+ 456              if base_url is None: 
+ 457                  raise TypeError( 
+ 458                      "No base_url given, and the document has no base_url") 
+ 459          if resolve_base_href: 
+ 460              self.resolve_base_href() 
+ 461   
+ 462          if handle_failures == 'ignore': 
+ 463              def link_repl(href): 
+ 464                  try: 
+ 465                      return urljoin(base_url, href) 
+ 466                  except ValueError: 
+ 467                      return href 
+
 468          elif handle_failures == 'discard': 
+ 469              def link_repl(href): 
+ 470                  try: 
+ 471                      return urljoin(base_url, href) 
+ 472                  except ValueError: 
+ 473                      return None 
+
 474          elif handle_failures is None: 
+ 475              def link_repl(href): 
+ 476                  return urljoin(base_url, href) 
+ 477          else: 
+ 478              raise ValueError( 
+ 479                  "unexpected value for handle_failures: %r" % handle_failures) 
+ 480   
+ 481          self.rewrite_links(link_repl) 
+ 482   
+ 483 -    def resolve_base_href(self, handle_failures=None): 
+
 484          """ 
+ 485          Find any ``<base href>`` tag in the document, and apply its 
+ 486          values to all links found in the document.  Also remove the 
+ 487          tag once it has been applied. 
+ 488   
+ 489          If ``handle_failures`` is None (default), a failure to process 
+ 490          a URL will abort the processing.  If set to 'ignore', errors 
+ 491          are ignored.  If set to 'discard', failing URLs will be removed. 
+ 492          """ 
+ 493          base_href = None 
+ 494          basetags = self.xpath('//base[@href]|//x:base[@href]', 
+ 495                                namespaces={'x': XHTML_NAMESPACE}) 
+ 496          for b in basetags: 
+ 497              base_href = b.get('href') 
+ 498              b.drop_tree() 
+ 499          if not base_href: 
+ 500              return 
+ 501          self.make_links_absolute(base_href, resolve_base_href=False, 
+ 502                                   handle_failures=handle_failures) 
+
 503   
+ 504 -    def iterlinks(self): 
+
 505          """ 
+ 506          Yield (element, attribute, link, pos), where attribute may be None 
+ 507          (indicating the link is in the text).  ``pos`` is the position 
+ 508          where the link occurs; often 0, but sometimes something else in 
+ 509          the case of links in stylesheets or style tags. 
+ 510   
+ 511          Note: <base href> is *not* taken into account in any way.  The 
+ 512          link you get is exactly the link in the document. 
+ 513   
+ 514          Note: multiple links inside of a single text string or 
+ 515          attribute value are returned in reversed order.  This makes it 
+ 516          possible to replace or delete them from the text string value 
+ 517          based on their reported text positions.  Otherwise, a 
+ 518          modification at one text position can change the positions of 
+ 519          links reported later on. 
+ 520          """ 
+ 521          link_attrs = defs.link_attrs 
+ 522          for el in self.iter(etree.Element): 
+ 523              attribs = el.attrib 
+ 524              tag = _nons(el.tag) 
+ 525              if tag == 'object': 
+ 526                  codebase = None 
+ 527                  ## <object> tags have attributes that are relative to 
+ 528                  ## codebase 
+ 529                  if 'codebase' in attribs: 
+ 530                      codebase = el.get('codebase') 
+ 531                      yield (el, 'codebase', codebase, 0) 
+ 532                  for attrib in ('classid', 'data'): 
+ 533                      if attrib in attribs: 
+ 534                          value = el.get(attrib) 
+ 535                          if codebase is not None: 
+ 536                              value = urljoin(codebase, value) 
+ 537                          yield (el, attrib, value, 0) 
+ 538                  if 'archive' in attribs: 
+ 539                      for match in _archive_re.finditer(el.get('archive')): 
+ 540                          value = match.group(0) 
+ 541                          if codebase is not None: 
+ 542                              value = urljoin(codebase, value) 
+ 543                          yield (el, 'archive', value, match.start()) 
+ 544              else: 
+ 545                  for attrib in link_attrs: 
+ 546                      if attrib in attribs: 
+ 547                          yield (el, attrib, attribs[attrib], 0) 
+ 548              if tag == 'meta': 
+ 549                  http_equiv = attribs.get('http-equiv', '').lower() 
+ 550                  if http_equiv == 'refresh': 
+ 551                      content = attribs.get('content', '') 
+ 552                      match = _parse_meta_refresh_url(content) 
+ 553                      url = (match.group('url') if match else content).strip() 
+ 554                      # unexpected content means the redirect won't work, but we might 
+ 555                      # as well be permissive and return the entire string. 
+ 556                      if url: 
+ 557                          url, pos = _unquote_match( 
+ 558                              url, match.start('url') if match else content.find(url)) 
+ 559                          yield (el, 'content', url, pos) 
+ 560              elif tag == 'param': 
+ 561                  valuetype = el.get('valuetype') or '' 
+ 562                  if valuetype.lower() == 'ref': 
+ 563                      ## FIXME: while it's fine we *find* this link, 
+ 564                      ## according to the spec we aren't supposed to 
+ 565                      ## actually change the value, including resolving 
+ 566                      ## it.  It can also still be a link, even if it 
+ 567                      ## doesn't have a valuetype="ref" (which seems to be the norm) 
+ 568                      ## http://www.w3.org/TR/html401/struct/objects.html#adef-valuetype 
+ 569                      yield (el, 'value', el.get('value'), 0) 
+ 570              elif tag == 'style' and el.text: 
+ 571                  urls = [ 
+ 572                      # (start_pos, url) 
+ 573                      _unquote_match(match.group(1), match.start(1))[::-1] 
+ 574                      for match in _iter_css_urls(el.text) 
+ 575                      ] + [ 
+ 576                      (match.start(1), match.group(1)) 
+ 577                      for match in _iter_css_imports(el.text) 
+ 578                      ] 
+ 579                  if urls: 
+ 580                      # sort by start pos to bring both match sets back into order 
+ 581                      # and reverse the list to report correct positions despite 
+ 582                      # modifications 
+ 583                      urls.sort(reverse=True) 
+ 584                      for start, url in urls: 
+ 585                          yield (el, None, url, start) 
+ 586              if 'style' in attribs: 
+ 587                  urls = list(_iter_css_urls(attribs['style'])) 
+ 588                  if urls: 
+ 589                      # return in reversed order to simplify in-place modifications 
+ 590                      for match in urls[::-1]: 
+ 591                          url, start = _unquote_match(match.group(1), match.start(1)) 
+ 592                          yield (el, 'style', url, start) 
+
 593   
+ 594 -    def rewrite_links(self, link_repl_func, resolve_base_href=True, 
+ 595                        base_href=None): 
+
 596          """ 
+ 597          Rewrite all the links in the document.  For each link 
+ 598          ``link_repl_func(link)`` will be called, and the return value 
+ 599          will replace the old link. 
+ 600   
+ 601          Note that links may not be absolute (unless you first called 
+ 602          ``make_links_absolute()``), and may be internal (e.g., 
+ 603          ``'#anchor'``).  They can also be values like 
+ 604          ``'mailto:email'`` or ``'javascript:expr'``. 
+ 605   
+ 606          If you give ``base_href`` then all links passed to 
+ 607          ``link_repl_func()`` will take that into account. 
+ 608   
+ 609          If the ``link_repl_func`` returns None, the attribute or 
+ 610          tag text will be removed completely. 
+ 611          """ 
+ 612          if base_href is not None: 
+ 613              # FIXME: this can be done in one pass with a wrapper 
+ 614              # around link_repl_func 
+ 615              self.make_links_absolute( 
+ 616                  base_href, resolve_base_href=resolve_base_href) 
+ 617          elif resolve_base_href: 
+ 618              self.resolve_base_href() 
+ 619   
+ 620          for el, attrib, link, pos in self.iterlinks(): 
+ 621              new_link = link_repl_func(link.strip()) 
+ 622              if new_link == link: 
+ 623                  continue 
+ 624              if new_link is None: 
+ 625                  # Remove the attribute or element content 
+ 626                  if attrib is None: 
+ 627                      el.text = '' 
+ 628                  else: 
+ 629                      del el.attrib[attrib] 
+ 630                  continue 
+ 631   
+ 632              if attrib is None: 
+ 633                  new = el.text[:pos] + new_link + el.text[pos+len(link):] 
+ 634                  el.text = new 
+ 635              else: 
+ 636                  cur = el.get(attrib) 
+ 637                  if not pos and len(cur) == len(link): 
+ 638                      new = new_link  # most common case 
+ 639                  else: 
+ 640                      new = cur[:pos] + new_link + cur[pos+len(link):] 
+ 641                  el.set(attrib, new) 
+
 642   
+ 643   
+ 644 -class _MethodFunc(object): 
+
 645      """ 
+ 646      An object that represents a method on an element as a function; 
+ 647      the function takes either an element or an HTML string.  It 
+ 648      returns whatever the function normally returns, or if the function 
+ 649      works in-place (and so returns None) it returns a serialized form 
+ 650      of the resulting document. 
+ 651      """ 
+ 652 -    def __init__(self, name, copy=False, source_class=HtmlMixin): 
+
 653          self.name = name 
+ 654          self.copy = copy 
+ 655          self.__doc__ = getattr(source_class, self.name).__doc__ 
+
 656 -    def __call__(self, doc, *args, **kw): 
+
 657          result_type = type(doc) 
+ 658          if isinstance(doc, basestring): 
+ 659              if 'copy' in kw: 
+ 660                  raise TypeError( 
+ 661                      "The keyword 'copy' can only be used with element inputs to %s, not a string input" % self.name) 
+ 662              doc = fromstring(doc, **kw) 
+ 663          else: 
+ 664              if 'copy' in kw: 
+ 665                  make_a_copy = kw.pop('copy') 
+ 666              else: 
+ 667                  make_a_copy = self.copy 
+ 668              if make_a_copy: 
+ 669                  doc = copy.deepcopy(doc) 
+ 670          meth = getattr(doc, self.name) 
+ 671          result = meth(*args, **kw) 
+ 672          # FIXME: this None test is a bit sloppy 
+ 673          if result is None: 
+ 674              # Then return what we got in 
+ 675              return _transform_result(result_type, doc) 
+ 676          else: 
+ 677              return result 
+
 678   
+ 679   
+ 680  find_rel_links = _MethodFunc('find_rel_links', copy=False) 
+ 681  find_class = _MethodFunc('find_class', copy=False) 
+ 682  make_links_absolute = _MethodFunc('make_links_absolute', copy=True) 
+ 683  resolve_base_href = _MethodFunc('resolve_base_href', copy=True) 
+ 684  iterlinks = _MethodFunc('iterlinks', copy=False) 
+ 685  rewrite_links = _MethodFunc('rewrite_links', copy=True) 
+ 686   
+ 687   
+ 688 -class HtmlComment(etree.CommentBase, HtmlMixin): 
+
 689      pass 
+
 690   
+ 691   
+ 692 -class HtmlElement(etree.ElementBase, HtmlMixin): 
+
 693      # Override etree.ElementBase.cssselect() and set(), despite the MRO (FIXME: change base order?) 
+ 694      cssselect = HtmlMixin.cssselect 
+ 695      set = HtmlMixin.set 
+
 696   
+ 697   
+ 698 -class HtmlProcessingInstruction(etree.PIBase, HtmlMixin): 
+
 699      pass 
+
 700   
+ 701   
+ 702 -class HtmlEntity(etree.EntityBase, HtmlMixin): 
+
 703      pass 
+
 704   
+ 705   
+ 706 -class HtmlElementClassLookup(etree.CustomElementClassLookup): 
+
 707      """A lookup scheme for HTML Element classes. 
+ 708   
+ 709      To create a lookup instance with different Element classes, pass a tag 
+ 710      name mapping of Element classes in the ``classes`` keyword argument and/or 
+ 711      a tag name mapping of Mixin classes in the ``mixins`` keyword argument. 
+ 712      The special key '*' denotes a Mixin class that should be mixed into all 
+ 713      Element classes. 
+ 714      """ 
+ 715      _default_element_classes = {} 
+ 716   
+ 717 -    def __init__(self, classes=None, mixins=None): 
+
 718          etree.CustomElementClassLookup.__init__(self) 
+ 719          if classes is None: 
+ 720              classes = self._default_element_classes.copy() 
+ 721          if mixins: 
+ 722              mixers = {} 
+ 723              for name, value in mixins: 
+ 724                  if name == '*': 
+ 725                      for n in classes.keys(): 
+ 726                          mixers.setdefault(n, []).append(value) 
+ 727                  else: 
+ 728                      mixers.setdefault(name, []).append(value) 
+ 729              for name, mix_bases in mixers.items(): 
+ 730                  cur = classes.get(name, HtmlElement) 
+ 731                  bases = tuple(mix_bases + [cur]) 
+ 732                  classes[name] = type(cur.__name__, bases, {}) 
+ 733          self._element_classes = classes 
+
 734   
+ 735 -    def lookup(self, node_type, document, namespace, name): 
+
 736          if node_type == 'element': 
+ 737              return self._element_classes.get(name.lower(), HtmlElement) 
+ 738          elif node_type == 'comment': 
+ 739              return HtmlComment 
+ 740          elif node_type == 'PI': 
+ 741              return HtmlProcessingInstruction 
+ 742          elif node_type == 'entity': 
+ 743              return HtmlEntity 
+ 744          # Otherwise normal lookup 
+ 745          return None 
+
 746   
+ 747   
+ 748  ################################################################################ 
+ 749  # parsing 
+ 750  ################################################################################ 
+ 751   
+ 752  _looks_like_full_html_unicode = re.compile( 
+ 753      unicode(r'^\s*<(?:html|!doctype)'), re.I).match 
+ 754  _looks_like_full_html_bytes = re.compile( 
+ 755      r'^\s*<(?:html|!doctype)'.encode('ascii'), re.I).match 
+ 756   
+ 757   
+ 758 -def document_fromstring(html, parser=None, ensure_head_body=False, **kw): 
+
 759      if parser is None: 
+ 760          parser = html_parser 
+ 761      value = etree.fromstring(html, parser, **kw) 
+ 762      if value is None: 
+ 763          raise etree.ParserError( 
+ 764              "Document is empty") 
+ 765      if ensure_head_body and value.find('head') is None: 
+ 766          value.insert(0, Element('head')) 
+ 767      if ensure_head_body and value.find('body') is None: 
+ 768          value.append(Element('body')) 
+ 769      return value 
+
 770   
+ 771   
+ 772 -def fragments_fromstring(html, no_leading_text=False, base_url=None, 
+ 773                           parser=None, **kw): 
+
 774      """Parses several HTML elements, returning a list of elements. 
+ 775   
+ 776      The first item in the list may be a string. 
+ 777      If no_leading_text is true, then it will be an error if there is 
+ 778      leading text, and it will always be a list of only elements. 
+ 779   
+ 780      base_url will set the document's base_url attribute 
+ 781      (and the tree's docinfo.URL). 
+ 782      """ 
+ 783      if parser is None: 
+ 784          parser = html_parser 
+ 785      # FIXME: check what happens when you give html with a body, head, etc. 
+ 786      if isinstance(html, bytes): 
+ 787          if not _looks_like_full_html_bytes(html): 
+ 788              # can't use %-formatting in early Py3 versions 
+ 789              html = ('<html><body>'.encode('ascii') + html + 
+ 790                      '</body></html>'.encode('ascii')) 
+ 791      else: 
+ 792          if not _looks_like_full_html_unicode(html): 
+ 793              html = '<html><body>%s</body></html>' % html 
+ 794      doc = document_fromstring(html, parser=parser, base_url=base_url, **kw) 
+ 795      assert _nons(doc.tag) == 'html' 
+ 796      bodies = [e for e in doc if _nons(e.tag) == 'body'] 
+ 797      assert len(bodies) == 1, ("too many bodies: %r in %r" % (bodies, html)) 
+ 798      body = bodies[0] 
+ 799      elements = [] 
+ 800      if no_leading_text and body.text and body.text.strip(): 
+ 801          raise etree.ParserError( 
+ 802              "There is leading text: %r" % body.text) 
+ 803      if body.text and body.text.strip(): 
+ 804          elements.append(body.text) 
+ 805      elements.extend(body) 
+ 806      # FIXME: removing the reference to the parent artificial document 
+ 807      # would be nice 
+ 808      return elements 
+
 809   
+ 810   
+ 811 -def fragment_fromstring(html, create_parent=False, base_url=None, 
+ 812                          parser=None, **kw): 
+
 813      """ 
+ 814      Parses a single HTML element; it is an error if there is more than 
+ 815      one element, or if anything but whitespace precedes or follows the 
+ 816      element. 
+ 817   
+ 818      If ``create_parent`` is true (or is a tag name) then a parent node 
+ 819      will be created to encapsulate the HTML in a single element.  In this 
+ 820      case, leading or trailing text is also allowed, as are multiple elements 
+ 821      as result of the parsing. 
+ 822   
+ 823      Passing a ``base_url`` will set the document's ``base_url`` attribute 
+ 824      (and the tree's docinfo.URL). 
+ 825      """ 
+ 826      if parser is None: 
+ 827          parser = html_parser 
+ 828   
+ 829      accept_leading_text = bool(create_parent) 
+ 830   
+ 831      elements = fragments_fromstring( 
+ 832          html, parser=parser, no_leading_text=not accept_leading_text, 
+ 833          base_url=base_url, **kw) 
+ 834   
+ 835      if create_parent: 
+ 836          if not isinstance(create_parent, basestring): 
+ 837              create_parent = 'div' 
+ 838          new_root = Element(create_parent) 
+ 839          if elements: 
+ 840              if isinstance(elements[0], basestring): 
+ 841                  new_root.text = elements[0] 
+ 842                  del elements[0] 
+ 843              new_root.extend(elements) 
+ 844          return new_root 
+ 845   
+ 846      if not elements: 
+ 847          raise etree.ParserError('No elements found') 
+ 848      if len(elements) > 1: 
+ 849          raise etree.ParserError( 
+ 850              "Multiple elements found (%s)" 
+ 851              % ', '.join([_element_name(e) for e in elements])) 
+ 852      el = elements[0] 
+ 853      if el.tail and el.tail.strip(): 
+ 854          raise etree.ParserError( 
+ 855              "Element followed by text: %r" % el.tail) 
+ 856      el.tail = None 
+ 857      return el 
+
 858   
+ 859   
+ 860 -def fromstring(html, base_url=None, parser=None, **kw): 
+
 861      """ 
+ 862      Parse the html, returning a single element/document. 
+ 863   
+ 864      This tries to minimally parse the chunk of text, without knowing if it 
+ 865      is a fragment or a document. 
+ 866   
+ 867      base_url will set the document's base_url attribute (and the tree's docinfo.URL) 
+ 868      """ 
+ 869      if parser is None: 
+ 870          parser = html_parser 
+ 871      if isinstance(html, bytes): 
+ 872          is_full_html = _looks_like_full_html_bytes(html) 
+ 873      else: 
+ 874          is_full_html = _looks_like_full_html_unicode(html) 
+ 875      doc = document_fromstring(html, parser=parser, base_url=base_url, **kw) 
+ 876      if is_full_html: 
+ 877          return doc 
+ 878      # otherwise, lets parse it out... 
+ 879      bodies = doc.findall('body') 
+ 880      if not bodies: 
+ 881          bodies = doc.findall('{%s}body' % XHTML_NAMESPACE) 
+ 882      if bodies: 
+ 883          body = bodies[0] 
+ 884          if len(bodies) > 1: 
+ 885              # Somehow there are multiple bodies, which is bad, but just 
+ 886              # smash them into one body 
+ 887              for other_body in bodies[1:]: 
+ 888                  if other_body.text: 
+ 889                      if len(body): 
+ 890                          body[-1].tail = (body[-1].tail or '') + other_body.text 
+ 891                      else: 
+ 892                          body.text = (body.text or '') + other_body.text 
+ 893                  body.extend(other_body) 
+ 894                  # We'll ignore tail 
+ 895                  # I guess we are ignoring attributes too 
+ 896                  other_body.drop_tree() 
+ 897      else: 
+ 898          body = None 
+ 899      heads = doc.findall('head') 
+ 900      if not heads: 
+ 901          heads = doc.findall('{%s}head' % XHTML_NAMESPACE) 
+ 902      if heads: 
+ 903          # Well, we have some sort of structure, so lets keep it all 
+ 904          head = heads[0] 
+ 905          if len(heads) > 1: 
+ 906              for other_head in heads[1:]: 
+ 907                  head.extend(other_head) 
+ 908                  # We don't care about text or tail in a head 
+ 909                  other_head.drop_tree() 
+ 910          return doc 
+ 911      if body is None: 
+ 912          return doc 
+ 913      if (len(body) == 1 and (not body.text or not body.text.strip()) 
+ 914          and (not body[-1].tail or not body[-1].tail.strip())): 
+ 915          # The body has just one element, so it was probably a single 
+ 916          # element passed in 
+ 917          return body[0] 
+ 918      # Now we have a body which represents a bunch of tags which have the 
+ 919      # content that was passed in.  We will create a fake container, which 
+ 920      # is the body tag, except <body> implies too much structure. 
+ 921      if _contains_block_level_tag(body): 
+ 922          body.tag = 'div' 
+ 923      else: 
+ 924          body.tag = 'span' 
+ 925      return body 
+
 926   
+ 927   
+ 928 -def parse(filename_or_url, parser=None, base_url=None, **kw): 
+
 929      """ 
+ 930      Parse a filename, URL, or file-like object into an HTML document 
+ 931      tree.  Note: this returns a tree, not an element.  Use 
+ 932      ``parse(...).getroot()`` to get the document root. 
+ 933   
+ 934      You can override the base URL with the ``base_url`` keyword.  This 
+ 935      is most useful when parsing from a file-like object. 
+ 936      """ 
+ 937      if parser is None: 
+ 938          parser = html_parser 
+ 939      return etree.parse(filename_or_url, parser, base_url=base_url, **kw) 
+
 940   
+ 941   
+ 942 -def _contains_block_level_tag(el): 
+
 943      # FIXME: I could do this with XPath, but would that just be 
+ 944      # unnecessarily slow? 
+ 945      for el in el.iter(etree.Element): 
+ 946          if _nons(el.tag) in defs.block_tags: 
+ 947              return True 
+ 948      return False 
+
 949   
+ 950   
+ 951 -def _element_name(el): 
+
 952      if isinstance(el, etree.CommentBase): 
+ 953          return 'comment' 
+ 954      elif isinstance(el, basestring): 
+ 955          return 'string' 
+ 956      else: 
+ 957          return _nons(el.tag) 
+
 958   
+ 959   
+ 960  ################################################################################ 
+ 961  # form handling 
+ 962  ################################################################################ 
+ 963   
+ 964 -class FormElement(HtmlElement): 
+
 965      """ 
+ 966      Represents a <form> element. 
+ 967      """ 
+ 968   
+ 969      @property 
+ 970 -    def inputs(self): 
+
 971          """ 
+ 972          Returns an accessor for all the input elements in the form. 
+ 973   
+ 974          See `InputGetter` for more information about the object. 
+ 975          """ 
+ 976          return InputGetter(self) 
+
 977   
+ 978      @property 
+ 979 -    def fields(self): 
+
 980          """ 
+ 981          Dictionary-like object that represents all the fields in this 
+ 982          form.  You can set values in this dictionary to effect the 
+ 983          form. 
+ 984          """ 
+ 985          return FieldsDict(self.inputs) 
+
 986   
+ 987      @fields.setter 
+ 988 -    def fields(self, value): 
+
 989          fields = self.fields 
+ 990          prev_keys = fields.keys() 
+ 991          for key, value in value.items(): 
+ 992              if key in prev_keys: 
+ 993                  prev_keys.remove(key) 
+ 994              fields[key] = value 
+ 995          for key in prev_keys: 
+ 996              if key is None: 
+ 997                  # Case of an unnamed input; these aren't really 
+ 998                  # expressed in form_values() anyway. 
+ 999                  continue 
+1000              fields[key] = None 
+
1001   
+1002 -    def _name(self): 
+
1003          if self.get('name'): 
+1004              return self.get('name') 
+1005          elif self.get('id'): 
+1006              return '#' + self.get('id') 
+1007          iter_tags = self.body.iter 
+1008          forms = list(iter_tags('form')) 
+1009          if not forms: 
+1010              forms = list(iter_tags('{%s}form' % XHTML_NAMESPACE)) 
+1011          return str(forms.index(self)) 
+
1012   
+1013 -    def form_values(self): 
+
1014          """ 
+1015          Return a list of tuples of the field values for the form. 
+1016          This is suitable to be passed to ``urllib.urlencode()``. 
+1017          """ 
+1018          results = [] 
+1019          for el in self.inputs: 
+1020              name = el.name 
+1021              if not name or 'disabled' in el.attrib: 
+1022                  continue 
+1023              tag = _nons(el.tag) 
+1024              if tag == 'textarea': 
+1025                  results.append((name, el.value)) 
+1026              elif tag == 'select': 
+1027                  value = el.value 
+1028                  if el.multiple: 
+1029                      for v in value: 
+1030                          results.append((name, v)) 
+1031                  elif value is not None: 
+1032                      results.append((name, el.value)) 
+1033              else: 
+1034                  assert tag == 'input', ( 
+1035                      "Unexpected tag: %r" % el) 
+1036                  if el.checkable and not el.checked: 
+1037                      continue 
+1038                  if el.type in ('submit', 'image', 'reset', 'file'): 
+1039                      continue 
+1040                  value = el.value 
+1041                  if value is not None: 
+1042                      results.append((name, el.value)) 
+1043          return results 
+
1044   
+1045      @property 
+1046 -    def action(self): 
+
1047          """ 
+1048          Get/set the form's ``action`` attribute. 
+1049          """ 
+1050          base_url = self.base_url 
+1051          action = self.get('action') 
+1052          if base_url and action is not None: 
+1053              return urljoin(base_url, action) 
+1054          else: 
+1055              return action 
+
1056   
+1057      @action.setter 
+1058 -    def action(self, value): 
+
1059          self.set('action', value) 
+
1060   
+1061      @action.deleter 
+1062 -    def action(self): 
+
1063          attrib = self.attrib 
+1064          if 'action' in attrib: 
+1065              del attrib['action'] 
+
1066   
+1067      @property 
+1068 -    def method(self): 
+
1069          """ 
+1070          Get/set the form's method.  Always returns a capitalized 
+1071          string, and defaults to ``'GET'`` 
+1072          """ 
+1073          return self.get('method', 'GET').upper() 
+
1074   
+1075      @method.setter 
+1076 -    def method(self, value): 
+
1077          self.set('method', value.upper()) 
+
1078   
+1079   
+1080  HtmlElementClassLookup._default_element_classes['form'] = FormElement 
+1081   
+1082   
+1083 -def submit_form(form, extra_values=None, open_http=None): 
+
1084      """ 
+1085      Helper function to submit a form.  Returns a file-like object, as from 
+1086      ``urllib.urlopen()``.  This object also has a ``.geturl()`` function, 
+1087      which shows the URL if there were any redirects. 
+1088   
+1089      You can use this like:: 
+1090   
+1091          form = doc.forms[0] 
+1092          form.inputs['foo'].value = 'bar' # etc 
+1093          response = form.submit() 
+1094          doc = parse(response) 
+1095          doc.make_links_absolute(response.geturl()) 
+1096   
+1097      To change the HTTP requester, pass a function as ``open_http`` keyword 
+1098      argument that opens the URL for you.  The function must have the following 
+1099      signature:: 
+1100   
+1101          open_http(method, URL, values) 
+1102   
+1103      The action is one of 'GET' or 'POST', the URL is the target URL as a 
+1104      string, and the values are a sequence of ``(name, value)`` tuples with the 
+1105      form data. 
+1106      """ 
+1107      values = form.form_values() 
+1108      if extra_values: 
+1109          if hasattr(extra_values, 'items'): 
+1110              extra_values = extra_values.items() 
+1111          values.extend(extra_values) 
+1112      if open_http is None: 
+1113          open_http = open_http_urllib 
+1114      if form.action: 
+1115          url = form.action 
+1116      else: 
+1117          url = form.base_url 
+1118      return open_http(form.method, url, values) 
+
1119   
+1120   
+1121 -def open_http_urllib(method, url, values): 
+
1122      if not url: 
+1123          raise ValueError("cannot submit, no URL provided") 
+1124      ## FIXME: should test that it's not a relative URL or something 
+1125      try: 
+1126          from urllib import urlencode, urlopen 
+1127      except ImportError: # Python 3 
+1128          from urllib.request import urlopen 
+1129          from urllib.parse import urlencode 
+1130      if method == 'GET': 
+1131          if '?' in url: 
+1132              url += '&' 
+1133          else: 
+1134              url += '?' 
+1135          url += urlencode(values) 
+1136          data = None 
+1137      else: 
+1138          data = urlencode(values) 
+1139          if not isinstance(data, bytes): 
+1140              data = data.encode('ASCII') 
+1141      return urlopen(url, data) 
+
1142   
+1143   
+1144 -class FieldsDict(MutableMapping): 
+
1145   
+1146 -    def __init__(self, inputs): 
+
1147          self.inputs = inputs 
+
1148 -    def __getitem__(self, item): 
+
1149          return self.inputs[item].value 
+
1150 -    def __setitem__(self, item, value): 
+
1151          self.inputs[item].value = value 
+
1152 -    def __delitem__(self, item): 
+
1153          raise KeyError( 
+1154              "You cannot remove keys from ElementDict") 
+
1155 -    def keys(self): 
+
1156          return self.inputs.keys() 
+
1157 -    def __contains__(self, item): 
+
1158          return item in self.inputs 
+
1159 -    def __iter__(self): 
+
1160          return iter(self.inputs.keys()) 
+
1161 -    def __len__(self): 
+
1162          return len(self.inputs) 
+
1163   
+1164 -    def __repr__(self): 
+
1165          return '<%s for form %s>' % ( 
+1166              self.__class__.__name__, 
+1167              self.inputs.form._name()) 
+
1168   
+1169   
+1170 -class InputGetter(object): 
+
1171   
+1172      """ 
+1173      An accessor that represents all the input fields in a form. 
+1174   
+1175      You can get fields by name from this, with 
+1176      ``form.inputs['field_name']``.  If there are a set of checkboxes 
+1177      with the same name, they are returned as a list (a `CheckboxGroup` 
+1178      which also allows value setting).  Radio inputs are handled 
+1179      similarly. 
+1180   
+1181      You can also iterate over this to get all input elements.  This 
+1182      won't return the same thing as if you get all the names, as 
+1183      checkboxes and radio elements are returned individually. 
+1184      """ 
+1185   
+1186      _name_xpath = etree.XPath(".//*[@name = $name and (local-name(.) = 'select' or local-name(.) = 'input' or local-name(.) = 'textarea')]") 
+1187      _all_xpath = etree.XPath(".//*[local-name() = 'select' or local-name() = 'input' or local-name() = 'textarea']") 
+1188   
+1189 -    def __init__(self, form): 
+
1190          self.form = form 
+
1191   
+1192 -    def __repr__(self): 
+
1193          return '<%s for form %s>' % ( 
+1194              self.__class__.__name__, 
+1195              self.form._name()) 
+
1196   
+1197      ## FIXME: there should be more methods, and it's unclear if this is 
+1198      ## a dictionary-like object or list-like object 
+1199   
+1200 -    def __getitem__(self, name): 
+
1201          results = self._name_xpath(self.form, name=name) 
+1202          if results: 
+1203              type = results[0].get('type') 
+1204              if type == 'radio' and len(results) > 1: 
+1205                  group = RadioGroup(results) 
+1206                  group.name = name 
+1207                  return group 
+1208              elif type == 'checkbox' and len(results) > 1: 
+1209                  group = CheckboxGroup(results) 
+1210                  group.name = name 
+1211                  return group 
+1212              else: 
+1213                  # I don't like throwing away elements like this 
+1214                  return results[0] 
+1215          else: 
+1216              raise KeyError( 
+1217                  "No input element with the name %r" % name) 
+
1218   
+1219 -    def __contains__(self, name): 
+
1220          results = self._name_xpath(self.form, name=name) 
+1221          return bool(results) 
+
1222   
+1223 -    def keys(self): 
+
1224          names = set() 
+1225          for el in self: 
+1226              names.add(el.name) 
+1227          if None in names: 
+1228              names.remove(None) 
+1229          return list(names) 
+
1230   
+1231 -    def __iter__(self): 
+
1232          ## FIXME: kind of dumb to turn a list into an iterator, only 
+1233          ## to have it likely turned back into a list again :( 
+1234          return iter(self._all_xpath(self.form)) 
+
1235   
+1236   
+1237 -class InputMixin(object): 
+
1238      """ 
+1239      Mix-in for all input elements (input, select, and textarea) 
+1240      """ 
+1241      @property 
+1242 -    def name(self): 
+
1243          """ 
+1244          Get/set the name of the element 
+1245          """ 
+1246          return self.get('name') 
+
1247   
+1248      @name.setter 
+1249 -    def name(self, value): 
+
1250          self.set('name', value) 
+
1251   
+1252      @name.deleter 
+1253 -    def name(self): 
+
1254          attrib = self.attrib 
+1255          if 'name' in attrib: 
+1256              del attrib['name'] 
+
1257   
+1258 -    def __repr__(self): 
+
1259          type_name = getattr(self, 'type', None) 
+1260          if type_name: 
+1261              type_name = ' type=%r' % type_name 
+1262          else: 
+1263              type_name = '' 
+1264          return '<%s %x name=%r%s>' % ( 
+1265              self.__class__.__name__, id(self), self.name, type_name) 
+
1266   
+1267   
+1268 -class TextareaElement(InputMixin, HtmlElement): 
+
1269      """ 
+1270      ``<textarea>`` element.  You can get the name with ``.name`` and 
+1271      get/set the value with ``.value`` 
+1272      """ 
+1273      @property 
+1274 -    def value(self): 
+
1275          """ 
+1276          Get/set the value (which is the contents of this element) 
+1277          """ 
+1278          content = self.text or '' 
+1279          if self.tag.startswith("{%s}" % XHTML_NAMESPACE): 
+1280              serialisation_method = 'xml' 
+1281          else: 
+1282              serialisation_method = 'html' 
+1283          for el in self: 
+1284              # it's rare that we actually get here, so let's not use ''.join() 
+1285              content += etree.tostring( 
+1286                  el, method=serialisation_method, encoding='unicode') 
+1287          return content 
+
1288   
+1289      @value.setter 
+1290 -    def value(self, value): 
+
1291          del self[:] 
+1292          self.text = value 
+
1293   
+1294      @value.deleter 
+1295 -    def value(self): 
+
1296          self.text = '' 
+1297          del self[:] 
+
1298   
+1299   
+1300  HtmlElementClassLookup._default_element_classes['textarea'] = TextareaElement 
+1301   
+1302   
+1303 -class SelectElement(InputMixin, HtmlElement): 
+
1304      """ 
+1305      ``<select>`` element.  You can get the name with ``.name``. 
+1306   
+1307      ``.value`` will be the value of the selected option, unless this 
+1308      is a multi-select element (``<select multiple>``), in which case 
+1309      it will be a set-like object.  In either case ``.value_options`` 
+1310      gives the possible values. 
+1311   
+1312      The boolean attribute ``.multiple`` shows if this is a 
+1313      multi-select. 
+1314      """ 
+1315      @property 
+1316 -    def value(self): 
+
1317          """ 
+1318          Get/set the value of this select (the selected option). 
+1319   
+1320          If this is a multi-select, this is a set-like object that 
+1321          represents all the selected options. 
+1322          """ 
+1323          if self.multiple: 
+1324              return MultipleSelectOptions(self) 
+1325          options = _options_xpath(self) 
+1326   
+1327          try: 
+1328              selected_option = next(el for el in reversed(options) if el.get('selected') is not None) 
+1329          except StopIteration: 
+1330              try: 
+1331                  selected_option = next(el for el in options if el.get('disabled') is None) 
+1332              except StopIteration: 
+1333                  return None 
+1334          value = selected_option.get('value') 
+1335          if value is None: 
+1336              value = (selected_option.text or '').strip() 
+1337          return value 
+
1338   
+1339      @value.setter 
+1340 -    def value(self, value): 
+
1341          if self.multiple: 
+1342              if isinstance(value, basestring): 
+1343                  raise TypeError("You must pass in a sequence") 
+1344              values = self.value 
+1345              values.clear() 
+1346              values.update(value) 
+1347              return 
+1348          checked_option = None 
+1349          if value is not None: 
+1350              for el in _options_xpath(self): 
+1351                  opt_value = el.get('value') 
+1352                  if opt_value is None: 
+1353                      opt_value = (el.text or '').strip() 
+1354                  if opt_value == value: 
+1355                      checked_option = el 
+1356                      break 
+1357              else: 
+1358                  raise ValueError( 
+1359                      "There is no option with the value of %r" % value) 
+1360          for el in _options_xpath(self): 
+1361              if 'selected' in el.attrib: 
+1362                  del el.attrib['selected'] 
+1363          if checked_option is not None: 
+1364              checked_option.set('selected', '') 
+
1365   
+1366      @value.deleter 
+1367 -    def value(self): 
+
1368          # FIXME: should del be allowed at all? 
+1369          if self.multiple: 
+1370              self.value.clear() 
+1371          else: 
+1372              self.value = None 
+
1373   
+1374      @property 
+1375 -    def value_options(self): 
+
1376          """ 
+1377          All the possible values this select can have (the ``value`` 
+1378          attribute of all the ``<option>`` elements. 
+1379          """ 
+1380          options = [] 
+1381          for el in _options_xpath(self): 
+1382              value = el.get('value') 
+1383              if value is None: 
+1384                  value = (el.text or '').strip() 
+1385              options.append(value) 
+1386          return options 
+
1387   
+1388      @property 
+1389 -    def multiple(self): 
+
1390          """ 
+1391          Boolean attribute: is there a ``multiple`` attribute on this element. 
+1392          """ 
+1393          return 'multiple' in self.attrib 
+
1394   
+1395      @multiple.setter 
+1396 -    def multiple(self, value): 
+
1397          if value: 
+1398              self.set('multiple', '') 
+1399          elif 'multiple' in self.attrib: 
+1400              del self.attrib['multiple'] 
+
1401   
+1402   
+1403  HtmlElementClassLookup._default_element_classes['select'] = SelectElement 
+1404   
+1405   
+1406 -class MultipleSelectOptions(SetMixin): 
+
1407      """ 
+1408      Represents all the selected options in a ``<select multiple>`` element. 
+1409   
+1410      You can add to this set-like option to select an option, or remove 
+1411      to unselect the option. 
+1412      """ 
+1413   
+1414 -    def __init__(self, select): 
+
1415          self.select = select 
+
1416   
+1417      @property 
+1418 -    def options(self): 
+
1419          """ 
+1420          Iterator of all the ``<option>`` elements. 
+1421          """ 
+1422          return iter(_options_xpath(self.select)) 
+
1423   
+1424 -    def __iter__(self): 
+
1425          for option in self.options: 
+1426              if 'selected' in option.attrib: 
+1427                  opt_value = option.get('value') 
+1428                  if opt_value is None: 
+1429                      opt_value = (option.text or '').strip() 
+1430                  yield opt_value 
+
1431   
+1432 -    def add(self, item): 
+
1433          for option in self.options: 
+1434              opt_value = option.get('value') 
+1435              if opt_value is None: 
+1436                  opt_value = (option.text or '').strip() 
+1437              if opt_value == item: 
+1438                  option.set('selected', '') 
+1439                  break 
+1440          else: 
+1441              raise ValueError( 
+1442                  "There is no option with the value %r" % item) 
+
1443   
+1444 -    def remove(self, item): 
+
1445          for option in self.options: 
+1446              opt_value = option.get('value') 
+1447              if opt_value is None: 
+1448                  opt_value = (option.text or '').strip() 
+1449              if opt_value == item: 
+1450                  if 'selected' in option.attrib: 
+1451                      del option.attrib['selected'] 
+1452                  else: 
+1453                      raise ValueError( 
+1454                          "The option %r is not currently selected" % item) 
+1455                  break 
+1456          else: 
+1457              raise ValueError( 
+1458                  "There is not option with the value %r" % item) 
+
1459   
+1460 -    def __repr__(self): 
+
1461          return '<%s {%s} for select name=%r>' % ( 
+1462              self.__class__.__name__, 
+1463              ', '.join([repr(v) for v in self]), 
+1464              self.select.name) 
+
1465   
+1466   
+1467 -class RadioGroup(list): 
+
1468      """ 
+1469      This object represents several ``<input type=radio>`` elements 
+1470      that have the same name. 
+1471   
+1472      You can use this like a list, but also use the property 
+1473      ``.value`` to check/uncheck inputs.  Also you can use 
+1474      ``.value_options`` to get the possible values. 
+1475      """ 
+1476      @property 
+1477 -    def value(self): 
+
1478          """ 
+1479          Get/set the value, which checks the radio with that value (and 
+1480          unchecks any other value). 
+1481          """ 
+1482          for el in self: 
+1483              if 'checked' in el.attrib: 
+1484                  return el.get('value') 
+1485          return None 
+
1486   
+1487      @value.setter 
+1488 -    def value(self, value): 
+
1489          checked_option = None 
+1490          if value is not None: 
+1491              for el in self: 
+1492                  if el.get('value') == value: 
+1493                      checked_option = el 
+1494                      break 
+1495              else: 
+1496                  raise ValueError("There is no radio input with the value %r" % value) 
+1497          for el in self: 
+1498              if 'checked' in el.attrib: 
+1499                  del el.attrib['checked'] 
+1500          if checked_option is not None: 
+1501              checked_option.set('checked', '') 
+
1502   
+1503      @value.deleter 
+1504 -    def value(self): 
+
1505          self.value = None 
+
1506   
+1507      @property 
+1508 -    def value_options(self): 
+
1509          """ 
+1510          Returns a list of all the possible values. 
+1511          """ 
+1512          return [el.get('value') for el in self] 
+
1513   
+1514 -    def __repr__(self): 
+
1515          return '%s(%s)' % ( 
+1516              self.__class__.__name__, 
+1517              list.__repr__(self)) 
+
1518   
+1519   
+1520 -class CheckboxGroup(list): 
+
1521      """ 
+1522      Represents a group of checkboxes (``<input type=checkbox>``) that 
+1523      have the same name. 
+1524   
+1525      In addition to using this like a list, the ``.value`` attribute 
+1526      returns a set-like object that you can add to or remove from to 
+1527      check and uncheck checkboxes.  You can also use ``.value_options`` 
+1528      to get the possible values. 
+1529      """ 
+1530      @property 
+1531 -    def value(self): 
+
1532          """ 
+1533          Return a set-like object that can be modified to check or 
+1534          uncheck individual checkboxes according to their value. 
+1535          """ 
+1536          return CheckboxValues(self) 
+
1537   
+1538      @value.setter 
+1539 -    def value(self, value): 
+
1540          values = self.value 
+1541          values.clear() 
+1542          if not hasattr(value, '__iter__'): 
+1543              raise ValueError( 
+1544                  "A CheckboxGroup (name=%r) must be set to a sequence (not %r)" 
+1545                  % (self[0].name, value)) 
+1546          values.update(value) 
+
1547   
+1548      @value.deleter 
+1549 -    def value(self): 
+
1550          self.value.clear() 
+
1551   
+1552      @property 
+1553 -    def value_options(self): 
+
1554          """ 
+1555          Returns a list of all the possible values. 
+1556          """ 
+1557          return [el.get('value') for el in self] 
+
1558   
+1559 -    def __repr__(self): 
+
1560          return '%s(%s)' % ( 
+1561              self.__class__.__name__, list.__repr__(self)) 
+
1562   
+1563   
+1564 -class CheckboxValues(SetMixin): 
+
1565      """ 
+1566      Represents the values of the checked checkboxes in a group of 
+1567      checkboxes with the same name. 
+1568      """ 
+1569   
+1570 -    def __init__(self, group): 
+
1571          self.group = group 
+
1572   
+1573 -    def __iter__(self): 
+
1574          return iter([ 
+1575              el.get('value') 
+1576              for el in self.group 
+1577              if 'checked' in el.attrib]) 
+
1578   
+1579 -    def add(self, value): 
+
1580          for el in self.group: 
+1581              if el.get('value') == value: 
+1582                  el.set('checked', '') 
+1583                  break 
+1584          else: 
+1585              raise KeyError("No checkbox with value %r" % value) 
+
1586   
+1587 -    def remove(self, value): 
+
1588          for el in self.group: 
+1589              if el.get('value') == value: 
+1590                  if 'checked' in el.attrib: 
+1591                      del el.attrib['checked'] 
+1592                  else: 
+1593                      raise KeyError( 
+1594                          "The checkbox with value %r was already unchecked" % value) 
+1595                  break 
+1596          else: 
+1597              raise KeyError( 
+1598                  "No checkbox with value %r" % value) 
+
1599   
+1600 -    def __repr__(self): 
+
1601          return '<%s {%s} for checkboxes name=%r>' % ( 
+1602              self.__class__.__name__, 
+1603              ', '.join([repr(v) for v in self]), 
+1604              self.group.name) 
+
1605   
+1606   
+1607 -class InputElement(InputMixin, HtmlElement): 
+
1608      """ 
+1609      Represents an ``<input>`` element. 
+1610   
+1611      You can get the type with ``.type`` (which is lower-cased and 
+1612      defaults to ``'text'``). 
+1613   
+1614      Also you can get and set the value with ``.value`` 
+1615   
+1616      Checkboxes and radios have the attribute ``input.checkable == 
+1617      True`` (for all others it is false) and a boolean attribute 
+1618      ``.checked``. 
+1619   
+1620      """ 
+1621   
+1622      ## FIXME: I'm a little uncomfortable with the use of .checked 
+1623      @property 
+1624 -    def value(self): 
+
1625          """ 
+1626          Get/set the value of this element, using the ``value`` attribute. 
+1627   
+1628          Also, if this is a checkbox and it has no value, this defaults 
+1629          to ``'on'``.  If it is a checkbox or radio that is not 
+1630          checked, this returns None. 
+1631          """ 
+1632          if self.checkable: 
+1633              if self.checked: 
+1634                  return self.get('value') or 'on' 
+1635              else: 
+1636                  return None 
+1637          return self.get('value') 
+
1638   
+1639      @value.setter 
+1640 -    def value(self, value): 
+
1641          if self.checkable: 
+1642              if not value: 
+1643                  self.checked = False 
+1644              else: 
+1645                  self.checked = True 
+1646                  if isinstance(value, basestring): 
+1647                      self.set('value', value) 
+1648          else: 
+1649              self.set('value', value) 
+
1650   
+1651      @value.deleter 
+1652 -    def value(self): 
+
1653          if self.checkable: 
+1654              self.checked = False 
+1655          else: 
+1656              if 'value' in self.attrib: 
+1657                  del self.attrib['value'] 
+
1658   
+1659      @property 
+1660 -    def type(self): 
+
1661          """ 
+1662          Return the type of this element (using the type attribute). 
+1663          """ 
+1664          return self.get('type', 'text').lower() 
+
1665   
+1666      @type.setter 
+1667 -    def type(self, value): 
+
1668          self.set('type', value) 
+
1669   
+1670      @property 
+1671 -    def checkable(self): 
+
1672          """ 
+1673          Boolean: can this element be checked? 
+1674          """ 
+1675          return self.type in ('checkbox', 'radio') 
+
1676   
+1677      @property 
+1678 -    def checked(self): 
+
1679          """ 
+1680          Boolean attribute to get/set the presence of the ``checked`` 
+1681          attribute. 
+1682   
+1683          You can only use this on checkable input types. 
+1684          """ 
+1685          if not self.checkable: 
+1686              raise AttributeError('Not a checkable input type') 
+1687          return 'checked' in self.attrib 
+
1688   
+1689      @checked.setter 
+1690 -    def checked(self, value): 
+
1691          if not self.checkable: 
+1692              raise AttributeError('Not a checkable input type') 
+1693          if value: 
+1694              self.set('checked', '') 
+1695          else: 
+1696              attrib = self.attrib 
+1697              if 'checked' in attrib: 
+1698                  del attrib['checked'] 
+
1699   
+1700   
+1701  HtmlElementClassLookup._default_element_classes['input'] = InputElement 
+1702   
+1703   
+1704 -class LabelElement(HtmlElement): 
+
1705      """ 
+1706      Represents a ``<label>`` element. 
+1707   
+1708      Label elements are linked to other elements with their ``for`` 
+1709      attribute.  You can access this element with ``label.for_element``. 
+1710      """ 
+1711      @property 
+1712 -    def for_element(self): 
+
1713          """ 
+1714          Get/set the element this label points to.  Return None if it 
+1715          can't be found. 
+1716          """ 
+1717          id = self.get('for') 
+1718          if not id: 
+1719              return None 
+1720          return self.body.get_element_by_id(id) 
+
1721   
+1722      @for_element.setter 
+1723 -    def for_element(self, other): 
+
1724          id = other.get('id') 
+1725          if not id: 
+1726              raise TypeError( 
+1727                  "Element %r has no id attribute" % other) 
+1728          self.set('for', id) 
+
1729   
+1730      @for_element.deleter 
+1731 -    def for_element(self): 
+
1732          attrib = self.attrib 
+1733          if 'id' in attrib: 
+1734              del attrib['id'] 
+
1735   
+1736   
+1737  HtmlElementClassLookup._default_element_classes['label'] = LabelElement 
+1738   
+1739   
+1740  ############################################################ 
+1741  ## Serialization 
+1742  ############################################################ 
+1743   
+1744 -def html_to_xhtml(html): 
+
1745      """Convert all tags in an HTML tree to XHTML by moving them to the 
+1746      XHTML namespace. 
+1747      """ 
+1748      try: 
+1749          html = html.getroot() 
+1750      except AttributeError: 
+1751          pass 
+1752      prefix = "{%s}" % XHTML_NAMESPACE 
+1753      for el in html.iter(etree.Element): 
+1754          tag = el.tag 
+1755          if tag[0] != '{': 
+1756              el.tag = prefix + tag 
+
1757   
+1758   
+1759 -def xhtml_to_html(xhtml): 
+
1760      """Convert all tags in an XHTML tree to HTML by removing their 
+1761      XHTML namespace. 
+1762      """ 
+1763      try: 
+1764          xhtml = xhtml.getroot() 
+1765      except AttributeError: 
+1766          pass 
+1767      prefix = "{%s}" % XHTML_NAMESPACE 
+1768      prefix_len = len(prefix) 
+1769      for el in xhtml.iter(prefix + "*"): 
+1770          el.tag = el.tag[prefix_len:] 
+
1771   
+1772   
+1773  # This isn't a general match, but it's a match for what libxml2 
+1774  # specifically serialises: 
+1775  __str_replace_meta_content_type = re.compile( 
+1776      r'<meta http-equiv="Content-Type"[^>]*>').sub 
+1777  __bytes_replace_meta_content_type = re.compile( 
+1778      r'<meta http-equiv="Content-Type"[^>]*>'.encode('ASCII')).sub 
+1779   
+1780   
+1781 -def tostring(doc, pretty_print=False, include_meta_content_type=False, 
+1782               encoding=None, method="html", with_tail=True, doctype=None): 
+
1783      """Return an HTML string representation of the document. 
+1784   
+1785      Note: if include_meta_content_type is true this will create a 
+1786      ``<meta http-equiv="Content-Type" ...>`` tag in the head; 
+1787      regardless of the value of include_meta_content_type any existing 
+1788      ``<meta http-equiv="Content-Type" ...>`` tag will be removed 
+1789   
+1790      The ``encoding`` argument controls the output encoding (defaults to 
+1791      ASCII, with &#...; character references for any characters outside 
+1792      of ASCII).  Note that you can pass the name ``'unicode'`` as 
+1793      ``encoding`` argument to serialise to a Unicode string. 
+1794   
+1795      The ``method`` argument defines the output method.  It defaults to 
+1796      'html', but can also be 'xml' for xhtml output, or 'text' to 
+1797      serialise to plain text without markup. 
+1798   
+1799      To leave out the tail text of the top-level element that is being 
+1800      serialised, pass ``with_tail=False``. 
+1801   
+1802      The ``doctype`` option allows passing in a plain string that will 
+1803      be serialised before the XML tree.  Note that passing in non 
+1804      well-formed content here will make the XML output non well-formed. 
+1805      Also, an existing doctype in the document tree will not be removed 
+1806      when serialising an ElementTree instance. 
+1807   
+1808      Example:: 
+1809   
+1810          >>> from lxml import html 
+1811          >>> root = html.fragment_fromstring('<p>Hello<br>world!</p>') 
+1812   
+1813          >>> html.tostring(root) 
+1814          b'<p>Hello<br>world!</p>' 
+1815          >>> html.tostring(root, method='html') 
+1816          b'<p>Hello<br>world!</p>' 
+1817   
+1818          >>> html.tostring(root, method='xml') 
+1819          b'<p>Hello<br/>world!</p>' 
+1820   
+1821          >>> html.tostring(root, method='text') 
+1822          b'Helloworld!' 
+1823   
+1824          >>> html.tostring(root, method='text', encoding='unicode') 
+1825          u'Helloworld!' 
+1826   
+1827          >>> root = html.fragment_fromstring('<div><p>Hello<br>world!</p>TAIL</div>') 
+1828          >>> html.tostring(root[0], method='text', encoding='unicode') 
+1829          u'Helloworld!TAIL' 
+1830   
+1831          >>> html.tostring(root[0], method='text', encoding='unicode', with_tail=False) 
+1832          u'Helloworld!' 
+1833   
+1834          >>> doc = html.document_fromstring('<p>Hello<br>world!</p>') 
+1835          >>> html.tostring(doc, method='html', encoding='unicode') 
+1836          u'<html><body><p>Hello<br>world!</p></body></html>' 
+1837   
+1838          >>> print(html.tostring(doc, method='html', encoding='unicode', 
+1839          ...          doctype='<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"' 
+1840          ...                  ' "http://www.w3.org/TR/html4/strict.dtd">')) 
+1841          <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> 
+1842          <html><body><p>Hello<br>world!</p></body></html> 
+1843      """ 
+1844      html = etree.tostring(doc, method=method, pretty_print=pretty_print, 
+1845                            encoding=encoding, with_tail=with_tail, 
+1846                            doctype=doctype) 
+1847      if method == 'html' and not include_meta_content_type: 
+1848          if isinstance(html, str): 
+1849              html = __str_replace_meta_content_type('', html) 
+1850          else: 
+1851              html = __bytes_replace_meta_content_type(bytes(), html) 
+1852      return html 
+
1853   
+1854   
+1855  tostring.__doc__ = __fix_docstring(tostring.__doc__) 
+1856   
+1857   
+1858 -def open_in_browser(doc, encoding=None): 
+
1859      """ 
+1860      Open the HTML document in a web browser, saving it to a temporary 
+1861      file to open it.  Note that this does not delete the file after 
+1862      use.  This is mainly meant for debugging. 
+1863      """ 
+1864      import os 
+1865      import webbrowser 
+1866      import tempfile 
+1867      if not isinstance(doc, etree._ElementTree): 
+1868          doc = etree.ElementTree(doc) 
+1869      handle, fn = tempfile.mkstemp(suffix='.html') 
+1870      f = os.fdopen(handle, 'wb') 
+1871      try: 
+1872          doc.write(f, method="html", encoding=encoding or doc.docinfo.encoding or "UTF-8") 
+1873      finally: 
+1874          # we leak the file itself here, but we should at least close it 
+1875          f.close() 
+1876      url = 'file://' + fn.replace(os.path.sep, '/') 
+1877      print(url) 
+1878      webbrowser.open(url) 
+
1879   
+1880   
+1881  ################################################################################ 
+1882  # configure Element class lookup 
+1883  ################################################################################ 
+1884   
+1885 -class HTMLParser(etree.HTMLParser): 
+
1886      """An HTML parser that is configured to return lxml.html Element 
+1887      objects. 
+1888      """ 
+1889 -    def __init__(self, **kwargs): 
+
1890          super(HTMLParser, self).__init__(**kwargs) 
+1891          self.set_element_class_lookup(HtmlElementClassLookup()) 
+
1892   
+1893   
+1894 -class XHTMLParser(etree.XMLParser): 
+
1895      """An XML parser that is configured to return lxml.html Element 
+1896      objects. 
+1897   
+1898      Note that this parser is not really XHTML aware unless you let it 
+1899      load a DTD that declares the HTML entities.  To do this, make sure 
+1900      you have the XHTML DTDs installed in your catalogs, and create the 
+1901      parser like this:: 
+1902   
+1903          >>> parser = XHTMLParser(load_dtd=True) 
+1904   
+1905      If you additionally want to validate the document, use this:: 
+1906   
+1907          >>> parser = XHTMLParser(dtd_validation=True) 
+1908   
+1909      For catalog support, see http://www.xmlsoft.org/catalog.html. 
+1910      """ 
+1911 -    def __init__(self, **kwargs): 
+
1912          super(XHTMLParser, self).__init__(**kwargs) 
+1913          self.set_element_class_lookup(HtmlElementClassLookup()) 
+
1914   
+1915   
+1916 -def Element(*args, **kw): 
+
1917      """Create a new HTML Element. 
+1918   
+1919      This can also be used for XHTML documents. 
+1920      """ 
+1921      v = html_parser.makeelement(*args, **kw) 
+1922      return v 
+
1923   
+1924   
+1925  html_parser = HTMLParser() 
+1926  xhtml_parser = XHTMLParser() 
+1927   
+
+object --+    
+         |    
+      list --+
+             |
+            CheckboxGroup
+
<input type=checkbox>
.value
.value_options
+       object --+                
+                |                
+    _abcoll.Sized --+            
+                    |            
+       object --+   |            
+                |   |            
+ _abcoll.Iterable --+            
+                    |            
+       object --+   |            
+                |   |            
+_abcoll.Container --+            
+                    |            
+          _abcoll.Set --+        
+                        |        
+       _abcoll.MutableSet --+    
+                            |    
+           _setmixin.SetMixin --+
+                                |
+                               CheckboxValues
+
+       object --+            
+                |            
+    _abcoll.Sized --+        
+                    |        
+       object --+   |        
+                |   |        
+ _abcoll.Iterable --+        
+                    |        
+       object --+   |        
+                |   |        
+_abcoll.Container --+        
+                    |        
+          _abcoll.Set --+    
+                        |    
+       _abcoll.MutableSet --+
+                            |
+                           Classes
+
+>>> el = fromstring('<p class="hidden large">Text</p>')
+>>> classes = el.classes  # or: classes = Classes(el.attrib)
+>>> classes |= ['block', 'paragraph']
+>>> el.get('class')
+'hidden large block paragraph'
+>>> classes.toggle('hidden')
+False
+>>> el.get('class')
+'large block paragraph'
+>>> classes -= ('some', 'classes', 'block')
+>>> el.get('class')
+'large paragraph'
+
+"""Legacy interface to the BeautifulSoup HTML parser.
+"""
+
+ 1  __doc__ = """Legacy interface to the BeautifulSoup HTML parser. 
+ 2  """ 
+ 3   
+ 4  __all__ = ["parse", "convert_tree"] 
+ 5   
+ 6  from soupparser import convert_tree, parse as _parse 
+ 7   
+ 8 -def parse(file, beautifulsoup=None, makeelement=None): 
+
 9      root = _parse(file, beautifulsoup=beautifulsoup, makeelement=makeelement) 
+10      return root.getroot() 
+
11   
+
+       object --+            
+                |            
+    _abcoll.Sized --+        
+                    |        
+       object --+   |        
+                |   |        
+ _abcoll.Iterable --+        
+                    |        
+       object --+   |        
+                |   |        
+_abcoll.Container --+        
+                    |        
+      _abcoll.Mapping --+    
+                        |    
+   _abcoll.MutableMapping --+
+                            |
+                           FieldsDict
+
+    object --+            
+             |            
+etree._Element --+        
+                 |        
+ etree.ElementBase --+    
+                     |    
+        object --+   |    
+                 |   |    
+         HtmlMixin --+    
+                     |    
+           HtmlElement --+
+                         |
+                        FormElement
+
urllib.urlencode()
action
'GET'
action
action
'GET'
'GET'
+    object --+            
+             |            
+??._BaseParser --+        
+                 |        
+ etree._FeedParser --+    
+                     |    
+      etree.HTMLParser --+
+                         |
+                        HTMLParser
+
+         object --+                
+                  |                
+     etree._Element --+            
+                      |            
+??.__ContentOnlyElement --+        
+                          |        
+             etree._Comment --+    
+                              |    
+              etree.CommentBase --+
+                                  |
+                     object --+   |
+                              |   |
+                      HtmlMixin --+
+                                  |
+                                 HtmlComment
+
+    object --+        
+             |        
+etree._Element --+    
+                 |    
+ etree.ElementBase --+
+                     |
+        object --+   |
+                 |   |
+         HtmlMixin --+
+                     |
+                    HtmlElement
+
form.set('novalidate')
form.set('novalidate')
+                  object --+            
+                           |            
+    etree.ElementClassLookup --+        
+                               |        
+etree.FallbackElementClassLookup --+    
+                                   |    
+      etree.CustomElementClassLookup --+
+                                       |
+                                      HtmlElementClassLookup
+
classes
mixins
+{'form': <class 'lxml.html.FormElement'>,
+ 'input': <class 'lxml.html.InputElement'>,
+ 'label': <class 'lxml.html.LabelElement'>,
+ 'select': <class 'lxml.html.SelectElement'>,
+ 'textarea': <class 'lxml.html.TextareaElement'>}
+
+         object --+                
+                  |                
+     etree._Element --+            
+                      |            
+??.__ContentOnlyElement --+        
+                          |        
+              etree._Entity --+    
+                              |    
+               etree.EntityBase --+
+                                  |
+                     object --+   |
+                              |   |
+                      HtmlMixin --+
+                                  |
+                                 HtmlEntity
+
+object --+
+         |
+        HtmlMixin
+
<a rel="{rel}">...</a>
pos
base_url
base_url
.base_url
<base href>
link_repl_func(link)
form.set('novalidate')
+>>> h = fragment_fromstring('<div>Hello <b>World!</b></div>')
+>>> h.find('.//b').drop_tag()
+>>> print(tostring(h, encoding='unicode'))
+<div>Hello World!</div>
+
pos
base_url
base_url
.base_url
resolve_base_href
<base href>
handle_failures
<base href>
handle_failures
link_repl_func(link)
make_links_absolute()
'#anchor'
'mailto:email'
'javascript:expr'
base_href
link_repl_func()
link_repl_func
urlparse.urljoin(el.base_url, href)
+          object --+                
+                   |                
+      etree._Element --+            
+                       |            
+ ??.__ContentOnlyElement --+        
+                           |        
+etree._ProcessingInstruction --+    
+                               |    
+                    etree.PIBase --+
+                                   |
+                      object --+   |
+                               |   |
+                       HtmlMixin --+
+                                   |
+                                  HtmlProcessingInstruction
+
+            object --+    
+                     |    
+            InputMixin --+
+                         |
+    object --+           |
+             |           |
+etree._Element --+       |
+                 |       |
+ etree.ElementBase --+   |
+                     |   |
+        object --+   |   |
+                 |   |   |
+         HtmlMixin --+   |
+                     |   |
+           HtmlElement --+
+                         |
+                        InputElement
+
<input>
.type
'text'
.value
input.checkable ==
+True
.checked
checked
value
checked
checked
value
'on'
value
+object --+
+         |
+        InputGetter
+
form.inputs['field_name']
+.//*[local-name() = 'select' or local-name() = 'input' or local-name()
+ = 'textarea']
+
+.//*[@name = $name and (local-name(.) = 'select' or local-name(.) = 'i
+nput' or local-name(.) = 'textarea')]
+
+object --+
+         |
+        InputMixin
+
+    object --+            
+             |            
+etree._Element --+        
+                 |        
+ etree.ElementBase --+    
+                     |    
+        object --+   |    
+                 |   |    
+         HtmlMixin --+    
+                     |    
+           HtmlElement --+
+                         |
+                        LabelElement
+
<label>
for
label.for_element
+       object --+                
+                |                
+    _abcoll.Sized --+            
+                    |            
+       object --+   |            
+                |   |            
+ _abcoll.Iterable --+            
+                    |            
+       object --+   |            
+                |   |            
+_abcoll.Container --+            
+                    |            
+          _abcoll.Set --+        
+                        |        
+       _abcoll.MutableSet --+    
+                            |    
+           _setmixin.SetMixin --+
+                                |
+                               MultipleSelectOptions
+
<select multiple>
<option>
<option>
<option>
+object --+    
+         |    
+      list --+
+             |
+            RadioGroup
+
<input type=radio>
.value
.value_options
+            object --+    
+                     |    
+            InputMixin --+
+                         |
+    object --+           |
+             |           |
+etree._Element --+       |
+                 |       |
+ etree.ElementBase --+   |
+                     |   |
+        object --+   |   |
+                 |   |   |
+         HtmlMixin --+   |
+                     |   |
+           HtmlElement --+
+                         |
+                        SelectElement
+
<select>
.name
.value
<select multiple>
.value_options
.multiple
multiple
value
<option>
multiple
multiple
value
<option>
value
<option>
+            object --+    
+                     |    
+            InputMixin --+
+                         |
+    object --+           |
+             |           |
+etree._Element --+       |
+                 |       |
+ etree.ElementBase --+   |
+                     |   |
+        object --+   |   |
+                 |   |   |
+         HtmlMixin --+   |
+                     |   |
+           HtmlElement --+
+                         |
+                        TextareaElement
+
<textarea>
.name
.value
+    object --+            
+             |            
+??._BaseParser --+        
+                 |        
+ etree._FeedParser --+    
+                     |    
+       etree.XMLParser --+
+                         |
+                        XHTMLParser
+
+>>> parser = XHTMLParser(load_dtd=True)
+
+>>> parser = XHTMLParser(dtd_validation=True)
+
+object --+
+         |
+        _MethodFunc
+
+>>> from lxml.html.builder import *
+>>> html = HTML(
+...            HEAD( TITLE("Hello World") ),
+...            BODY( CLASS("main"),
+...                  H1("Hello World !")
+...            )
+...        )
+
+>>> import lxml.etree
+>>> print lxml.etree.tostring(html, pretty_print=True)
+<html>
+  <head>
+    <title>Hello World</title>
+  </head>
+  <body class="main">
+    <h1>Hello World !</h1>
+  </body>
+</html>
+
+  1  # -------------------------------------------------------------------- 
+  2  # The ElementTree toolkit is 
+  3  # Copyright (c) 1999-2004 by Fredrik Lundh 
+  4  # -------------------------------------------------------------------- 
+  5   
+  6  """ 
+  7  A set of HTML generator tags for building HTML documents. 
+  8   
+  9  Usage:: 
+ 10   
+ 11      >>> from lxml.html.builder import * 
+ 12      >>> html = HTML( 
+ 13      ...            HEAD( TITLE("Hello World") ), 
+ 14      ...            BODY( CLASS("main"), 
+ 15      ...                  H1("Hello World !") 
+ 16      ...            ) 
+ 17      ...        ) 
+ 18   
+ 19      >>> import lxml.etree 
+ 20      >>> print lxml.etree.tostring(html, pretty_print=True) 
+ 21      <html> 
+ 22        <head> 
+ 23          <title>Hello World</title> 
+ 24        </head> 
+ 25        <body class="main"> 
+ 26          <h1>Hello World !</h1> 
+ 27        </body> 
+ 28      </html> 
+ 29   
+ 30  """ 
+ 31   
+ 32  from lxml.builder import ElementMaker 
+ 33  from lxml.html import html_parser 
+ 34   
+ 35  E = ElementMaker(makeelement=html_parser.makeelement) 
+ 36   
+ 37  # elements 
+ 38  A = E.a # anchor 
+ 39  ABBR = E.abbr # abbreviated form (e.g., WWW, HTTP, etc.) 
+ 40  ACRONYM = E.acronym #  
+ 41  ADDRESS = E.address # information on author 
+ 42  APPLET = E.applet # Java applet (DEPRECATED) 
+ 43  AREA = E.area # client-side image map area 
+ 44  B = E.b # bold text style 
+ 45  BASE = E.base # document base URI 
+ 46  BASEFONT = E.basefont # base font size (DEPRECATED) 
+ 47  BDO = E.bdo # I18N BiDi over-ride 
+ 48  BIG = E.big # large text style 
+ 49  BLOCKQUOTE = E.blockquote # long quotation 
+ 50  BODY = E.body # document body 
+ 51  BR = E.br # forced line break 
+ 52  BUTTON = E.button # push button 
+ 53  CAPTION = E.caption # table caption 
+ 54  CENTER = E.center # shorthand for DIV align=center (DEPRECATED) 
+ 55  CITE = E.cite # citation 
+ 56  CODE = E.code # computer code fragment 
+ 57  COL = E.col # table column 
+ 58  COLGROUP = E.colgroup # table column group 
+ 59  DD = E.dd # definition description 
+ 60  DEL = getattr(E, 'del') # deleted text 
+ 61  DFN = E.dfn # instance definition 
+ 62  DIR = E.dir # directory list (DEPRECATED) 
+ 63  DIV = E.div # generic language/style container 
+ 64  DL = E.dl # definition list 
+ 65  DT = E.dt # definition term 
+ 66  EM = E.em # emphasis 
+ 67  FIELDSET = E.fieldset # form control group 
+ 68  FONT = E.font # local change to font (DEPRECATED) 
+ 69  FORM = E.form # interactive form 
+ 70  FRAME = E.frame # subwindow 
+ 71  FRAMESET = E.frameset # window subdivision 
+ 72  H1 = E.h1 # heading 
+ 73  H2 = E.h2 # heading 
+ 74  H3 = E.h3 # heading 
+ 75  H4 = E.h4 # heading 
+ 76  H5 = E.h5 # heading 
+ 77  H6 = E.h6 # heading 
+ 78  HEAD = E.head # document head 
+ 79  HR = E.hr # horizontal rule 
+ 80  HTML = E.html # document root element 
+ 81  I = E.i # italic text style 
+ 82  IFRAME = E.iframe # inline subwindow 
+ 83  IMG = E.img # Embedded image 
+ 84  INPUT = E.input # form control 
+ 85  INS = E.ins # inserted text 
+ 86  ISINDEX = E.isindex # single line prompt (DEPRECATED) 
+ 87  KBD = E.kbd # text to be entered by the user 
+ 88  LABEL = E.label # form field label text 
+ 89  LEGEND = E.legend # fieldset legend 
+ 90  LI = E.li # list item 
+ 91  LINK = E.link # a media-independent link 
+ 92  MAP = E.map # client-side image map 
+ 93  MENU = E.menu # menu list (DEPRECATED) 
+ 94  META = E.meta # generic metainformation 
+ 95  NOFRAMES = E.noframes # alternate content container for non frame-based rendering 
+ 96  NOSCRIPT = E.noscript # alternate content container for non script-based rendering 
+ 97  OBJECT = E.object # generic embedded object 
+ 98  OL = E.ol # ordered list 
+ 99  OPTGROUP = E.optgroup # option group 
+100  OPTION = E.option # selectable choice 
+101  P = E.p # paragraph 
+102  PARAM = E.param # named property value 
+103  PRE = E.pre # preformatted text 
+104  Q = E.q # short inline quotation 
+105  S = E.s # strike-through text style (DEPRECATED) 
+106  SAMP = E.samp # sample program output, scripts, etc. 
+107  SCRIPT = E.script # script statements 
+108  SELECT = E.select # option selector 
+109  SMALL = E.small # small text style 
+110  SPAN = E.span # generic language/style container 
+111  STRIKE = E.strike # strike-through text (DEPRECATED) 
+112  STRONG = E.strong # strong emphasis 
+113  STYLE = E.style # style info 
+114  SUB = E.sub # subscript 
+115  SUP = E.sup # superscript 
+116  TABLE = E.table #  
+117  TBODY = E.tbody # table body 
+118  TD = E.td # table data cell 
+119  TEXTAREA = E.textarea # multi-line text field 
+120  TFOOT = E.tfoot # table footer 
+121  TH = E.th # table header cell 
+122  THEAD = E.thead # table header 
+123  TITLE = E.title # document title 
+124  TR = E.tr # table row 
+125  TT = E.tt # teletype or monospaced text style 
+126  U = E.u # underlined text style (DEPRECATED) 
+127  UL = E.ul # unordered list 
+128  VAR = E.var # instance of a variable or program argument 
+129   
+130  # attributes (only reserved words are included here) 
+131  ATTR = dict 
+132 -def CLASS(v): return {'class': v} 
+
133 -def FOR(v): return {'for': v} 
+
134   
+
<textarea>
<pre>
+re.compile(r'(?is)\[if[\s\n\r]+.*?\][\s\n\r]*>')
+
+descendant-or-self::a  [normalize-space(@href) and substring(normalize
+-space(@href),1,1) != '#'] |descendant-or-self::x:a[normalize-space(@h
+ref) and substring(normalize-space(@href),1,1) != '#']
+
+[re.compile(r'(?i)(?P<body>https?://(?P<host>[a-z0-9\._-]+)(?:/[/-_\.,
+a-z0-9%&\?;=~]*)?(?:\([/-_\.,a-z0-9%&\?;=~]*\))?)'),
+ re.compile(r'(?i)mailto:(?P<body>[a-z0-9\._-]+@(?P<host>[a-z0-9_\.-]+
+[a-z]))')]
+
+['textarea', 'pre', 'code', 'head', 'select', 'a']
+
+[re.compile(r'(?i)^localhost'),
+ re.compile(r'(?i)\bexample\.(?:com|org|net)$'),
+ re.compile(r'^127\.0\.0\.1$')]
+
+  1  # cython: language_level=2 
+  2   
+  3  """A cleanup tool for HTML. 
+  4   
+  5  Removes unwanted tags and content.  See the `Cleaner` class for 
+  6  details. 
+  7  """ 
+  8   
+  9  from __future__ import absolute_import 
+ 10   
+ 11  import re 
+ 12  import copy 
+ 13  try: 
+ 14      from urlparse import urlsplit 
+ 15      from urllib import unquote_plus 
+ 16  except ImportError: 
+ 17      # Python 3 
+ 18      from urllib.parse import urlsplit, unquote_plus 
+ 19  from lxml import etree 
+ 20  from lxml.html import defs 
+ 21  from lxml.html import fromstring, XHTML_NAMESPACE 
+ 22  from lxml.html import xhtml_to_html, _transform_result 
+ 23   
+ 24  try: 
+ 25      unichr 
+ 26  except NameError: 
+ 27      # Python 3 
+ 28      unichr = chr 
+ 29  try: 
+ 30      unicode 
+ 31  except NameError: 
+ 32      # Python 3 
+ 33      unicode = str 
+ 34  try: 
+ 35      basestring 
+ 36  except NameError: 
+ 37      basestring = (str, bytes) 
+ 38   
+ 39   
+ 40  __all__ = ['clean_html', 'clean', 'Cleaner', 'autolink', 'autolink_html', 
+ 41             'word_break', 'word_break_html'] 
+ 42   
+ 43  # Look at http://code.sixapart.com/trac/livejournal/browser/trunk/cgi-bin/cleanhtml.pl 
+ 44  #   Particularly the CSS cleaning; most of the tag cleaning is integrated now 
+ 45  # I have multiple kinds of schemes searched; but should schemes be 
+ 46  #   whitelisted instead? 
+ 47  # max height? 
+ 48  # remove images?  Also in CSS?  background attribute? 
+ 49  # Some way to whitelist object, iframe, etc (e.g., if you want to 
+ 50  #   allow *just* embedded YouTube movies) 
+ 51  # Log what was deleted and why? 
+ 52  # style="behavior: ..." might be bad in IE? 
+ 53  # Should we have something for just <meta http-equiv>?  That's the worst of the 
+ 54  #   metas. 
+ 55  # UTF-7 detections?  Example: 
+ 56  #     <HEAD><META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=UTF-7"> </HEAD>+ADw-SCRIPT+AD4-alert('XSS');+ADw-/SCRIPT+AD4- 
+ 57  #   you don't always have to have the charset set, if the page has no charset 
+ 58  #   and there's UTF7-like code in it. 
+ 59  # Look at these tests: http://htmlpurifier.org/live/smoketests/xssAttacks.php 
+ 60   
+ 61   
+ 62  # This is an IE-specific construct you can have in a stylesheet to 
+ 63  # run some Javascript: 
+ 64  _css_javascript_re = re.compile( 
+ 65      r'expression\s*\(.*?\)', re.S|re.I) 
+ 66   
+ 67  # Do I have to worry about @\nimport? 
+ 68  _css_import_re = re.compile( 
+ 69      r'@\s*import', re.I) 
+ 70   
+ 71  # All kinds of schemes besides just javascript: that can cause 
+ 72  # execution: 
+ 73  _is_image_dataurl = re.compile( 
+ 74      r'^data:image/.+;base64', re.I).search 
+ 75  _is_possibly_malicious_scheme = re.compile( 
+ 76      r'(?:javascript|jscript|livescript|vbscript|data|about|mocha):', 
+ 77      re.I).search 
+ 78 -def _is_javascript_scheme(s): 
+
 79      if _is_image_dataurl(s): 
+ 80          return None 
+ 81      return _is_possibly_malicious_scheme(s) 
+
 82   
+ 83  _substitute_whitespace = re.compile(r'[\s\x00-\x08\x0B\x0C\x0E-\x19]+').sub 
+ 84  # FIXME: should data: be blocked? 
+ 85   
+ 86  # FIXME: check against: http://msdn2.microsoft.com/en-us/library/ms537512.aspx 
+ 87  _conditional_comment_re = re.compile( 
+ 88      r'\[if[\s\n\r]+.*?][\s\n\r]*>', re.I|re.S) 
+ 89   
+ 90  _find_styled_elements = etree.XPath( 
+ 91      "descendant-or-self::*[@style]") 
+ 92   
+ 93  _find_external_links = etree.XPath( 
+ 94      ("descendant-or-self::a  [normalize-space(@href) and substring(normalize-space(@href),1,1) != '#'] |" 
+ 95       "descendant-or-self::x:a[normalize-space(@href) and substring(normalize-space(@href),1,1) != '#']"), 
+ 96      namespaces={'x':XHTML_NAMESPACE}) 
+ 97   
+ 98   
+ 99 -class Cleaner(object): 
+
100      """ 
+101      Instances cleans the document of each of the possible offending 
+102      elements.  The cleaning is controlled by attributes; you can 
+103      override attributes in a subclass, or set them in the constructor. 
+104   
+105      ``scripts``: 
+106          Removes any ``<script>`` tags. 
+107   
+108      ``javascript``: 
+109          Removes any Javascript, like an ``onclick`` attribute. Also removes stylesheets 
+110          as they could contain Javascript. 
+111   
+112      ``comments``: 
+113          Removes any comments. 
+114   
+115      ``style``: 
+116          Removes any style tags. 
+117   
+118      ``inline_style`` 
+119          Removes any style attributes.  Defaults to the value of the ``style`` option. 
+120   
+121      ``links``: 
+122          Removes any ``<link>`` tags 
+123   
+124      ``meta``: 
+125          Removes any ``<meta>`` tags 
+126   
+127      ``page_structure``: 
+128          Structural parts of a page: ``<head>``, ``<html>``, ``<title>``. 
+129   
+130      ``processing_instructions``: 
+131          Removes any processing instructions. 
+132   
+133      ``embedded``: 
+134          Removes any embedded objects (flash, iframes) 
+135   
+136      ``frames``: 
+137          Removes any frame-related tags 
+138   
+139      ``forms``: 
+140          Removes any form tags 
+141   
+142      ``annoying_tags``: 
+143          Tags that aren't *wrong*, but are annoying.  ``<blink>`` and ``<marquee>`` 
+144   
+145      ``remove_tags``: 
+146          A list of tags to remove.  Only the tags will be removed, 
+147          their content will get pulled up into the parent tag. 
+148   
+149      ``kill_tags``: 
+150          A list of tags to kill.  Killing also removes the tag's content, 
+151          i.e. the whole subtree, not just the tag itself. 
+152   
+153      ``allow_tags``: 
+154          A list of tags to include (default include all). 
+155   
+156      ``remove_unknown_tags``: 
+157          Remove any tags that aren't standard parts of HTML. 
+158   
+159      ``safe_attrs_only``: 
+160          If true, only include 'safe' attributes (specifically the list 
+161          from the feedparser HTML sanitisation web site). 
+162   
+163      ``safe_attrs``: 
+164          A set of attribute names to override the default list of attributes 
+165          considered 'safe' (when safe_attrs_only=True). 
+166   
+167      ``add_nofollow``: 
+168          If true, then any <a> tags will have ``rel="nofollow"`` added to them. 
+169   
+170      ``host_whitelist``: 
+171          A list or set of hosts that you can use for embedded content 
+172          (for content like ``<object>``, ``<link rel="stylesheet">``, etc). 
+173          You can also implement/override the method 
+174          ``allow_embedded_url(el, url)`` or ``allow_element(el)`` to 
+175          implement more complex rules for what can be embedded. 
+176          Anything that passes this test will be shown, regardless of 
+177          the value of (for instance) ``embedded``. 
+178   
+179          Note that this parameter might not work as intended if you do not 
+180          make the links absolute before doing the cleaning. 
+181   
+182          Note that you may also need to set ``whitelist_tags``. 
+183   
+184      ``whitelist_tags``: 
+185          A set of tags that can be included with ``host_whitelist``. 
+186          The default is ``iframe`` and ``embed``; you may wish to 
+187          include other tags like ``script``, or you may want to 
+188          implement ``allow_embedded_url`` for more control.  Set to None to 
+189          include all tags. 
+190   
+191      This modifies the document *in place*. 
+192      """ 
+193   
+194      scripts = True 
+195      javascript = True 
+196      comments = True 
+197      style = False 
+198      inline_style = None 
+199      links = True 
+200      meta = True 
+201      page_structure = True 
+202      processing_instructions = True 
+203      embedded = True 
+204      frames = True 
+205      forms = True 
+206      annoying_tags = True 
+207      remove_tags = None 
+208      allow_tags = None 
+209      kill_tags = None 
+210      remove_unknown_tags = True 
+211      safe_attrs_only = True 
+212      safe_attrs = defs.safe_attrs 
+213      add_nofollow = False 
+214      host_whitelist = () 
+215      whitelist_tags = {'iframe', 'embed'} 
+216   
+217 -    def __init__(self, **kw): 
+
218          for name, value in kw.items(): 
+219              if not hasattr(self, name): 
+220                  raise TypeError( 
+221                      "Unknown parameter: %s=%r" % (name, value)) 
+222              setattr(self, name, value) 
+223          if self.inline_style is None and 'inline_style' not in kw: 
+224              self.inline_style = self.style 
+
225   
+226      # Used to lookup the primary URL for a given tag that is up for 
+227      # removal: 
+228      _tag_link_attrs = dict( 
+229          script='src', 
+230          link='href', 
+231          # From: http://java.sun.com/j2se/1.4.2/docs/guide/misc/applet.html 
+232          # From what I can tell, both attributes can contain a link: 
+233          applet=['code', 'object'], 
+234          iframe='src', 
+235          embed='src', 
+236          layer='src', 
+237          # FIXME: there doesn't really seem like a general way to figure out what 
+238          # links an <object> tag uses; links often go in <param> tags with values 
+239          # that we don't really know.  You'd have to have knowledge about specific 
+240          # kinds of plugins (probably keyed off classid), and match against those. 
+241          ##object=?, 
+242          # FIXME: not looking at the action currently, because it is more complex 
+243          # than than -- if you keep the form, you should keep the form controls. 
+244          ##form='action', 
+245          a='href', 
+246          ) 
+247   
+248 -    def __call__(self, doc): 
+
249          """ 
+250          Cleans the document. 
+251          """ 
+252          if hasattr(doc, 'getroot'): 
+253              # ElementTree instance, instead of an element 
+254              doc = doc.getroot() 
+255          # convert XHTML to HTML 
+256          xhtml_to_html(doc) 
+257          # Normalize a case that IE treats <image> like <img>, and that 
+258          # can confuse either this step or later steps. 
+259          for el in doc.iter('image'): 
+260              el.tag = 'img' 
+261          if not self.comments: 
+262              # Of course, if we were going to kill comments anyway, we don't 
+263              # need to worry about this 
+264              self.kill_conditional_comments(doc) 
+265   
+266          kill_tags = set(self.kill_tags or ()) 
+267          remove_tags = set(self.remove_tags or ()) 
+268          allow_tags = set(self.allow_tags or ()) 
+269   
+270          if self.scripts: 
+271              kill_tags.add('script') 
+272          if self.safe_attrs_only: 
+273              safe_attrs = set(self.safe_attrs) 
+274              for el in doc.iter(etree.Element): 
+275                  attrib = el.attrib 
+276                  for aname in attrib.keys(): 
+277                      if aname not in safe_attrs: 
+278                          del attrib[aname] 
+279          if self.javascript: 
+280              if not (self.safe_attrs_only and 
+281                      self.safe_attrs == defs.safe_attrs): 
+282                  # safe_attrs handles events attributes itself 
+283                  for el in doc.iter(etree.Element): 
+284                      attrib = el.attrib 
+285                      for aname in attrib.keys(): 
+286                          if aname.startswith('on'): 
+287                              del attrib[aname] 
+288              doc.rewrite_links(self._remove_javascript_link, 
+289                                resolve_base_href=False) 
+290              # If we're deleting style then we don't have to remove JS links 
+291              # from styles, otherwise... 
+292              if not self.inline_style: 
+293                  for el in _find_styled_elements(doc): 
+294                      old = el.get('style') 
+295                      new = _css_javascript_re.sub('', old) 
+296                      new = _css_import_re.sub('', new) 
+297                      if self._has_sneaky_javascript(new): 
+298                          # Something tricky is going on... 
+299                          del el.attrib['style'] 
+300                      elif new != old: 
+301                          el.set('style', new) 
+302              if not self.style: 
+303                  for el in list(doc.iter('style')): 
+304                      if el.get('type', '').lower().strip() == 'text/javascript': 
+305                          el.drop_tree() 
+306                          continue 
+307                      old = el.text or '' 
+308                      new = _css_javascript_re.sub('', old) 
+309                      # The imported CSS can do anything; we just can't allow: 
+310                      new = _css_import_re.sub('', old) 
+311                      if self._has_sneaky_javascript(new): 
+312                          # Something tricky is going on... 
+313                          el.text = '/* deleted */' 
+314                      elif new != old: 
+315                          el.text = new 
+316          if self.comments or self.processing_instructions: 
+317              # FIXME: why either?  I feel like there's some obscure reason 
+318              # because you can put PIs in comments...?  But I've already 
+319              # forgotten it 
+320              kill_tags.add(etree.Comment) 
+321          if self.processing_instructions: 
+322              kill_tags.add(etree.ProcessingInstruction) 
+323          if self.style: 
+324              kill_tags.add('style') 
+325          if self.inline_style: 
+326              etree.strip_attributes(doc, 'style') 
+327          if self.links: 
+328              kill_tags.add('link') 
+329          elif self.style or self.javascript: 
+330              # We must get rid of included stylesheets if Javascript is not 
+331              # allowed, as you can put Javascript in them 
+332              for el in list(doc.iter('link')): 
+333                  if 'stylesheet' in el.get('rel', '').lower(): 
+334                      # Note this kills alternate stylesheets as well 
+335                      if not self.allow_element(el): 
+336                          el.drop_tree() 
+337          if self.meta: 
+338              kill_tags.add('meta') 
+339          if self.page_structure: 
+340              remove_tags.update(('head', 'html', 'title')) 
+341          if self.embedded: 
+342              # FIXME: is <layer> really embedded? 
+343              # We should get rid of any <param> tags not inside <applet>; 
+344              # These are not really valid anyway. 
+345              for el in list(doc.iter('param')): 
+346                  found_parent = False 
+347                  parent = el.getparent() 
+348                  while parent is not None and parent.tag not in ('applet', 'object'): 
+349                      parent = parent.getparent() 
+350                  if parent is None: 
+351                      el.drop_tree() 
+352              kill_tags.update(('applet',)) 
+353              # The alternate contents that are in an iframe are a good fallback: 
+354              remove_tags.update(('iframe', 'embed', 'layer', 'object', 'param')) 
+355          if self.frames: 
+356              # FIXME: ideally we should look at the frame links, but 
+357              # generally frames don't mix properly with an HTML 
+358              # fragment anyway. 
+359              kill_tags.update(defs.frame_tags) 
+360          if self.forms: 
+361              remove_tags.add('form') 
+362              kill_tags.update(('button', 'input', 'select', 'textarea')) 
+363          if self.annoying_tags: 
+364              remove_tags.update(('blink', 'marquee')) 
+365   
+366          _remove = [] 
+367          _kill = [] 
+368          for el in doc.iter(): 
+369              if el.tag in kill_tags: 
+370                  if self.allow_element(el): 
+371                      continue 
+372                  _kill.append(el) 
+373              elif el.tag in remove_tags: 
+374                  if self.allow_element(el): 
+375                      continue 
+376                  _remove.append(el) 
+377   
+378          if _remove and _remove[0] == doc: 
+379              # We have to drop the parent-most tag, which we can't 
+380              # do.  Instead we'll rewrite it: 
+381              el = _remove.pop(0) 
+382              el.tag = 'div' 
+383              el.attrib.clear() 
+384          elif _kill and _kill[0] == doc: 
+385              # We have to drop the parent-most element, which we can't 
+386              # do.  Instead we'll clear it: 
+387              el = _kill.pop(0) 
+388              if el.tag != 'html': 
+389                  el.tag = 'div' 
+390              el.clear() 
+391   
+392          _kill.reverse() # start with innermost tags 
+393          for el in _kill: 
+394              el.drop_tree() 
+395          for el in _remove: 
+396              el.drop_tag() 
+397   
+398          if self.remove_unknown_tags: 
+399              if allow_tags: 
+400                  raise ValueError( 
+401                      "It does not make sense to pass in both allow_tags and remove_unknown_tags") 
+402              allow_tags = set(defs.tags) 
+403          if allow_tags: 
+404              bad = [] 
+405              for el in doc.iter(): 
+406                  if el.tag not in allow_tags: 
+407                      bad.append(el) 
+408              if bad: 
+409                  if bad[0] is doc: 
+410                      el = bad.pop(0) 
+411                      el.tag = 'div' 
+412                      el.attrib.clear() 
+413                  for el in bad: 
+414                      el.drop_tag() 
+415          if self.add_nofollow: 
+416              for el in _find_external_links(doc): 
+417                  if not self.allow_follow(el): 
+418                      rel = el.get('rel') 
+419                      if rel: 
+420                          if ('nofollow' in rel 
+421                                  and ' nofollow ' in (' %s ' % rel)): 
+422                              continue 
+423                          rel = '%s nofollow' % rel 
+424                      else: 
+425                          rel = 'nofollow' 
+426                      el.set('rel', rel) 
+
427   
+428 -    def allow_follow(self, anchor): 
+
429          """ 
+430          Override to suppress rel="nofollow" on some anchors. 
+431          """ 
+432          return False 
+
433   
+434 -    def allow_element(self, el): 
+
435          """ 
+436          Decide whether an element is configured to be accepted or rejected. 
+437   
+438          :param el: an element. 
+439          :return: true to accept the element or false to reject/discard it. 
+440          """ 
+441          if el.tag not in self._tag_link_attrs: 
+442              return False 
+443          attr = self._tag_link_attrs[el.tag] 
+444          if isinstance(attr, (list, tuple)): 
+445              for one_attr in attr: 
+446                  url = el.get(one_attr) 
+447                  if not url: 
+448                      return False 
+449                  if not self.allow_embedded_url(el, url): 
+450                      return False 
+451              return True 
+452          else: 
+453              url = el.get(attr) 
+454              if not url: 
+455                  return False 
+456              return self.allow_embedded_url(el, url) 
+
457   
+458 -    def allow_embedded_url(self, el, url): 
+
459          """ 
+460          Decide whether a URL that was found in an element's attributes or text 
+461          if configured to be accepted or rejected. 
+462   
+463          :param el: an element. 
+464          :param url: a URL found on the element. 
+465          :return: true to accept the URL and false to reject it. 
+466          """ 
+467          if self.whitelist_tags is not None and el.tag not in self.whitelist_tags: 
+468              return False 
+469          scheme, netloc, path, query, fragment = urlsplit(url) 
+470          netloc = netloc.lower().split(':', 1)[0] 
+471          if scheme not in ('http', 'https'): 
+472              return False 
+473          if netloc in self.host_whitelist: 
+474              return True 
+475          return False 
+
476   
+477 -    def kill_conditional_comments(self, doc): 
+
478          """ 
+479          IE conditional comments basically embed HTML that the parser 
+480          doesn't normally see.  We can't allow anything like that, so 
+481          we'll kill any comments that could be conditional. 
+482          """ 
+483          bad = [] 
+484          self._kill_elements( 
+485              doc, lambda el: _conditional_comment_re.search(el.text), 
+486              etree.Comment)                 
+
487   
+488 -    def _kill_elements(self, doc, condition, iterate=None): 
+
489          bad = [] 
+490          for el in doc.iter(iterate): 
+491              if condition(el): 
+492                  bad.append(el) 
+493          for el in bad: 
+494              el.drop_tree() 
+
495   
+496 -    def _remove_javascript_link(self, link): 
+
497          # links like "j a v a s c r i p t:" might be interpreted in IE 
+498          new = _substitute_whitespace('', unquote_plus(link)) 
+499          if _is_javascript_scheme(new): 
+500              # FIXME: should this be None to delete? 
+501              return '' 
+502          return link 
+
503   
+504      _substitute_comments = re.compile(r'/\*.*?\*/', re.S).sub 
+505   
+506 -    def _has_sneaky_javascript(self, style): 
+
507          """ 
+508          Depending on the browser, stuff like ``e x p r e s s i o n(...)`` 
+509          can get interpreted, or ``expre/* stuff */ssion(...)``.  This 
+510          checks for attempt to do stuff like this. 
+511   
+512          Typically the response will be to kill the entire style; if you 
+513          have just a bit of Javascript in the style another rule will catch 
+514          that and remove only the Javascript from the style; this catches 
+515          more sneaky attempts. 
+516          """ 
+517          style = self._substitute_comments('', style) 
+518          style = style.replace('\\', '') 
+519          style = _substitute_whitespace('', style) 
+520          style = style.lower() 
+521          if 'javascript:' in style: 
+522              return True 
+523          if 'expression(' in style: 
+524              return True 
+525          return False 
+
526   
+527 -    def clean_html(self, html): 
+
528          result_type = type(html) 
+529          if isinstance(html, basestring): 
+530              doc = fromstring(html) 
+531          else: 
+532              doc = copy.deepcopy(html) 
+533          self(doc) 
+534          return _transform_result(result_type, doc) 
+
535   
+536  clean = Cleaner() 
+537  clean_html = clean.clean_html 
+538   
+539  ############################################################ 
+540  ## Autolinking 
+541  ############################################################ 
+542   
+543  _link_regexes = [ 
+544      re.compile(r'(?P<body>https?://(?P<host>[a-z0-9._-]+)(?:/[/\-_.,a-z0-9%&?;=~]*)?(?:\([/\-_.,a-z0-9%&?;=~]*\))?)', re.I), 
+545      # This is conservative, but autolinking can be a bit conservative: 
+546      re.compile(r'mailto:(?P<body>[a-z0-9._-]+@(?P<host>[a-z0-9_.-]+[a-z]))', re.I), 
+547      ] 
+548   
+549  _avoid_elements = ['textarea', 'pre', 'code', 'head', 'select', 'a'] 
+550   
+551  _avoid_hosts = [ 
+552      re.compile(r'^localhost', re.I), 
+553      re.compile(r'\bexample\.(?:com|org|net)$', re.I), 
+554      re.compile(r'^127\.0\.0\.1$'), 
+555      ] 
+556   
+557  _avoid_classes = ['nolink'] 
+558   
+559 -def autolink(el, link_regexes=_link_regexes, 
+560               avoid_elements=_avoid_elements, 
+561               avoid_hosts=_avoid_hosts, 
+562               avoid_classes=_avoid_classes): 
+
563      """ 
+564      Turn any URLs into links. 
+565   
+566      It will search for links identified by the given regular 
+567      expressions (by default mailto and http(s) links). 
+568   
+569      It won't link text in an element in avoid_elements, or an element 
+570      with a class in avoid_classes.  It won't link to anything with a 
+571      host that matches one of the regular expressions in avoid_hosts 
+572      (default localhost and 127.0.0.1). 
+573   
+574      If you pass in an element, the element's tail will not be 
+575      substituted, only the contents of the element. 
+576      """ 
+577      if el.tag in avoid_elements: 
+578          return 
+579      class_name = el.get('class') 
+580      if class_name: 
+581          class_name = class_name.split() 
+582          for match_class in avoid_classes: 
+583              if match_class in class_name: 
+584                  return 
+585      for child in list(el): 
+586          autolink(child, link_regexes=link_regexes, 
+587                   avoid_elements=avoid_elements, 
+588                   avoid_hosts=avoid_hosts, 
+589                   avoid_classes=avoid_classes) 
+590          if child.tail: 
+591              text, tail_children = _link_text( 
+592                  child.tail, link_regexes, avoid_hosts, factory=el.makeelement) 
+593              if tail_children: 
+594                  child.tail = text 
+595                  index = el.index(child) 
+596                  el[index+1:index+1] = tail_children 
+597      if el.text: 
+598          text, pre_children = _link_text( 
+599              el.text, link_regexes, avoid_hosts, factory=el.makeelement) 
+600          if pre_children: 
+601              el.text = text 
+602              el[:0] = pre_children 
+
603   
+604 -def _link_text(text, link_regexes, avoid_hosts, factory): 
+
605      leading_text = '' 
+606      links = [] 
+607      last_pos = 0 
+608      while 1: 
+609          best_match, best_pos = None, None 
+610          for regex in link_regexes: 
+611              regex_pos = last_pos 
+612              while 1: 
+613                  match = regex.search(text, pos=regex_pos) 
+614                  if match is None: 
+615                      break 
+616                  host = match.group('host') 
+617                  for host_regex in avoid_hosts: 
+618                      if host_regex.search(host): 
+619                          regex_pos = match.end() 
+620                          break 
+621                  else: 
+622                      break 
+623              if match is None: 
+624                  continue 
+625              if best_pos is None or match.start() < best_pos: 
+626                  best_match = match 
+627                  best_pos = match.start() 
+628          if best_match is None: 
+629              # No more matches 
+630              if links: 
+631                  assert not links[-1].tail 
+632                  links[-1].tail = text 
+633              else: 
+634                  assert not leading_text 
+635                  leading_text = text 
+636              break 
+637          link = best_match.group(0) 
+638          end = best_match.end() 
+639          if link.endswith('.') or link.endswith(','): 
+640              # These punctuation marks shouldn't end a link 
+641              end -= 1 
+642              link = link[:-1] 
+643          prev_text = text[:best_match.start()] 
+644          if links: 
+645              assert not links[-1].tail 
+646              links[-1].tail = prev_text 
+647          else: 
+648              assert not leading_text 
+649              leading_text = prev_text 
+650          anchor = factory('a') 
+651          anchor.set('href', link) 
+652          body = best_match.group('body') 
+653          if not body: 
+654              body = link 
+655          if body.endswith('.') or body.endswith(','): 
+656              body = body[:-1] 
+657          anchor.text = body 
+658          links.append(anchor) 
+659          text = text[end:] 
+660      return leading_text, links 
+
661                   
+662 -def autolink_html(html, *args, **kw): 
+
663      result_type = type(html) 
+664      if isinstance(html, basestring): 
+665          doc = fromstring(html) 
+666      else: 
+667          doc = copy.deepcopy(html) 
+668      autolink(doc, *args, **kw) 
+669      return _transform_result(result_type, doc) 
+
670   
+671  autolink_html.__doc__ = autolink.__doc__ 
+672   
+673  ############################################################ 
+674  ## Word wrapping 
+675  ############################################################ 
+676   
+677  _avoid_word_break_elements = ['pre', 'textarea', 'code'] 
+678  _avoid_word_break_classes = ['nobreak'] 
+679   
+680 -def word_break(el, max_width=40, 
+681                 avoid_elements=_avoid_word_break_elements, 
+682                 avoid_classes=_avoid_word_break_classes, 
+683                 break_character=unichr(0x200b)): 
+
684      """ 
+685      Breaks any long words found in the body of the text (not attributes). 
+686   
+687      Doesn't effect any of the tags in avoid_elements, by default 
+688      ``<textarea>`` and ``<pre>`` 
+689   
+690      Breaks words by inserting &#8203;, which is a unicode character 
+691      for Zero Width Space character.  This generally takes up no space 
+692      in rendering, but does copy as a space, and in monospace contexts 
+693      usually takes up space. 
+694   
+695      See http://www.cs.tut.fi/~jkorpela/html/nobr.html for a discussion 
+696      """ 
+697      # Character suggestion of &#8203 comes from: 
+698      #   http://www.cs.tut.fi/~jkorpela/html/nobr.html 
+699      if el.tag in _avoid_word_break_elements: 
+700          return 
+701      class_name = el.get('class') 
+702      if class_name: 
+703          dont_break = False 
+704          class_name = class_name.split() 
+705          for avoid in avoid_classes: 
+706              if avoid in class_name: 
+707                  dont_break = True 
+708                  break 
+709          if dont_break: 
+710              return 
+711      if el.text: 
+712          el.text = _break_text(el.text, max_width, break_character) 
+713      for child in el: 
+714          word_break(child, max_width=max_width, 
+715                     avoid_elements=avoid_elements, 
+716                     avoid_classes=avoid_classes, 
+717                     break_character=break_character) 
+718          if child.tail: 
+719              child.tail = _break_text(child.tail, max_width, break_character) 
+
720   
+721 -def word_break_html(html, *args, **kw): 
+
722      result_type = type(html) 
+723      doc = fromstring(html) 
+724      word_break(doc, *args, **kw) 
+725      return _transform_result(result_type, doc) 
+
726   
+727 -def _break_text(text, max_width, break_character): 
+
728      words = text.split() 
+729      for word in words: 
+730          if len(word) > max_width: 
+731              replacement = _insert_break(word, max_width, break_character) 
+732              text = text.replace(word, replacement) 
+733      return text 
+
734   
+735  _break_prefer_re = re.compile(r'[^a-z]', re.I) 
+736   
+737 -def _insert_break(word, width, break_character): 
+
738      orig_word = word 
+739      result = '' 
+740      while len(word) > width: 
+741          start = word[:width] 
+742          breaks = list(_break_prefer_re.finditer(start)) 
+743          if breaks: 
+744              last_break = breaks[-1] 
+745              # Only walk back up to 10 characters to find a nice break: 
+746              if last_break.end() > width-10: 
+747                  # FIXME: should the break character be at the end of the 
+748                  # chunk, or the beginning of the next chunk? 
+749                  start = word[:last_break.end()] 
+750          result += start + break_character 
+751          word = word[len(start):] 
+752      result += word 
+753      return result 
+
754   
+
+object --+
+         |
+        Cleaner
+
scripts
<script>
javascript
onclick
comments
style
inline_style
style
links
<link>
meta
<meta>
page_structure
<head>
<html>
<title>
processing_instructions
embedded
frames
forms
annoying_tags
<blink>
<marquee>
remove_tags
kill_tags
allow_tags
remove_unknown_tags
safe_attrs_only
safe_attrs
add_nofollow
rel="nofollow"
host_whitelist
<object>
<link rel="stylesheet">
allow_embedded_url(el, url)
allow_element(el)
embedded
whitelist_tags
whitelist_tags
host_whitelist
iframe
embed
script
allow_embedded_url
e x p r e s s i o n(...)
expre/* stuff */ssion(...)
e x p r e s s i o n(...)
expre/* stuff */ssion(...)
+frozenset(['abbr',
+           'accept',
+           'accept-charset',
+           'accesskey',
+           'action',
+           'align',
+           'alt',
+           'axis',
+...
+
+{'a': 'href',
+ 'applet': ['code', 'object'],
+ 'embed': 'src',
+ 'iframe': 'src',
+ 'layer': 'src',
+ 'link': 'href',
+ 'script': 'src'}
+
+frozenset(['area',
+           'base',
+           'basefont',
+           'br',
+           'col',
+           'frame',
+           'hr',
+           'img',
+...
+
+frozenset(['applet',
+           'basefont',
+           'center',
+           'dir',
+           'font',
+           'isindex',
+           'menu',
+           's',
+...
+
+frozenset(['action',
+           'archive',
+           'background',
+           'cite',
+           'classid',
+           'codebase',
+           'data',
+           'dynsrc',
+...
+
+frozenset(['onblur',
+           'onchange',
+           'onclick',
+           'ondblclick',
+           'onerror',
+           'onfocus',
+           'onkeydown',
+           'onkeypress',
+...
+
+frozenset(['abbr',
+           'accept',
+           'accept-charset',
+           'accesskey',
+           'action',
+           'align',
+           'alt',
+           'axis',
+...
+
+frozenset(['base',
+           'isindex',
+           'link',
+           'meta',
+           'script',
+           'style',
+           'title'])
+
+frozenset(['address',
+           'blockquote',
+           'center',
+           'del',
+           'div',
+           'h1',
+           'h2',
+           'h3',
+...
+
+frozenset(['dd', 'dir', 'dl', 'dt', 'li', 'menu', 'ol', 'ul'])
+
+frozenset(['caption',
+           'col',
+           'colgroup',
+           'table',
+           'tbody',
+           'td',
+           'tfoot',
+           'th',
+...
+
+frozenset(['address',
+           'blockquote',
+           'caption',
+           'center',
+           'col',
+           'colgroup',
+           'dd',
+           'del',
+...
+
+frozenset(['button',
+           'fieldset',
+           'form',
+           'input',
+           'label',
+           'legend',
+           'optgroup',
+           'option',
+...
+
+frozenset(['a',
+           'applet',
+           'area',
+           'basefont',
+           'bdo',
+           'br',
+           'embed',
+           'font',
+...
+
+frozenset(['abbr',
+           'acronym',
+           'cite',
+           'code',
+           'del',
+           'dfn',
+           'em',
+           'ins',
+...
+
+frozenset(['b', 'big', 'i', 's', 'small', 'strike', 'tt', 'u'])
+
+frozenset(['article',
+           'aside',
+           'audio',
+           'canvas',
+           'command',
+           'datalist',
+           'details',
+           'embed',
+...
+
+frozenset(['a',
+           'abbr',
+           'acronym',
+           'address',
+           'applet',
+           'area',
+           'article',
+           'aside',
+...
+
+  1  # FIXME: this should all be confirmed against what a DTD says 
+  2  # (probably in a test; this may not match the DTD exactly, but we 
+  3  # should document just how it differs). 
+  4   
+  5  # Data taken from http://www.w3.org/TR/html401/index/elements.html 
+  6  # and http://www.w3.org/community/webed/wiki/HTML/New_HTML5_Elements 
+  7  # for html5_tags. 
+  8   
+  9  empty_tags = frozenset([ 
+ 10      'area', 'base', 'basefont', 'br', 'col', 'frame', 'hr', 
+ 11      'img', 'input', 'isindex', 'link', 'meta', 'param', 'source', 'track']) 
+ 12   
+ 13  deprecated_tags = frozenset([ 
+ 14      'applet', 'basefont', 'center', 'dir', 'font', 'isindex', 
+ 15      'menu', 's', 'strike', 'u']) 
+ 16   
+ 17  # archive actually takes a space-separated list of URIs 
+ 18  link_attrs = frozenset([ 
+ 19      'action', 'archive', 'background', 'cite', 'classid', 
+ 20      'codebase', 'data', 'href', 'longdesc', 'profile', 'src', 
+ 21      'usemap', 
+ 22      # Not standard: 
+ 23      'dynsrc', 'lowsrc', 
+ 24      ]) 
+ 25   
+ 26  # Not in the HTML 4 spec: 
+ 27  # onerror, onresize 
+ 28  event_attrs = frozenset([ 
+ 29      'onblur', 'onchange', 'onclick', 'ondblclick', 'onerror', 
+ 30      'onfocus', 'onkeydown', 'onkeypress', 'onkeyup', 'onload', 
+ 31      'onmousedown', 'onmousemove', 'onmouseout', 'onmouseover', 
+ 32      'onmouseup', 'onreset', 'onresize', 'onselect', 'onsubmit', 
+ 33      'onunload', 
+ 34      ]) 
+ 35   
+ 36  safe_attrs = frozenset([ 
+ 37      'abbr', 'accept', 'accept-charset', 'accesskey', 'action', 'align', 
+ 38      'alt', 'axis', 'border', 'cellpadding', 'cellspacing', 'char', 'charoff', 
+ 39      'charset', 'checked', 'cite', 'class', 'clear', 'cols', 'colspan', 
+ 40      'color', 'compact', 'coords', 'datetime', 'dir', 'disabled', 'enctype', 
+ 41      'for', 'frame', 'headers', 'height', 'href', 'hreflang', 'hspace', 'id', 
+ 42      'ismap', 'label', 'lang', 'longdesc', 'maxlength', 'media', 'method', 
+ 43      'multiple', 'name', 'nohref', 'noshade', 'nowrap', 'prompt', 'readonly', 
+ 44      'rel', 'rev', 'rows', 'rowspan', 'rules', 'scope', 'selected', 'shape', 
+ 45      'size', 'span', 'src', 'start', 'summary', 'tabindex', 'target', 'title', 
+ 46      'type', 'usemap', 'valign', 'value', 'vspace', 'width']) 
+ 47   
+ 48  # From http://htmlhelp.com/reference/html40/olist.html 
+ 49  top_level_tags = frozenset([ 
+ 50      'html', 'head', 'body', 'frameset', 
+ 51      ]) 
+ 52   
+ 53  head_tags = frozenset([ 
+ 54      'base', 'isindex', 'link', 'meta', 'script', 'style', 'title', 
+ 55      ]) 
+ 56   
+ 57  general_block_tags = frozenset([ 
+ 58      'address', 
+ 59      'blockquote', 
+ 60      'center', 
+ 61      'del', 
+ 62      'div', 
+ 63      'h1', 
+ 64      'h2', 
+ 65      'h3', 
+ 66      'h4', 
+ 67      'h5', 
+ 68      'h6', 
+ 69      'hr', 
+ 70      'ins', 
+ 71      'isindex', 
+ 72      'noscript', 
+ 73      'p', 
+ 74      'pre', 
+ 75      ]) 
+ 76   
+ 77  list_tags = frozenset([ 
+ 78      'dir', 'dl', 'dt', 'dd', 'li', 'menu', 'ol', 'ul', 
+ 79      ]) 
+ 80   
+ 81  table_tags = frozenset([ 
+ 82      'table', 'caption', 'colgroup', 'col', 
+ 83      'thead', 'tfoot', 'tbody', 'tr', 'td', 'th', 
+ 84      ]) 
+ 85   
+ 86  # just this one from 
+ 87  # http://www.georgehernandez.com/h/XComputers/HTML/2BlockLevel.htm 
+ 88  block_tags = general_block_tags | list_tags | table_tags | frozenset([ 
+ 89      # Partial form tags 
+ 90      'fieldset', 'form', 'legend', 'optgroup', 'option', 
+ 91      ]) 
+ 92   
+ 93  form_tags = frozenset([ 
+ 94      'form', 'button', 'fieldset', 'legend', 'input', 'label', 
+ 95      'select', 'optgroup', 'option', 'textarea', 
+ 96      ]) 
+ 97   
+ 98  special_inline_tags = frozenset([ 
+ 99      'a', 'applet', 'basefont', 'bdo', 'br', 'embed', 'font', 'iframe', 
+100      'img', 'map', 'area', 'object', 'param', 'q', 'script', 
+101      'span', 'sub', 'sup', 
+102      ]) 
+103   
+104  phrase_tags = frozenset([ 
+105      'abbr', 'acronym', 'cite', 'code', 'del', 'dfn', 'em', 
+106      'ins', 'kbd', 'samp', 'strong', 'var', 
+107      ]) 
+108   
+109  font_style_tags = frozenset([ 
+110      'b', 'big', 'i', 's', 'small', 'strike', 'tt', 'u', 
+111      ]) 
+112   
+113  frame_tags = frozenset([ 
+114      'frameset', 'frame', 'noframes', 
+115      ]) 
+116       
+117  html5_tags = frozenset([ 
+118      'article', 'aside', 'audio', 'canvas', 'command', 'datalist', 
+119      'details', 'embed', 'figcaption', 'figure', 'footer', 'header', 
+120      'hgroup', 'keygen', 'mark', 'math', 'meter', 'nav', 'output', 
+121      'progress', 'rp', 'rt', 'ruby', 'section', 'source', 'summary', 
+122      'svg', 'time', 'track', 'video', 'wbr' 
+123      ]) 
+124   
+125  # These tags aren't standard 
+126  nonstandard_tags = frozenset(['blink', 'marquee']) 
+127   
+128   
+129  tags = (top_level_tags | head_tags | general_block_tags | list_tags 
+130          | table_tags | form_tags | special_inline_tags | phrase_tags 
+131          | font_style_tags | nonstandard_tags | html5_tags) 
+132   
+
+>>> version1 = 'Hello World'
+>>> version2 = 'Goodbye World'
+>>> print(html_annotate([(version1, 'version 1'),
+...                      (version2, 'version 2')]))
+<span title="version 2">Goodbye</span> <span title="version 1">World</span>
+
+>>> print(default_markup('Some Text', 'by Joe'))
+<span title="by Joe">Some Text</span>
+>>> unbalanced_start = ['<div>']
+>>> doc = ['<p>', 'Text', '</p>', '<div>', 'More Text', '</div>']
+>>> pre, post = doc[:3], doc[3:]
+>>> pre, post
+(['<p>', 'Text', '</p>'], ['<div>', 'More Text', '</div>'])
+>>> locate_unbalanced_start(unbalanced_start, pre, post)
+>>> pre, post
+(['<p>', 'Text', '</p>', '<div>'], ['More Text', '</div>'])
+
+(u'param',
+ u'img',
+ u'area',
+ u'br',
+ u'basefont',
+ u'input',
+ u'base',
+ u'meta',
+...
+
+(u'address',
+ u'blockquote',
+ u'center',
+ u'dir',
+ u'div',
+ u'dl',
+ u'fieldset',
+ u'form',
+...
+
+(u'dd',
+ u'dt',
+ u'frameset',
+ u'li',
+ u'tbody',
+ u'td',
+ u'tfoot',
+ u'th',
+...
+
+{u'html_annotate (line 35)': u'''
+    doclist should be ordered from oldest to newest, like::
+
+        >>> version1 = 'Hello World'
+        >>> version2 = 'Goodbye World'
+        >>> print(html_annotate([(version1, 'version 1'),
+        ...                      (version2, 'version 2')]))
+        <span title="version 2">Goodbye</span> <span title="version 1"
+...
+
+  1  # cython: language_level=3 
+  2   
+  3  from __future__ import absolute_import 
+  4   
+  5  import difflib 
+  6  from lxml import etree 
+  7  from lxml.html import fragment_fromstring 
+  8  import re 
+  9   
+ 10  __all__ = ['html_annotate', 'htmldiff'] 
+ 11   
+ 12  try: 
+ 13      from html import escape as html_escape 
+ 14  except ImportError: 
+ 15      from cgi import escape as html_escape 
+ 16  try: 
+ 17      _unicode = unicode 
+ 18  except NameError: 
+ 19      # Python 3 
+ 20      _unicode = str 
+ 21  try: 
+ 22      basestring 
+ 23  except NameError: 
+ 24      # Python 3 
+ 25      basestring = str 
+ 26   
+ 27  ############################################################ 
+ 28  ## Annotation 
+ 29  ############################################################ 
+ 30   
+ 31 -def default_markup(text, version): 
+
 32      return '<span title="%s">%s</span>' % ( 
+ 33          html_escape(_unicode(version), 1), text) 
+
 34   
+ 35 -def html_annotate(doclist, markup=default_markup): 
+
 36      """ 
+ 37      doclist should be ordered from oldest to newest, like:: 
+ 38   
+ 39          >>> version1 = 'Hello World' 
+ 40          >>> version2 = 'Goodbye World' 
+ 41          >>> print(html_annotate([(version1, 'version 1'), 
+ 42          ...                      (version2, 'version 2')])) 
+ 43          <span title="version 2">Goodbye</span> <span title="version 1">World</span> 
+ 44   
+ 45      The documents must be *fragments* (str/UTF8 or unicode), not 
+ 46      complete documents 
+ 47   
+ 48      The markup argument is a function to markup the spans of words. 
+ 49      This function is called like markup('Hello', 'version 2'), and 
+ 50      returns HTML.  The first argument is text and never includes any 
+ 51      markup.  The default uses a span with a title: 
+ 52   
+ 53          >>> print(default_markup('Some Text', 'by Joe')) 
+ 54          <span title="by Joe">Some Text</span> 
+ 55      """ 
+ 56      # The basic strategy we have is to split the documents up into 
+ 57      # logical tokens (which are words with attached markup).  We then 
+ 58      # do diffs of each of the versions to track when a token first 
+ 59      # appeared in the document; the annotation attached to the token 
+ 60      # is the version where it first appeared. 
+ 61      tokenlist = [tokenize_annotated(doc, version) 
+ 62                   for doc, version in doclist] 
+ 63      cur_tokens = tokenlist[0] 
+ 64      for tokens in tokenlist[1:]: 
+ 65          html_annotate_merge_annotations(cur_tokens, tokens) 
+ 66          cur_tokens = tokens 
+ 67   
+ 68      # After we've tracked all the tokens, we can combine spans of text 
+ 69      # that are adjacent and have the same annotation 
+ 70      cur_tokens = compress_tokens(cur_tokens) 
+ 71      # And finally add markup 
+ 72      result = markup_serialize_tokens(cur_tokens, markup) 
+ 73      return ''.join(result).strip() 
+
 74   
+ 75 -def tokenize_annotated(doc, annotation):  
+
 76      """Tokenize a document and add an annotation attribute to each token 
+ 77      """ 
+ 78      tokens = tokenize(doc, include_hrefs=False) 
+ 79      for tok in tokens:  
+ 80          tok.annotation = annotation 
+ 81      return tokens 
+ 82   
+ 83 -def html_annotate_merge_annotations(tokens_old, tokens_new):  
+
 84      """Merge the annotations from tokens_old into tokens_new, when the 
+ 85      tokens in the new document already existed in the old document. 
+ 86      """ 
+ 87      s = InsensitiveSequenceMatcher(a=tokens_old, b=tokens_new) 
+ 88      commands = s.get_opcodes() 
+ 89   
+ 90      for command, i1, i2, j1, j2 in commands: 
+ 91          if command == 'equal':  
+ 92              eq_old = tokens_old[i1:i2] 
+ 93              eq_new = tokens_new[j1:j2] 
+ 94              copy_annotations(eq_old, eq_new) 
+ 95   
+ 96 -def copy_annotations(src, dest):  
+
 97      """ 
+ 98      Copy annotations from the tokens listed in src to the tokens in dest 
+ 99      """ 
+100      assert len(src) == len(dest) 
+101      for src_tok, dest_tok in zip(src, dest):  
+102          dest_tok.annotation = src_tok.annotation 
+103   
+104 -def compress_tokens(tokens): 
+
105      """ 
+106      Combine adjacent tokens when there is no HTML between the tokens,  
+107      and they share an annotation 
+108      """ 
+109      result = [tokens[0]]  
+110      for tok in tokens[1:]:  
+111          if (not result[-1].post_tags and  
+112              not tok.pre_tags and  
+113              result[-1].annotation == tok.annotation):  
+114              compress_merge_back(result, tok) 
+115          else:  
+116              result.append(tok) 
+117      return result 
+
118   
+119 -def compress_merge_back(tokens, tok):  
+
120      """ Merge tok into the last element of tokens (modifying the list of 
+121      tokens in-place).  """ 
+122      last = tokens[-1] 
+123      if type(last) is not token or type(tok) is not token:  
+124          tokens.append(tok) 
+125      else: 
+126          text = _unicode(last) 
+127          if last.trailing_whitespace: 
+128              text += last.trailing_whitespace 
+129          text += tok 
+130          merged = token(text, 
+131                         pre_tags=last.pre_tags, 
+132                         post_tags=tok.post_tags, 
+133                         trailing_whitespace=tok.trailing_whitespace) 
+134          merged.annotation = last.annotation 
+135          tokens[-1] = merged 
+136       
+137 -def markup_serialize_tokens(tokens, markup_func): 
+
138      """ 
+139      Serialize the list of tokens into a list of text chunks, calling 
+140      markup_func around text to add annotations. 
+141      """ 
+142      for token in tokens: 
+143          for pre in token.pre_tags: 
+144              yield pre 
+145          html = token.html() 
+146          html = markup_func(html, token.annotation) 
+147          if token.trailing_whitespace: 
+148              html += token.trailing_whitespace 
+149          yield html 
+150          for post in token.post_tags: 
+151              yield post 
+
152   
+153   
+154  ############################################################ 
+155  ## HTML Diffs 
+156  ############################################################ 
+157   
+158 -def htmldiff(old_html, new_html): 
+
159      ## FIXME: this should take parsed documents too, and use their body 
+160      ## or other content. 
+161      """ Do a diff of the old and new document.  The documents are HTML 
+162      *fragments* (str/UTF8 or unicode), they are not complete documents 
+163      (i.e., no <html> tag). 
+164   
+165      Returns HTML with <ins> and <del> tags added around the 
+166      appropriate text.   
+167   
+168      Markup is generally ignored, with the markup from new_html 
+169      preserved, and possibly some markup from old_html (though it is 
+170      considered acceptable to lose some of the old markup).  Only the 
+171      words in the HTML are diffed.  The exception is <img> tags, which 
+172      are treated like words, and the href attribute of <a> tags, which 
+173      are noted inside the tag itself when there are changes. 
+174      """  
+175      old_html_tokens = tokenize(old_html) 
+176      new_html_tokens = tokenize(new_html) 
+177      result = htmldiff_tokens(old_html_tokens, new_html_tokens) 
+178      result = ''.join(result).strip() 
+179      return fixup_ins_del_tags(result) 
+
180   
+181 -def htmldiff_tokens(html1_tokens, html2_tokens): 
+
182      """ Does a diff on the tokens themselves, returning a list of text 
+183      chunks (not tokens). 
+184      """ 
+185      # There are several passes as we do the differences.  The tokens 
+186      # isolate the portion of the content we care to diff; difflib does 
+187      # all the actual hard work at that point.   
+188      # 
+189      # Then we must create a valid document from pieces of both the old 
+190      # document and the new document.  We generally prefer to take 
+191      # markup from the new document, and only do a best effort attempt 
+192      # to keep markup from the old document; anything that we can't 
+193      # resolve we throw away.  Also we try to put the deletes as close 
+194      # to the location where we think they would have been -- because 
+195      # we are only keeping the markup from the new document, it can be 
+196      # fuzzy where in the new document the old text would have gone. 
+197      # Again we just do a best effort attempt. 
+198      s = InsensitiveSequenceMatcher(a=html1_tokens, b=html2_tokens) 
+199      commands = s.get_opcodes() 
+200      result = [] 
+201      for command, i1, i2, j1, j2 in commands: 
+202          if command == 'equal': 
+203              result.extend(expand_tokens(html2_tokens[j1:j2], equal=True)) 
+204              continue 
+205          if command == 'insert' or command == 'replace': 
+206              ins_tokens = expand_tokens(html2_tokens[j1:j2]) 
+207              merge_insert(ins_tokens, result) 
+208          if command == 'delete' or command == 'replace': 
+209              del_tokens = expand_tokens(html1_tokens[i1:i2]) 
+210              merge_delete(del_tokens, result) 
+211      # If deletes were inserted directly as <del> then we'd have an 
+212      # invalid document at this point.  Instead we put in special 
+213      # markers, and when the complete diffed document has been created 
+214      # we try to move the deletes around and resolve any problems. 
+215      result = cleanup_delete(result) 
+216   
+217      return result 
+
218   
+219 -def expand_tokens(tokens, equal=False): 
+
220      """Given a list of tokens, return a generator of the chunks of 
+221      text for the data in the tokens. 
+222      """ 
+223      for token in tokens: 
+224          for pre in token.pre_tags: 
+225              yield pre 
+226          if not equal or not token.hide_when_equal: 
+227              if token.trailing_whitespace: 
+228                  yield token.html() + token.trailing_whitespace 
+229              else: 
+230                  yield token.html() 
+231          for post in token.post_tags: 
+232              yield post 
+
233   
+234 -def merge_insert(ins_chunks, doc): 
+
235      """ doc is the already-handled document (as a list of text chunks); 
+236      here we add <ins>ins_chunks</ins> to the end of that.  """ 
+237      # Though we don't throw away unbalanced_start or unbalanced_end 
+238      # (we assume there is accompanying markup later or earlier in the 
+239      # document), we only put <ins> around the balanced portion. 
+240      unbalanced_start, balanced, unbalanced_end = split_unbalanced(ins_chunks) 
+241      doc.extend(unbalanced_start) 
+242      if doc and not doc[-1].endswith(' '): 
+243          # Fix up the case where the word before the insert didn't end with  
+244          # a space 
+245          doc[-1] += ' ' 
+246      doc.append('<ins>') 
+247      if balanced and balanced[-1].endswith(' '): 
+248          # We move space outside of </ins> 
+249          balanced[-1] = balanced[-1][:-1] 
+250      doc.extend(balanced) 
+251      doc.append('</ins> ') 
+252      doc.extend(unbalanced_end) 
+
253   
+254  # These are sentinals to represent the start and end of a <del> 
+255  # segment, until we do the cleanup phase to turn them into proper 
+256  # markup: 
+257 -class DEL_START: 
+
258      pass 
+
259 -class DEL_END: 
+
260      pass 
+
261   
+262 -class NoDeletes(Exception): 
+
263      """ Raised when the document no longer contains any pending deletes 
+264      (DEL_START/DEL_END) """ 
+
265   
+266 -def merge_delete(del_chunks, doc): 
+
267      """ Adds the text chunks in del_chunks to the document doc (another 
+268      list of text chunks) with marker to show it is a delete. 
+269      cleanup_delete later resolves these markers into <del> tags.""" 
+270      doc.append(DEL_START) 
+271      doc.extend(del_chunks) 
+272      doc.append(DEL_END) 
+
273   
+274 -def cleanup_delete(chunks): 
+
275      """ Cleans up any DEL_START/DEL_END markers in the document, replacing 
+276      them with <del></del>.  To do this while keeping the document 
+277      valid, it may need to drop some tags (either start or end tags). 
+278   
+279      It may also move the del into adjacent tags to try to move it to a 
+280      similar location where it was originally located (e.g., moving a 
+281      delete into preceding <div> tag, if the del looks like (DEL_START, 
+282      'Text</div>', DEL_END)""" 
+283      while 1: 
+284          # Find a pending DEL_START/DEL_END, splitting the document 
+285          # into stuff-preceding-DEL_START, stuff-inside, and 
+286          # stuff-following-DEL_END 
+287          try: 
+288              pre_delete, delete, post_delete = split_delete(chunks) 
+289          except NoDeletes: 
+290              # Nothing found, we've cleaned up the entire doc 
+291              break 
+292          # The stuff-inside-DEL_START/END may not be well balanced 
+293          # markup.  First we figure out what unbalanced portions there are: 
+294          unbalanced_start, balanced, unbalanced_end = split_unbalanced(delete) 
+295          # Then we move the span forward and/or backward based on these 
+296          # unbalanced portions: 
+297          locate_unbalanced_start(unbalanced_start, pre_delete, post_delete) 
+298          locate_unbalanced_end(unbalanced_end, pre_delete, post_delete) 
+299          doc = pre_delete 
+300          if doc and not doc[-1].endswith(' '): 
+301              # Fix up case where the word before us didn't have a trailing space 
+302              doc[-1] += ' ' 
+303          doc.append('<del>') 
+304          if balanced and balanced[-1].endswith(' '): 
+305              # We move space outside of </del> 
+306              balanced[-1] = balanced[-1][:-1] 
+307          doc.extend(balanced) 
+308          doc.append('</del> ') 
+309          doc.extend(post_delete) 
+310          chunks = doc 
+311      return chunks 
+
312   
+313 -def split_unbalanced(chunks): 
+
314      """Return (unbalanced_start, balanced, unbalanced_end), where each is 
+315      a list of text and tag chunks. 
+316   
+317      unbalanced_start is a list of all the tags that are opened, but 
+318      not closed in this span.  Similarly, unbalanced_end is a list of 
+319      tags that are closed but were not opened.  Extracting these might 
+320      mean some reordering of the chunks.""" 
+321      start = [] 
+322      end = [] 
+323      tag_stack = [] 
+324      balanced = [] 
+325      for chunk in chunks: 
+326          if not chunk.startswith('<'): 
+327              balanced.append(chunk) 
+328              continue 
+329          endtag = chunk[1] == '/' 
+330          name = chunk.split()[0].strip('<>/') 
+331          if name in empty_tags: 
+332              balanced.append(chunk) 
+333              continue 
+334          if endtag: 
+335              if tag_stack and tag_stack[-1][0] == name: 
+336                  balanced.append(chunk) 
+337                  name, pos, tag = tag_stack.pop() 
+338                  balanced[pos] = tag 
+339              elif tag_stack: 
+340                  start.extend([tag for name, pos, tag in tag_stack]) 
+341                  tag_stack = [] 
+342                  end.append(chunk) 
+343              else: 
+344                  end.append(chunk) 
+345          else: 
+346              tag_stack.append((name, len(balanced), chunk)) 
+347              balanced.append(None) 
+348      start.extend( 
+349          [chunk for name, pos, chunk in tag_stack]) 
+350      balanced = [chunk for chunk in balanced if chunk is not None] 
+351      return start, balanced, end 
+
352   
+353 -def split_delete(chunks): 
+
354      """ Returns (stuff_before_DEL_START, stuff_inside_DEL_START_END, 
+355      stuff_after_DEL_END).  Returns the first case found (there may be 
+356      more DEL_STARTs in stuff_after_DEL_END).  Raises NoDeletes if 
+357      there's no DEL_START found. """ 
+358      try: 
+359          pos = chunks.index(DEL_START) 
+360      except ValueError: 
+361          raise NoDeletes 
+362      pos2 = chunks.index(DEL_END) 
+363      return chunks[:pos], chunks[pos+1:pos2], chunks[pos2+1:] 
+
364   
+365 -def locate_unbalanced_start(unbalanced_start, pre_delete, post_delete): 
+
366      """ pre_delete and post_delete implicitly point to a place in the 
+367      document (where the two were split).  This moves that point (by 
+368      popping items from one and pushing them onto the other).  It moves 
+369      the point to try to find a place where unbalanced_start applies. 
+370   
+371      As an example:: 
+372   
+373          >>> unbalanced_start = ['<div>'] 
+374          >>> doc = ['<p>', 'Text', '</p>', '<div>', 'More Text', '</div>'] 
+375          >>> pre, post = doc[:3], doc[3:] 
+376          >>> pre, post 
+377          (['<p>', 'Text', '</p>'], ['<div>', 'More Text', '</div>']) 
+378          >>> locate_unbalanced_start(unbalanced_start, pre, post) 
+379          >>> pre, post 
+380          (['<p>', 'Text', '</p>', '<div>'], ['More Text', '</div>']) 
+381   
+382      As you can see, we moved the point so that the dangling <div> that 
+383      we found will be effectively replaced by the div in the original 
+384      document.  If this doesn't work out, we just throw away 
+385      unbalanced_start without doing anything. 
+386      """ 
+387      while 1: 
+388          if not unbalanced_start: 
+389              # We have totally succeeded in finding the position 
+390              break 
+391          finding = unbalanced_start[0] 
+392          finding_name = finding.split()[0].strip('<>') 
+393          if not post_delete: 
+394              break 
+395          next = post_delete[0] 
+396          if next is DEL_START or not next.startswith('<'): 
+397              # Reached a word, we can't move the delete text forward 
+398              break 
+399          if next[1] == '/': 
+400              # Reached a closing tag, can we go further?  Maybe not... 
+401              break 
+402          name = next.split()[0].strip('<>') 
+403          if name == 'ins': 
+404              # Can't move into an insert 
+405              break 
+406          assert name != 'del', ( 
+407              "Unexpected delete tag: %r" % next) 
+408          if name == finding_name: 
+409              unbalanced_start.pop(0) 
+410              pre_delete.append(post_delete.pop(0)) 
+411          else: 
+412              # Found a tag that doesn't match 
+413              break 
+
414   
+415 -def locate_unbalanced_end(unbalanced_end, pre_delete, post_delete): 
+
416      """ like locate_unbalanced_start, except handling end tags and 
+417      possibly moving the point earlier in the document.  """ 
+418      while 1: 
+419          if not unbalanced_end: 
+420              # Success 
+421              break 
+422          finding = unbalanced_end[-1] 
+423          finding_name = finding.split()[0].strip('<>/') 
+424          if not pre_delete: 
+425              break 
+426          next = pre_delete[-1] 
+427          if next is DEL_END or not next.startswith('</'): 
+428              # A word or a start tag 
+429              break 
+430          name = next.split()[0].strip('<>/') 
+431          if name == 'ins' or name == 'del': 
+432              # Can't move into an insert or delete 
+433              break 
+434          if name == finding_name: 
+435              unbalanced_end.pop() 
+436              post_delete.insert(0, pre_delete.pop()) 
+437          else: 
+438              # Found a tag that doesn't match 
+439              break 
+
440   
+441 -class token(_unicode): 
+
442      """ Represents a diffable token, generally a word that is displayed to 
+443      the user.  Opening tags are attached to this token when they are 
+444      adjacent (pre_tags) and closing tags that follow the word 
+445      (post_tags).  Some exceptions occur when there are empty tags 
+446      adjacent to a word, so there may be close tags in pre_tags, or 
+447      open tags in post_tags. 
+448   
+449      We also keep track of whether the word was originally followed by 
+450      whitespace, even though we do not want to treat the word as 
+451      equivalent to a similar word that does not have a trailing 
+452      space.""" 
+453   
+454      # When this is true, the token will be eliminated from the 
+455      # displayed diff if no change has occurred: 
+456      hide_when_equal = False 
+457   
+458 -    def __new__(cls, text, pre_tags=None, post_tags=None, trailing_whitespace=""): 
+
459          obj = _unicode.__new__(cls, text) 
+460   
+461          if pre_tags is not None: 
+462              obj.pre_tags = pre_tags 
+463          else: 
+464              obj.pre_tags = [] 
+465   
+466          if post_tags is not None: 
+467              obj.post_tags = post_tags 
+468          else: 
+469              obj.post_tags = [] 
+470   
+471          obj.trailing_whitespace = trailing_whitespace 
+472   
+473          return obj 
+
474   
+475 -    def __repr__(self): 
+
476          return 'token(%s, %r, %r, %r)' % (_unicode.__repr__(self), self.pre_tags, 
+477                                            self.post_tags, self.trailing_whitespace) 
+
478   
+479 -    def html(self): 
+
480          return _unicode(self) 
+
481   
+482 -class tag_token(token): 
+
483   
+484      """ Represents a token that is actually a tag.  Currently this is just 
+485      the <img> tag, which takes up visible space just like a word but 
+486      is only represented in a document by a tag.  """ 
+487   
+488 -    def __new__(cls, tag, data, html_repr, pre_tags=None,  
+489                  post_tags=None, trailing_whitespace=""): 
+
490          obj = token.__new__(cls, "%s: %s" % (type, data),  
+491                              pre_tags=pre_tags,  
+492                              post_tags=post_tags,  
+493                              trailing_whitespace=trailing_whitespace) 
+494          obj.tag = tag 
+495          obj.data = data 
+496          obj.html_repr = html_repr 
+497          return obj 
+
498   
+499 -    def __repr__(self): 
+
500          return 'tag_token(%s, %s, html_repr=%s, post_tags=%r, pre_tags=%r, trailing_whitespace=%r)' % ( 
+501              self.tag,  
+502              self.data,  
+503              self.html_repr,  
+504              self.pre_tags,  
+505              self.post_tags,  
+506              self.trailing_whitespace) 
+
507 -    def html(self): 
+
508          return self.html_repr 
+
509   
+510 -class href_token(token): 
+
511   
+512      """ Represents the href in an anchor tag.  Unlike other words, we only 
+513      show the href when it changes.  """ 
+514   
+515      hide_when_equal = True 
+516   
+517 -    def html(self): 
+
518          return ' Link: %s' % self 
+
519   
+520 -def tokenize(html, include_hrefs=True): 
+
521      """ 
+522      Parse the given HTML and returns token objects (words with attached tags). 
+523   
+524      This parses only the content of a page; anything in the head is 
+525      ignored, and the <head> and <body> elements are themselves 
+526      optional.  The content is then parsed by lxml, which ensures the 
+527      validity of the resulting parsed document (though lxml may make 
+528      incorrect guesses when the markup is particular bad). 
+529   
+530      <ins> and <del> tags are also eliminated from the document, as 
+531      that gets confusing. 
+532   
+533      If include_hrefs is true, then the href attribute of <a> tags is 
+534      included as a special kind of diffable token.""" 
+535      if etree.iselement(html): 
+536          body_el = html 
+537      else: 
+538          body_el = parse_html(html, cleanup=True) 
+539      # Then we split the document into text chunks for each tag, word, and end tag: 
+540      chunks = flatten_el(body_el, skip_tag=True, include_hrefs=include_hrefs) 
+541      # Finally re-joining them into token objects: 
+542      return fixup_chunks(chunks) 
+
543   
+544 -def parse_html(html, cleanup=True): 
+
545      """ 
+546      Parses an HTML fragment, returning an lxml element.  Note that the HTML will be 
+547      wrapped in a <div> tag that was not in the original document. 
+548   
+549      If cleanup is true, make sure there's no <head> or <body>, and get 
+550      rid of any <ins> and <del> tags. 
+551      """ 
+552      if cleanup: 
+553          # This removes any extra markup or structure like <head>: 
+554          html = cleanup_html(html) 
+555      return fragment_fromstring(html, create_parent=True) 
+
556   
+557  _body_re = re.compile(r'<body.*?>', re.I|re.S) 
+558  _end_body_re = re.compile(r'</body.*?>', re.I|re.S) 
+559  _ins_del_re = re.compile(r'</?(ins|del).*?>', re.I|re.S) 
+560   
+561 -def cleanup_html(html): 
+
562      """ This 'cleans' the HTML, meaning that any page structure is removed 
+563      (only the contents of <body> are used, if there is any <body). 
+564      Also <ins> and <del> tags are removed.  """ 
+565      match = _body_re.search(html) 
+566      if match: 
+567          html = html[match.end():] 
+568      match = _end_body_re.search(html) 
+569      if match: 
+570          html = html[:match.start()] 
+571      html = _ins_del_re.sub('', html) 
+572      return html 
+
573       
+574   
+575  end_whitespace_re = re.compile(r'[ \t\n\r]$') 
+576   
+577 -def split_trailing_whitespace(word): 
+
578      """ 
+579      This function takes a word, such as 'test\n\n' and returns ('test','\n\n') 
+580      """ 
+581      stripped_length = len(word.rstrip()) 
+582      return word[0:stripped_length], word[stripped_length:] 
+
583   
+584   
+585 -def fixup_chunks(chunks): 
+
586      """ 
+587      This function takes a list of chunks and produces a list of tokens. 
+588      """ 
+589      tag_accum = [] 
+590      cur_word = None 
+591      result = [] 
+592      for chunk in chunks: 
+593          if isinstance(chunk, tuple): 
+594              if chunk[0] == 'img': 
+595                  src = chunk[1] 
+596                  tag, trailing_whitespace = split_trailing_whitespace(chunk[2]) 
+597                  cur_word = tag_token('img', src, html_repr=tag, 
+598                                       pre_tags=tag_accum, 
+599                                       trailing_whitespace=trailing_whitespace) 
+600                  tag_accum = [] 
+601                  result.append(cur_word) 
+602   
+603              elif chunk[0] == 'href': 
+604                  href = chunk[1] 
+605                  cur_word = href_token(href, pre_tags=tag_accum, trailing_whitespace=" ") 
+606                  tag_accum = [] 
+607                  result.append(cur_word) 
+608              continue 
+609   
+610          if is_word(chunk): 
+611              chunk, trailing_whitespace = split_trailing_whitespace(chunk) 
+612              cur_word = token(chunk, pre_tags=tag_accum, trailing_whitespace=trailing_whitespace) 
+613              tag_accum = [] 
+614              result.append(cur_word) 
+615   
+616          elif is_start_tag(chunk): 
+617              tag_accum.append(chunk) 
+618   
+619          elif is_end_tag(chunk): 
+620              if tag_accum: 
+621                  tag_accum.append(chunk) 
+622              else: 
+623                  assert cur_word, ( 
+624                      "Weird state, cur_word=%r, result=%r, chunks=%r of %r" 
+625                      % (cur_word, result, chunk, chunks)) 
+626                  cur_word.post_tags.append(chunk) 
+627          else: 
+628              assert False 
+629   
+630      if not result: 
+631          return [token('', pre_tags=tag_accum)] 
+632      else: 
+633          result[-1].post_tags.extend(tag_accum) 
+634   
+635      return result 
+
636   
+637   
+638  # All the tags in HTML that don't require end tags: 
+639  empty_tags = ( 
+640      'param', 'img', 'area', 'br', 'basefont', 'input', 
+641      'base', 'meta', 'link', 'col') 
+642   
+643  block_level_tags = ( 
+644      'address', 
+645      'blockquote', 
+646      'center', 
+647      'dir', 
+648      'div', 
+649      'dl', 
+650      'fieldset', 
+651      'form', 
+652      'h1', 
+653      'h2', 
+654      'h3', 
+655      'h4', 
+656      'h5', 
+657      'h6', 
+658      'hr', 
+659      'isindex', 
+660      'menu', 
+661      'noframes', 
+662      'noscript', 
+663      'ol', 
+664      'p', 
+665      'pre', 
+666      'table', 
+667      'ul', 
+668      ) 
+669   
+670  block_level_container_tags = ( 
+671      'dd', 
+672      'dt', 
+673      'frameset', 
+674      'li', 
+675      'tbody', 
+676      'td', 
+677      'tfoot', 
+678      'th', 
+679      'thead', 
+680      'tr', 
+681      ) 
+682   
+683   
+684 -def flatten_el(el, include_hrefs, skip_tag=False): 
+
685      """ Takes an lxml element el, and generates all the text chunks for 
+686      that tag.  Each start tag is a chunk, each word is a chunk, and each 
+687      end tag is a chunk. 
+688   
+689      If skip_tag is true, then the outermost container tag is 
+690      not returned (just its contents).""" 
+691      if not skip_tag: 
+692          if el.tag == 'img': 
+693              yield ('img', el.get('src'), start_tag(el)) 
+694          else: 
+695              yield start_tag(el) 
+696      if el.tag in empty_tags and not el.text and not len(el) and not el.tail: 
+697          return 
+698      start_words = split_words(el.text) 
+699      for word in start_words: 
+700          yield html_escape(word) 
+701      for child in el: 
+702          for item in flatten_el(child, include_hrefs=include_hrefs): 
+703              yield item 
+704      if el.tag == 'a' and el.get('href') and include_hrefs: 
+705          yield ('href', el.get('href')) 
+706      if not skip_tag: 
+707          yield end_tag(el) 
+708          end_words = split_words(el.tail) 
+709          for word in end_words: 
+710              yield html_escape(word) 
+
711   
+712  split_words_re = re.compile(r'\S+(?:\s+|$)', re.U) 
+713   
+714 -def split_words(text): 
+
715      """ Splits some text into words. Includes trailing whitespace 
+716      on each word when appropriate.  """ 
+717      if not text or not text.strip(): 
+718          return [] 
+719   
+720      words = split_words_re.findall(text) 
+721      return words 
+
722   
+723  start_whitespace_re = re.compile(r'^[ \t\n\r]') 
+724   
+725 -def start_tag(el): 
+
726      """ 
+727      The text representation of the start tag for a tag. 
+728      """ 
+729      return '<%s%s>' % ( 
+730          el.tag, ''.join([' %s="%s"' % (name, html_escape(value, True)) 
+731                           for name, value in el.attrib.items()])) 
+
732   
+733 -def end_tag(el): 
+
734      """ The text representation of an end tag for a tag.  Includes 
+735      trailing whitespace when appropriate.  """ 
+736      if el.tail and start_whitespace_re.search(el.tail): 
+737          extra = ' ' 
+738      else: 
+739          extra = '' 
+740      return '</%s>%s' % (el.tag, extra) 
+
741   
+742 -def is_word(tok): 
+
743      return not tok.startswith('<') 
+
744   
+745 -def is_end_tag(tok): 
+
746      return tok.startswith('</') 
+
747   
+748 -def is_start_tag(tok): 
+
749      return tok.startswith('<') and not tok.startswith('</') 
+
750   
+751 -def fixup_ins_del_tags(html): 
+
752      """ Given an html string, move any <ins> or <del> tags inside of any 
+753      block-level elements, e.g. transform <ins><p>word</p></ins> to 
+754      <p><ins>word</ins></p> """ 
+755      doc = parse_html(html, cleanup=False) 
+756      _fixup_ins_del_tags(doc) 
+757      html = serialize_html_fragment(doc, skip_outer=True) 
+758      return html 
+
759   
+760 -def serialize_html_fragment(el, skip_outer=False): 
+
761      """ Serialize a single lxml element as HTML.  The serialized form 
+762      includes the elements tail.   
+763   
+764      If skip_outer is true, then don't serialize the outermost tag 
+765      """ 
+766      assert not isinstance(el, basestring), ( 
+767          "You should pass in an element, not a string like %r" % el) 
+768      html = etree.tostring(el, method="html", encoding=_unicode) 
+769      if skip_outer: 
+770          # Get rid of the extra starting tag: 
+771          html = html[html.find('>')+1:] 
+772          # Get rid of the extra end tag: 
+773          html = html[:html.rfind('<')] 
+774          return html.strip() 
+775      else: 
+776          return html 
+
777   
+778 -def _fixup_ins_del_tags(doc): 
+
779      """fixup_ins_del_tags that works on an lxml document in-place 
+780      """ 
+781      for tag in ['ins', 'del']: 
+782          for el in doc.xpath('descendant-or-self::%s' % tag): 
+783              if not _contains_block_level_tag(el): 
+784                  continue 
+785              _move_el_inside_block(el, tag=tag) 
+786              el.drop_tag() 
+
787              #_merge_element_contents(el) 
+788   
+789 -def _contains_block_level_tag(el): 
+
790      """True if the element contains any block-level elements, like <p>, <td>, etc. 
+791      """ 
+792      if el.tag in block_level_tags or el.tag in block_level_container_tags: 
+793          return True 
+794      for child in el: 
+795          if _contains_block_level_tag(child): 
+796              return True 
+797      return False 
+
798   
+799 -def _move_el_inside_block(el, tag): 
+
800      """ helper for _fixup_ins_del_tags; actually takes the <ins> etc tags 
+801      and moves them inside any block-level tags.  """ 
+802      for child in el: 
+803          if _contains_block_level_tag(child): 
+804              break 
+805      else: 
+806          # No block-level tags in any child 
+807          children_tag = etree.Element(tag) 
+808          children_tag.text = el.text 
+809          el.text = None 
+810          children_tag.extend(list(el)) 
+811          el[:] = [children_tag] 
+812          return 
+813      for child in list(el): 
+814          if _contains_block_level_tag(child): 
+815              _move_el_inside_block(child, tag) 
+816              if child.tail: 
+817                  tail_tag = etree.Element(tag) 
+818                  tail_tag.text = child.tail 
+819                  child.tail = None 
+820                  el.insert(el.index(child)+1, tail_tag) 
+821          else: 
+822              child_tag = etree.Element(tag) 
+823              el.replace(child, child_tag) 
+824              child_tag.append(child) 
+825      if el.text: 
+826          text_tag = etree.Element(tag) 
+827          text_tag.text = el.text 
+828          el.text = None 
+829          el.insert(0, text_tag) 
+
830               
+831 -def _merge_element_contents(el): 
+
832      """ 
+833      Removes an element, but merges its contents into its place, e.g., 
+834      given <p>Hi <i>there!</i></p>, if you remove the <i> element you get 
+835      <p>Hi there!</p> 
+836      """ 
+837      parent = el.getparent() 
+838      text = el.text or '' 
+839      if el.tail: 
+840          if not len(el): 
+841              text += el.tail 
+842          else: 
+843              if el[-1].tail: 
+844                  el[-1].tail += el.tail 
+845              else: 
+846                  el[-1].tail = el.tail 
+847      index = parent.index(el) 
+848      if text: 
+849          if index == 0: 
+850              previous = None 
+851          else: 
+852              previous = parent[index-1] 
+853          if previous is None: 
+854              if parent.text: 
+855                  parent.text += text 
+856              else: 
+857                  parent.text = text 
+858          else: 
+859              if previous.tail: 
+860                  previous.tail += text 
+861              else: 
+862                  previous.tail = text 
+863      parent[index:index+1] = el.getchildren() 
+
864   
+865 -class InsensitiveSequenceMatcher(difflib.SequenceMatcher): 
+
866      """ 
+867      Acts like SequenceMatcher, but tries not to find very small equal 
+868      blocks amidst large spans of changes 
+869      """ 
+870   
+871      threshold = 2 
+872       
+873 -    def get_matching_blocks(self): 
+
874          size = min(len(self.b), len(self.b)) 
+875          threshold = min(self.threshold, size / 4) 
+876          actual = difflib.SequenceMatcher.get_matching_blocks(self) 
+877          return [item for item in actual 
+878                  if item[2] > threshold 
+879                  or not item[2]] 
+
880   
+881  if __name__ == '__main__': 
+882      from lxml.html import _diffcommand 
+883      _diffcommand.main() 
+884   
+
+difflib.SequenceMatcher --+
+                          |
+                         InsensitiveSequenceMatcher
+
+>>> s = SequenceMatcher(None, "abxcd", "abcd")
+>>> s.get_matching_blocks()
+[Match(a=0, b=0, size=2), Match(a=3, b=2, size=2), Match(a=5, b=4, size=0)]
+              object --+        
+                       |        
+exceptions.BaseException --+    
+                           |    
+        exceptions.Exception --+
+                               |
+                              NoDeletes
+
+object --+            
+         |            
+basestring --+        
+             |        
+       unicode --+    
+                 |    
+             token --+
+                     |
+                    href_token
+
+object --+            
+         |            
+basestring --+        
+             |        
+       unicode --+    
+                 |    
+             token --+
+                     |
+                    tag_token
+
+object --+        
+         |        
+basestring --+    
+             |    
+       unicode --+
+                 |
+                token
+
+descendant-or-self::form[name=$name]|descendant-or-self::x:form[name=$
+name]
+
+descendant-or-self::input|descendant-or-self::select|descendant-or-sel
+f::textarea|descendant-or-self::x:input|descendant-or-self::x:select|d
+escendant-or-self::x:textarea
+
+<lxml.html.formfill.DefaultErrorCreator object>
+
+  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   
+
+object --+
+         |
+        DefaultErrorCreator
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+        exceptions.StandardError --+    
+                                   |    
+              exceptions.LookupError --+
+                                       |
+                                      FormNotFound
+
parse(...).getroot()
parse(...).getroot()
guess_charset
useChardet
+  1  """ 
+  2  An interface to html5lib that mimics the lxml.html interface. 
+  3  """ 
+  4  import sys 
+  5  import string 
+  6   
+  7  from html5lib import HTMLParser as _HTMLParser 
+  8  from html5lib.treebuilders.etree_lxml import TreeBuilder 
+  9  from lxml import etree 
+ 10  from lxml.html import Element, XHTML_NAMESPACE, _contains_block_level_tag 
+ 11   
+ 12  # python3 compatibility 
+ 13  try: 
+ 14      _strings = basestring 
+ 15  except NameError: 
+ 16      _strings = (bytes, str) 
+ 17  try: 
+ 18      from urllib2 import urlopen 
+ 19  except ImportError: 
+ 20      from urllib.request import urlopen 
+ 21  try: 
+ 22      from urlparse import urlparse 
+ 23  except ImportError: 
+ 24      from urllib.parse import urlparse 
+ 25   
+ 26   
+ 27 -class HTMLParser(_HTMLParser): 
+
 28      """An html5lib HTML parser with lxml as tree.""" 
+ 29   
+ 30 -    def __init__(self, strict=False, **kwargs): 
+
 31          _HTMLParser.__init__(self, strict=strict, tree=TreeBuilder, **kwargs) 
+
 32   
+ 33   
+ 34  try: 
+ 35      from html5lib import XHTMLParser as _XHTMLParser 
+ 36  except ImportError: 
+ 37      pass 
+ 38  else: 
+ 39 -    class XHTMLParser(_XHTMLParser): 
+
 40          """An html5lib XHTML Parser with lxml as tree.""" 
+ 41   
+ 42 -        def __init__(self, strict=False, **kwargs): 
+
 43              _XHTMLParser.__init__(self, strict=strict, tree=TreeBuilder, **kwargs) 
+
 44   
+ 45      xhtml_parser = XHTMLParser() 
+ 46   
+ 47   
+ 48 -def _find_tag(tree, tag): 
+
 49      elem = tree.find(tag) 
+ 50      if elem is not None: 
+ 51          return elem 
+ 52      return tree.find('{%s}%s' % (XHTML_NAMESPACE, tag)) 
+
 53   
+ 54   
+ 55 -def document_fromstring(html, guess_charset=None, parser=None): 
+
 56      """ 
+ 57      Parse a whole document into a string. 
+ 58   
+ 59      If `guess_charset` is true, or if the input is not Unicode but a 
+ 60      byte string, the `chardet` library will perform charset guessing 
+ 61      on the string. 
+ 62      """ 
+ 63      if not isinstance(html, _strings): 
+ 64          raise TypeError('string required') 
+ 65   
+ 66      if parser is None: 
+ 67          parser = html_parser 
+ 68   
+ 69      options = {} 
+ 70      if guess_charset is None and isinstance(html, bytes): 
+ 71          # html5lib does not accept useChardet as an argument, if it 
+ 72          # detected the html argument would produce unicode objects. 
+ 73          guess_charset = True 
+ 74      if guess_charset is not None: 
+ 75          options['useChardet'] = guess_charset 
+ 76      return parser.parse(html, **options).getroot() 
+
 77   
+ 78   
+ 79 -def fragments_fromstring(html, no_leading_text=False, 
+ 80                           guess_charset=None, parser=None): 
+
 81      """Parses several HTML elements, returning a list of elements. 
+ 82   
+ 83      The first item in the list may be a string.  If no_leading_text is true, 
+ 84      then it will be an error if there is leading text, and it will always be 
+ 85      a list of only elements. 
+ 86   
+ 87      If `guess_charset` is true, the `chardet` library will perform charset 
+ 88      guessing on the string. 
+ 89      """ 
+ 90      if not isinstance(html, _strings): 
+ 91          raise TypeError('string required') 
+ 92   
+ 93      if parser is None: 
+ 94          parser = html_parser 
+ 95   
+ 96      options = {} 
+ 97      if guess_charset is None and isinstance(html, bytes): 
+ 98          # html5lib does not accept useChardet as an argument, if it 
+ 99          # detected the html argument would produce unicode objects. 
+100          guess_charset = False 
+101      if guess_charset is not None: 
+102          options['useChardet'] = guess_charset 
+103      children = parser.parseFragment(html, 'div', **options) 
+104      if children and isinstance(children[0], _strings): 
+105          if no_leading_text: 
+106              if children[0].strip(): 
+107                  raise etree.ParserError('There is leading text: %r' % 
+108                                          children[0]) 
+109              del children[0] 
+110      return children 
+
111   
+112   
+113 -def fragment_fromstring(html, create_parent=False, 
+114                          guess_charset=None, parser=None): 
+
115      """Parses a single HTML element; it is an error if there is more than 
+116      one element, or if anything but whitespace precedes or follows the 
+117      element. 
+118   
+119      If 'create_parent' is true (or is a tag name) then a parent node 
+120      will be created to encapsulate the HTML in a single element.  In 
+121      this case, leading or trailing text is allowed. 
+122   
+123      If `guess_charset` is true, the `chardet` library will perform charset 
+124      guessing on the string. 
+125      """ 
+126      if not isinstance(html, _strings): 
+127          raise TypeError('string required') 
+128   
+129      accept_leading_text = bool(create_parent) 
+130   
+131      elements = fragments_fromstring( 
+132          html, guess_charset=guess_charset, parser=parser, 
+133          no_leading_text=not accept_leading_text) 
+134   
+135      if create_parent: 
+136          if not isinstance(create_parent, _strings): 
+137              create_parent = 'div' 
+138          new_root = Element(create_parent) 
+139          if elements: 
+140              if isinstance(elements[0], _strings): 
+141                  new_root.text = elements[0] 
+142                  del elements[0] 
+143              new_root.extend(elements) 
+144          return new_root 
+145   
+146      if not elements: 
+147          raise etree.ParserError('No elements found') 
+148      if len(elements) > 1: 
+149          raise etree.ParserError('Multiple elements found') 
+150      result = elements[0] 
+151      if result.tail and result.tail.strip(): 
+152          raise etree.ParserError('Element followed by text: %r' % result.tail) 
+153      result.tail = None 
+154      return result 
+
155   
+156   
+157 -def fromstring(html, guess_charset=None, parser=None): 
+
158      """Parse the html, returning a single element/document. 
+159   
+160      This tries to minimally parse the chunk of text, without knowing if it 
+161      is a fragment or a document. 
+162   
+163      'base_url' will set the document's base_url attribute (and the tree's 
+164      docinfo.URL) 
+165   
+166      If `guess_charset` is true, or if the input is not Unicode but a 
+167      byte string, the `chardet` library will perform charset guessing 
+168      on the string. 
+169      """ 
+170      if not isinstance(html, _strings): 
+171          raise TypeError('string required') 
+172      doc = document_fromstring(html, parser=parser, 
+173                                guess_charset=guess_charset) 
+174   
+175      # document starts with doctype or <html>, full document! 
+176      start = html[:50] 
+177      if isinstance(start, bytes): 
+178          # Allow text comparison in python3. 
+179          # Decode as ascii, that also covers latin-1 and utf-8 for the 
+180          # characters we need. 
+181          start = start.decode('ascii', 'replace') 
+182   
+183      start = start.lstrip().lower() 
+184      if start.startswith('<html') or start.startswith('<!doctype'): 
+185          return doc 
+186   
+187      head = _find_tag(doc, 'head') 
+188   
+189      # if the head is not empty we have a full document 
+190      if len(head): 
+191          return doc 
+192   
+193      body = _find_tag(doc, 'body') 
+194   
+195      # The body has just one element, so it was probably a single 
+196      # element passed in 
+197      if (len(body) == 1 and (not body.text or not body.text.strip()) 
+198          and (not body[-1].tail or not body[-1].tail.strip())): 
+199          return body[0] 
+200   
+201      # Now we have a body which represents a bunch of tags which have the 
+202      # content that was passed in.  We will create a fake container, which 
+203      # is the body tag, except <body> implies too much structure. 
+204      if _contains_block_level_tag(body): 
+205          body.tag = 'div' 
+206      else: 
+207          body.tag = 'span' 
+208      return body 
+
209   
+210   
+211 -def parse(filename_url_or_file, guess_charset=None, parser=None): 
+
212      """Parse a filename, URL, or file-like object into an HTML document 
+213      tree.  Note: this returns a tree, not an element.  Use 
+214      ``parse(...).getroot()`` to get the document root. 
+215   
+216      If ``guess_charset`` is true, the ``useChardet`` option is passed into 
+217      html5lib to enable character detection.  This option is on by default 
+218      when parsing from URLs, off by default when parsing from file(-like) 
+219      objects (which tend to return Unicode more often than not), and on by 
+220      default when parsing from a file path (which is read in binary mode). 
+221      """ 
+222      if parser is None: 
+223          parser = html_parser 
+224      if not isinstance(filename_url_or_file, _strings): 
+225          fp = filename_url_or_file 
+226          if guess_charset is None: 
+227              # assume that file-like objects return Unicode more often than bytes 
+228              guess_charset = False 
+229      elif _looks_like_url(filename_url_or_file): 
+230          fp = urlopen(filename_url_or_file) 
+231          if guess_charset is None: 
+232              # assume that URLs return bytes 
+233              guess_charset = True 
+234      else: 
+235          fp = open(filename_url_or_file, 'rb') 
+236          if guess_charset is None: 
+237              guess_charset = True 
+238   
+239      options = {} 
+240      # html5lib does not accept useChardet as an argument, if it 
+241      # detected the html argument would produce unicode objects. 
+242      if guess_charset: 
+243          options['useChardet'] = guess_charset 
+244      return parser.parse(fp, **options) 
+
245   
+246   
+247 -def _looks_like_url(str): 
+
248      scheme = urlparse(str)[0] 
+249      if not scheme: 
+250          return False 
+251      elif (sys.platform == 'win32' and 
+252              scheme in string.ascii_letters 
+253              and len(scheme) == 1): 
+254          # looks like a 'normal' absolute path 
+255          return False 
+256      else: 
+257          return True 
+
258   
+259   
+260  html_parser = HTMLParser() 
+261   
+
+                     object --+    
+                              |    
+html5lib.html5parser.HTMLParser --+
+                                  |
+                                 HTMLParser
+
+html5lib.XHTMLParser --+
+                       |
+                      XHTMLParser
+
<html>
BeautifulSoup
BeautifulSoup
+(<class 'bs4.element.Declaration'>, <class 'bs4.element.Doctype'>)
+
+  1  """External interface to the BeautifulSoup HTML parser. 
+  2  """ 
+  3   
+  4  __all__ = ["fromstring", "parse", "convert_tree"] 
+  5   
+  6  import re 
+  7  from lxml import etree, html 
+  8   
+  9  try: 
+ 10      from bs4 import ( 
+ 11          BeautifulSoup, Tag, Comment, ProcessingInstruction, NavigableString, 
+ 12          Declaration, Doctype) 
+ 13      _DECLARATION_OR_DOCTYPE = (Declaration, Doctype) 
+ 14  except ImportError: 
+ 15      from BeautifulSoup import ( 
+ 16          BeautifulSoup, Tag, Comment, ProcessingInstruction, NavigableString, 
+ 17          Declaration) 
+ 18      _DECLARATION_OR_DOCTYPE = Declaration 
+ 19   
+ 20   
+ 21 -def fromstring(data, beautifulsoup=None, makeelement=None, **bsargs): 
+
 22      """Parse a string of HTML data into an Element tree using the 
+ 23      BeautifulSoup parser. 
+ 24   
+ 25      Returns the root ``<html>`` Element of the tree. 
+ 26   
+ 27      You can pass a different BeautifulSoup parser through the 
+ 28      `beautifulsoup` keyword, and a diffent Element factory function 
+ 29      through the `makeelement` keyword.  By default, the standard 
+ 30      ``BeautifulSoup`` class and the default factory of `lxml.html` are 
+ 31      used. 
+ 32      """ 
+ 33      return _parse(data, beautifulsoup, makeelement, **bsargs) 
+
 34   
+ 35   
+ 36 -def parse(file, beautifulsoup=None, makeelement=None, **bsargs): 
+
 37      """Parse a file into an ElemenTree using the BeautifulSoup parser. 
+ 38   
+ 39      You can pass a different BeautifulSoup parser through the 
+ 40      `beautifulsoup` keyword, and a diffent Element factory function 
+ 41      through the `makeelement` keyword.  By default, the standard 
+ 42      ``BeautifulSoup`` class and the default factory of `lxml.html` are 
+ 43      used. 
+ 44      """ 
+ 45      if not hasattr(file, 'read'): 
+ 46          file = open(file) 
+ 47      root = _parse(file, beautifulsoup, makeelement, **bsargs) 
+ 48      return etree.ElementTree(root) 
+
 49   
+ 50   
+ 51 -def convert_tree(beautiful_soup_tree, makeelement=None): 
+
 52      """Convert a BeautifulSoup tree to a list of Element trees. 
+ 53   
+ 54      Returns a list instead of a single root Element to support 
+ 55      HTML-like soup with more than one root element. 
+ 56   
+ 57      You can pass a different Element factory through the `makeelement` 
+ 58      keyword. 
+ 59      """ 
+ 60      root = _convert_tree(beautiful_soup_tree, makeelement) 
+ 61      children = root.getchildren() 
+ 62      for child in children: 
+ 63          root.remove(child) 
+ 64      return children 
+
 65   
+ 66   
+ 67  # helpers 
+ 68   
+ 69 -def _parse(source, beautifulsoup, makeelement, **bsargs): 
+
 70      if beautifulsoup is None: 
+ 71          beautifulsoup = BeautifulSoup 
+ 72      if hasattr(beautifulsoup, "HTML_ENTITIES"):  # bs3 
+ 73          if 'convertEntities' not in bsargs: 
+ 74              bsargs['convertEntities'] = 'html' 
+ 75      if hasattr(beautifulsoup, "DEFAULT_BUILDER_FEATURES"):  # bs4 
+ 76          if 'features' not in bsargs: 
+ 77              bsargs['features'] = 'html.parser'  # use Python html parser 
+ 78      tree = beautifulsoup(source, **bsargs) 
+ 79      root = _convert_tree(tree, makeelement) 
+ 80      # from ET: wrap the document in a html root element, if necessary 
+ 81      if len(root) == 1 and root[0].tag == "html": 
+ 82          return root[0] 
+ 83      root.tag = "html" 
+ 84      return root 
+
 85   
+ 86   
+ 87  _parse_doctype_declaration = re.compile( 
+ 88      r'(?:\s|[<!])*DOCTYPE\s*HTML' 
+ 89      r'(?:\s+PUBLIC)?(?:\s+(\'[^\']*\'|"[^"]*"))?' 
+ 90      r'(?:\s+(\'[^\']*\'|"[^"]*"))?', 
+ 91      re.IGNORECASE).match 
+ 92   
+ 93   
+ 94 -class _PseudoTag: 
+
 95      # Minimal imitation of BeautifulSoup.Tag 
+ 96 -    def __init__(self, contents): 
+
 97          self.name = 'html' 
+ 98          self.attrs = [] 
+ 99          self.contents = contents 
+
100   
+101 -    def __iter__(self): 
+
102          return self.contents.__iter__() 
+
103   
+104   
+105 -def _convert_tree(beautiful_soup_tree, makeelement): 
+
106      if makeelement is None: 
+107          makeelement = html.html_parser.makeelement 
+108   
+109      # Split the tree into three parts: 
+110      # i) everything before the root element: document type 
+111      # declaration, comments, processing instructions, whitespace 
+112      # ii) the root(s), 
+113      # iii) everything after the root: comments, processing 
+114      # instructions, whitespace 
+115      first_element_idx = last_element_idx = None 
+116      html_root = declaration = None 
+117      for i, e in enumerate(beautiful_soup_tree): 
+118          if isinstance(e, Tag): 
+119              if first_element_idx is None: 
+120                  first_element_idx = i 
+121              last_element_idx = i 
+122              if html_root is None and e.name and e.name.lower() == 'html': 
+123                  html_root = e 
+124          elif declaration is None and isinstance(e, _DECLARATION_OR_DOCTYPE): 
+125              declaration = e 
+126   
+127      # For a nice, well-formatted document, the variable roots below is 
+128      # a list consisting of a single <html> element. However, the document 
+129      # may be a soup like '<meta><head><title>Hello</head><body>Hi 
+130      # all<\p>'. In this example roots is a list containing meta, head 
+131      # and body elements. 
+132      if first_element_idx is None: 
+133          pre_root = post_root = [] 
+134          roots = beautiful_soup_tree.contents 
+135      else: 
+136          pre_root = beautiful_soup_tree.contents[:first_element_idx] 
+137          roots = beautiful_soup_tree.contents[first_element_idx:last_element_idx+1] 
+138          post_root = beautiful_soup_tree.contents[last_element_idx+1:] 
+139   
+140      # Reorganize so that there is one <html> root... 
+141      if html_root is not None: 
+142          # ... use existing one if possible, ... 
+143          i = roots.index(html_root) 
+144          html_root.contents = roots[:i] + html_root.contents + roots[i+1:] 
+145      else: 
+146          # ... otherwise create a new one. 
+147          html_root = _PseudoTag(roots) 
+148   
+149      convert_node = _init_node_converters(makeelement) 
+150   
+151      # Process pre_root 
+152      res_root = convert_node(html_root) 
+153      prev = res_root 
+154      for e in reversed(pre_root): 
+155          converted = convert_node(e) 
+156          if converted is not None: 
+157              prev.addprevious(converted) 
+158              prev = converted 
+159   
+160      # ditto for post_root 
+161      prev = res_root 
+162      for e in post_root: 
+163          converted = convert_node(e) 
+164          if converted is not None: 
+165              prev.addnext(converted) 
+166              prev = converted 
+167   
+168      if declaration is not None: 
+169          try: 
+170              # bs4 provides full Doctype string 
+171              doctype_string = declaration.output_ready() 
+172          except AttributeError: 
+173              doctype_string = declaration.string 
+174   
+175          match = _parse_doctype_declaration(doctype_string) 
+176          if not match: 
+177              # Something is wrong if we end up in here. Since soupparser should 
+178              # tolerate errors, do not raise Exception, just let it pass. 
+179              pass 
+180          else: 
+181              external_id, sys_uri = match.groups() 
+182              docinfo = res_root.getroottree().docinfo 
+183              # strip quotes and update DOCTYPE values (any of None, '', '...') 
+184              docinfo.public_id = external_id and external_id[1:-1] 
+185              docinfo.system_url = sys_uri and sys_uri[1:-1] 
+186   
+187      return res_root 
+
188   
+189   
+190 -def _init_node_converters(makeelement): 
+
191      converters = {} 
+192      ordered_node_types = [] 
+193   
+194      def converter(*types): 
+195          def add(handler): 
+196              for t in types: 
+197                  converters[t] = handler 
+198                  ordered_node_types.append(t) 
+199              return handler 
+
200          return add 
+201   
+202      def find_best_converter(node): 
+203          for t in ordered_node_types: 
+204              if isinstance(node, t): 
+205                  return converters[t] 
+206          return None 
+207   
+208      def convert_node(bs_node, parent=None): 
+209          # duplicated in convert_tag() below 
+210          try: 
+211              handler = converters[type(bs_node)] 
+212          except KeyError: 
+213              handler = converters[type(bs_node)] = find_best_converter(bs_node) 
+214          if handler is None: 
+215              return None 
+216          return handler(bs_node, parent) 
+217   
+218      def map_attrs(bs_attrs): 
+219          if isinstance(bs_attrs, dict):  # bs4 
+220              attribs = {} 
+221              for k, v in bs_attrs.items(): 
+222                  if isinstance(v, list): 
+223                      v = " ".join(v) 
+224                  attribs[k] = unescape(v) 
+225          else: 
+226              attribs = dict((k, unescape(v)) for k, v in bs_attrs) 
+227          return attribs 
+228   
+229      def append_text(parent, text): 
+230          if len(parent) == 0: 
+231              parent.text = (parent.text or '') + text 
+232          else: 
+233              parent[-1].tail = (parent[-1].tail or '') + text 
+234   
+235      # converters are tried in order of their definition 
+236   
+237      @converter(Tag, _PseudoTag) 
+238      def convert_tag(bs_node, parent): 
+239          attrs = bs_node.attrs 
+240          if parent is not None: 
+241              attribs = map_attrs(attrs) if attrs else None 
+242              res = etree.SubElement(parent, bs_node.name, attrib=attribs) 
+243          else: 
+244              attribs = map_attrs(attrs) if attrs else {} 
+245              res = makeelement(bs_node.name, attrib=attribs) 
+246   
+247          for child in bs_node: 
+248              # avoid double recursion by inlining convert_node(), see above 
+249              try: 
+250                  handler = converters[type(child)] 
+251              except KeyError: 
+252                  pass 
+253              else: 
+254                  if handler is not None: 
+255                      handler(child, res) 
+256                  continue 
+257              convert_node(child, res) 
+258          return res 
+259   
+260      @converter(Comment) 
+261      def convert_comment(bs_node, parent): 
+262          res = html.HtmlComment(bs_node) 
+263          if parent is not None: 
+264              parent.append(res) 
+265          return res 
+266   
+267      @converter(ProcessingInstruction) 
+268      def convert_pi(bs_node, parent): 
+269          if bs_node.endswith('?'): 
+270              # The PI is of XML style (<?as df?>) but BeautifulSoup 
+271              # interpreted it as being SGML style (<?as df>). Fix. 
+272              bs_node = bs_node[:-1] 
+273          res = etree.ProcessingInstruction(*bs_node.split(' ', 1)) 
+274          if parent is not None: 
+275              parent.append(res) 
+276          return res 
+277   
+278      @converter(NavigableString) 
+279      def convert_text(bs_node, parent): 
+280          if parent is not None: 
+281              append_text(parent, unescape(bs_node)) 
+282          return None 
+283   
+284      return convert_node 
+285   
+286   
+287  # copied from ET's ElementSoup 
+288   
+289  try: 
+290      from html.entities import name2codepoint  # Python 3 
+291  except ImportError: 
+292      from htmlentitydefs import name2codepoint 
+293   
+294   
+295  handle_entities = re.compile(r"&(\w+);").sub 
+296   
+297   
+298  try: 
+299      unichr 
+300  except NameError: 
+301      # Python 3 
+302      unichr = chr 
+303   
+304   
+305 -def unescape(string): 
+
306      if not string: 
+307          return '' 
+308      # work around oddities in BeautifulSoup's entity handling 
+309      def unescape_entity(m): 
+310          try: 
+311              return unichr(name2codepoint[m.group(1)]) 
+312          except KeyError: 
+313              return m.group(0)  # use as is 
+
314      return handle_entities(unescape_entity, string) 
+315   
+
+>>> import lxml.html.usedoctest
+>>> # now do your HTML doctests ...
+
+ 1  """Doctest module for HTML comparison. 
+ 2   
+ 3  Usage:: 
+ 4   
+ 5     >>> import lxml.html.usedoctest 
+ 6     >>> # now do your HTML doctests ... 
+ 7   
+ 8  See `lxml.doctestcompare`. 
+ 9  """ 
+10   
+11  from lxml import doctestcompare 
+12   
+13  doctestcompare.temp_install(html=True, del_module=__name__) 
+14   
+
+1   
+2   
+
lxml.isoschematron
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/isoschematron/r
+esources'
+
+  1  """The ``lxml.isoschematron`` package implements ISO Schematron support on top 
+  2  of the pure-xslt 'skeleton' implementation. 
+  3  """ 
+  4   
+  5  import sys 
+  6  import os.path 
+  7  from lxml import etree as _etree # due to validator __init__ signature 
+  8   
+  9   
+ 10  # some compat stuff, borrowed from lxml.html 
+ 11  try: 
+ 12      unicode 
+ 13  except NameError: 
+ 14      # Python 3 
+ 15      unicode = str 
+ 16  try: 
+ 17      basestring 
+ 18  except NameError: 
+ 19      # Python 3 
+ 20      basestring = str 
+ 21   
+ 22   
+ 23  __all__ = ['extract_xsd', 'extract_rng', 'iso_dsdl_include', 
+ 24             'iso_abstract_expand', 'iso_svrl_for_xslt1', 
+ 25             'svrl_validation_errors', 'schematron_schema_valid', 
+ 26             'stylesheet_params', 'Schematron'] 
+ 27   
+ 28   
+ 29  # some namespaces 
+ 30  #FIXME: Maybe lxml should provide a dedicated place for common namespace 
+ 31  #FIXME: definitions? 
+ 32  XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema" 
+ 33  RELAXNG_NS = "http://relaxng.org/ns/structure/1.0" 
+ 34  SCHEMATRON_NS = "http://purl.oclc.org/dsdl/schematron" 
+ 35  SVRL_NS = "http://purl.oclc.org/dsdl/svrl" 
+ 36   
+ 37   
+ 38  # some helpers 
+ 39  _schematron_root = '{%s}schema' % SCHEMATRON_NS 
+ 40  _xml_schema_root = '{%s}schema' % XML_SCHEMA_NS 
+ 41  _resources_dir = os.path.join(os.path.dirname(__file__), 'resources') 
+ 42   
+ 43   
+ 44  # the iso-schematron skeleton implementation steps aka xsl transformations 
+ 45  extract_xsd = _etree.XSLT(_etree.parse( 
+ 46      os.path.join(_resources_dir, 'xsl', 'XSD2Schtrn.xsl'))) 
+ 47  extract_rng = _etree.XSLT(_etree.parse( 
+ 48      os.path.join(_resources_dir, 'xsl', 'RNG2Schtrn.xsl'))) 
+ 49  iso_dsdl_include = _etree.XSLT(_etree.parse( 
+ 50      os.path.join(_resources_dir, 'xsl', 'iso-schematron-xslt1', 
+ 51                   'iso_dsdl_include.xsl'))) 
+ 52  iso_abstract_expand = _etree.XSLT(_etree.parse( 
+ 53      os.path.join(_resources_dir, 'xsl', 'iso-schematron-xslt1', 
+ 54                   'iso_abstract_expand.xsl'))) 
+ 55  iso_svrl_for_xslt1 = _etree.XSLT(_etree.parse( 
+ 56      os.path.join(_resources_dir, 
+ 57                   'xsl', 'iso-schematron-xslt1', 'iso_svrl_for_xslt1.xsl'))) 
+ 58   
+ 59   
+ 60  # svrl result accessors 
+ 61  svrl_validation_errors = _etree.XPath( 
+ 62      '//svrl:failed-assert', namespaces={'svrl': SVRL_NS}) 
+ 63   
+ 64   
+ 65  # RelaxNG validator for schematron schemas 
+ 66  schematron_schema_valid = _etree.RelaxNG( 
+ 67      file=os.path.join(_resources_dir, 'rng', 'iso-schematron.rng')) 
+ 68   
+ 69   
+ 70 -def stylesheet_params(**kwargs): 
+
 71      """Convert keyword args to a dictionary of stylesheet parameters. 
+ 72      XSL stylesheet parameters must be XPath expressions, i.e.: 
+ 73   
+ 74      * string expressions, like "'5'" 
+ 75      * simple (number) expressions, like "5" 
+ 76      * valid XPath expressions, like "/a/b/text()" 
+ 77   
+ 78      This function converts native Python keyword arguments to stylesheet 
+ 79      parameters following these rules: 
+ 80      If an arg is a string wrap it with XSLT.strparam(). 
+ 81      If an arg is an XPath object use its path string. 
+ 82      If arg is None raise TypeError. 
+ 83      Else convert arg to string. 
+ 84      """ 
+ 85      result = {} 
+ 86      for key, val in kwargs.items(): 
+ 87          if isinstance(val, basestring): 
+ 88              val = _etree.XSLT.strparam(val) 
+ 89          elif val is None: 
+ 90              raise TypeError('None not allowed as a stylesheet parameter') 
+ 91          elif not isinstance(val, _etree.XPath): 
+ 92              val = unicode(val) 
+ 93          result[key] = val 
+ 94      return result 
+
 95   
+ 96   
+ 97  # helper function for use in Schematron __init__ 
+ 98 -def _stylesheet_param_dict(paramsDict, kwargsDict): 
+
 99      """Return a copy of paramsDict, updated with kwargsDict entries, wrapped as 
+100      stylesheet arguments. 
+101      kwargsDict entries with a value of None are ignored. 
+102      """ 
+103      # beware of changing mutable default arg 
+104      paramsDict = dict(paramsDict) 
+105      for k, v in kwargsDict.items(): 
+106          if v is not None: # None values do not override 
+107              paramsDict[k] = v 
+108      paramsDict = stylesheet_params(**paramsDict) 
+109      return paramsDict 
+
110   
+111   
+112 -class Schematron(_etree._Validator): 
+
113      """An ISO Schematron validator. 
+114   
+115      Pass a root Element or an ElementTree to turn it into a validator. 
+116      Alternatively, pass a filename as keyword argument 'file' to parse from 
+117      the file system. 
+118   
+119      Schematron is a less well known, but very powerful schema language. 
+120      The main idea is to use the capabilities of XPath to put restrictions on 
+121      the structure and the content of XML documents. 
+122   
+123      The standard behaviour is to fail on ``failed-assert`` findings only 
+124      (``ASSERTS_ONLY``).  To change this, you can either pass a report filter 
+125      function to the ``error_finder`` parameter (e.g. ``ASSERTS_AND_REPORTS`` 
+126      or a custom ``XPath`` object), or subclass isoschematron.Schematron for 
+127      complete control of the validation process. 
+128   
+129      Built on the Schematron language 'reference' skeleton pure-xslt 
+130      implementation, the validator is created as an XSLT 1.0 stylesheet using 
+131      these steps: 
+132   
+133       0) (Extract from XML Schema or RelaxNG schema) 
+134       1) Process inclusions 
+135       2) Process abstract patterns 
+136       3) Compile the schematron schema to XSLT 
+137   
+138      The ``include`` and ``expand`` keyword arguments can be used to switch off 
+139      steps 1) and 2). 
+140      To set parameters for steps 1), 2) and 3) hand parameter dictionaries to the 
+141      keyword arguments ``include_params``, ``expand_params`` or 
+142      ``compile_params``. 
+143      For convenience, the compile-step parameter ``phase`` is also exposed as a 
+144      keyword argument ``phase``. This takes precedence if the parameter is also 
+145      given in the parameter dictionary. 
+146   
+147      If ``store_schematron`` is set to True, the (included-and-expanded) 
+148      schematron document tree is stored and available through the ``schematron`` 
+149      property. 
+150      If ``store_xslt`` is set to True, the validation XSLT document tree will be 
+151      stored and can be retrieved through the ``validator_xslt`` property. 
+152      With ``store_report`` set to True (default: False), the resulting validation 
+153      report document gets stored and can be accessed as the ``validation_report`` 
+154      property. 
+155   
+156      Here is a usage example:: 
+157   
+158        >>> from lxml import etree 
+159        >>> from lxml.isoschematron import Schematron 
+160   
+161        >>> schematron = Schematron(etree.XML(''' 
+162        ... <schema xmlns="http://purl.oclc.org/dsdl/schematron" > 
+163        ...   <pattern id="id_only_attribute"> 
+164        ...     <title>id is the only permitted attribute name</title> 
+165        ...     <rule context="*"> 
+166        ...       <report test="@*[not(name()='id')]">Attribute 
+167        ...         <name path="@*[not(name()='id')]"/> is forbidden<name/> 
+168        ...       </report> 
+169        ...     </rule> 
+170        ...   </pattern> 
+171        ... </schema>'''), 
+172        ... error_finder=Schematron.ASSERTS_AND_REPORTS) 
+173   
+174        >>> xml = etree.XML(''' 
+175        ... <AAA name="aaa"> 
+176        ...   <BBB id="bbb"/> 
+177        ...   <CCC color="ccc"/> 
+178        ... </AAA> 
+179        ... ''') 
+180   
+181        >>> schematron.validate(xml) 
+182        False 
+183   
+184        >>> xml = etree.XML(''' 
+185        ... <AAA id="aaa"> 
+186        ...   <BBB id="bbb"/> 
+187        ...   <CCC/> 
+188        ... </AAA> 
+189        ... ''') 
+190   
+191        >>> schematron.validate(xml) 
+192        True 
+193      """ 
+194   
+195      # libxml2 error categorization for validation errors 
+196      _domain = _etree.ErrorDomains.SCHEMATRONV 
+197      _level = _etree.ErrorLevels.ERROR 
+198      _error_type = _etree.ErrorTypes.SCHEMATRONV_ASSERT 
+199   
+200      # convenience definitions for common behaviours 
+201      ASSERTS_ONLY = svrl_validation_errors  # Default 
+202      ASSERTS_AND_REPORTS = _etree.XPath( 
+203          '//svrl:failed-assert | //svrl:successful-report', 
+204          namespaces={'svrl': SVRL_NS}) 
+205   
+206 -    def _extract(self, element): 
+
207          """Extract embedded schematron schema from non-schematron host schema. 
+208          This method will only be called by __init__ if the given schema document 
+209          is not a schematron schema by itself. 
+210          Must return a schematron schema document tree or None. 
+211          """ 
+212          schematron = None 
+213          if element.tag == _xml_schema_root: 
+214              schematron = self._extract_xsd(element) 
+215          elif element.nsmap[element.prefix] == RELAXNG_NS: 
+216              # RelaxNG does not have a single unique root element 
+217              schematron = self._extract_rng(element) 
+218          return schematron 
+
219   
+220      # customization points 
+221      # etree.XSLT objects that provide the extract, include, expand, compile 
+222      # steps 
+223      _extract_xsd = extract_xsd 
+224      _extract_rng = extract_rng 
+225      _include = iso_dsdl_include 
+226      _expand = iso_abstract_expand 
+227      _compile = iso_svrl_for_xslt1 
+228   
+229      # etree.xpath object that determines input document validity when applied to 
+230      # the svrl result report; must return a list of result elements (empty if 
+231      # valid) 
+232      _validation_errors = ASSERTS_ONLY 
+233   
+234 -    def __init__(self, etree=None, file=None, include=True, expand=True, 
+235                   include_params={}, expand_params={}, compile_params={}, 
+236                   store_schematron=False, store_xslt=False, store_report=False, 
+237                   phase=None, error_finder=ASSERTS_ONLY): 
+
238          super(Schematron, self).__init__() 
+239   
+240          self._store_report = store_report 
+241          self._schematron = None 
+242          self._validator_xslt = None 
+243          self._validation_report = None 
+244          if error_finder is not self.ASSERTS_ONLY: 
+245              self._validation_errors = error_finder 
+246   
+247          # parse schema document, may be a schematron schema or an XML Schema or 
+248          # a RelaxNG schema with embedded schematron rules 
+249          root = None 
+250          try: 
+251              if etree is not None: 
+252                  if _etree.iselement(etree): 
+253                      root = etree 
+254                  else: 
+255                      root = etree.getroot() 
+256              elif file is not None: 
+257                  root = _etree.parse(file).getroot() 
+258          except Exception: 
+259              raise _etree.SchematronParseError( 
+260                  "No tree or file given: %s" % sys.exc_info()[1]) 
+261          if root is None: 
+262              raise ValueError("Empty tree") 
+263          if root.tag == _schematron_root: 
+264              schematron = root 
+265          else: 
+266              schematron = self._extract(root) 
+267          if schematron is None: 
+268              raise _etree.SchematronParseError( 
+269                  "Document is not a schematron schema or schematron-extractable") 
+270          # perform the iso-schematron skeleton implementation steps to get a 
+271          # validating xslt 
+272          if include: 
+273              schematron = self._include(schematron, **include_params) 
+274          if expand: 
+275              schematron = self._expand(schematron, **expand_params) 
+276          if not schematron_schema_valid(schematron): 
+277              raise _etree.SchematronParseError( 
+278                  "invalid schematron schema: %s" % 
+279                  schematron_schema_valid.error_log) 
+280          if store_schematron: 
+281              self._schematron = schematron 
+282          # add new compile keyword args here if exposing them 
+283          compile_kwargs = {'phase': phase} 
+284          compile_params = _stylesheet_param_dict(compile_params, compile_kwargs) 
+285          validator_xslt = self._compile(schematron, **compile_params) 
+286          if store_xslt: 
+287              self._validator_xslt = validator_xslt 
+288          self._validator = _etree.XSLT(validator_xslt) 
+
289   
+290 -    def __call__(self, etree): 
+
291          """Validate doc using Schematron. 
+292   
+293          Returns true if document is valid, false if not. 
+294          """ 
+295          self._clear_error_log() 
+296          result = self._validator(etree) 
+297          if self._store_report: 
+298              self._validation_report = result 
+299          errors = self._validation_errors(result) 
+300          if errors: 
+301              if _etree.iselement(etree): 
+302                  fname = etree.getroottree().docinfo.URL or '<file>' 
+303              else: 
+304                  fname = etree.docinfo.URL or '<file>' 
+305              for error in errors: 
+306                  # Does svrl report the line number, anywhere? Don't think so. 
+307                  self._append_log_message( 
+308                      domain=self._domain, type=self._error_type, 
+309                      level=self._level, line=0, 
+310                      message=_etree.tostring(error, encoding='unicode'), 
+311                      filename=fname) 
+312              return False 
+313          return True 
+
314   
+315      @property 
+316 -    def schematron(self): 
+
317          """ISO-schematron schema document (None if object has been initialized 
+318          with store_schematron=False). 
+319          """ 
+320          return self._schematron 
+
321   
+322      @property 
+323 -    def validator_xslt(self): 
+
324          """ISO-schematron skeleton implementation XSLT validator document (None 
+325          if object has been initialized with store_xslt=False). 
+326          """ 
+327          return self._validator_xslt 
+
328   
+329      @property 
+330 -    def validation_report(self): 
+
331          """ISO-schematron validation result report (None if result-storing has 
+332          been turned off). 
+333          """ 
+334          return self._validation_report 
+
335   
+
+      object --+    
+               |    
+etree._Validator --+
+                   |
+                  Schematron
+
failed-assert
ASSERTS_ONLY
error_finder
ASSERTS_AND_REPORTS
XPath
include
expand
include_params
expand_params
compile_params
phase
phase
store_schematron
schematron
store_xslt
validator_xslt
store_report
validation_report
+>>> from lxml import etree
+>>> from lxml.isoschematron import Schematron
+
+>>> schematron = Schematron(etree.XML('''
+... <schema xmlns="http://purl.oclc.org/dsdl/schematron" >
+...   <pattern id="id_only_attribute">
+...     <title>id is the only permitted attribute name</title>
+...     <rule context="*">
+...       <report test="@*[not(name()='id')]">Attribute
+...         <name path="@*[not(name()='id')]"/> is forbidden<name/>
+...       </report>
+...     </rule>
+...   </pattern>
+... </schema>'''),
+... error_finder=Schematron.ASSERTS_AND_REPORTS)
+
+>>> xml = etree.XML('''
+... <AAA name="aaa">
+...   <BBB id="bbb"/>
+...   <CCC color="ccc"/>
+... </AAA>
+... ''')
+
+>>> schematron.validate(xml)
+False
+
+>>> xml = etree.XML('''
+... <AAA id="aaa">
+...   <BBB id="bbb"/>
+...   <CCC/>
+... </AAA>
+... ''')
+
+>>> schematron.validate(xml)
+True
+
+//svrl:failed-assert | //svrl:successful-report
+
lxml.objectify
base_url
empty_pytype
empty_type
cleanup_namespaces=True
base_url
etree.XMLParser()
remove_blank_text
base_url
ignore_xsi
xsi:type
empty_pytype
ignore_pytype
pytype
empty_type
+'{http://codespeak.net/lxml/objectify/pytype}pytype'
+
+    object --+                        
+             |                        
+etree._Element --+                    
+                 |                    
+ etree.ElementBase --+                
+                     |                
+    ObjectifiedElement --+            
+                         |            
+    ObjectifiedDataElement --+        
+                             |        
+                 NumberElement --+    
+                                 |    
+                        IntElement --+
+                                     |
+                                    BoolElement
+
+object --+
+         |
+        ElementMaker
+
+>>> M = ElementMaker(annotate=False)
+>>> attributes = {'class': 'par'}
+>>> html = M.html( M.body( M.p('hello', attributes, M.br, 'objectify', style="font-weight: bold") ) )
+
+>>> from lxml.etree import tostring
+>>> print(tostring(html, method='html').decode('ascii'))
+<html><body><p style="font-weight: bold" class="par">hello<br>objectify</p></body></html>
+
+>>> root = M('tricky-tag', 'some text')
+>>> print(root.tag)
+tricky-tag
+>>> print(root.text)
+some text
+
E
+    object --+                    
+             |                    
+etree._Element --+                
+                 |                
+ etree.ElementBase --+            
+                     |            
+    ObjectifiedElement --+        
+                         |        
+    ObjectifiedDataElement --+    
+                             |    
+                 NumberElement --+
+                                 |
+                                FloatElement
+
+    object --+                    
+             |                    
+etree._Element --+                
+                 |                
+ etree.ElementBase --+            
+                     |            
+    ObjectifiedElement --+        
+                         |        
+    ObjectifiedDataElement --+    
+                             |    
+                 NumberElement --+
+                                 |
+                                IntElement
+
+    object --+                    
+             |                    
+etree._Element --+                
+                 |                
+ etree.ElementBase --+            
+                     |            
+    ObjectifiedElement --+        
+                         |        
+    ObjectifiedDataElement --+    
+                             |    
+                 NumberElement --+
+                                 |
+                                LongElement
+
+    object --+                
+             |                
+etree._Element --+            
+                 |            
+ etree.ElementBase --+        
+                     |        
+    ObjectifiedElement --+    
+                         |    
+    ObjectifiedDataElement --+
+                             |
+                            NoneElement
+
+    object --+                
+             |                
+etree._Element --+            
+                 |            
+ etree.ElementBase --+        
+                     |        
+    ObjectifiedElement --+    
+                         |    
+    ObjectifiedDataElement --+
+                             |
+                            NumberElement
+
+object --+
+         |
+        ObjectPath
+
+    object --+            
+             |            
+etree._Element --+        
+                 |        
+ etree.ElementBase --+    
+                     |    
+    ObjectifiedElement --+
+                         |
+                        ObjectifiedDataElement
+
+    object --+        
+             |        
+etree._Element --+    
+                 |    
+ etree.ElementBase --+
+                     |
+                    ObjectifiedElement
+
+>>> root = XML("<root><c1><c2>0</c2><c2>1</c2></c1></root>")
+>>> second_c2 = root.c1.c2[1]
+>>> print(second_c2.text)
+1
+
text
+              object --+    
+                       |    
+etree.ElementClassLookup --+
+                           |
+                          ObjectifyElementClassLookup
+
+object --+
+         |
+        PyType
+
+PyType('int', int, MyIntClass).register()
+
+    object --+                
+             |                
+etree._Element --+            
+                 |            
+ etree.ElementBase --+        
+                     |        
+    ObjectifiedElement --+    
+                         |    
+    ObjectifiedDataElement --+
+                             |
+                            StringElement
+
+1  # dummy module for backwards compatibility 
+2   
+3  from lxml.etree import PythonElementClassLookup 
+4   
+
+{'_getNsTag': <capsule object "PyObject *(PyObject *)" at 0x7f4dd2c7e9
+90>}
+
+  1  # cython: language_level=2 
+  2   
+  3  """ 
+  4  SAX-based adapter to copy trees from/to the Python standard library. 
+  5   
+  6  Use the `ElementTreeContentHandler` class to build an ElementTree from 
+  7  SAX events. 
+  8   
+  9  Use the `ElementTreeProducer` class or the `saxify()` function to fire 
+ 10  the SAX events of an ElementTree against a SAX ContentHandler. 
+ 11   
+ 12  See http://codespeak.net/lxml/sax.html 
+ 13  """ 
+ 14   
+ 15  from __future__ import absolute_import 
+ 16   
+ 17  from xml.sax.handler import ContentHandler 
+ 18  from lxml import etree 
+ 19  from lxml.etree import ElementTree, SubElement 
+ 20  from lxml.etree import Comment, ProcessingInstruction 
+ 21   
+ 22   
+ 23 -class SaxError(etree.LxmlError): 
+
 24      """General SAX error. 
+ 25      """ 
+
 26   
+ 27   
+ 28 -def _getNsTag(tag): 
+
 29      if tag[0] == '{': 
+ 30          return tuple(tag[1:].split('}', 1)) 
+ 31      else: 
+ 32          return None, tag 
+
 33   
+ 34   
+ 35 -class ElementTreeContentHandler(ContentHandler): 
+
 36      """Build an lxml ElementTree from SAX events. 
+ 37      """ 
+ 38 -    def __init__(self, makeelement=None): 
+
 39          ContentHandler.__init__(self) 
+ 40          self._root = None 
+ 41          self._root_siblings = [] 
+ 42          self._element_stack = [] 
+ 43          self._default_ns = None 
+ 44          self._ns_mapping = { None : [None] } 
+ 45          self._new_mappings = {} 
+ 46          if makeelement is None: 
+ 47              makeelement = etree.Element 
+ 48          self._makeelement = makeelement 
+
 49   
+ 50 -    def _get_etree(self): 
+
 51          "Contains the generated ElementTree after parsing is finished." 
+ 52          return ElementTree(self._root) 
+
 53   
+ 54      etree = property(_get_etree, doc=_get_etree.__doc__) 
+ 55   
+ 56 -    def setDocumentLocator(self, locator): 
+
 57          pass 
+
 58   
+ 59 -    def startDocument(self): 
+
 60          pass 
+
 61   
+ 62 -    def endDocument(self): 
+
 63          pass 
+
 64   
+ 65 -    def startPrefixMapping(self, prefix, uri): 
+
 66          self._new_mappings[prefix] = uri 
+ 67          try: 
+ 68              self._ns_mapping[prefix].append(uri) 
+ 69          except KeyError: 
+ 70              self._ns_mapping[prefix] = [uri] 
+ 71          if prefix is None: 
+ 72              self._default_ns = uri 
+
 73   
+ 74 -    def endPrefixMapping(self, prefix): 
+
 75          ns_uri_list = self._ns_mapping[prefix] 
+ 76          ns_uri_list.pop() 
+ 77          if prefix is None: 
+ 78              self._default_ns = ns_uri_list[-1] 
+
 79   
+ 80 -    def _buildTag(self, ns_name_tuple): 
+
 81          ns_uri, local_name = ns_name_tuple 
+ 82          if ns_uri: 
+ 83              el_tag = "{%s}%s" % ns_name_tuple 
+ 84          elif self._default_ns: 
+ 85              el_tag = "{%s}%s" % (self._default_ns, local_name) 
+ 86          else: 
+ 87              el_tag = local_name 
+ 88          return el_tag 
+
 89   
+ 90 -    def startElementNS(self, ns_name, qname, attributes=None): 
+
 91          el_name = self._buildTag(ns_name) 
+ 92          if attributes: 
+ 93              attrs = {} 
+ 94              try: 
+ 95                  iter_attributes = attributes.iteritems() 
+ 96              except AttributeError: 
+ 97                  iter_attributes = attributes.items() 
+ 98   
+ 99              for name_tuple, value in iter_attributes: 
+100                  if name_tuple[0]: 
+101                      attr_name = "{%s}%s" % name_tuple 
+102                  else: 
+103                      attr_name = name_tuple[1] 
+104                  attrs[attr_name] = value 
+105          else: 
+106              attrs = None 
+107   
+108          element_stack = self._element_stack 
+109          if self._root is None: 
+110              element = self._root = \ 
+111                        self._makeelement(el_name, attrs, self._new_mappings) 
+112              if self._root_siblings and hasattr(element, 'addprevious'): 
+113                  for sibling in self._root_siblings: 
+114                      element.addprevious(sibling) 
+115              del self._root_siblings[:] 
+116          else: 
+117              element = SubElement(element_stack[-1], el_name, 
+118                                   attrs, self._new_mappings) 
+119          element_stack.append(element) 
+120   
+121          self._new_mappings.clear() 
+
122   
+123 -    def processingInstruction(self, target, data): 
+
124          pi = ProcessingInstruction(target, data) 
+125          if self._root is None: 
+126              self._root_siblings.append(pi) 
+127          else: 
+128              self._element_stack[-1].append(pi) 
+
129   
+130 -    def endElementNS(self, ns_name, qname): 
+
131          element = self._element_stack.pop() 
+132          el_tag = self._buildTag(ns_name) 
+133          if el_tag != element.tag: 
+134              raise SaxError("Unexpected element closed: " + el_tag) 
+
135   
+136 -    def startElement(self, name, attributes=None): 
+
137          if attributes: 
+138              attributes = dict( 
+139                      [((None, k), v) for k, v in attributes.items()] 
+140                  ) 
+141          self.startElementNS((None, name), name, attributes) 
+
142   
+143 -    def endElement(self, name): 
+
144          self.endElementNS((None, name), name) 
+
145   
+146 -    def characters(self, data): 
+
147          last_element = self._element_stack[-1] 
+148          try: 
+149              # if there already is a child element, we must append to its tail 
+150              last_element = last_element[-1] 
+151              last_element.tail = (last_element.tail or '') + data 
+152          except IndexError: 
+153              # otherwise: append to the text 
+154              last_element.text = (last_element.text or '') + data 
+
155   
+156      ignorableWhitespace = characters 
+
157   
+158   
+159 -class ElementTreeProducer(object): 
+
160      """Produces SAX events for an element and children. 
+161      """ 
+162 -    def __init__(self, element_or_tree, content_handler): 
+
163          try: 
+164              element = element_or_tree.getroot() 
+165          except AttributeError: 
+166              element = element_or_tree 
+167          self._element = element 
+168          self._content_handler = content_handler 
+169          from xml.sax.xmlreader import AttributesNSImpl as attr_class 
+170          self._attr_class = attr_class 
+171          self._empty_attributes = attr_class({}, {}) 
+
172   
+173 -    def saxify(self): 
+
174          self._content_handler.startDocument() 
+175   
+176          element = self._element 
+177          if hasattr(element, 'getprevious'): 
+178              siblings = [] 
+179              sibling = element.getprevious() 
+180              while getattr(sibling, 'tag', None) is ProcessingInstruction: 
+181                  siblings.append(sibling) 
+182                  sibling = sibling.getprevious() 
+183              for sibling in siblings[::-1]: 
+184                  self._recursive_saxify(sibling, {}) 
+185   
+186          self._recursive_saxify(element, {}) 
+187   
+188          if hasattr(element, 'getnext'): 
+189              sibling = element.getnext() 
+190              while getattr(sibling, 'tag', None) is ProcessingInstruction: 
+191                  self._recursive_saxify(sibling, {}) 
+192                  sibling = sibling.getnext() 
+193   
+194          self._content_handler.endDocument() 
+
195   
+196 -    def _recursive_saxify(self, element, parent_nsmap): 
+
197          content_handler = self._content_handler 
+198          tag = element.tag 
+199          if tag is Comment or tag is ProcessingInstruction: 
+200              if tag is ProcessingInstruction: 
+201                  content_handler.processingInstruction( 
+202                      element.target, element.text) 
+203              tail = element.tail 
+204              if tail: 
+205                  content_handler.characters(tail) 
+206              return 
+207   
+208          element_nsmap = element.nsmap 
+209          new_prefixes = [] 
+210          if element_nsmap != parent_nsmap: 
+211              # There have been updates to the namespace 
+212              for prefix, ns_uri in element_nsmap.items(): 
+213                  if parent_nsmap.get(prefix) != ns_uri: 
+214                      new_prefixes.append( (prefix, ns_uri) ) 
+215   
+216          attribs = element.items() 
+217          if attribs: 
+218              attr_values = {} 
+219              attr_qnames = {} 
+220              for attr_ns_name, value in attribs: 
+221                  attr_ns_tuple = _getNsTag(attr_ns_name) 
+222                  attr_values[attr_ns_tuple] = value 
+223                  attr_qnames[attr_ns_tuple] = self._build_qname( 
+224                      attr_ns_tuple[0], attr_ns_tuple[1], element_nsmap, 
+225                      preferred_prefix=None, is_attribute=True) 
+226              sax_attributes = self._attr_class(attr_values, attr_qnames) 
+227          else: 
+228              sax_attributes = self._empty_attributes 
+229   
+230          ns_uri, local_name = _getNsTag(tag) 
+231          qname = self._build_qname( 
+232              ns_uri, local_name, element_nsmap, element.prefix, is_attribute=False) 
+233   
+234          for prefix, uri in new_prefixes: 
+235              content_handler.startPrefixMapping(prefix, uri) 
+236          content_handler.startElementNS( 
+237              (ns_uri, local_name), qname, sax_attributes) 
+238          text = element.text 
+239          if text: 
+240              content_handler.characters(text) 
+241          for child in element: 
+242              self._recursive_saxify(child, element_nsmap) 
+243          content_handler.endElementNS((ns_uri, local_name), qname) 
+244          for prefix, uri in new_prefixes: 
+245              content_handler.endPrefixMapping(prefix) 
+246          tail = element.tail 
+247          if tail: 
+248              content_handler.characters(tail) 
+
249   
+250 -    def _build_qname(self, ns_uri, local_name, nsmap, preferred_prefix, is_attribute): 
+
251          if ns_uri is None: 
+252              return local_name 
+253   
+254          if not is_attribute and nsmap.get(preferred_prefix) == ns_uri: 
+255              prefix = preferred_prefix 
+256          else: 
+257              # Pick the first matching prefix, in alphabetical order. 
+258              candidates = [ 
+259                  pfx for (pfx, uri) in nsmap.items() 
+260                  if pfx is not None and uri == ns_uri 
+261              ] 
+262              prefix = ( 
+263                  candidates[0] if len(candidates) == 1 
+264                  else min(candidates) if candidates 
+265                  else None 
+266              ) 
+267   
+268          if prefix is None: 
+269              # Default namespace 
+270              return local_name 
+271          return prefix + ':' + local_name 
+
272   
+273   
+274 -def saxify(element_or_tree, content_handler): 
+
275      """One-shot helper to generate SAX events from an XML tree and fire 
+276      them against a SAX ContentHandler. 
+277      """ 
+278      return ElementTreeProducer(element_or_tree, content_handler).saxify() 
+
279   
+
+xml.sax.handler.ContentHandler --+
+                                 |
+                                ElementTreeContentHandler
+
+object --+
+         |
+        ElementTreeProducer
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+                     etree.Error --+    
+                                   |    
+                     etree.LxmlError --+
+                                       |
+                                      SaxError
+
+1  """ 
+2  The lxml test suite for lxml, ElementTree and cElementTree. 
+3  """ 
+4   
+
+  1  import gc 
+  2  import os 
+  3  import os.path 
+  4  import re 
+  5  import sys 
+  6  import tempfile 
+  7  import unittest 
+  8  from contextlib import contextmanager 
+  9   
+ 10  try: 
+ 11      import urlparse 
+ 12  except ImportError: 
+ 13      import urllib.parse as urlparse  
+ 14   
+ 15  try: 
+ 16      from urllib import pathname2url 
+ 17  except: 
+ 18      from urllib.request import pathname2url 
+ 19   
+ 20  from lxml import etree, html 
+ 21   
+ 22 -def make_version_tuple(version_string): 
+
 23      return tuple( 
+ 24          int(part) if part.isdigit() else part 
+ 25          for part in re.findall('([0-9]+|[^0-9.]+)', version_string) 
+ 26      ) 
+
 27   
+ 28  IS_PYPY = (getattr(sys, 'implementation', None) == 'pypy' or 
+ 29             getattr(sys, 'pypy_version_info', None) is not None) 
+ 30   
+ 31  IS_PYTHON3 = sys.version_info[0] >= 3 
+ 32  IS_PYTHON2 = sys.version_info[0] < 3 
+ 33   
+ 34  from xml.etree import ElementTree 
+ 35   
+ 36  if hasattr(ElementTree, 'VERSION'): 
+ 37      ET_VERSION = make_version_tuple(ElementTree.VERSION) 
+ 38  else: 
+ 39      ET_VERSION = (0,0,0) 
+ 40   
+ 41  if IS_PYTHON2: 
+ 42      from xml.etree import cElementTree 
+ 43   
+ 44      if hasattr(cElementTree, 'VERSION'): 
+ 45          CET_VERSION = make_version_tuple(cElementTree.VERSION) 
+ 46      else: 
+ 47          CET_VERSION = (0,0,0) 
+ 48  else: 
+ 49      CET_VERSION = (0, 0, 0) 
+ 50      cElementTree = None 
+ 51   
+ 52   
+ 53 -def filter_by_version(test_class, version_dict, current_version): 
+
 54      """Remove test methods that do not work with the current lib version. 
+ 55      """ 
+ 56      find_required_version = version_dict.get 
+ 57      def dummy_test_method(self): 
+ 58          pass 
+
 59      for name in dir(test_class): 
+ 60          expected_version = find_required_version(name, (0,0,0)) 
+ 61          if expected_version > current_version: 
+ 62              setattr(test_class, name, dummy_test_method) 
+ 63   
+ 64  import doctest 
+ 65   
+ 66  try: 
+ 67      next 
+ 68  except NameError: 
+ 69 -    def next(it): 
+
 70          return it.next() 
+
 71  else: 
+ 72      locals()['next'] = next 
+ 73   
+ 74   
+ 75  try: 
+ 76      import pytest 
+ 77  except ImportError: 
+ 78 -    class skipif(object): 
+
 79          "Using a class because a function would bind into a method when used in classes" 
+ 80 -        def __init__(self, *args): pass 
+
 81 -        def __call__(self, func, *args): return func 
+
 82  else: 
+ 83      skipif = pytest.mark.skipif 
+ 84   
+ 85 -def _get_caller_relative_path(filename, frame_depth=2): 
+
 86      module = sys.modules[sys._getframe(frame_depth).f_globals['__name__']] 
+ 87      return os.path.normpath(os.path.join( 
+ 88              os.path.dirname(getattr(module, '__file__', '')), filename)) 
+
 89   
+ 90  from io import StringIO 
+ 91   
+ 92  unichr_escape = re.compile(r'\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}') 
+ 93   
+ 94  if sys.version_info[0] >= 3: 
+ 95      # Python 3 
+ 96      from builtins import str as unicode 
+ 97      from codecs import unicode_escape_decode 
+ 98      _chr = chr 
+ 99 -    def _str(s, encoding="UTF-8"): 
+
100          return unichr_escape.sub(lambda x: unicode_escape_decode(x.group(0))[0], s) 
+
101 -    def _bytes(s, encoding="UTF-8"): 
+
102          return s.encode(encoding) 
+
103      from io import BytesIO as _BytesIO 
+104 -    def BytesIO(*args): 
+
105          if args and isinstance(args[0], str): 
+106              args = (args[0].encode("UTF-8"),) 
+107          return _BytesIO(*args) 
+
108   
+109      doctest_parser = doctest.DocTestParser() 
+110      _fix_unicode = re.compile(r'(\s+)u(["\'])').sub 
+111      _fix_exceptions = re.compile(r'(.*except [^(]*),\s*(.*:)').sub 
+112 -    def make_doctest(filename): 
+
113          filename = _get_caller_relative_path(filename) 
+114          doctests = read_file(filename) 
+115          doctests = _fix_unicode(r'\1\2', doctests) 
+116          doctests = _fix_exceptions(r'\1 as \2', doctests) 
+117          return doctest.DocTestCase( 
+118              doctest_parser.get_doctest( 
+119                  doctests, {}, os.path.basename(filename), filename, 0)) 
+
120  else: 
+121      # Python 2 
+122      from __builtin__ import unicode 
+123      _chr = unichr 
+124 -    def _str(s, encoding="UTF-8"): 
+
125          s = unicode(s, encoding=encoding) 
+126          return unichr_escape.sub(lambda x: 
+127                                       x.group(0).decode('unicode-escape'), 
+128                                   s) 
+
129 -    def _bytes(s, encoding="UTF-8"): 
+
130          return s 
+
131      from io import BytesIO 
+132   
+133      doctest_parser = doctest.DocTestParser() 
+134      _fix_traceback = re.compile(r'^(\s*)(?:\w+\.)+(\w*(?:Error|Exception|Invalid):)', re.M).sub 
+135      _fix_exceptions = re.compile(r'(.*except [^(]*)\s+as\s+(.*:)').sub 
+136      _fix_bytes = re.compile(r'(\s+)b(["\'])').sub 
+137 -    def make_doctest(filename): 
+
138          filename = _get_caller_relative_path(filename) 
+139          doctests = read_file(filename) 
+140          doctests = _fix_traceback(r'\1\2', doctests) 
+141          doctests = _fix_exceptions(r'\1, \2', doctests) 
+142          doctests = _fix_bytes(r'\1\2', doctests) 
+143          return doctest.DocTestCase( 
+144              doctest_parser.get_doctest( 
+145                  doctests, {}, os.path.basename(filename), filename, 0)) 
+
146   
+147  try: 
+148      skipIf = unittest.skipIf 
+149  except AttributeError: 
+150 -    def skipIf(condition, why): 
+
151          def _skip(thing): 
+152              import types 
+153              if isinstance(thing, (type, types.ClassType)): 
+154                  return type(thing.__name__, (object,), {}) 
+155              else: 
+156                  return None 
+
157          if condition: 
+158              return _skip 
+159          return lambda thing: thing 
+160   
+161   
+162 -class HelperTestCase(unittest.TestCase): 
+
163 -    def tearDown(self): 
+
164          gc.collect() 
+
165   
+166 -    def parse(self, text, parser=None): 
+
167          f = BytesIO(text) if isinstance(text, bytes) else StringIO(text) 
+168          return etree.parse(f, parser=parser) 
+
169       
+170 -    def _rootstring(self, tree): 
+
171          return etree.tostring(tree.getroot()).replace( 
+172              _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes('')) 
+
173   
+174   
+175 -class SillyFileLike: 
+
176 -    def __init__(self, xml_data=_bytes('<foo><bar/></foo>')): 
+
177          self.xml_data = xml_data 
+
178           
+179 -    def read(self, amount=None): 
+
180          if self.xml_data: 
+181              if amount: 
+182                  data = self.xml_data[:amount] 
+183                  self.xml_data = self.xml_data[amount:] 
+184              else: 
+185                  data = self.xml_data 
+186                  self.xml_data = _bytes('') 
+187              return data 
+188          return _bytes('') 
+
189   
+190 -class LargeFileLike: 
+
191 -    def __init__(self, charlen=100, depth=4, children=5): 
+
192          self.data = BytesIO() 
+193          self.chars  = _bytes('a') * charlen 
+194          self.children = range(children) 
+195          self.more = self.iterelements(depth) 
+
196   
+197 -    def iterelements(self, depth): 
+
198          yield _bytes('<root>') 
+199          depth -= 1 
+200          if depth > 0: 
+201              for child in self.children: 
+202                  for element in self.iterelements(depth): 
+203                      yield element 
+204                  yield self.chars 
+205          else: 
+206              yield self.chars 
+207          yield _bytes('</root>') 
+
208   
+209 -    def read(self, amount=None): 
+
210          data = self.data 
+211          append = data.write 
+212          if amount: 
+213              for element in self.more: 
+214                  append(element) 
+215                  if data.tell() >= amount: 
+216                      break 
+217          else: 
+218              for element in self.more: 
+219                  append(element) 
+220          result = data.getvalue() 
+221          data.seek(0) 
+222          data.truncate() 
+223          if amount: 
+224              append(result[amount:]) 
+225              result = result[:amount] 
+226          return result 
+
227   
+228 -class LargeFileLikeUnicode(LargeFileLike): 
+
229 -    def __init__(self, charlen=100, depth=4, children=5): 
+
230          LargeFileLike.__init__(self, charlen, depth, children) 
+231          self.data = StringIO() 
+232          self.chars  = _str('a') * charlen 
+233          self.more = self.iterelements(depth) 
+
234   
+235 -    def iterelements(self, depth): 
+
236          yield _str('<root>') 
+237          depth -= 1 
+238          if depth > 0: 
+239              for child in self.children: 
+240                  for element in self.iterelements(depth): 
+241                      yield element 
+242                  yield self.chars 
+243          else: 
+244              yield self.chars 
+245          yield _str('</root>') 
+
246   
+247 -def fileInTestDir(name): 
+
248      _testdir = os.path.dirname(__file__) 
+249      return os.path.join(_testdir, name) 
+
250   
+251 -def path2url(path): 
+
252      return urlparse.urljoin( 
+253          'file:', pathname2url(path)) 
+
254   
+255 -def fileUrlInTestDir(name): 
+
256      return path2url(fileInTestDir(name)) 
+
257   
+258 -def read_file(name, mode='r'): 
+
259      with open(name, mode) as f: 
+260          data = f.read() 
+261      return data 
+
262   
+263 -def write_to_file(name, data, mode='w'): 
+
264      with open(name, mode) as f: 
+265          f.write(data) 
+
266   
+267 -def readFileInTestDir(name, mode='r'): 
+
268      return read_file(fileInTestDir(name), mode) 
+
269   
+270 -def canonicalize(xml): 
+
271      tree = etree.parse(BytesIO(xml) if isinstance(xml, bytes) else StringIO(xml)) 
+272      f = BytesIO() 
+273      tree.write_c14n(f) 
+274      return f.getvalue() 
+
275   
+276   
+277  @contextmanager 
+278 -def tmpfile(**kwargs): 
+
279      handle, filename = tempfile.mkstemp(**kwargs) 
+280      try: 
+281          yield filename 
+282      finally: 
+283          os.close(handle) 
+284          os.remove(filename) 
+
285   
+
+            object --+    
+                     |    
+unittest.case.TestCase --+
+                         |
+                        HelperTestCase
+
+LargeFileLike --+
+                |
+               LargeFileLikeUnicode
+
+object --+
+         |
+        skipif
+
+ 1  """ 
+ 2  Simple HTTP request dumper for tests. 
+ 3  """ 
+ 4   
+ 5  import sys 
+ 6  from contextlib import contextmanager 
+ 7   
+ 8  try: 
+ 9      import urlparse 
+10  except ImportError: 
+11      # Python 3 
+12      import urllib.parse as urlparse 
+13   
+14   
+15  @contextmanager 
+16 -def webserver(app, port=0, host=None): 
+
17      """Context manager entry point for the 'with' statement. 
+18   
+19      Pass 0 as port number to dynamically allocate a free port. 
+20   
+21      Usage: 
+22   
+23      with webserver(wsgi_app_function, 8080) as host_url: 
+24          do_ws_calls(host_url) 
+25      """ 
+26      server = build_web_server(app, port, host or '127.0.0.1') 
+27      host, port = server.socket.getsockname() 
+28   
+29      import threading 
+30      thread = threading.Thread(target=server.serve_forever, 
+31                                kwargs={'poll_interval': 0.5}) 
+32      thread.setDaemon(True) 
+33      thread.start() 
+34      try: 
+35          yield 'http://%s:%s/' % (host, port)  # yield control to 'with' body 
+36      finally: 
+37          server.shutdown() 
+38          server.server_close() 
+39      thread.join(timeout=1) 
+
40   
+41   
+42  try: 
+43      from SocketServer import ThreadingMixIn 
+44  except ImportError: 
+45      # Python 3 
+46      from socketserver import ThreadingMixIn 
+47   
+48  import wsgiref.simple_server as wsgiserver 
+49 -class WebServer(wsgiserver.WSGIServer, ThreadingMixIn): 
+
50      """A web server that starts a new thread for each request. 
+51      """ 
+
52   
+53   
+54 -class _RequestHandler(wsgiserver.WSGIRequestHandler): 
+
55 -    def get_stderr(self): 
+
56          # don't write to stderr 
+57          return sys.stdout 
+
58   
+59 -    def log_message(self, format, *args): 
+
60          # message = "wsmock(%s) %s" % (self.address_string(), format % args) 
+61          pass  # don't log messages 
+
62   
+63   
+64 -def build_web_server(app, port, host=None): 
+
65      server = wsgiserver.make_server( 
+66          host or '', port, app, 
+67          server_class=WebServer, 
+68          handler_class=_RequestHandler) 
+69      return server 
+
70   
+71   
+72 -class HTTPRequestCollector(object): 
+
73 -    def __init__(self, response_data, response_code=200, headers=()): 
+
74          self.requests = [] 
+75          self.response_code = response_code 
+76          self.response_data = response_data 
+77          self.headers = list(headers or ()) 
+
78   
+79 -    def __call__(self, environ, start_response): 
+
80          self.requests.append(( 
+81              environ.get('PATH_INFO'), 
+82              urlparse.parse_qsl(environ.get('QUERY_STRING')))) 
+83          start_response('%s OK' % self.response_code, self.headers) 
+84          return [self.response_data] 
+
85   
+
+object --+
+         |
+        HTTPRequestCollector
+
+SocketServer.BaseServer --+            
+                          |            
+     SocketServer.TCPServer --+        
+                              |        
+      BaseHTTPServer.HTTPServer --+    
+                                  |    
+   wsgiref.simple_server.WSGIServer --+
+                                      |
+        SocketServer.ThreadingMixIn --+
+                                      |
+                                     WebServer
+
+SocketServer.BaseRequestHandler --+            
+                                  |            
+  SocketServer.StreamRequestHandler --+        
+                                      |        
+  BaseHTTPServer.BaseHTTPRequestHandler --+    
+                                          |    
+   wsgiref.simple_server.WSGIRequestHandler --+
+                                              |
+                                             _RequestHandler
+
+>>> elem = SAMPLE_XML
+>>> elem.find("tag").tag
+'tag'
+>>> ElementTree.ElementTree(elem).find("tag").tag
+'tag'
+>>> elem.find("section/tag").tag
+'tag'
+>>> ElementTree.ElementTree(elem).find("section/tag").tag
+'tag'
+>>> elem.findtext("tag")
+'text'
+>>> elem.findtext("tog")
+>>> elem.findtext("tog", "default")
+'default'
+>>> ElementTree.ElementTree(elem).findtext("tag")
+'text'
+>>> elem.findtext("section/tag")
+'subtext'
+>>> ElementTree.ElementTree(elem).findtext("section/tag")
+'subtext'
+>>> summarize_list(elem.findall("tag"))
+['tag', 'tag']
+>>> summarize_list(elem.findall("*"))
+['tag', 'tag', 'section']
+>>> summarize_list(elem.findall(".//tag"))
+['tag', 'tag', 'tag']
+>>> summarize_list(elem.findall("section/tag"))
+['tag']
+>>> summarize_list(elem.findall("section//tag"))
+['tag']
+>>> summarize_list(elem.findall("section/*"))
+['tag']
+>>> summarize_list(elem.findall("section//*"))
+['tag']
+>>> summarize_list(elem.findall("section/.//*"))
+['tag']
+>>> summarize_list(elem.findall("*/*"))
+['tag']
+>>> summarize_list(elem.findall("*//*"))
+['tag']
+>>> summarize_list(elem.findall("*/tag"))
+['tag']
+>>> summarize_list(elem.findall("*/./tag"))
+['tag']
+>>> summarize_list(elem.findall("./tag"))
+['tag', 'tag']
+>>> summarize_list(elem.findall(".//tag"))
+['tag', 'tag', 'tag']
+>>> summarize_list(elem.findall("././tag"))
+['tag', 'tag']
+>>> summarize_list(elem.findall(".//tag[@class]"))
+['tag', 'tag', 'tag']
+>>> summarize_list(elem.findall(".//tag[@class='a']"))
+['tag']
+>>> summarize_list(elem.findall(".//tag[@class='b']"))
+['tag', 'tag']
+>>> summarize_list(elem.findall(".//tag[@id]"))
+['tag']
+>>> summarize_list(elem.findall(".//section[tag]"))
+['section']
+>>> summarize_list(elem.findall(".//section[element]"))
+[]
+>>> summarize_list(elem.findall("../tag"))
+[]
+>>> summarize_list(elem.findall("section/../tag"))
+['tag', 'tag']
+>>> summarize_list(ElementTree.ElementTree(elem).findall("./tag"))
+['tag', 'tag']
+>>> summarize_list(ElementTree.ElementTree(elem).findall("/tag"))
+['tag', 'tag']
+>>> elem = SAMPLE_XML
+>>> elem.findall("/tag")
+Traceback (most recent call last):
+SyntaxError: cannot use absolute path on element
+>>> tree = ElementTree.parse("samples/simple.xml")
+>>> normalize_crlf(tree)
+>>> tree.write(stdout())
+<root>
+   <element key="value">text</element>
+   <element>text</element>tail
+   <empty-element/>
+</root>
+>>> tree = ElementTree.parse("samples/simple-ns.xml")
+>>> normalize_crlf(tree)
+>>> tree.write(stdout())
+<root xmlns="http://namespace/">
+   <element key="value">text</element>
+   <element>text</element>tail
+   <empty-element/>
+</root>
+>>> element = ElementTree.XML("<html><body>text</body></html>")
+>>> ElementTree.ElementTree(element).write(stdout())
+<html><body>text</body></html>
+>>> element = ElementTree.fromstring("<html><body>text</body></html>")
+>>> ElementTree.ElementTree(element).write(stdout())
+<html><body>text</body></html>
+>>> print(repr(ElementTree.tostring(element)).lstrip('b'))
+'<html><body>text</body></html>'
+>>> _, ids = ElementTree.XMLID("<html><body>text</body></html>")
+>>> len(ids)
+0
+>>> _, ids = ElementTree.XMLID("<html><body id='body'>text</body></html>")
+>>> len(ids)
+1
+>>> ids["body"].tag
+'body'
+>>> elem = ElementTree.XML("<tag xml:lang='en' />")
+>>> serialize(elem) # 1.1
+'<tag xml:lang="en"/>'
+>>> elem = ElementTree.XML("<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' />")
+>>> serialize(elem) # 2.1
+'<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"/>'
+>>> elem = ElementTree.XML("<html:html xmlns:html='http://www.w3.org/1999/xhtml' />")
+>>> serialize(elem) # 2.2
+'<html:html xmlns:html="http://www.w3.org/1999/xhtml"/>'
+>>> elem = ElementTree.XML("<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope' />")
+>>> serialize(elem) # 2.3
+'<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope"/>'
+>>> elem = ElementTree.Element("{uri}tag")
+>>> serialize(elem) # 1.1
+'<ns0:tag xmlns:ns0="uri"/>'
+>>> elem = ElementTree.Element(ElementTree.QName("{uri}tag"))
+>>> serialize(elem) # 1.2
+'<ns0:tag xmlns:ns0="uri"/>'
+>>> elem = ElementTree.Element(ElementTree.QName("uri", "tag"))
+>>> serialize(elem) # 1.3
+'<ns0:tag xmlns:ns0="uri"/>'
+>>> document = xinclude_loader("C1.xml")
+>>> ElementInclude.include(document, xinclude_loader)
+>>> print(serialize(document)) # C1
+<document>
+  <p>120 Mz is adequate for an average home user.</p>
+  <disclaimer>
+  <p>The opinions represented herein represent those of the individual
+  and should not be interpreted as official policy endorsed by this
+  organization.</p>
+</disclaimer>
+</document>
+>>> document = xinclude_loader("C2.xml")
+>>> ElementInclude.include(document, xinclude_loader)
+>>> print(serialize(document)) # C2
+<document>
+  <p>This document has been accessed
+  324387 times.</p>
+</document>
+>>> document = xinclude_loader("C3.xml")
+>>> ElementInclude.include(document, xinclude_loader)
+>>> print(serialize(document)) # C3
+<document>
+  <p>The following is the source of the "data.xml" resource:</p>
+  <example>&lt;?xml version='1.0'?&gt;
+&lt;data&gt;
+  &lt;item&gt;&lt;![CDATA[Brooks &amp; Shields]]&gt;&lt;/item&gt;
+&lt;/data&gt;
+</example>
+</document>
+ElementTree.XML("""
+<body>
+  <tag class='a'>text</tag>
+  <tag class='b' />
+   <section>
+    <tag class='b' id='inner'>subtext</tag>
+   </section>
+</body>
+...
+
+'''<!DOCTYPE points [
+<!ENTITY % user-entities SYSTEM \'user-entities.xml\'>
+%user-entities;
+]>
+<document>&entity;</document>
+'''
+
+{'C1.xml': '''<?xml version=\'1.0\'?>
+<document xmlns:xi="http://www.w3.org/2001/XInclude">
+  <p>120 Mz is adequate for an average home user.</p>
+  <xi:include href="disclaimer.xml"/>
+</document>
+''',
+ 'C2.xml': '''<?xml version=\'1.0\'?>
+<document xmlns:xi="http://www.w3.org/2001/XInclude">
+...
+
+   1  # $Id: selftest.py 3276 2007-09-12 06:52:30Z fredrik $ 
+   2  # -*- coding: iso-8859-1 -*- 
+   3  # elementtree selftest program 
+   4   
+   5  # this test script uses Python's "doctest" module to check that the 
+   6  # *test script* works as expected. 
+   7   
+   8  # TODO: add more elementtree method tests 
+   9  # TODO: add xml/html parsing tests 
+  10  # TODO: etc 
+  11   
+  12  import re, sys 
+  13   
+  14 -def stdout(): 
+
  15      if sys.version_info[0] < 3: 
+  16          return sys.stdout 
+  17      class bytes_stdout(object): 
+  18          def write(self, data): 
+  19              if isinstance(data, bytes): 
+  20                  data = data.decode('ISO8859-1') 
+  21              sys.stdout.write(data) 
+
  22      return bytes_stdout() 
+  23   
+  24  try: 
+  25      from StringIO import StringIO as BytesIO 
+  26  except ImportError: 
+  27      from io import BytesIO 
+  28   
+  29  from lxml import etree as ElementTree 
+  30  from lxml import _elementpath as ElementPath 
+  31  from lxml import ElementInclude 
+  32  ET = ElementTree 
+  33   
+  34  #from elementtree import ElementTree 
+  35  #from elementtree import ElementPath 
+  36  #from elementtree import ElementInclude 
+  37  #from elementtree import HTMLTreeBuilder 
+  38  #from elementtree import SimpleXMLWriter 
+  39   
+  40 -def fix_compatibility(xml_data): 
+
  41      xml_data = re.sub(r'\s*xmlns:[a-z0-9]+="http://www.w3.org/2001/XInclude"', '', xml_data) 
+  42      xml_data = xml_data.replace(' />', '/>') 
+  43      if xml_data[-1:] == '\n': 
+  44          xml_data = xml_data[:-1] 
+  45      return xml_data 
+
  46   
+  47 -def serialize(elem, **options): 
+
  48      file = BytesIO() 
+  49      tree = ElementTree.ElementTree(elem) 
+  50      tree.write(file, **options) 
+  51      if sys.version_info[0] < 3: 
+  52          try: 
+  53              encoding = options["encoding"] 
+  54          except KeyError: 
+  55              encoding = "utf-8" 
+  56      else: 
+  57          encoding = 'ISO8859-1' 
+  58      result = fix_compatibility(file.getvalue().decode(encoding)) 
+  59      if sys.version_info[0] < 3: 
+  60          result = result.encode(encoding) 
+  61      return result 
+
  62   
+  63 -def summarize(elem): 
+
  64      return elem.tag 
+
  65   
+  66 -def summarize_list(seq): 
+
  67      return list(map(summarize, seq)) 
+
  68   
+  69 -def normalize_crlf(tree): 
+
  70      for elem in tree.getiterator(): 
+  71          if elem.text: elem.text = elem.text.replace("\r\n", "\n") 
+  72          if elem.tail: elem.tail = elem.tail.replace("\r\n", "\n") 
+
  73   
+  74  SAMPLE_XML = ElementTree.XML(""" 
+  75  <body> 
+  76    <tag class='a'>text</tag> 
+  77    <tag class='b' /> 
+  78     <section> 
+  79      <tag class='b' id='inner'>subtext</tag> 
+  80     </section> 
+  81  </body> 
+  82  """) 
+  83   
+  84  # 
+  85  # interface tests 
+  86   
+  87 -def check_string(string): 
+
  88      len(string) 
+  89      for char in string: 
+  90          if len(char) != 1: 
+  91              print("expected one-character string, got %r" % char) 
+  92      new_string = string + "" 
+  93      new_string = string + " " 
+  94      string[:0] 
+
  95   
+  96 -def check_string_or_none(value): 
+
  97      if value is None: 
+  98          return 
+  99      return check_string(value) 
+
 100   
+ 101 -def check_mapping(mapping): 
+
 102      len(mapping) 
+ 103      keys = mapping.keys() 
+ 104      items = mapping.items() 
+ 105      for key in keys: 
+ 106          item = mapping[key] 
+ 107      mapping["key"] = "value" 
+ 108      if mapping["key"] != "value": 
+ 109          print("expected value string, got %r" % mapping["key"]) 
+
 110   
+ 111 -def check_element(element): 
+
 112      if not hasattr(element, "tag"): 
+ 113          print("no tag member") 
+ 114      if not hasattr(element, "attrib"): 
+ 115          print("no attrib member") 
+ 116      if not hasattr(element, "text"): 
+ 117          print("no text member") 
+ 118      if not hasattr(element, "tail"): 
+ 119          print("no tail member") 
+ 120      check_string(element.tag) 
+ 121      check_mapping(element.attrib) 
+ 122      check_string_or_none(element.text) 
+ 123      check_string_or_none(element.tail) 
+ 124      for elem in element: 
+ 125          check_element(elem) 
+
 126   
+ 127 -def check_element_tree(tree): 
+
 128      check_element(tree.getroot()) 
+
 129   
+ 130  # -------------------------------------------------------------------- 
+ 131  # element tree tests 
+ 132   
+ 133 -def sanity(): 
+
 134      """ 
+ 135      >>> from elementtree.ElementTree import * 
+ 136      >>> from elementtree.ElementInclude import * 
+ 137      >>> from elementtree.ElementPath import * 
+ 138      >>> from elementtree.HTMLTreeBuilder import * 
+ 139      >>> from elementtree.SimpleXMLWriter import * 
+ 140      >>> from elementtree.TidyTools import * 
+ 141      """ 
+
 142   
+ 143  # doesn't work with lxml.etree 
+ 144  del sanity 
+ 145   
+ 146 -def version(): 
+
 147      """ 
+ 148      >>> ElementTree.VERSION 
+ 149      '1.3a2' 
+ 150      """ 
+
 151   
+ 152  # doesn't work with lxml.etree 
+ 153  del version 
+ 154   
+ 155 -def interface(): 
+
 156      """ 
+ 157      Test element tree interface. 
+ 158   
+ 159      >>> element = ElementTree.Element("tag") 
+ 160      >>> check_element(element) 
+ 161      >>> tree = ElementTree.ElementTree(element) 
+ 162      >>> check_element_tree(tree) 
+ 163      """ 
+
 164   
+ 165 -def simpleops(): 
+
 166      """ 
+ 167      >>> elem = ElementTree.XML("<body><tag/></body>") 
+ 168      >>> serialize(elem) 
+ 169      '<body><tag/></body>' 
+ 170      >>> e = ElementTree.Element("tag2") 
+ 171      >>> elem.append(e) 
+ 172      >>> serialize(elem) 
+ 173      '<body><tag/><tag2/></body>' 
+ 174      >>> elem.remove(e) 
+ 175      >>> serialize(elem) 
+ 176      '<body><tag/></body>' 
+ 177      >>> elem.insert(0, e) 
+ 178      >>> serialize(elem) 
+ 179      '<body><tag2/><tag/></body>' 
+ 180      >>> elem.remove(e) 
+ 181      >>> elem.extend([e]) 
+ 182      >>> serialize(elem) 
+ 183      '<body><tag/><tag2/></body>' 
+ 184      >>> elem.remove(e) 
+ 185      """ 
+
 186   
+ 187 -def simplefind(): 
+
 188      """ 
+ 189      Test find methods using the elementpath fallback. 
+ 190   
+ 191      >>> CurrentElementPath = ElementTree.ElementPath 
+ 192      >>> ElementTree.ElementPath = ElementTree._SimpleElementPath() 
+ 193      >>> elem = SAMPLE_XML 
+ 194      >>> elem.find("tag").tag 
+ 195      'tag' 
+ 196      >>> ElementTree.ElementTree(elem).find("tag").tag 
+ 197      'tag' 
+ 198      >>> elem.findtext("tag") 
+ 199      'text' 
+ 200      >>> elem.findtext("tog") 
+ 201      >>> elem.findtext("tog", "default") 
+ 202      'default' 
+ 203      >>> ElementTree.ElementTree(elem).findtext("tag") 
+ 204      'text' 
+ 205      >>> summarize_list(elem.findall("tag")) 
+ 206      ['tag', 'tag'] 
+ 207      >>> summarize_list(elem.findall(".//tag")) 
+ 208      ['tag', 'tag', 'tag'] 
+ 209   
+ 210      Path syntax doesn't work in this case. 
+ 211   
+ 212      >>> elem.find("section/tag") 
+ 213      >>> elem.findtext("section/tag") 
+ 214      >>> elem.findall("section/tag") 
+ 215      [] 
+ 216   
+ 217      >>> ElementTree.ElementPath = CurrentElementPath 
+ 218      """ 
+
 219   
+ 220  # doesn't work with lxml.etree 
+ 221  del simplefind 
+ 222   
+ 223 -def find(): 
+
 224      """ 
+ 225      Test find methods (including xpath syntax). 
+ 226   
+ 227      >>> elem = SAMPLE_XML 
+ 228      >>> elem.find("tag").tag 
+ 229      'tag' 
+ 230      >>> ElementTree.ElementTree(elem).find("tag").tag 
+ 231      'tag' 
+ 232      >>> elem.find("section/tag").tag 
+ 233      'tag' 
+ 234      >>> ElementTree.ElementTree(elem).find("section/tag").tag 
+ 235      'tag' 
+ 236      >>> elem.findtext("tag") 
+ 237      'text' 
+ 238      >>> elem.findtext("tog") 
+ 239      >>> elem.findtext("tog", "default") 
+ 240      'default' 
+ 241      >>> ElementTree.ElementTree(elem).findtext("tag") 
+ 242      'text' 
+ 243      >>> elem.findtext("section/tag") 
+ 244      'subtext' 
+ 245      >>> ElementTree.ElementTree(elem).findtext("section/tag") 
+ 246      'subtext' 
+ 247      >>> summarize_list(elem.findall("tag")) 
+ 248      ['tag', 'tag'] 
+ 249      >>> summarize_list(elem.findall("*")) 
+ 250      ['tag', 'tag', 'section'] 
+ 251      >>> summarize_list(elem.findall(".//tag")) 
+ 252      ['tag', 'tag', 'tag'] 
+ 253      >>> summarize_list(elem.findall("section/tag")) 
+ 254      ['tag'] 
+ 255      >>> summarize_list(elem.findall("section//tag")) 
+ 256      ['tag'] 
+ 257      >>> summarize_list(elem.findall("section/*")) 
+ 258      ['tag'] 
+ 259      >>> summarize_list(elem.findall("section//*")) 
+ 260      ['tag'] 
+ 261      >>> summarize_list(elem.findall("section/.//*")) 
+ 262      ['tag'] 
+ 263      >>> summarize_list(elem.findall("*/*")) 
+ 264      ['tag'] 
+ 265      >>> summarize_list(elem.findall("*//*")) 
+ 266      ['tag'] 
+ 267      >>> summarize_list(elem.findall("*/tag")) 
+ 268      ['tag'] 
+ 269      >>> summarize_list(elem.findall("*/./tag")) 
+ 270      ['tag'] 
+ 271      >>> summarize_list(elem.findall("./tag")) 
+ 272      ['tag', 'tag'] 
+ 273      >>> summarize_list(elem.findall(".//tag")) 
+ 274      ['tag', 'tag', 'tag'] 
+ 275      >>> summarize_list(elem.findall("././tag")) 
+ 276      ['tag', 'tag'] 
+ 277      >>> summarize_list(elem.findall(".//tag[@class]")) 
+ 278      ['tag', 'tag', 'tag'] 
+ 279      >>> summarize_list(elem.findall(".//tag[@class='a']")) 
+ 280      ['tag'] 
+ 281      >>> summarize_list(elem.findall(".//tag[@class='b']")) 
+ 282      ['tag', 'tag'] 
+ 283      >>> summarize_list(elem.findall(".//tag[@id]")) 
+ 284      ['tag'] 
+ 285      >>> summarize_list(elem.findall(".//section[tag]")) 
+ 286      ['section'] 
+ 287      >>> summarize_list(elem.findall(".//section[element]")) 
+ 288      [] 
+ 289      >>> summarize_list(elem.findall("../tag")) 
+ 290      [] 
+ 291      >>> summarize_list(elem.findall("section/../tag")) 
+ 292      ['tag', 'tag'] 
+ 293      >>> summarize_list(ElementTree.ElementTree(elem).findall("./tag")) 
+ 294      ['tag', 'tag'] 
+ 295   
+ 296      FIXME: ET's Path module handles this case incorrectly; this gives 
+ 297      a warning in 1.3, and the behaviour will be modified in 1.4. 
+ 298   
+ 299      >>> summarize_list(ElementTree.ElementTree(elem).findall("/tag")) 
+ 300      ['tag', 'tag'] 
+ 301      """ 
+
 302   
+ 303 -def bad_find(): 
+
 304      """ 
+ 305      Check bad or unsupported path expressions. 
+ 306   
+ 307      >>> elem = SAMPLE_XML 
+ 308      >>> elem.findall("/tag") 
+ 309      Traceback (most recent call last): 
+ 310      SyntaxError: cannot use absolute path on element 
+ 311   
+ 312      # this is supported in ET 1.3: 
+ 313      #>>> elem.findall("section//") 
+ 314      #Traceback (most recent call last): 
+ 315      #SyntaxError: invalid path 
+ 316      """ 
+
 317   
+ 318 -def parsefile(): 
+
 319      """ 
+ 320      Test parsing from file. 
+ 321   
+ 322      >>> tree = ElementTree.parse("samples/simple.xml") 
+ 323      >>> normalize_crlf(tree) 
+ 324      >>> tree.write(stdout()) 
+ 325      <root> 
+ 326         <element key="value">text</element> 
+ 327         <element>text</element>tail 
+ 328         <empty-element/> 
+ 329      </root> 
+ 330      >>> tree = ElementTree.parse("samples/simple-ns.xml") 
+ 331      >>> normalize_crlf(tree) 
+ 332      >>> tree.write(stdout()) 
+ 333      <root xmlns="http://namespace/"> 
+ 334         <element key="value">text</element> 
+ 335         <element>text</element>tail 
+ 336         <empty-element/> 
+ 337      </root> 
+ 338   
+ 339  ##     <ns0:root xmlns:ns0="http://namespace/"> 
+ 340  ##        <ns0:element key="value">text</ns0:element> 
+ 341  ##        <ns0:element>text</ns0:element>tail 
+ 342  ##        <ns0:empty-element/> 
+ 343  ##     </ns0:root> 
+ 344      """ 
+
 345   
+ 346 -def parsehtml(): 
+
 347      """ 
+ 348      Test HTML parsing. 
+ 349   
+ 350      >>> # p = HTMLTreeBuilder.TreeBuilder() 
+ 351      >>> p = ElementTree.HTMLParser() 
+ 352      >>> p.feed("<p><p>spam<b>egg</b></p>") 
+ 353      >>> serialize(p.close()) 
+ 354      '<p>spam<b>egg</b></p>' 
+ 355      """ 
+
 356   
+ 357  # doesn't work with lxml.etree 
+ 358  del parsehtml 
+ 359   
+ 360 -def parseliteral(): 
+
 361      r""" 
+ 362      >>> element = ElementTree.XML("<html><body>text</body></html>") 
+ 363      >>> ElementTree.ElementTree(element).write(stdout()) 
+ 364      <html><body>text</body></html> 
+ 365      >>> element = ElementTree.fromstring("<html><body>text</body></html>") 
+ 366      >>> ElementTree.ElementTree(element).write(stdout()) 
+ 367      <html><body>text</body></html> 
+ 368   
+ 369  ##     >>> sequence = ["<html><body>", "text</bo", "dy></html>"] 
+ 370  ##     >>> element = ElementTree.fromstringlist(sequence) 
+ 371  ##     >>> ElementTree.ElementTree(element).write(stdout()) 
+ 372  ##     <html><body>text</body></html> 
+ 373   
+ 374      >>> print(repr(ElementTree.tostring(element)).lstrip('b')) 
+ 375      '<html><body>text</body></html>' 
+ 376   
+ 377  # looks different in lxml 
+ 378  #    >>> print(ElementTree.tostring(element, "ascii")) 
+ 379  #    <?xml version='1.0' encoding='ascii'?> 
+ 380  #    <html><body>text</body></html> 
+ 381   
+ 382      >>> _, ids = ElementTree.XMLID("<html><body>text</body></html>") 
+ 383      >>> len(ids) 
+ 384      0 
+ 385      >>> _, ids = ElementTree.XMLID("<html><body id='body'>text</body></html>") 
+ 386      >>> len(ids) 
+ 387      1 
+ 388      >>> ids["body"].tag 
+ 389      'body' 
+ 390      """ 
+
 391   
+ 392 -def simpleparsefile(): 
+
 393      """ 
+ 394      Test the xmllib-based parser. 
+ 395   
+ 396      >>> from elementtree import SimpleXMLTreeBuilder 
+ 397      >>> parser = SimpleXMLTreeBuilder.TreeBuilder() 
+ 398      >>> tree = ElementTree.parse("samples/simple.xml", parser) 
+ 399      >>> normalize_crlf(tree) 
+ 400      >>> tree.write(sys.stdout) 
+ 401      <root> 
+ 402         <element key="value">text</element> 
+ 403         <element>text</element>tail 
+ 404         <empty-element /> 
+ 405      </root> 
+ 406      """ 
+
 407   
+ 408  # doesn't work with lxml.etree 
+ 409  del simpleparsefile 
+ 410   
+ 411 -def iterparse(): 
+
 412      """ 
+ 413      Test iterparse interface. 
+ 414   
+ 415      >>> iterparse = ElementTree.iterparse 
+ 416   
+ 417      >>> context = iterparse("samples/simple.xml") 
+ 418      >>> for action, elem in context: 
+ 419      ...   print("%s %s" % (action, elem.tag)) 
+ 420      end element 
+ 421      end element 
+ 422      end empty-element 
+ 423      end root 
+ 424      >>> context.root.tag 
+ 425      'root' 
+ 426   
+ 427      >>> context = iterparse("samples/simple-ns.xml") 
+ 428      >>> for action, elem in context: 
+ 429      ...   print("%s %s" % (action, elem.tag)) 
+ 430      end {http://namespace/}element 
+ 431      end {http://namespace/}element 
+ 432      end {http://namespace/}empty-element 
+ 433      end {http://namespace/}root 
+ 434   
+ 435      >>> events = () 
+ 436      >>> context = iterparse("samples/simple.xml", events) 
+ 437      >>> for action, elem in context: 
+ 438      ...   print("%s %s" % (action, elem.tag)) 
+ 439   
+ 440      >>> events = () 
+ 441      >>> context = iterparse("samples/simple.xml", events=events) 
+ 442      >>> for action, elem in context: 
+ 443      ...   print("%s %s" % (action, elem.tag)) 
+ 444   
+ 445      >>> events = ("start", "end") 
+ 446      >>> context = iterparse("samples/simple.xml", events) 
+ 447      >>> for action, elem in context: 
+ 448      ...   print("%s %s" % (action, elem.tag)) 
+ 449      start root 
+ 450      start element 
+ 451      end element 
+ 452      start element 
+ 453      end element 
+ 454      start empty-element 
+ 455      end empty-element 
+ 456      end root 
+ 457   
+ 458      >>> events = ("start", "end", "start-ns", "end-ns") 
+ 459      >>> context = iterparse("samples/simple-ns.xml", events) 
+ 460      >>> for action, elem in context: 
+ 461      ...   if action in ("start", "end"): 
+ 462      ...     print("%s %s" % (action, elem.tag)) 
+ 463      ...   else: 
+ 464      ...     print("%s %s" % (action, elem)) 
+ 465      start-ns ('', 'http://namespace/') 
+ 466      start {http://namespace/}root 
+ 467      start {http://namespace/}element 
+ 468      end {http://namespace/}element 
+ 469      start {http://namespace/}element 
+ 470      end {http://namespace/}element 
+ 471      start {http://namespace/}empty-element 
+ 472      end {http://namespace/}empty-element 
+ 473      end {http://namespace/}root 
+ 474      end-ns None 
+ 475   
+ 476      """ 
+
 477   
+ 478 -def fancyparsefile(): 
+
 479      """ 
+ 480      Test the "fancy" parser. 
+ 481   
+ 482      Sanity check. 
+ 483      >>> from elementtree import XMLTreeBuilder 
+ 484      >>> parser = XMLTreeBuilder.FancyTreeBuilder() 
+ 485      >>> tree = ElementTree.parse("samples/simple.xml", parser) 
+ 486      >>> normalize_crlf(tree) 
+ 487      >>> tree.write(sys.stdout) 
+ 488      <root> 
+ 489         <element key="value">text</element> 
+ 490         <element>text</element>tail 
+ 491         <empty-element /> 
+ 492      </root> 
+ 493   
+ 494      Callback check. 
+ 495      >>> class MyFancyParser(XMLTreeBuilder.FancyTreeBuilder): 
+ 496      ...     def start(self, elem): 
+ 497      ...         print("START %s" % elem.tag) 
+ 498      ...     def end(self, elem): 
+ 499      ...         print("END %s" % elem.tag) 
+ 500      >>> parser = MyFancyParser() 
+ 501      >>> tree = ElementTree.parse("samples/simple.xml", parser) 
+ 502      START root 
+ 503      START element 
+ 504      END element 
+ 505      START element 
+ 506      END element 
+ 507      START empty-element 
+ 508      END empty-element 
+ 509      END root 
+ 510      """ 
+
 511   
+ 512  # doesn't work with lxml.etree 
+ 513  del fancyparsefile 
+ 514   
+ 515 -def writefile(): 
+
 516      """ 
+ 517      >>> elem = ElementTree.Element("tag") 
+ 518      >>> elem.text = "text" 
+ 519      >>> serialize(elem) 
+ 520      '<tag>text</tag>' 
+ 521      >>> ElementTree.SubElement(elem, "subtag").text = "subtext" 
+ 522      >>> serialize(elem) 
+ 523      '<tag>text<subtag>subtext</subtag></tag>' 
+ 524   
+ 525  ##     Test tag suppression 
+ 526  ##     >>> elem.tag = None 
+ 527  ##     >>> serialize(elem) 
+ 528  ##     'text<subtag>subtext</subtag>' 
+ 529      """ 
+
 530   
+ 531 -def writestring(): 
+
 532      """ 
+ 533      >>> elem = ElementTree.XML("<html><body>text</body></html>") 
+ 534      >>> print(repr(ElementTree.tostring(elem)).lstrip('b')) 
+ 535      '<html><body>text</body></html>' 
+ 536      >>> elem = ElementTree.fromstring("<html><body>text</body></html>") 
+ 537      >>> print(repr(ElementTree.tostring(elem)).lstrip('b')) 
+ 538      '<html><body>text</body></html>' 
+ 539      """ 
+
 540   
+ 541 -def encoding(): 
+
 542      r""" 
+ 543      Test encoding issues. 
+ 544   
+ 545      >>> elem = ElementTree.Element("tag") 
+ 546      >>> elem.text = u'abc' 
+ 547      >>> serialize(elem) 
+ 548      '<tag>abc</tag>' 
+ 549      >>> serialize(elem, encoding="utf-8") 
+ 550      '<tag>abc</tag>' 
+ 551      >>> serialize(elem, encoding="us-ascii") 
+ 552      '<tag>abc</tag>' 
+ 553      >>> serialize(elem, encoding="iso-8859-1").lower() 
+ 554      "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>abc</tag>" 
+ 555   
+ 556      >>> elem.text = "<&\"\'>" 
+ 557      >>> serialize(elem) 
+ 558      '<tag>&lt;&amp;"\'&gt;</tag>' 
+ 559      >>> serialize(elem, encoding="utf-8") 
+ 560      '<tag>&lt;&amp;"\'&gt;</tag>' 
+ 561      >>> serialize(elem, encoding="us-ascii") # cdata characters 
+ 562      '<tag>&lt;&amp;"\'&gt;</tag>' 
+ 563      >>> serialize(elem, encoding="iso-8859-1").lower() 
+ 564      '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag>&lt;&amp;"\'&gt;</tag>' 
+ 565   
+ 566      >>> elem.attrib["key"] = "<&\"\'>" 
+ 567      >>> elem.text = None 
+ 568      >>> serialize(elem) 
+ 569      '<tag key="&lt;&amp;&quot;\'&gt;"/>' 
+ 570      >>> serialize(elem, encoding="utf-8") 
+ 571      '<tag key="&lt;&amp;&quot;\'&gt;"/>' 
+ 572      >>> serialize(elem, encoding="us-ascii") 
+ 573      '<tag key="&lt;&amp;&quot;\'&gt;"/>' 
+ 574      >>> serialize(elem, encoding="iso-8859-1").lower() 
+ 575      '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="&lt;&amp;&quot;\'&gt;"/>' 
+ 576   
+ 577      >>> elem.text = u'\xe5\xf6\xf6<>' 
+ 578      >>> elem.attrib.clear() 
+ 579      >>> serialize(elem) 
+ 580      '<tag>&#229;&#246;&#246;&lt;&gt;</tag>' 
+ 581      >>> serialize(elem, encoding="utf-8") 
+ 582      '<tag>\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;</tag>' 
+ 583      >>> serialize(elem, encoding="us-ascii") 
+ 584      '<tag>&#229;&#246;&#246;&lt;&gt;</tag>' 
+ 585      >>> serialize(elem, encoding="iso-8859-1").lower() 
+ 586      "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>\xe5\xf6\xf6&lt;&gt;</tag>" 
+ 587   
+ 588      >>> elem.attrib["key"] = u'\xe5\xf6\xf6<>' 
+ 589      >>> elem.text = None 
+ 590      >>> serialize(elem) 
+ 591      '<tag key="&#229;&#246;&#246;&lt;&gt;"/>' 
+ 592      >>> serialize(elem, encoding="utf-8") 
+ 593      '<tag key="\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;"/>' 
+ 594      >>> serialize(elem, encoding="us-ascii") 
+ 595      '<tag key="&#229;&#246;&#246;&lt;&gt;"/>' 
+ 596      >>> serialize(elem, encoding="iso-8859-1").lower() 
+ 597      '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="\xe5\xf6\xf6&lt;&gt;"/>' 
+ 598      """ 
+
 599   
+ 600  if sys.version_info[0] >= 3: 
+ 601      encoding.__doc__ = encoding.__doc__.replace("u'", "'") 
+ 602   
+ 603 -def methods(): 
+
 604      r""" 
+ 605      Test serialization methods. 
+ 606   
+ 607      >>> e = ET.XML("<html><link/><script>1 &lt; 2</script></html>") 
+ 608      >>> e.tail = "\n" 
+ 609      >>> serialize(e) 
+ 610      '<html><link /><script>1 &lt; 2</script></html>\n' 
+ 611      >>> serialize(e, method=None) 
+ 612      '<html><link /><script>1 &lt; 2</script></html>\n' 
+ 613      >>> serialize(e, method="xml") 
+ 614      '<html><link /><script>1 &lt; 2</script></html>\n' 
+ 615      >>> serialize(e, method="html") 
+ 616      '<html><link><script>1 < 2</script></html>\n' 
+ 617      >>> serialize(e, method="text") 
+ 618      '1 < 2\n' 
+ 619   
+ 620      """ 
+
 621   
+ 622  # doesn't work with lxml.etree 
+ 623  del methods 
+ 624   
+ 625 -def iterators(): 
+
 626      """ 
+ 627      Test iterators. 
+ 628   
+ 629      >>> e = ET.XML("<html><body>this is a <i>paragraph</i>.</body>..</html>") 
+ 630      >>> summarize_list(e.iter()) 
+ 631      ['html', 'body', 'i'] 
+ 632      >>> summarize_list(e.find("body").iter()) 
+ 633      ['body', 'i'] 
+ 634      >>> "".join(e.itertext()) 
+ 635      'this is a paragraph...' 
+ 636      >>> "".join(e.find("body").itertext()) 
+ 637      'this is a paragraph.' 
+ 638      """ 
+
 639   
+ 640  ENTITY_XML = """\ 
+ 641  <!DOCTYPE points [ 
+ 642  <!ENTITY % user-entities SYSTEM 'user-entities.xml'> 
+ 643  %user-entities; 
+ 644  ]> 
+ 645  <document>&entity;</document> 
+ 646  """ 
+ 647   
+ 648 -def entity(): 
+
 649      """ 
+ 650      Test entity handling. 
+ 651   
+ 652      1) bad entities 
+ 653   
+ 654      >>> ElementTree.XML("<document>&entity;</document>") 
+ 655      Traceback (most recent call last): 
+ 656      ExpatError: undefined entity: line 1, column 10 
+ 657   
+ 658      >>> ElementTree.XML(ENTITY_XML) 
+ 659      Traceback (most recent call last): 
+ 660      ExpatError: undefined entity &entity;: line 5, column 10 
+ 661   
+ 662      (add more tests here) 
+ 663   
+ 664      """ 
+
 665   
+ 666  # doesn't work with lxml.etree 
+ 667  del entity 
+ 668   
+ 669 -def error(xml): 
+
 670      """ 
+ 671      Test error handling. 
+ 672   
+ 673      >>> error("foo").position 
+ 674      (1, 0) 
+ 675      >>> error("<tag>&foo;</tag>").position 
+ 676      (1, 5) 
+ 677      >>> error("foobar<").position 
+ 678      (1, 6) 
+ 679   
+ 680      """ 
+ 681      try: 
+ 682          ET.XML(xml) 
+ 683      except ET.ParseError: 
+ 684          return sys.exc_value 
+
 685   
+ 686  # doesn't work with lxml.etree -> different positions 
+ 687  del error 
+ 688   
+ 689 -def namespace(): 
+
 690      """ 
+ 691      Test namespace issues. 
+ 692   
+ 693      1) xml namespace 
+ 694   
+ 695      >>> elem = ElementTree.XML("<tag xml:lang='en' />") 
+ 696      >>> serialize(elem) # 1.1 
+ 697      '<tag xml:lang="en"/>' 
+ 698   
+ 699      2) other "well-known" namespaces 
+ 700   
+ 701      >>> elem = ElementTree.XML("<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' />") 
+ 702      >>> serialize(elem) # 2.1 
+ 703      '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"/>' 
+ 704   
+ 705      >>> elem = ElementTree.XML("<html:html xmlns:html='http://www.w3.org/1999/xhtml' />") 
+ 706      >>> serialize(elem) # 2.2 
+ 707      '<html:html xmlns:html="http://www.w3.org/1999/xhtml"/>' 
+ 708   
+ 709      >>> elem = ElementTree.XML("<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope' />") 
+ 710      >>> serialize(elem) # 2.3 
+ 711      '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope"/>' 
+ 712   
+ 713      3) unknown namespaces 
+ 714   
+ 715      """ 
+
 716   
+ 717 -def qname(): 
+
 718      """ 
+ 719      Test QName handling. 
+ 720   
+ 721      1) decorated tags 
+ 722   
+ 723      >>> elem = ElementTree.Element("{uri}tag") 
+ 724      >>> serialize(elem) # 1.1 
+ 725      '<ns0:tag xmlns:ns0="uri"/>' 
+ 726      >>> elem = ElementTree.Element(ElementTree.QName("{uri}tag")) 
+ 727      >>> serialize(elem) # 1.2 
+ 728      '<ns0:tag xmlns:ns0="uri"/>' 
+ 729      >>> elem = ElementTree.Element(ElementTree.QName("uri", "tag")) 
+ 730      >>> serialize(elem) # 1.3 
+ 731      '<ns0:tag xmlns:ns0="uri"/>' 
+ 732   
+ 733  # ns/attribute order ... 
+ 734   
+ 735  ##     2) decorated attributes 
+ 736   
+ 737  ##     >>> elem.clear() 
+ 738  ##     >>> elem.attrib["{uri}key"] = "value" 
+ 739  ##     >>> serialize(elem) # 2.1 
+ 740  ##     '<ns0:tag ns0:key="value" xmlns:ns0="uri"/>' 
+ 741   
+ 742  ##     >>> elem.clear() 
+ 743  ##     >>> elem.attrib[ElementTree.QName("{uri}key")] = "value" 
+ 744  ##     >>> serialize(elem) # 2.2 
+ 745  ##     '<ns0:tag ns0:key="value" xmlns:ns0="uri"/>' 
+ 746   
+ 747  ##     3) decorated values are not converted by default, but the 
+ 748  ##        QName wrapper can be used for values 
+ 749   
+ 750  ##     >>> elem.clear() 
+ 751  ##     >>> elem.attrib["{uri}key"] = "{uri}value" 
+ 752  ##     >>> serialize(elem) # 3.1 
+ 753  ##     '<ns0:tag ns0:key="{uri}value" xmlns:ns0="uri"/>' 
+ 754   
+ 755  ##     >>> elem.clear() 
+ 756  ##     >>> elem.attrib["{uri}key"] = ElementTree.QName("{uri}value") 
+ 757  ##     >>> serialize(elem) # 3.2 
+ 758  ##     '<ns0:tag ns0:key="ns0:value" xmlns:ns0="uri"/>' 
+ 759   
+ 760  ##     >>> elem.clear() 
+ 761  ##     >>> subelem = ElementTree.Element("tag") 
+ 762  ##     >>> subelem.attrib["{uri1}key"] = ElementTree.QName("{uri2}value") 
+ 763  ##     >>> elem.append(subelem) 
+ 764  ##     >>> elem.append(subelem) 
+ 765  ##     >>> serialize(elem) # 3.3 
+ 766  ##     '<ns0:tag xmlns:ns0="uri"><tag ns1:key="ns2:value" xmlns:ns1="uri1" xmlns:ns2="uri2"/><tag ns1:key="ns2:value" xmlns:ns1="uri1" xmlns:ns2="uri2"/></ns0:tag>' 
+ 767   
+ 768      """ 
+
 769   
+ 770 -def xpath_tokenizer(p): 
+
 771      """ 
+ 772      Test the XPath tokenizer. 
+ 773   
+ 774      >>> # tests from the xml specification 
+ 775      >>> xpath_tokenizer("*") 
+ 776      ['*'] 
+ 777      >>> xpath_tokenizer("text()") 
+ 778      ['text', '()'] 
+ 779      >>> xpath_tokenizer("@name") 
+ 780      ['@', 'name'] 
+ 781      >>> xpath_tokenizer("@*") 
+ 782      ['@', '*'] 
+ 783      >>> xpath_tokenizer("para[1]") 
+ 784      ['para', '[', '1', ']'] 
+ 785      >>> xpath_tokenizer("para[last()]") 
+ 786      ['para', '[', 'last', '()', ']'] 
+ 787      >>> xpath_tokenizer("*/para") 
+ 788      ['*', '/', 'para'] 
+ 789      >>> xpath_tokenizer("/doc/chapter[5]/section[2]") 
+ 790      ['/', 'doc', '/', 'chapter', '[', '5', ']', '/', 'section', '[', '2', ']'] 
+ 791      >>> xpath_tokenizer("chapter//para") 
+ 792      ['chapter', '//', 'para'] 
+ 793      >>> xpath_tokenizer("//para") 
+ 794      ['//', 'para'] 
+ 795      >>> xpath_tokenizer("//olist/item") 
+ 796      ['//', 'olist', '/', 'item'] 
+ 797      >>> xpath_tokenizer(".") 
+ 798      ['.'] 
+ 799      >>> xpath_tokenizer(".//para") 
+ 800      ['.', '//', 'para'] 
+ 801      >>> xpath_tokenizer("..") 
+ 802      ['..'] 
+ 803      >>> xpath_tokenizer("../@lang") 
+ 804      ['..', '/', '@', 'lang'] 
+ 805      >>> xpath_tokenizer("chapter[title]") 
+ 806      ['chapter', '[', 'title', ']'] 
+ 807      >>> xpath_tokenizer("employee[@secretary and @assistant]") 
+ 808      ['employee', '[', '@', 'secretary', '', 'and', '', '@', 'assistant', ']'] 
+ 809   
+ 810      >>> # additional tests 
+ 811      >>> xpath_tokenizer("{http://spam}egg") 
+ 812      ['{http://spam}egg'] 
+ 813      >>> xpath_tokenizer("./spam.egg") 
+ 814      ['.', '/', 'spam.egg'] 
+ 815      >>> xpath_tokenizer(".//{http://spam}egg") 
+ 816      ['.', '//', '{http://spam}egg'] 
+ 817      """ 
+ 818      out = [] 
+ 819      for op, tag in ElementPath.xpath_tokenizer(p): 
+ 820          out.append(op or tag) 
+ 821      return out 
+
 822   
+ 823  # 
+ 824  # xinclude tests (samples from appendix C of the xinclude specification) 
+ 825   
+ 826  XINCLUDE = { 
+ 827      "C1.xml": """\ 
+ 828  <?xml version='1.0'?> 
+ 829  <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+ 830    <p>120 Mz is adequate for an average home user.</p> 
+ 831    <xi:include href="disclaimer.xml"/> 
+ 832  </document> 
+ 833  """, "disclaimer.xml": """\ 
+ 834  <?xml version='1.0'?> 
+ 835  <disclaimer> 
+ 836    <p>The opinions represented herein represent those of the individual 
+ 837    and should not be interpreted as official policy endorsed by this 
+ 838    organization.</p> 
+ 839  </disclaimer> 
+ 840  """, 
+ 841      "C2.xml": """\ 
+ 842  <?xml version='1.0'?> 
+ 843  <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+ 844    <p>This document has been accessed 
+ 845    <xi:include href="count.txt" parse="text"/> times.</p> 
+ 846  </document> 
+ 847  """, "count.txt": "324387", "C3.xml": """\ 
+ 848  <?xml version='1.0'?> 
+ 849  <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+ 850    <p>The following is the source of the "data.xml" resource:</p> 
+ 851    <example><xi:include href="data.xml" parse="text"/></example> 
+ 852  </document> 
+ 853  """, "data.xml": """\ 
+ 854  <?xml version='1.0'?> 
+ 855  <data> 
+ 856    <item><![CDATA[Brooks & Shields]]></item> 
+ 857  </data> 
+ 858  """, 
+ 859      "C5.xml": """\ 
+ 860  <?xml version='1.0'?> 
+ 861  <div xmlns:xi="http://www.w3.org/2001/XInclude"> 
+ 862    <xi:include href="example.txt" parse="text"> 
+ 863      <xi:fallback> 
+ 864        <xi:include href="fallback-example.txt" parse="text"> 
+ 865          <xi:fallback><a href="mailto:bob@example.org">Report error</a></xi:fallback> 
+ 866        </xi:include> 
+ 867      </xi:fallback> 
+ 868    </xi:include> 
+ 869  </div> 
+ 870  """, 
+ 871      "default.xml": """\ 
+ 872  <?xml version='1.0'?> 
+ 873  <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+ 874    <p>Example.</p> 
+ 875    <xi:include href="samples/simple.xml"/> 
+ 876  </document> 
+ 877  """} 
+ 878   
+ 879   
+ 880 -def xinclude_loader(href, parse="xml", encoding=None): 
+
 881      try: 
+ 882          data = XINCLUDE[href] 
+ 883      except KeyError: 
+ 884          raise IOError("resource not found") 
+ 885      if parse == "xml": 
+ 886          return ElementTree.XML(data) 
+ 887      return data 
+
 888   
+ 889 -def xinclude(): 
+
 890      r""" 
+ 891      Basic inclusion example (XInclude C.1) 
+ 892   
+ 893      >>> document = xinclude_loader("C1.xml") 
+ 894      >>> ElementInclude.include(document, xinclude_loader) 
+ 895      >>> print(serialize(document)) # C1 
+ 896      <document> 
+ 897        <p>120 Mz is adequate for an average home user.</p> 
+ 898        <disclaimer> 
+ 899        <p>The opinions represented herein represent those of the individual 
+ 900        and should not be interpreted as official policy endorsed by this 
+ 901        organization.</p> 
+ 902      </disclaimer> 
+ 903      </document> 
+ 904   
+ 905      Textual inclusion example (XInclude C.2) 
+ 906   
+ 907      >>> document = xinclude_loader("C2.xml") 
+ 908      >>> ElementInclude.include(document, xinclude_loader) 
+ 909      >>> print(serialize(document)) # C2 
+ 910      <document> 
+ 911        <p>This document has been accessed 
+ 912        324387 times.</p> 
+ 913      </document> 
+ 914   
+ 915      Textual inclusion of XML example (XInclude C.3) 
+ 916   
+ 917      >>> document = xinclude_loader("C3.xml") 
+ 918      >>> ElementInclude.include(document, xinclude_loader) 
+ 919      >>> print(serialize(document)) # C3 
+ 920      <document> 
+ 921        <p>The following is the source of the "data.xml" resource:</p> 
+ 922        <example>&lt;?xml version='1.0'?&gt; 
+ 923      &lt;data&gt; 
+ 924        &lt;item&gt;&lt;![CDATA[Brooks &amp; Shields]]&gt;&lt;/item&gt; 
+ 925      &lt;/data&gt; 
+ 926      </example> 
+ 927      </document> 
+ 928   
+ 929  ##     Fallback example (XInclude C.5) 
+ 930  ##     Note! Fallback support is not yet implemented 
+ 931   
+ 932  ##     >>> document = xinclude_loader("C5.xml") 
+ 933  ##     >>> ElementInclude.include(document, xinclude_loader) 
+ 934  ##     Traceback (most recent call last): 
+ 935  ##     IOError: resource not found 
+ 936  ##     >>> # print(serialize(document)) # C5 
+ 937   
+ 938      """ 
+
 939   
+ 940 -def xinclude_default(): 
+
 941      """ 
+ 942      >>> document = xinclude_loader("default.xml") 
+ 943      >>> ElementInclude.include(document) 
+ 944      >>> print(serialize(document)) # default 
+ 945      <document> 
+ 946        <p>Example.</p> 
+ 947        <root> 
+ 948         <element key="value">text</element> 
+ 949         <element>text</element>tail 
+ 950         <empty-element/> 
+ 951      </root> 
+ 952      </document> 
+ 953      """ 
+
 954   
+ 955  # 
+ 956  # xmlwriter 
+ 957   
+ 958 -def xmlwriter(): 
+
 959      r""" 
+ 960      >>> file = BytesIO() 
+ 961      >>> w = SimpleXMLWriter.XMLWriter(file) 
+ 962      >>> html = w.start("html") 
+ 963      >>> x = w.start("head") 
+ 964      >>> w.element("title", "my document") 
+ 965      >>> w.data("\n") 
+ 966      >>> w.element("meta", name="hello", value="goodbye") 
+ 967      >>> w.data("\n") 
+ 968      >>> w.end() 
+ 969      >>> x = w.start("body") 
+ 970      >>> w.element("h1", "this is a heading") 
+ 971      >>> w.data("\n") 
+ 972      >>> w.element("p", u"this is a paragraph") 
+ 973      >>> w.data("\n") 
+ 974      >>> w.element("p", u"reserved characters: <&>") 
+ 975      >>> w.data("\n") 
+ 976      >>> w.element("p", u"detta är också ett stycke") 
+ 977      >>> w.data("\n") 
+ 978      >>> w.close(html) 
+ 979      >>> print(file.getvalue()) 
+ 980      <html><head><title>my document</title> 
+ 981      <meta name="hello" value="goodbye" /> 
+ 982      </head><body><h1>this is a heading</h1> 
+ 983      <p>this is a paragraph</p> 
+ 984      <p>reserved characters: &lt;&amp;&gt;</p> 
+ 985      <p>detta &#228;r ocks&#229; ett stycke</p> 
+ 986      </body></html> 
+ 987      """ 
+
 988   
+ 989  # doesn't work with lxml.etree 
+ 990  del xmlwriter 
+ 991   
+ 992  # -------------------------------------------------------------------- 
+ 993  # reported bugs 
+ 994   
+ 995 -def bug_xmltoolkit21(): 
+
 996      """ 
+ 997      marshaller gives obscure errors for non-string values 
+ 998   
+ 999      >>> elem = ElementTree.Element(123) 
+1000      >>> serialize(elem) # tag 
+1001      Traceback (most recent call last): 
+1002      TypeError: cannot serialize 123 (type int) 
+1003      >>> elem = ElementTree.Element("elem") 
+1004      >>> elem.text = 123 
+1005      >>> serialize(elem) # text 
+1006      Traceback (most recent call last): 
+1007      TypeError: cannot serialize 123 (type int) 
+1008      >>> elem = ElementTree.Element("elem") 
+1009      >>> elem.tail = 123 
+1010      >>> serialize(elem) # tail 
+1011      Traceback (most recent call last): 
+1012      TypeError: cannot serialize 123 (type int) 
+1013      >>> elem = ElementTree.Element("elem") 
+1014      >>> elem.set(123, "123") 
+1015      >>> serialize(elem) # attribute key 
+1016      Traceback (most recent call last): 
+1017      TypeError: cannot serialize 123 (type int) 
+1018      >>> elem = ElementTree.Element("elem") 
+1019      >>> elem.set("123", 123) 
+1020      >>> serialize(elem) # attribute value 
+1021      Traceback (most recent call last): 
+1022      TypeError: cannot serialize 123 (type int) 
+1023   
+1024      """ 
+
1025   
+1026  # doesn't work with lxml.etree 
+1027  del bug_xmltoolkit21 
+1028   
+1029 -def bug_xmltoolkit25(): 
+
1030      """ 
+1031      typo in ElementTree.findtext 
+1032   
+1033      >>> tree = ElementTree.ElementTree(SAMPLE_XML) 
+1034      >>> tree.findtext("tag") 
+1035      'text' 
+1036      >>> tree.findtext("section/tag") 
+1037      'subtext' 
+1038      """ 
+
1039   
+1040 -def bug_xmltoolkit28(): 
+
1041      """ 
+1042      .//tag causes exceptions 
+1043   
+1044      >>> tree = ElementTree.XML("<doc><table><tbody/></table></doc>") 
+1045      >>> summarize_list(tree.findall(".//thead")) 
+1046      [] 
+1047      >>> summarize_list(tree.findall(".//tbody")) 
+1048      ['tbody'] 
+1049      """ 
+
1050   
+1051 -def bug_xmltoolkitX1(): 
+
1052      """ 
+1053      dump() doesn't flush the output buffer 
+1054   
+1055      >>> tree = ElementTree.XML("<doc><table><tbody/></table></doc>") 
+1056      >>> ElementTree.dump(tree); sys.stdout.write("tail") 
+1057      <doc><table><tbody /></table></doc> 
+1058      tail 
+1059      """ 
+
1060   
+1061  # doesn't work with lxml.etree 
+1062  del bug_xmltoolkitX1 
+1063   
+1064 -def bug_xmltoolkit39(): 
+
1065      """ 
+1066      non-ascii element and attribute names doesn't work 
+1067   
+1068      >>> tree = ElementTree.XML("<?xml version='1.0' encoding='iso-8859-1'?><täg />") 
+1069      >>> ElementTree.tostring(tree, "utf-8") 
+1070      '<t\\xc3\\xa4g />' 
+1071   
+1072      >>> tree = ElementTree.XML("<?xml version='1.0' encoding='iso-8859-1'?><tag ättr='v&#228;lue' />") 
+1073      >>> tree.attrib 
+1074      {u'\\xe4ttr': u'v\\xe4lue'} 
+1075      >>> ElementTree.tostring(tree, "utf-8") 
+1076      '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />' 
+1077   
+1078      >>> tree = ElementTree.XML("<?xml version='1.0' encoding='iso-8859-1'?><täg>text</täg>") 
+1079      >>> ElementTree.tostring(tree, "utf-8") 
+1080      '<t\\xc3\\xa4g>text</t\\xc3\\xa4g>' 
+1081   
+1082      >>> tree = ElementTree.Element(u"täg") 
+1083      >>> ElementTree.tostring(tree, "utf-8") 
+1084      '<t\\xc3\\xa4g />' 
+1085   
+1086      >>> tree = ElementTree.Element("tag") 
+1087      >>> tree.set(u"ättr", u"välue") 
+1088      >>> ElementTree.tostring(tree, "utf-8") 
+1089      '<tag \\xc3\\xa4ttr="v\\xc3\\xa4lue" />' 
+1090   
+1091      """ 
+
1092   
+1093  # doesn't work with lxml.etree 
+1094  del bug_xmltoolkit39 
+1095   
+1096 -def bug_xmltoolkit45(): 
+
1097      """ 
+1098      problems parsing mixed unicode/non-ascii html documents 
+1099   
+1100      latin-1 text 
+1101      >>> p = HTMLTreeBuilder.TreeBuilder() 
+1102      >>> p.feed("<p>välue</p>") 
+1103      >>> serialize(p.close()) 
+1104      '<p>v&#228;lue</p>' 
+1105   
+1106      utf-8 text 
+1107      >>> p = HTMLTreeBuilder.TreeBuilder(encoding="utf-8") 
+1108      >>> p.feed("<p>v\xc3\xa4lue</p>") 
+1109      >>> serialize(p.close()) 
+1110      '<p>v&#228;lue</p>' 
+1111   
+1112      utf-8 text using meta tag 
+1113      >>> p = HTMLTreeBuilder.TreeBuilder() 
+1114      >>> p.feed("<html><meta http-equiv='Content-Type' content='text/html; charset=utf-8'><p>v\xc3\xa4lue</p></html>") 
+1115      >>> serialize(p.close().find("p")) 
+1116      '<p>v&#228;lue</p>' 
+1117   
+1118      latin-1 character references 
+1119      >>> p = HTMLTreeBuilder.TreeBuilder() 
+1120      >>> p.feed("<p>v&#228;lue</p>") 
+1121      >>> serialize(p.close()) 
+1122      '<p>v&#228;lue</p>' 
+1123   
+1124      latin-1 character entities 
+1125      >>> p = HTMLTreeBuilder.TreeBuilder() 
+1126      >>> p.feed("<p>v&auml;lue</p>") 
+1127      >>> serialize(p.close()) 
+1128      '<p>v&#228;lue</p>' 
+1129   
+1130      mixed latin-1 text and unicode entities 
+1131      >>> p = HTMLTreeBuilder.TreeBuilder() 
+1132      >>> p.feed("<p>&#8221;välue&#8221;</p>") 
+1133      >>> serialize(p.close()) 
+1134      '<p>&#8221;v&#228;lue&#8221;</p>' 
+1135   
+1136      mixed unicode and latin-1 entities 
+1137      >>> p = HTMLTreeBuilder.TreeBuilder() 
+1138      >>> p.feed("<p>&#8221;v&auml;lue&#8221;</p>") 
+1139      >>> serialize(p.close()) 
+1140      '<p>&#8221;v&#228;lue&#8221;</p>' 
+1141   
+1142      """ 
+
1143   
+1144  # doesn't work with lxml.etree 
+1145  del bug_xmltoolkit45 
+1146   
+1147 -def bug_xmltoolkit46(): 
+
1148      """ 
+1149      problems parsing open BR tags 
+1150   
+1151     >>> p = HTMLTreeBuilder.TreeBuilder() 
+1152      >>> p.feed("<p>key<br>value</p>") 
+1153      >>> serialize(p.close()) 
+1154      '<p>key<br />value</p>' 
+1155   
+1156      """ 
+
1157   
+1158  # doesn't work with lxml.etree 
+1159  del bug_xmltoolkit46 
+1160   
+1161 -def bug_xmltoolkit54(): 
+
1162      """ 
+1163      problems handling internally defined entities 
+1164   
+1165      >>> e = ElementTree.XML("<!DOCTYPE doc [<!ENTITY ldots '&#x8230;'>]><doc>&ldots;</doc>") 
+1166      >>> serialize(e) 
+1167      '<doc>&#33328;</doc>' 
+1168      """ 
+
1169   
+1170  # doesn't work with lxml.etree 
+1171  del bug_xmltoolkit54 
+1172   
+1173 -def bug_xmltoolkit55(): 
+
1174      """ 
+1175      make sure we're reporting the first error, not the last 
+1176   
+1177      >>> e = ElementTree.XML("<!DOCTYPE doc SYSTEM 'doc.dtd'><doc>&ldots;&ndots;&rdots;</doc>") 
+1178      Traceback (most recent call last): 
+1179      ParseError: undefined entity &ldots;: line 1, column 36 
+1180      """ 
+
1181   
+1182  # doesn't work with lxml.etree 
+1183  del bug_xmltoolkit55 
+1184   
+1185 -def bug_200708_version(): 
+
1186      """ 
+1187      >>> parser = ET.XMLParser() 
+1188      >>> parser.version 
+1189      'Expat 2.0.0' 
+1190      >>> parser.feed(open("samples/simple.xml").read()) 
+1191      >>> print(serialize(parser.close())) 
+1192      <root> 
+1193         <element key="value">text</element> 
+1194         <element>text</element>tail 
+1195         <empty-element /> 
+1196      </root> 
+1197      """ 
+
1198   
+1199  # doesn't work with lxml.etree 
+1200  del bug_200708_version 
+1201   
+1202 -def bug_200708_newline(): 
+
1203      r""" 
+1204   
+1205      Preserve newlines in attributes. 
+1206   
+1207      >>> e = ET.Element('SomeTag', text="def _f():\n  return 3\n") 
+1208      >>> ET.tostring(e) 
+1209      '<SomeTag text="def _f():&#10;  return 3&#10;" />' 
+1210      >>> ET.XML(ET.tostring(e)).get("text") 
+1211      'def _f():\n  return 3\n' 
+1212      >>> ET.tostring(ET.XML(ET.tostring(e))) 
+1213      '<SomeTag text="def _f():&#10;  return 3&#10;" />' 
+1214      """ 
+
1215   
+1216  # doesn't work with lxml.etree 
+1217  del bug_200708_newline 
+1218   
+1219 -def bug_200709_default_namespace(): 
+
1220      """ 
+1221   
+1222      >>> e = ET.Element("{default}elem") 
+1223      >>> s = ET.SubElement(e, "{default}elem") 
+1224      >>> serialize(e, default_namespace="default") # 1 
+1225      '<elem xmlns="default"><elem /></elem>' 
+1226   
+1227      >>> e = ET.Element("{default}elem") 
+1228      >>> s = ET.SubElement(e, "{default}elem") 
+1229      >>> s = ET.SubElement(e, "{not-default}elem") 
+1230      >>> serialize(e, default_namespace="default") # 2 
+1231      '<elem xmlns="default" xmlns:ns1="not-default"><elem /><ns1:elem /></elem>' 
+1232   
+1233      >>> e = ET.Element("{default}elem") 
+1234      >>> s = ET.SubElement(e, "{default}elem") 
+1235      >>> s = ET.SubElement(e, "elem") # unprefixed name 
+1236      >>> serialize(e, default_namespace="default") # 3 
+1237      Traceback (most recent call last): 
+1238      ValueError: cannot use non-qualified names with default_namespace option 
+1239   
+1240      """ 
+
1241   
+1242  # doesn't work with lxml.etree 
+1243  del bug_200709_default_namespace 
+1244   
+1245  # -------------------------------------------------------------------- 
+1246   
+1247  if __name__ == "__main__": 
+1248      import doctest, selftest 
+1249      failed, tested = doctest.testmod(selftest) 
+1250      print("%d tests ok." % (tested - failed)) 
+1251      if failed > 0: 
+1252          print("%d tests failed. Exiting with non-zero return code." % failed) 
+1253          sys.exit(1) 
+1254   
+
+>>> elem = ElementTree.Element("{uri}tag")
+>>> serialize(elem) # 1.1
+'<ns0:tag xmlns:ns0="uri"/>'
+>>> import copy
+>>> e1 = unserialize("<tag>hello<foo/></tag>")
+>>> # e2 = copy.copy(e1)
+>>> e3 = copy.deepcopy(e1)
+>>> e1.find("foo").tag = "bar"
+>>> serialize(e1).replace(' ', '')
+'<tag>hello<bar/></tag>'
+>>> serialize(e3).replace(' ', '')
+'<tag>hello<foo/></tag>'
+unserialize("""
+<body>
+  <tag>text</tag>
+  <tag />
+  <section>
+    <tag>subtext</tag>
+  </section>
+</body>
+...
+
+unserialize("""
+<body xmlns="http://effbot.org/ns">
+  <tag>text</tag>
+  <tag />
+  <section>
+    <tag>subtext</tag>
+  </section>
+</body>
+...
+
+'''<!DOCTYPE points [
+<!ENTITY % user-entities SYSTEM \'user-entities.xml\'>
+%user-entities;
+]>
+<document>&entity;</document>
+'''
+
+  1  # $Id: selftest.py 2213 2005-01-11 18:49:47Z fredrik $ 
+  2  # elementtree selftest program 
+  3   
+  4  # this test script uses Python's "doctest" module to check that the 
+  5  # *test script* works as expected. 
+  6   
+  7  import sys 
+  8   
+  9  try: 
+ 10      from StringIO import StringIO 
+ 11      BytesIO = StringIO 
+ 12  except ImportError: 
+ 13      from io import BytesIO, StringIO 
+ 14   
+ 15  from lxml import etree as ElementTree 
+ 16   
+ 17 -def stdout(): 
+
 18      if sys.version_info[0] < 3: 
+ 19          return sys.stdout 
+ 20      class bytes_stdout(object): 
+ 21          def write(self, data): 
+ 22              if isinstance(data, bytes): 
+ 23                  data = data.decode('ISO8859-1') 
+ 24              sys.stdout.write(data) 
+
 25      return bytes_stdout() 
+ 26   
+ 27 -def unserialize(text): 
+
 28      file = StringIO(text) 
+ 29      tree = ElementTree.parse(file) 
+ 30      return tree.getroot() 
+
 31   
+ 32 -def serialize(elem, encoding=None): 
+
 33      file = BytesIO() 
+ 34      tree = ElementTree.ElementTree(elem) 
+ 35      if encoding: 
+ 36          tree.write(file, encoding=encoding) 
+ 37      else: 
+ 38          tree.write(file) 
+ 39      result = file.getvalue() 
+ 40      if sys.version_info[0] >= 3: 
+ 41          result = result.decode('ISO8859-1') 
+ 42      result = result.replace(' />', '/>') 
+ 43      if result[-1:] == '\n': 
+ 44          result = result[:-1] 
+ 45      return result 
+
 46   
+ 47 -def summarize(elem): 
+
 48      return elem.tag 
+
 49   
+ 50 -def summarize_list(seq): 
+
 51      return list(map(summarize, seq)) 
+
 52   
+ 53  SAMPLE_XML = unserialize(""" 
+ 54  <body> 
+ 55    <tag>text</tag> 
+ 56    <tag /> 
+ 57    <section> 
+ 58      <tag>subtext</tag> 
+ 59    </section> 
+ 60  </body> 
+ 61  """) 
+ 62   
+ 63  SAMPLE_XML_NS = unserialize(""" 
+ 64  <body xmlns="http://effbot.org/ns"> 
+ 65    <tag>text</tag> 
+ 66    <tag /> 
+ 67    <section> 
+ 68      <tag>subtext</tag> 
+ 69    </section> 
+ 70  </body> 
+ 71  """) 
+ 72   
+ 73  # interface tests 
+ 74   
+ 75 -def check_string(string): 
+
 76      len(string) 
+ 77      for char in string: 
+ 78          if len(char) != 1: 
+ 79              print("expected one-character string, got %r" % char) 
+ 80      new_string = string + "" 
+ 81      new_string = string + " " 
+ 82      string[:0] 
+
 83   
+ 84 -def check_mapping(mapping): 
+
 85      len(mapping) 
+ 86      keys = mapping.keys() 
+ 87      items = mapping.items() 
+ 88      for key in keys: 
+ 89          item = mapping[key] 
+ 90      mapping["key"] = "value" 
+ 91      if mapping["key"] != "value": 
+ 92          print("expected value string, got %r" % mapping["key"]) 
+
 93   
+ 94 -def check_element(element): 
+
 95      if not hasattr(element, "tag"): 
+ 96          print("no tag member") 
+ 97      if not hasattr(element, "attrib"): 
+ 98          print("no attrib member") 
+ 99      if not hasattr(element, "text"): 
+100          print("no text member") 
+101      if not hasattr(element, "tail"): 
+102          print("no tail member") 
+103      check_string(element.tag) 
+104      check_mapping(element.attrib) 
+105      if element.text is not None: 
+106          check_string(element.text) 
+107      if element.tail is not None: 
+108          check_string(element.tail) 
+
109   
+110 -def check_element_tree(tree): 
+
111      check_element(tree.getroot()) 
+
112   
+113 -def element(): 
+
114      """ 
+115      Test element tree interface. 
+116   
+117      >>> element = ElementTree.Element("tag") 
+118      >>> check_element(element) 
+119      >>> tree = ElementTree.ElementTree(element) 
+120      >>> check_element_tree(tree) 
+121      """ 
+
122   
+123 -def parsefile(): 
+
124      """ 
+125      Test parsing from file.  Note that we're opening the files in 
+126      here; by default, the 'parse' function opens the file in binary 
+127      mode, and doctest doesn't filter out carriage returns. 
+128   
+129      >>> file = open("samples/simple.xml", "rb") 
+130      >>> tree = ElementTree.parse(file) 
+131      >>> file.close() 
+132      >>> tree.write(stdout()) 
+133      <root> 
+134         <element key="value">text</element> 
+135         <element>text</element>tail 
+136         <empty-element/> 
+137      </root> 
+138      >>> file = open("samples/simple-ns.xml", "rb") 
+139      >>> tree = ElementTree.parse(file) 
+140      >>> file.close() 
+141      >>> tree.write(stdout()) 
+142      <root xmlns="http://namespace/"> 
+143         <element key="value">text</element> 
+144         <element>text</element>tail 
+145         <empty-element/> 
+146      </root> 
+147      """ 
+
148   
+149 -def writefile(): 
+
150      """ 
+151      >>> elem = ElementTree.Element("tag") 
+152      >>> elem.text = "text" 
+153      >>> serialize(elem) 
+154      '<tag>text</tag>' 
+155      >>> ElementTree.SubElement(elem, "subtag").text = "subtext" 
+156      >>> serialize(elem) 
+157      '<tag>text<subtag>subtext</subtag></tag>' 
+158      """ 
+
159   
+160 -def encoding(): 
+
161      r""" 
+162      Test encoding issues. 
+163   
+164      >>> elem = ElementTree.Element("tag") 
+165      >>> elem.text = u'abc' 
+166      >>> serialize(elem) 
+167      '<tag>abc</tag>' 
+168      >>> serialize(elem, "utf-8") 
+169      '<tag>abc</tag>' 
+170      >>> serialize(elem, "us-ascii") 
+171      '<tag>abc</tag>' 
+172      >>> serialize(elem, "iso-8859-1").lower() 
+173      "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>abc</tag>" 
+174   
+175      >>> elem.text = "<&\"\'>" 
+176      >>> serialize(elem) 
+177      '<tag>&lt;&amp;"\'&gt;</tag>' 
+178      >>> serialize(elem, "utf-8") 
+179      '<tag>&lt;&amp;"\'&gt;</tag>' 
+180      >>> serialize(elem, "us-ascii") # cdata characters 
+181      '<tag>&lt;&amp;"\'&gt;</tag>' 
+182      >>> serialize(elem, "iso-8859-1").lower() 
+183      '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag>&lt;&amp;"\'&gt;</tag>' 
+184   
+185      >>> elem.attrib["key"] = "<&\"\'>" 
+186      >>> elem.text = None 
+187      >>> serialize(elem) 
+188      '<tag key="&lt;&amp;&quot;\'&gt;"/>' 
+189      >>> serialize(elem, "utf-8") 
+190      '<tag key="&lt;&amp;&quot;\'&gt;"/>' 
+191      >>> serialize(elem, "us-ascii") 
+192      '<tag key="&lt;&amp;&quot;\'&gt;"/>' 
+193      >>> serialize(elem, "iso-8859-1").lower() 
+194      '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="&lt;&amp;&quot;\'&gt;"/>' 
+195   
+196      >>> elem.text = u'\xe5\xf6\xf6<>' 
+197      >>> elem.attrib.clear() 
+198      >>> serialize(elem) 
+199      '<tag>&#229;&#246;&#246;&lt;&gt;</tag>' 
+200      >>> serialize(elem, "utf-8") 
+201      '<tag>\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;</tag>' 
+202      >>> serialize(elem, "us-ascii") 
+203      '<tag>&#229;&#246;&#246;&lt;&gt;</tag>' 
+204      >>> serialize(elem, "iso-8859-1").lower() 
+205      "<?xml version='1.0' encoding='iso-8859-1'?>\n<tag>\xe5\xf6\xf6&lt;&gt;</tag>" 
+206   
+207      >>> elem.attrib["key"] = u'\xe5\xf6\xf6<>' 
+208      >>> elem.text = None 
+209      >>> serialize(elem) 
+210      '<tag key="&#229;&#246;&#246;&lt;&gt;"/>' 
+211      >>> serialize(elem, "utf-8") 
+212      '<tag key="\xc3\xa5\xc3\xb6\xc3\xb6&lt;&gt;"/>' 
+213      >>> serialize(elem, "us-ascii") 
+214      '<tag key="&#229;&#246;&#246;&lt;&gt;"/>' 
+215      >>> serialize(elem, "iso-8859-1").lower() 
+216      '<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>\n<tag key="\xe5\xf6\xf6&lt;&gt;"/>' 
+217   
+218      """ 
+
219   
+220  if sys.version_info[0] >= 3: 
+221      encoding.__doc__ = encoding.__doc__.replace("u'", "'") 
+222   
+223 -def qname(): 
+
224      """ 
+225      Test QName handling. 
+226   
+227      1) decorated tags 
+228   
+229      >>> elem = ElementTree.Element("{uri}tag") 
+230      >>> serialize(elem) # 1.1 
+231      '<ns0:tag xmlns:ns0="uri"/>' 
+232   
+233  ##     2) decorated attributes 
+234   
+235  ##     >>> elem.attrib["{uri}key"] = "value" 
+236  ##     >>> serialize(elem) # 2.1 
+237  ##     '<ns0:tag ns0:key="value" xmlns:ns0="uri"/>' 
+238   
+239      """ 
+
240   
+241 -def cdata(): 
+
242      """ 
+243      Test CDATA handling (etc). 
+244   
+245      >>> serialize(unserialize("<tag>hello</tag>")) 
+246      '<tag>hello</tag>' 
+247      >>> serialize(unserialize("<tag>&#104;&#101;&#108;&#108;&#111;</tag>")) 
+248      '<tag>hello</tag>' 
+249      >>> serialize(unserialize("<tag><![CDATA[hello]]></tag>")) 
+250      '<tag>hello</tag>' 
+251   
+252      """ 
+
253   
+254 -def find(): 
+
255      """ 
+256      Test find methods (including xpath syntax). 
+257   
+258      >>> elem = SAMPLE_XML 
+259      >>> elem.find("tag").tag 
+260      'tag' 
+261      >>> ElementTree.ElementTree(elem).find("tag").tag 
+262      'tag' 
+263      >>> elem.find("section/tag").tag 
+264      'tag' 
+265      >>> ElementTree.ElementTree(elem).find("section/tag").tag 
+266      'tag' 
+267      >>> elem.findtext("tag") 
+268      'text' 
+269      >>> elem.findtext("tog", "default") 
+270      'default' 
+271      >>> ElementTree.ElementTree(elem).findtext("tag") 
+272      'text' 
+273      >>> elem.findtext("section/tag") 
+274      'subtext' 
+275      >>> ElementTree.ElementTree(elem).findtext("section/tag") 
+276      'subtext' 
+277      >>> summarize_list(elem.findall("tag")) 
+278      ['tag', 'tag'] 
+279      >>> summarize_list(elem.findall("*")) 
+280      ['tag', 'tag', 'section'] 
+281      >>> summarize_list(elem.findall(".//tag")) 
+282      ['tag', 'tag', 'tag'] 
+283      >>> summarize_list(elem.findall("section/tag")) 
+284      ['tag'] 
+285      >>> summarize_list(elem.findall("section//tag")) 
+286      ['tag'] 
+287      >>> summarize_list(elem.findall("section/*")) 
+288      ['tag'] 
+289      >>> summarize_list(elem.findall("section//*")) 
+290      ['tag'] 
+291      >>> summarize_list(elem.findall("section/.//*")) 
+292      ['tag'] 
+293      >>> summarize_list(elem.findall("*/*")) 
+294      ['tag'] 
+295      >>> summarize_list(elem.findall("*//*")) 
+296      ['tag'] 
+297      >>> summarize_list(elem.findall("*/tag")) 
+298      ['tag'] 
+299      >>> summarize_list(elem.findall("*/./tag")) 
+300      ['tag'] 
+301      >>> summarize_list(elem.findall("./tag")) 
+302      ['tag', 'tag'] 
+303      >>> summarize_list(elem.findall(".//tag")) 
+304      ['tag', 'tag', 'tag'] 
+305      >>> summarize_list(elem.findall("././tag")) 
+306      ['tag', 'tag'] 
+307      >>> summarize_list(ElementTree.ElementTree(elem).findall("/tag")) 
+308      ['tag', 'tag'] 
+309      >>> summarize_list(ElementTree.ElementTree(elem).findall("./tag")) 
+310      ['tag', 'tag'] 
+311      >>> elem = SAMPLE_XML_NS 
+312      >>> summarize_list(elem.findall("tag")) 
+313      [] 
+314      >>> summarize_list(elem.findall("{http://effbot.org/ns}tag")) 
+315      ['{http://effbot.org/ns}tag', '{http://effbot.org/ns}tag'] 
+316      >>> summarize_list(elem.findall(".//{http://effbot.org/ns}tag")) 
+317      ['{http://effbot.org/ns}tag', '{http://effbot.org/ns}tag', '{http://effbot.org/ns}tag'] 
+318      """ 
+
319   
+320  # XXX only deep copying is supported 
+321   
+322 -def copy(): 
+
323      """ 
+324      Test copy handling (etc). 
+325   
+326      >>> import copy 
+327      >>> e1 = unserialize("<tag>hello<foo/></tag>") 
+328      >>> # e2 = copy.copy(e1) 
+329      >>> e3 = copy.deepcopy(e1) 
+330      >>> e1.find("foo").tag = "bar" 
+331   
+332      >>> serialize(e1).replace(' ', '') 
+333      '<tag>hello<bar/></tag>' 
+334   
+335  ##     >>> serialize(e2).replace(' ', '') 
+336  ##     '<tag>hello<bar/></tag>' 
+337   
+338      >>> serialize(e3).replace(' ', '') 
+339      '<tag>hello<foo/></tag>' 
+340   
+341      """ 
+
342   
+343 -def attrib(): 
+
344      """ 
+345      Test attribute handling. 
+346   
+347      >>> elem = ElementTree.Element("tag") 
+348      >>> elem.get("key") # 1.1 
+349      >>> elem.get("key", "default") # 1.2 
+350      'default' 
+351      >>> elem.set("key", "value") 
+352      >>> elem.get("key") # 1.3 
+353      'value' 
+354   
+355      >>> elem = ElementTree.Element("tag", key="value") 
+356      >>> elem.get("key") # 2.1 
+357      'value' 
+358      >>> elem.attrib # 2.2 
+359      {'key': 'value'} 
+360   
+361      >>> elem = ElementTree.Element("tag", {"key": "value"}) 
+362      >>> elem.get("key") # 3.1 
+363      'value' 
+364      >>> elem.attrib # 3.2 
+365      {'key': 'value'} 
+366   
+367      >>> elem = ElementTree.Element("tag", {"key": "other"}, key="value") 
+368      >>> elem.get("key") # 4.1 
+369      'value' 
+370      >>> elem.attrib # 4.2 
+371      {'key': 'value'} 
+372   
+373      """ 
+
374   
+375 -def makeelement(): 
+
376      """ 
+377      Test makeelement handling. 
+378   
+379      >>> elem = ElementTree.Element("tag") 
+380      >>> subelem = elem.makeelement("subtag", {"key": "value"}) 
+381      >>> elem.append(subelem) 
+382      >>> serialize(elem) 
+383      '<tag><subtag key="value"/></tag>' 
+384   
+385      >>> elem.clear() 
+386      >>> serialize(elem) 
+387      '<tag/>' 
+388      >>> elem.append(subelem) 
+389      >>> serialize(elem) 
+390      '<tag><subtag key="value"/></tag>' 
+391   
+392      """ 
+
393   
+394  ## def observer(): 
+395  ##     """ 
+396  ##     Test observers. 
+397   
+398  ##     >>> def observer(action, elem): 
+399  ##     ...     print("%s %s" % (action, elem.tag)) 
+400  ##     >>> builder = ElementTree.TreeBuilder() 
+401  ##     >>> builder.addobserver(observer) 
+402  ##     >>> parser = ElementTree.XMLParser(builder) 
+403  ##     >>> file = open("samples/simple.xml", "rb") 
+404  ##     >>> parser.feed(file.read()) 
+405  ##     start root 
+406  ##     start element 
+407  ##     end element 
+408  ##     start element 
+409  ##     end element 
+410  ##     start empty-element 
+411  ##     end empty-element 
+412  ##     end root 
+413  ##     >>> file.close() 
+414   
+415  ##     """ 
+416   
+417  ENTITY_XML = """\ 
+418  <!DOCTYPE points [ 
+419  <!ENTITY % user-entities SYSTEM 'user-entities.xml'> 
+420  %user-entities; 
+421  ]> 
+422  <document>&entity;</document> 
+423  """ 
+424   
+425  ## def entity(): 
+426  ##     """ 
+427  ##     Test entity handling. 
+428   
+429  ##     1) bad entities 
+430   
+431  ##     >>> ElementTree.XML("<document>&entity;</document>") 
+432  ##     Traceback (most recent call last): 
+433  ##     SyntaxError: undefined entity: line 1, column 10 
+434   
+435  ##     2) custom entity 
+436   
+437  ##     >>> parser = ElementTree.XMLParser() 
+438  ##     >>> parser.entity["entity"] = "text" 
+439  ##     >>> parser.feed(ENTITY_XML) 
+440  ##     >>> root = parser.close() 
+441  ##     >>> serialize(root) 
+442  ##     '<document>text</document>' 
+443   
+444  ##     """ 
+445   
+446  if __name__ == "__main__": 
+447      import doctest, selftest2 
+448      failed, tested = doctest.testmod(selftest2) 
+449      print("%d tests ok." % (tested - failed)) 
+450      if failed > 0: 
+451          print("%d tests failed. Exiting with non-zero return code." % failed) 
+452          sys.exit(1) 
+453   
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+ 1  # -*- coding: utf-8 -*- 
+ 2  import unittest 
+ 3   
+ 4  """ 
+ 5  Tests that ElementMaker works properly. 
+ 6  """ 
+ 7   
+ 8  import sys, os.path 
+ 9  from lxml import etree 
+10  from lxml.builder import E 
+11   
+12  this_dir = os.path.dirname(__file__) 
+13  if this_dir not in sys.path: 
+14      sys.path.insert(0, this_dir) # needed for Py3 
+15   
+16  from common_imports import HelperTestCase, BytesIO, _bytes 
+17   
+18   
+19 -class BuilderTestCase(HelperTestCase): 
+
20      etree = etree 
+21   
+22 -    def test_build_from_xpath_result(self): 
+
23          class StringSubclass(str): pass 
+24          wrapped = E.b(StringSubclass('Hello')) 
+25          self.assertEqual(_bytes('<b>Hello</b>'), etree.tostring(wrapped)) 
+
26   
+27 -    def test_unknown_type_raises(self): 
+
28          class UnknownType(object): 
+29              pass 
+
30          self.assertRaises(TypeError, E.b, UnknownType()) 
+
31   
+32 -    def test_cdata(self): 
+
33          wrapped = E.b(etree.CDATA('Hello')) 
+34          self.assertEqual(_bytes('<b><![CDATA[Hello]]></b>'), etree.tostring(wrapped)) 
+
35   
+36 -    def test_cdata_solo(self): 
+
37          self.assertRaises(ValueError, E.b, 'Hello', etree.CDATA('World')) 
+
38   
+39   
+40 -def test_suite(): 
+
41      suite = unittest.TestSuite() 
+42      suite.addTests([unittest.makeSuite(BuilderTestCase)]) 
+43      return suite 
+
44   
+45  if __name__ == '__main__': 
+46      print('to test use test.py %s' % __file__) 
+47   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               BuilderTestCase
+
lxml.etree
lxml.etree
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+'''<root xmlns="myNS" xmlns:other="otherNS">
+  <c1 a1="A1" a2="A2" other:a3="A3">
+    <c2 a1="C2">0</c2>
+    <c2>1</c2>
+    <other:c2>2</other:c2>
+  </c1>
+</root>'''
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Tests for different Element class lookup mechanisms. 
+  5  """ 
+  6   
+  7   
+  8  import unittest, os.path, sys, gc 
+  9   
+ 10  this_dir = os.path.dirname(__file__) 
+ 11  if this_dir not in sys.path: 
+ 12      sys.path.insert(0, this_dir) # needed for Py3 
+ 13   
+ 14  from common_imports import etree, HelperTestCase, SillyFileLike, fileInTestDir 
+ 15  from common_imports import canonicalize, _bytes, _str, BytesIO, StringIO 
+ 16   
+ 17  xml_str = _bytes('''\ 
+ 18  <root xmlns="myNS" xmlns:other="otherNS"> 
+ 19    <c1 a1="A1" a2="A2" other:a3="A3"> 
+ 20      <c2 a1="C2">0</c2> 
+ 21      <c2>1</c2> 
+ 22      <other:c2>2</other:c2> 
+ 23    </c1> 
+ 24  </root>''') 
+ 25   
+ 26   
+ 27 -class ProxyTestCase(HelperTestCase): 
+
 28      """Basic tests for element proxy behaviour. 
+ 29      """ 
+ 30      etree = etree 
+ 31   
+ 32 -    def test_proxy_reuse(self): 
+
 33          root = etree.XML('<a><b><c/></b></a>') 
+ 34          b = root.find('b') 
+ 35          self.assertTrue(b is root[0]) 
+
 36   
+ 37 -    def test_proxy_reuse_after_gc(self): 
+
 38          root = etree.XML('<a><b><c/></b></a>') 
+ 39          b = root.find('b') 
+ 40          self.assertTrue(self.etree.iselement(b)) 
+ 41          gc.collect() 
+ 42          self.assertTrue(b is root[0]) 
+
 43   
+ 44 -    def test_proxy_reuse_after_del_root(self): 
+
 45          root = etree.XML('<a><b><c/></b></a>') 
+ 46          b = root.find('b') 
+ 47          self.assertTrue(self.etree.iselement(b)) 
+ 48          c = b.find('c') 
+ 49          self.assertTrue(self.etree.iselement(c)) 
+ 50          del root 
+ 51          gc.collect() 
+ 52          self.assertTrue(b[0] is c) 
+
 53   
+ 54 -    def test_proxy_hashing(self): 
+
 55          root = etree.XML('<a><b><c/></b></a>') 
+ 56          old_elements = set(root.iter()) 
+ 57          elements = root.iter() 
+ 58          del root 
+ 59          gc.collect() 
+ 60   
+ 61          missing = len(old_elements) 
+ 62          self.assertEqual(3, missing) 
+ 63          for new in elements: 
+ 64              for old in old_elements: 
+ 65                  if old == new: 
+ 66                      self.assertTrue(old is new) 
+ 67                      missing -= 1 
+ 68                      break 
+ 69              else: 
+ 70                  self.assertTrue(False, "element '%s' is missing" % new.tag) 
+ 71          self.assertEqual(0, missing) 
+
 72   
+ 73 -    def test_element_base(self): 
+
 74          el = self.etree.ElementBase() 
+ 75          self.assertEqual('ElementBase', el.tag) 
+ 76          root = self.etree.ElementBase() 
+ 77          root.append(el) 
+ 78          self.assertEqual('ElementBase', root[0].tag) 
+
 79   
+ 80 -    def test_element_base_children(self): 
+
 81          el = self.etree.ElementBase(etree.ElementBase()) 
+ 82          self.assertEqual('ElementBase', el.tag) 
+ 83          self.assertEqual(1, len(el)) 
+ 84          self.assertEqual('ElementBase', el[0].tag) 
+ 85   
+ 86          root = self.etree.ElementBase() 
+ 87          root.append(el) 
+ 88          self.assertEqual('ElementBase', root[0].tag) 
+ 89          self.assertEqual('ElementBase', root[0][0].tag) 
+
 90   
+ 91 -    def test_comment_base(self): 
+
 92          el = self.etree.CommentBase('some text') 
+ 93          self.assertEqual(self.etree.Comment, el.tag) 
+ 94          self.assertEqual('some text', el.text) 
+ 95          root = self.etree.Element('root') 
+ 96          root.append(el) 
+ 97          self.assertEqual('some text', root[0].text) 
+
 98   
+ 99 -    def test_pi_base(self): 
+
100          el = self.etree.PIBase('the target', 'some text') 
+101          self.assertEqual(self.etree.ProcessingInstruction, el.tag) 
+102          self.assertEqual('some text', el.text) 
+103          root = self.etree.Element('root') 
+104          root.append(el) 
+105          self.assertEqual('some text', root[0].text) 
+
106   
+107   
+108 -class ClassLookupTestCase(HelperTestCase): 
+
109      """Test cases for different Element class lookup mechanisms. 
+110      """ 
+111      etree = etree 
+112   
+113 -    def tearDown(self): 
+
114          etree.set_element_class_lookup() 
+115          super(ClassLookupTestCase, self).tearDown() 
+
116   
+117 -    def test_namespace_lookup(self): 
+
118          class TestElement(etree.ElementBase): 
+119              FIND_ME = "namespace class" 
+
120   
+121          lookup = etree.ElementNamespaceClassLookup() 
+122          etree.set_element_class_lookup(lookup) 
+123   
+124          ns = lookup.get_namespace("myNS") 
+125          ns[None] = TestElement 
+126   
+127          root = etree.XML(xml_str) 
+128          self.assertEqual(root.FIND_ME, 
+129                            TestElement.FIND_ME) 
+130          self.assertEqual(root[0].FIND_ME, 
+131                            TestElement.FIND_ME) 
+132          self.assertFalse(hasattr(root[0][-1], 'FIND_ME')) 
+
133   
+134 -    def test_default_class_lookup(self): 
+
135          class TestElement(etree.ElementBase): 
+136              FIND_ME = "default element" 
+
137          class TestComment(etree.CommentBase): 
+138              FIND_ME = "default comment" 
+139          class TestPI(etree.PIBase): 
+140              FIND_ME = "default pi" 
+141   
+142          parser = etree.XMLParser() 
+143   
+144          lookup = etree.ElementDefaultClassLookup( 
+145              element=TestElement, comment=TestComment, pi=TestPI) 
+146          parser.set_element_class_lookup(lookup) 
+147   
+148          root = etree.XML(_bytes("""<?xml version='1.0'?> 
+149          <root> 
+150            <?myPI?> 
+151            <!-- hi --> 
+152          </root> 
+153          """), parser) 
+154   
+155          self.assertEqual("default element", root.FIND_ME) 
+156          self.assertEqual("default pi", root[0].FIND_ME) 
+157          self.assertEqual("default comment", root[1].FIND_ME) 
+158   
+159 -    def test_default_class_lookup_pull_parser(self): 
+
160          class TestElement(etree.ElementBase): 
+161              FIND_ME = "default element" 
+
162          class TestComment(etree.CommentBase): 
+163              FIND_ME = "default comment" 
+164          class TestPI(etree.PIBase): 
+165              FIND_ME = "default pi" 
+166   
+167          parser = etree.XMLPullParser(events=('start', 'end', 'comment', 'pi')) 
+168          lookup = etree.ElementDefaultClassLookup( 
+169              element=TestElement, comment=TestComment, pi=TestPI) 
+170          parser.set_element_class_lookup(lookup) 
+171   
+172          events_seen = [] 
+173   
+174          def add_events(events): 
+175              for ev, el in events: 
+176                  events_seen.append((ev, el.FIND_ME)) 
+177   
+178          parser.feed("""<?xml version='1.0'?> 
+179          <root> 
+180            <?myPI?> 
+181          """) 
+182          add_events(parser.read_events()) 
+183   
+184          parser.feed("<!-- hi -->") 
+185          add_events(parser.read_events()) 
+186   
+187          parser.feed("</root>") 
+188          root = parser.close() 
+189          add_events(parser.read_events()) 
+190   
+191          self.assertEqual([ 
+192              ('start',   "default element"), 
+193              ('pi',      "default pi"), 
+194              ('comment', "default comment"), 
+195              ('end',     "default element"), 
+196          ], events_seen) 
+197   
+198          self.assertEqual("default element", root.FIND_ME) 
+199          self.assertEqual("default pi", root[0].FIND_ME) 
+200          self.assertEqual("default comment", root[1].FIND_ME) 
+201   
+202 -    def test_evil_class_lookup(self): 
+
203          class MyLookup(etree.CustomElementClassLookup): 
+204              def lookup(self, t, d, ns, name): 
+205                  if name == 'none': 
+206                      return None 
+207                  elif name == 'obj': 
+208                      return object() 
+209                  else: 
+210                      return etree.ElementBase 
+
211   
+212          parser = etree.XMLParser() 
+213          parser.set_element_class_lookup(MyLookup()) 
+214   
+215          root = etree.XML(_bytes('<none/>'), parser) 
+216          self.assertEqual('none', root.tag) 
+217   
+218          self.assertRaises( 
+219              TypeError, 
+220              etree.XML, _bytes("<obj />"), parser) 
+221   
+222          root = etree.XML(_bytes('<root/>'), parser) 
+223          self.assertEqual('root', root.tag) 
+224   
+225 -    def test_class_lookup_type_mismatch(self): 
+
226          class MyLookup(etree.CustomElementClassLookup): 
+227              def lookup(self, t, d, ns, name): 
+228                  if t == 'element': 
+229                      if name == 'root': 
+230                          return etree.ElementBase 
+231                      return etree.CommentBase 
+232                  elif t == 'comment': 
+233                      return etree.PIBase 
+234                  elif t == 'PI': 
+235                      return etree.EntityBase 
+236                  elif t == 'entity': 
+237                      return etree.ElementBase 
+238                  else: 
+239                      raise ValueError('got type %s' % t) 
+
240   
+241          parser = etree.XMLParser(resolve_entities=False) 
+242          parser.set_element_class_lookup(MyLookup()) 
+243   
+244          root = etree.XML(_bytes('<root></root>'), parser) 
+245          self.assertEqual('root', root.tag) 
+246          self.assertEqual(etree.ElementBase, type(root)) 
+247   
+248          root = etree.XML(_bytes("<root><test/></root>"), parser) 
+249          self.assertRaises(TypeError, root.__getitem__, 0) 
+250   
+251          root = etree.XML(_bytes("<root><!-- test --></root>"), parser) 
+252          self.assertRaises(TypeError, root.__getitem__, 0) 
+253   
+254          root = etree.XML(_bytes("<root><?test?></root>"), parser) 
+255          self.assertRaises(TypeError, root.__getitem__, 0) 
+256   
+257          root = etree.XML( 
+258              _bytes('<!DOCTYPE root [<!ENTITY myent "ent">]>' 
+259                     '<root>&myent;</root>'), 
+260              parser) 
+261          self.assertRaises(TypeError, root.__getitem__, 0) 
+262   
+263          root = etree.XML(_bytes('<root><root/></root>'), parser) 
+264          self.assertEqual('root', root[0].tag) 
+265   
+266 -    def test_attribute_based_lookup(self): 
+
267          class TestElement(etree.ElementBase): 
+268              FIND_ME = "attribute_based" 
+
269   
+270          class_dict = {"A1" : TestElement} 
+271   
+272          lookup = etree.AttributeBasedElementClassLookup( 
+273              "a1", class_dict) 
+274          etree.set_element_class_lookup(lookup) 
+275   
+276          root = etree.XML(xml_str) 
+277          self.assertFalse(hasattr(root, 'FIND_ME')) 
+278          self.assertEqual(root[0].FIND_ME, 
+279                            TestElement.FIND_ME) 
+280          self.assertFalse(hasattr(root[0][0], 'FIND_ME')) 
+281   
+282 -    def test_custom_lookup(self): 
+
283          class TestElement(etree.ElementBase): 
+284              FIND_ME = "custom" 
+
285   
+286          class MyLookup(etree.CustomElementClassLookup): 
+287              def lookup(self, t, d, ns, name): 
+288                  if name == 'c1': 
+289                      return TestElement 
+290   
+291          etree.set_element_class_lookup( MyLookup() ) 
+292   
+293          root = etree.XML(xml_str) 
+294          self.assertFalse(hasattr(root, 'FIND_ME')) 
+295          self.assertEqual(root[0].FIND_ME, 
+296                            TestElement.FIND_ME) 
+297          self.assertFalse(hasattr(root[0][1], 'FIND_ME')) 
+298   
+299 -    def test_custom_lookup_ns_fallback(self): 
+
300          class TestElement1(etree.ElementBase): 
+301              FIND_ME = "custom" 
+
302   
+303          class TestElement2(etree.ElementBase): 
+304              FIND_ME = "nsclasses" 
+305   
+306          class MyLookup(etree.CustomElementClassLookup): 
+307              def lookup(self, t, d, ns, name): 
+308                  if name == 'c1': 
+309                      return TestElement1 
+310   
+311          lookup = etree.ElementNamespaceClassLookup( MyLookup() ) 
+312          etree.set_element_class_lookup(lookup) 
+313   
+314          ns = lookup.get_namespace("otherNS") 
+315          ns[None] = TestElement2 
+316   
+317          root = etree.XML(xml_str) 
+318          self.assertFalse(hasattr(root, 'FIND_ME')) 
+319          self.assertEqual(root[0].FIND_ME, 
+320                            TestElement1.FIND_ME) 
+321          self.assertFalse(hasattr(root[0][1], 'FIND_ME')) 
+322          self.assertEqual(root[0][-1].FIND_ME, 
+323                            TestElement2.FIND_ME) 
+324   
+325 -    def test_parser_based_lookup(self): 
+
326          class TestElement(etree.ElementBase): 
+327              FIND_ME = "parser_based" 
+
328   
+329          lookup = etree.ParserBasedElementClassLookup() 
+330          etree.set_element_class_lookup(lookup) 
+331   
+332          class MyLookup(etree.CustomElementClassLookup): 
+333              def lookup(self, t, d, ns, name): 
+334                  return TestElement 
+335   
+336          parser = etree.XMLParser() 
+337          parser.set_element_class_lookup( MyLookup() ) 
+338   
+339          root = etree.parse(BytesIO(xml_str), parser).getroot() 
+340          self.assertEqual(root.FIND_ME, 
+341                            TestElement.FIND_ME) 
+342          self.assertEqual(root[0].FIND_ME, 
+343                            TestElement.FIND_ME) 
+344   
+345          root = etree.parse(BytesIO(xml_str)).getroot() 
+346          self.assertFalse(hasattr(root, 'FIND_ME')) 
+347          self.assertFalse(hasattr(root[0], 'FIND_ME')) 
+348   
+349 -    def test_class_lookup_reentry(self): 
+
350          XML = self.etree.XML 
+351   
+352          class TestElement(etree.ElementBase): 
+353              FIND_ME = "here" 
+
354   
+355          root = None 
+356          class MyLookup(etree.CustomElementClassLookup): 
+357              el = None 
+358              def lookup(self, t, d, ns, name): 
+359                  if root is not None: # not in the parser 
+360                      if self.el is None and name == "a": 
+361                          self.el = [] 
+362                          self.el.append(root.find(name)) 
+363                  return TestElement 
+364   
+365          parser = self.etree.XMLParser() 
+366          parser.set_element_class_lookup(MyLookup()) 
+367   
+368          root = XML(_bytes('<root><a>A</a><b xmlns="test">B</b></root>'), 
+369                     parser) 
+370   
+371          a = root[0] 
+372          self.assertEqual(a.tag, "a") 
+373          self.assertEqual(root[0].tag, "a") 
+374          del a 
+375          self.assertEqual(root[0].tag, "a") 
+376   
+377 -    def test_lookup_without_fallback(self): 
+
378          class Lookup(etree.CustomElementClassLookup): 
+379               def __init__(self): 
+380                   # no super call here, so no fallback is set 
+381                   pass 
+
382   
+383               def lookup(self, node_type, document, namespace, name): 
+384                   return Foo 
+385   
+386          class Foo(etree.ElementBase): 
+387               def custom(self): 
+388                   return "test" 
+389   
+390          parser = self.etree.XMLParser() 
+391          parser.set_element_class_lookup( Lookup() ) 
+392   
+393          root = etree.XML('<foo/>', parser) 
+394   
+395          self.assertEqual("test", root.custom()) 
+396   
+397   
+398 -def test_suite(): 
+
399      suite = unittest.TestSuite() 
+400      suite.addTests([unittest.makeSuite(ProxyTestCase)]) 
+401      suite.addTests([unittest.makeSuite(ClassLookupTestCase)]) 
+402      return suite 
+
403   
+404  if __name__ == '__main__': 
+405      print('to test use test.py %s' % __file__) 
+406   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ClassLookupTestCase
+
lxml.etree
lxml.etree
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ProxyTestCase
+
lxml.etree
lxml.etree
+'''
+<div>
+  <a href="foo">link</a>
+  <a>anchor</a>
+</div>
+'''
+
+ 1  import unittest 
+ 2   
+ 3  import lxml.html 
+ 4   
+ 5  from lxml.tests.common_imports import doctest, HelperTestCase, skipif 
+ 6   
+ 7  try: 
+ 8      import cssselect 
+ 9  except ImportError: 
+10      cssselect = None 
+11   
+12   
+13  HTML = ''' 
+14  <div> 
+15    <a href="foo">link</a> 
+16    <a>anchor</a> 
+17  </div> 
+18  ''' 
+19   
+20   
+21 -class CSSTestCase(HelperTestCase): 
+
22   
+23      pytestmark = skipif('cssselect is None') 
+24   
+25 -    def test_cssselect(self): 
+
26          div, = lxml.html.fromstring(HTML).xpath('//div') 
+27   
+28          def count(selector, expected_count, **kwargs): 
+29              result = div.cssselect(selector, **kwargs) 
+30              self.assertEqual(len(result), expected_count) 
+
31   
+32          count('div', 1) 
+33          count('a', 2) 
+34          count('em', 0) 
+35          # Element names are case-insensitive in HTML 
+36          count('DIV', 1) 
+37          # ... but not in XHTML or XML 
+38          count('DIV', 0, translator='xhtml') 
+39          count('DIV', 0, translator='xml') 
+40   
+41          # :contains() is case-insensitive in lxml 
+42          count(':contains("link")', 2)  # div, a 
+43          count(':contains("LInk")', 2) 
+44          # Whatever the document language 
+45          count(':contains("LInk")', 2, translator='xhtml') 
+46          count(':contains("LInk")', 2, translator='xml') 
+47          # ... but not in upstream cssselect 
+48          import cssselect 
+49          count(':contains("link")', 2, translator=cssselect.HTMLTranslator()) 
+50          count(':contains("LInk")', 0, translator=cssselect.HTMLTranslator()) 
+
51   
+52   
+53 -def test_suite(): 
+
54      suite = unittest.TestSuite() 
+55      try: 
+56          import cssselect 
+57      except ImportError: 
+58          # no 'cssselect' installed 
+59          print("Skipping tests in lxml.cssselect - external cssselect package is not installed") 
+60          return suite 
+61   
+62      import lxml.cssselect 
+63      suite.addTests(doctest.DocTestSuite(lxml.cssselect)) 
+64      suite.addTests([unittest.makeSuite(CSSTestCase)]) 
+65      return suite 
+
66   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               CSSTestCase
+
+  1  import unittest 
+  2   
+  3  from lxml import etree 
+  4  from lxml.tests.common_imports import HelperTestCase 
+  5  from lxml.doctestcompare import LXMLOutputChecker, PARSE_HTML, PARSE_XML 
+  6   
+  7   
+  8 -class DummyInput: 
+
  9 -    def __init__(self, **kw): 
+
 10          for name, value in kw.items(): 
+ 11              setattr(self, name, value) 
+
 12   
+ 13   
+ 14 -def indent(elem, level=0): 
+
 15      i = "\n" + level*"  " 
+ 16      if len(elem): 
+ 17          if not elem.text or not elem.text.strip(): 
+ 18              elem.text = i + "  " 
+ 19          if not elem.tail or not elem.tail.strip(): 
+ 20              elem.tail = i 
+ 21          for elem in elem: 
+ 22              indent(elem, level+1) 
+ 23          if not elem.tail or not elem.tail.strip(): 
+ 24              elem.tail = i 
+ 25      else: 
+ 26          if level and (not elem.tail or not elem.tail.strip()): 
+ 27              elem.tail = i 
+
 28   
+ 29   
+ 30 -class DoctestCompareTest(HelperTestCase): 
+
 31      _checker = LXMLOutputChecker() 
+ 32   
+ 33 -    def compare(self, want, got, html=False): 
+
 34          if html: 
+ 35              options = PARSE_HTML 
+ 36          else: 
+ 37              options = PARSE_XML 
+ 38   
+ 39          parse = self._checker.get_parser(want, got, options) 
+ 40          want_doc = parse(want) 
+ 41          got_doc = parse(got) 
+ 42          return self._checker.collect_diff( 
+ 43              want_doc, got_doc, html, indent=0).lstrip() 
+
 44   
+ 45 -    def assert_diff(self, want, got, diff, html=False): 
+
 46          self.assertEqual(self.compare(want, got, html), diff) 
+
 47   
+ 48 -    def assert_nodiff(self, want, got, html=False): 
+
 49          root = etree.fromstring(want) 
+ 50          root.tail = '\n' 
+ 51          indent(root) 
+ 52          diff = etree.tostring( 
+ 53              root, encoding='unicode', method=html and 'html' or 'xml') 
+ 54          self.assert_diff(want, got, diff, html=html) 
+
 55   
+ 56 -    def test_equal_input(self): 
+
 57          self.assert_nodiff( 
+ 58              '<p title="expected">Expected</p>', 
+ 59              '<p title="expected">Expected</p>') 
+
 60   
+ 61 -    def test_differing_tags(self): 
+
 62          self.assert_diff( 
+ 63              '<p title="expected">Expected</p>', 
+ 64              '<b title="expected">Expected</b>', 
+ 65              '<p (got: b) title="expected">Expected</p (got: b)>\n') 
+
 66   
+ 67 -    def test_tags_upper_lower_case(self): 
+
 68          self.assert_diff( 
+ 69              '<p title="expected">Expected</p>', 
+ 70              '<P title="expected">Expected</P>', 
+ 71              '<p (got: P) title="expected">Expected</p (got: P)>\n') 
+
 72   
+ 73 -    def test_tags_upper_lower_case_html(self): 
+
 74          self.assert_nodiff( 
+ 75              '<html><body><p title="expected">Expected</p></body></html>', 
+ 76              '<HTML><BODY><P title="expected">Expected</P></BODY></HTML>', 
+ 77              html=True) 
+
 78   
+ 79 -    def test_differing_attributes(self): 
+
 80          self.assert_diff( 
+ 81              '<p title="expected">Expected</p>', 
+ 82              '<p title="actual">Actual</p>', 
+ 83              '<p title="expected (got: actual)">Expected (got: Actual)</p>\n') 
+
 84   
+ 85 -    def test_extra_children(self): 
+
 86          # https://bugs.launchpad.net/lxml/+bug/1238503 
+ 87          self.assert_diff( 
+ 88              '<p><span>One</span></p>', 
+ 89              '<p><span>One</span><b>Two</b><em>Three</em></p>', 
+ 90              '<p>\n' 
+ 91              '  <span>One</span>\n' 
+ 92              '  +<b>Two</b>\n' 
+ 93              '  +<em>Three</em>\n' 
+ 94              '</p>\n') 
+
 95   
+ 96 -    def test_missing_children(self): 
+
 97          self.assert_diff( 
+ 98              '<p><span>One</span><b>Two</b><em>Three</em></p>', 
+ 99              '<p><span>One</span></p>', 
+100              '<p>\n' 
+101              '  <span>One</span>\n' 
+102              '  -<b>Two</b>\n' 
+103              '  -<em>Three</em>\n' 
+104              '</p>\n') 
+
105   
+106 -    def test_extra_attributes(self): 
+
107          self.assert_diff( 
+108              '<p><span class="foo">Text</span></p>', 
+109              '<p><span class="foo" id="bar">Text</span></p>', 
+110              '<p>\n' 
+111              '  <span class="foo" +id="bar">Text</span>\n' 
+112              '</p>\n') 
+
113   
+114 -    def test_missing_attributes(self): 
+
115          self.assert_diff( 
+116              '<p><span class="foo" id="bar">Text</span></p>', 
+117              '<p><span class="foo">Text</span></p>', 
+118              '<p>\n' 
+119              '  <span class="foo" -id="bar">Text</span>\n' 
+120              '</p>\n') 
+
121   
+122   
+123 -def test_suite(): 
+
124      suite = unittest.TestSuite() 
+125      suite.addTests([unittest.makeSuite(DoctestCompareTest)]) 
+126      return suite 
+
127   
+128   
+129  if __name__ == '__main__': 
+130      unittest.main() 
+131   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               DoctestCompareTest
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Test cases related to DTD parsing and validation 
+  5  """ 
+  6   
+  7  import unittest, sys, os.path 
+  8   
+  9  this_dir = os.path.dirname(__file__) 
+ 10  if this_dir not in sys.path: 
+ 11      sys.path.insert(0, this_dir)  # needed for Py3 
+ 12   
+ 13  from common_imports import etree, html, BytesIO, _bytes, _str 
+ 14  from common_imports import HelperTestCase, make_doctest, skipIf 
+ 15  from common_imports import fileInTestDir, fileUrlInTestDir 
+ 16   
+ 17   
+ 18 -class ETreeDtdTestCase(HelperTestCase): 
+
 19 -    def test_dtd(self): 
+
 20          pass 
+
 21   
+ 22 -    def test_dtd_file(self): 
+
 23          parse = etree.parse 
+ 24          tree = parse(fileInTestDir("test.xml")) 
+ 25          root = tree.getroot() 
+ 26   
+ 27          dtd = etree.DTD(fileInTestDir("test.dtd")) 
+ 28          self.assertTrue(dtd.validate(root)) 
+
 29   
+ 30 -    def test_dtd_stringio(self): 
+
 31          root = etree.XML(_bytes("<b/>")) 
+ 32          dtd = etree.DTD(BytesIO("<!ELEMENT b EMPTY>")) 
+ 33          self.assertTrue(dtd.validate(root)) 
+
 34   
+ 35 -    def test_dtd_parse_invalid(self): 
+
 36          fromstring = etree.fromstring 
+ 37          parser = etree.XMLParser(dtd_validation=True) 
+ 38          xml = _bytes('<!DOCTYPE b SYSTEM "%s"><b><a/></b>' % 
+ 39                       fileInTestDir("test.dtd")) 
+ 40          self.assertRaises(etree.XMLSyntaxError, 
+ 41                            fromstring, xml, parser=parser) 
+
 42   
+ 43 -    def test_dtd_parse_file_not_found(self): 
+
 44          fromstring = etree.fromstring 
+ 45          dtd_filename = fileUrlInTestDir("__nosuch.dtd") 
+ 46          parser = etree.XMLParser(dtd_validation=True) 
+ 47          xml = _bytes('<!DOCTYPE b SYSTEM "%s"><b><a/></b>' % dtd_filename) 
+ 48          self.assertRaises(etree.XMLSyntaxError, 
+ 49                            fromstring, xml, parser=parser) 
+ 50          errors = None 
+ 51          try: 
+ 52              fromstring(xml, parser=parser) 
+ 53          except etree.XMLSyntaxError: 
+ 54              e = sys.exc_info()[1] 
+ 55              self.assertTrue(e.error_log) 
+ 56              self.assertTrue(parser.error_log) 
+ 57              errors = [entry.message for entry in e.error_log 
+ 58                        if dtd_filename in entry.message] 
+ 59          self.assertTrue(errors) 
+
 60   
+ 61 -    def test_dtd_parse_valid(self): 
+
 62          parser = etree.XMLParser(dtd_validation=True) 
+ 63          xml = ('<!DOCTYPE a SYSTEM "%s"><a><b/></a>' % 
+ 64                 fileUrlInTestDir("test.dtd")) 
+ 65          root = etree.fromstring(xml, parser=parser) 
+
 66   
+ 67 -    def test_dtd_parse_valid_file_url(self): 
+
 68          parser = etree.XMLParser(dtd_validation=True) 
+ 69          xml = ('<!DOCTYPE a SYSTEM "%s"><a><b/></a>' % 
+ 70                 fileUrlInTestDir("test.dtd")) 
+ 71          root = etree.fromstring(xml, parser=parser) 
+
 72   
+ 73 -    def test_dtd_parse_valid_relative(self): 
+
 74          parser = etree.XMLParser(dtd_validation=True) 
+ 75          xml = '<!DOCTYPE a SYSTEM "test.dtd"><a><b/></a>' 
+ 76          root = etree.fromstring( 
+ 77              xml, parser=parser, base_url=fileUrlInTestDir("test.xml")) 
+
 78   
+ 79 -    def test_dtd_parse_valid_relative_file_url(self): 
+
 80          parser = etree.XMLParser(dtd_validation=True) 
+ 81          xml = '<!DOCTYPE a SYSTEM "test.dtd"><a><b/></a>' 
+ 82          root = etree.fromstring( 
+ 83              xml, parser=parser, base_url=fileUrlInTestDir("test.xml")) 
+
 84   
+ 85 -    def test_dtd_invalid(self): 
+
 86          root = etree.XML("<b><a/></b>") 
+ 87          dtd = etree.DTD(BytesIO("<!ELEMENT b EMPTY>")) 
+ 88          self.assertRaises(etree.DocumentInvalid, dtd.assertValid, root) 
+
 89   
+ 90 -    def test_dtd_assertValid(self): 
+
 91          root = etree.XML("<b><a/></b>") 
+ 92          dtd = etree.DTD(BytesIO("<!ELEMENT b (a)><!ELEMENT a EMPTY>")) 
+ 93          dtd.assertValid(root) 
+
 94   
+ 95 -    def test_dtd_internal(self): 
+
 96          root = etree.XML(_bytes(''' 
+ 97          <!DOCTYPE b SYSTEM "none" [ 
+ 98          <!ELEMENT b (a)> 
+ 99          <!ELEMENT a EMPTY> 
+100          ]> 
+101          <b><a/></b> 
+102          ''')) 
+103          dtd = etree.ElementTree(root).docinfo.internalDTD 
+104          self.assertTrue(dtd) 
+105          dtd.assertValid(root) 
+
106   
+107 -    def test_dtd_internal_invalid(self): 
+
108          root = etree.XML(_bytes(''' 
+109          <!DOCTYPE b SYSTEM "none" [ 
+110          <!ELEMENT b (a)> 
+111          <!ELEMENT a (c)> 
+112          <!ELEMENT c EMPTY> 
+113          ]> 
+114          <b><a/></b> 
+115          ''')) 
+116          dtd = etree.ElementTree(root).docinfo.internalDTD 
+117          self.assertTrue(dtd) 
+118          self.assertFalse(dtd.validate(root)) 
+
119   
+120 -    def test_dtd_invalid_duplicate_id(self): 
+
121          root = etree.XML(_bytes(''' 
+122          <a><b id="id1"/><b id="id2"/><b id="id1"/></a> 
+123          ''')) 
+124          dtd = etree.DTD(BytesIO(_bytes(""" 
+125          <!ELEMENT a (b*)> 
+126          <!ATTLIST b 
+127              id ID #REQUIRED 
+128          > 
+129          <!ELEMENT b EMPTY> 
+130          """))) 
+131          self.assertFalse(dtd.validate(root)) 
+132          self.assertTrue(dtd.error_log) 
+133          self.assertTrue([error for error in dtd.error_log 
+134                           if 'id1' in error.message]) 
+
135   
+136 -    def test_dtd_api_internal(self): 
+
137          root = etree.XML(_bytes(''' 
+138          <!DOCTYPE b SYSTEM "none" [ 
+139          <!ATTLIST a 
+140            attr1 (x | y | z) "z" 
+141            attr2 CDATA #FIXED "X" 
+142          > 
+143          <!ELEMENT b (a)> 
+144          <!ELEMENT a EMPTY> 
+145          ]> 
+146          <b><a/></b> 
+147          ''')) 
+148          dtd = etree.ElementTree(root).docinfo.internalDTD 
+149          self.assertTrue(dtd) 
+150          dtd.assertValid(root) 
+151   
+152          seen = [] 
+153          for el in dtd.iterelements(): 
+154              if el.name == 'a': 
+155                  self.assertEqual(2, len(el.attributes())) 
+156                  for attr in el.iterattributes(): 
+157                      if attr.name == 'attr1': 
+158                          self.assertEqual('enumeration', attr.type) 
+159                          self.assertEqual('none', attr.default) 
+160                          self.assertEqual('z', attr.default_value) 
+161                          values = attr.values() 
+162                          values.sort() 
+163                          self.assertEqual(['x', 'y', 'z'], values) 
+164                      else: 
+165                          self.assertEqual('attr2', attr.name) 
+166                          self.assertEqual('cdata', attr.type) 
+167                          self.assertEqual('fixed', attr.default) 
+168                          self.assertEqual('X', attr.default_value) 
+169              else: 
+170                  self.assertEqual('b', el.name) 
+171                  self.assertEqual(0, len(el.attributes())) 
+172              seen.append(el.name) 
+173          seen.sort() 
+174          self.assertEqual(['a', 'b'], seen) 
+175          self.assertEqual(2, len(dtd.elements())) 
+
176   
+177 -    def test_internal_dtds(self): 
+
178          for el_count in range(2, 5): 
+179              for attr_count in range(4): 
+180                  root = etree.XML(_bytes(''' 
+181                  <!DOCTYPE el0 SYSTEM "none" [ 
+182                  ''' + ''.join([''' 
+183                  <!ATTLIST el%d 
+184                    attr%d (x | y | z) "z" 
+185                  > 
+186                  ''' % (e, a) for a in range(attr_count) for e in range(el_count) 
+187                  ]) + ''.join([''' 
+188                  <!ELEMENT el%d EMPTY> 
+189                  ''' % e for e in range(1, el_count) 
+190                  ]) + ''' 
+191                  ''' + '<!ELEMENT el0 (%s)>' % '|'.join([ 
+192                      'el%d' % e for e in range(1, el_count)]) + ''' 
+193                  ]> 
+194                  <el0><el1 %s /></el0> 
+195                  ''' % ' '.join(['attr%d="x"' % a for a in range(attr_count)]))) 
+196                  dtd = etree.ElementTree(root).docinfo.internalDTD 
+197                  self.assertTrue(dtd) 
+198                  dtd.assertValid(root) 
+199   
+200                  e = -1 
+201                  for e, el in enumerate(dtd.iterelements()): 
+202                      self.assertEqual(attr_count, len(el.attributes())) 
+203                      a = -1 
+204                      for a, attr in enumerate(el.iterattributes()): 
+205                          self.assertEqual('enumeration', attr.type) 
+206                          self.assertEqual('none', attr.default) 
+207                          self.assertEqual('z', attr.default_value) 
+208                          values = sorted(attr.values()) 
+209                          self.assertEqual(['x', 'y', 'z'], values) 
+210                      self.assertEqual(attr_count - 1, a) 
+211                  self.assertEqual(el_count - 1, e) 
+212                  self.assertEqual(el_count, len(dtd.elements())) 
+
213   
+214 -    def test_dtd_broken(self): 
+
215          self.assertRaises(etree.DTDParseError, etree.DTD, 
+216                            BytesIO("<!ELEMENT b HONKEY>")) 
+
217   
+218 -    def test_parse_file_dtd(self): 
+
219          parser = etree.XMLParser(attribute_defaults=True) 
+220   
+221          tree = etree.parse(fileInTestDir('test.xml'), parser) 
+222          root = tree.getroot() 
+223   
+224          self.assertEqual( 
+225              "valueA", 
+226              root.get("default")) 
+227          self.assertEqual( 
+228              "valueB", 
+229              root[0].get("default")) 
+
230   
+231      @skipIf(etree.LIBXML_VERSION == (2, 9, 0), 
+232              "DTD loading is broken for incremental parsing in libxml2 2.9.0") 
+233 -    def test_iterparse_file_dtd_start(self): 
+
234          iterparse = etree.iterparse 
+235          iterator = iterparse(fileInTestDir("test.xml"), events=('start',), 
+236                               attribute_defaults=True) 
+237          attributes = [ element.get("default") 
+238                         for event, element in iterator ] 
+239          self.assertEqual( 
+240              ["valueA", "valueB"], 
+241              attributes) 
+
242   
+243      @skipIf(etree.LIBXML_VERSION == (2, 9, 0), 
+244              "DTD loading is broken for incremental parsing in libxml2 2.9.0") 
+245 -    def test_iterparse_file_dtd_end(self): 
+
246          iterparse = etree.iterparse 
+247          iterator = iterparse(fileInTestDir("test.xml"), events=('end',), 
+248                               attribute_defaults=True) 
+249          attributes = [ element.get("default") 
+250                         for event, element in iterator ] 
+251          self.assertEqual( 
+252              ["valueB", "valueA"], 
+253              attributes) 
+
254   
+255 -    def test_dtd_attrs(self): 
+
256          dtd = etree.DTD(fileUrlInTestDir("test.dtd")) 
+257   
+258          # Test DTD.system_url attribute 
+259          self.assertTrue(dtd.system_url.endswith("test.dtd")) 
+260   
+261          # Test elements and their attributes 
+262          a = dtd.elements()[0] 
+263          self.assertEqual(a.name, "a") 
+264          self.assertEqual(a.type, "element") 
+265          self.assertEqual(a.content.name, "b") 
+266          self.assertEqual(a.content.type, "element") 
+267          self.assertEqual(a.content.occur, "once") 
+268   
+269          aattr = a.attributes()[0] 
+270          self.assertEqual(aattr.name, "default") 
+271          self.assertEqual(aattr.type, "enumeration") 
+272          self.assertEqual(aattr.values(), ["valueA", "valueB"]) 
+273          self.assertEqual(aattr.default_value, "valueA") 
+274   
+275          b = dtd.elements()[1] 
+276          self.assertEqual(b.name, "b") 
+277          self.assertEqual(b.type, "empty") 
+278          self.assertEqual(b.content, None) 
+279   
+280          # Test entities and their attributes 
+281          c = dtd.entities()[0] 
+282          self.assertEqual(c.name, "c") 
+283          self.assertEqual(c.orig, "&#42;") 
+284          self.assertEqual(c.content, "*") 
+285   
+286          # Test DTD.name attribute 
+287          root = etree.XML(_bytes(''' 
+288          <!DOCTYPE a SYSTEM "none" [ 
+289          <!ELEMENT a EMPTY> 
+290          ]> 
+291          <a/> 
+292          ''')) 
+293          dtd = etree.ElementTree(root).docinfo.internalDTD 
+294          self.assertEqual(dtd.name, "a") 
+295   
+296          # Test DTD.name and DTD.systemID attributes 
+297          parser = etree.XMLParser(dtd_validation=True) 
+298          xml = '<!DOCTYPE a SYSTEM "test.dtd"><a><b/></a>' 
+299          root = etree.fromstring(xml, parser=parser, 
+300                                  base_url=fileUrlInTestDir("test.xml")) 
+301   
+302          dtd = root.getroottree().docinfo.internalDTD 
+303          self.assertEqual(dtd.name, "a") 
+304          self.assertEqual(dtd.system_url, "test.dtd") 
+
305   
+306 -    def test_declaration_escape_quote_pid(self): 
+
307          # Standard allows quotes in systemliteral, but in that case 
+308          # systemliteral must be escaped with single quotes. 
+309          # See http://www.w3.org/TR/REC-xml/#sec-prolog-dtd. 
+310          root = etree.XML('''<!DOCTYPE a PUBLIC 'foo' '"'><a/>''') 
+311          doc = root.getroottree() 
+312          self.assertEqual(doc.docinfo.doctype, 
+313                           '''<!DOCTYPE a PUBLIC "foo" '"'>''') 
+314          self.assertEqual(etree.tostring(doc), 
+315                           _bytes('''<!DOCTYPE a PUBLIC "foo" '"'>\n<a/>''')) 
+
316   
+317 -    def test_declaration_quote_withoutpid(self): 
+
318          root = etree.XML('''<!DOCTYPE a SYSTEM '"'><a/>''') 
+319          doc = root.getroottree() 
+320          self.assertEqual(doc.docinfo.doctype, '''<!DOCTYPE a SYSTEM '"'>''') 
+321          self.assertEqual(etree.tostring(doc), 
+322                           _bytes('''<!DOCTYPE a SYSTEM '"'>\n<a/>''')) 
+
323   
+324 -    def test_declaration_apos(self): 
+
325          root = etree.XML('''<!DOCTYPE a SYSTEM "'"><a/>''') 
+326          doc = root.getroottree() 
+327          self.assertEqual(doc.docinfo.doctype, '''<!DOCTYPE a SYSTEM "'">''') 
+328          self.assertEqual(etree.tostring(doc), 
+329                           _bytes('''<!DOCTYPE a SYSTEM "'">\n<a/>''')) 
+
330   
+331 -    def test_ietf_decl(self): 
+
332          html_data = ( 
+333              '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">\n' 
+334              '<html></html>') 
+335          root = etree.HTML(html_data) 
+336          doc = root.getroottree() 
+337          self.assertEqual(doc.docinfo.doctype, 
+338                           '<!DOCTYPE html PUBLIC "-//IETF//DTD HTML//EN">') 
+339          self.assertEqual(etree.tostring(doc, method='html'), _bytes(html_data)) 
+
340   
+341 -    def test_set_decl_public(self): 
+
342          doc = etree.Element('test').getroottree() 
+343          doc.docinfo.public_id = 'bar' 
+344          doc.docinfo.system_url = 'baz' 
+345          self.assertEqual(doc.docinfo.doctype, 
+346                           '<!DOCTYPE test PUBLIC "bar" "baz">') 
+347          self.assertEqual(etree.tostring(doc), 
+348                           _bytes('<!DOCTYPE test PUBLIC "bar" "baz">\n<test/>')) 
+
349   
+350 -    def test_html_decl(self): 
+
351          # Slightly different to one above: when we create an html element, 
+352          # we do not start with a blank slate. 
+353          doc = html.Element('html').getroottree() 
+354          doc.docinfo.public_id = 'bar' 
+355          doc.docinfo.system_url = 'baz' 
+356          self.assertEqual(doc.docinfo.doctype, 
+357                           '<!DOCTYPE html PUBLIC "bar" "baz">') 
+358          self.assertEqual(etree.tostring(doc), 
+359                           _bytes('<!DOCTYPE html PUBLIC "bar" "baz">\n<html/>')) 
+
360   
+361 -    def test_clean_doctype(self): 
+
362          doc = html.Element('html').getroottree() 
+363          self.assertTrue(doc.docinfo.doctype != '') 
+364          doc.docinfo.clear() 
+365          self.assertTrue(doc.docinfo.doctype == '') 
+
366   
+367 -    def test_set_decl_system(self): 
+
368          doc = etree.Element('test').getroottree() 
+369          doc.docinfo.system_url = 'baz' 
+370          self.assertEqual(doc.docinfo.doctype, 
+371                           '<!DOCTYPE test SYSTEM "baz">') 
+372          self.assertEqual(etree.tostring(doc), 
+373                           _bytes('<!DOCTYPE test SYSTEM "baz">\n<test/>')) 
+
374   
+375 -    def test_empty_decl(self): 
+
376          doc = etree.Element('test').getroottree() 
+377          doc.docinfo.public_id = None 
+378          self.assertEqual(doc.docinfo.doctype, 
+379                           '<!DOCTYPE test>') 
+380          self.assertTrue(doc.docinfo.public_id is None) 
+381          self.assertTrue(doc.docinfo.system_url is None) 
+382          self.assertEqual(etree.tostring(doc), 
+383                           _bytes('<!DOCTYPE test>\n<test/>')) 
+
384   
+385 -    def test_invalid_decl_1(self): 
+
386          docinfo = etree.Element('test').getroottree().docinfo 
+387   
+388          def set_public_id(value): 
+389              docinfo.public_id = value 
+
390          self.assertRaises(ValueError, set_public_id, _str('ä')) 
+391          self.assertRaises(ValueError, set_public_id, _str('qwerty ä asdf')) 
+
392   
+393 -    def test_invalid_decl_2(self): 
+
394          docinfo = etree.Element('test').getroottree().docinfo 
+395   
+396          def set_system_url(value): 
+397              docinfo.system_url = value 
+
398          self.assertRaises(ValueError, set_system_url, '\'"') 
+399          self.assertRaises(ValueError, set_system_url, '"\'') 
+400          self.assertRaises(ValueError, set_system_url, '  "  \'  ') 
+401   
+402 -    def test_comment_before_dtd(self): 
+
403          data = '<!--comment--><!DOCTYPE test>\n<!-- --><test/>' 
+404          doc = etree.fromstring(data).getroottree() 
+405          self.assertEqual(etree.tostring(doc), 
+406                           _bytes(data)) 
+
407   
+408   
+409 -def test_suite(): 
+
410      suite = unittest.TestSuite() 
+411      suite.addTests([unittest.makeSuite(ETreeDtdTestCase)]) 
+412      suite.addTests( 
+413          [make_doctest('../../../doc/validation.txt')]) 
+414      return suite 
+
415   
+416  if __name__ == '__main__': 
+417      print('to test use test.py %s' % __file__) 
+418   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeDtdTestCase
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Tests for the ElementPath implementation. 
+  5  """ 
+  6   
+  7  from __future__ import absolute_import 
+  8   
+  9  import unittest 
+ 10  from copy import deepcopy 
+ 11  from .common_imports import etree, HelperTestCase 
+ 12   
+ 13   
+ 14 -def summarize(elem): 
+
 15      return elem.tag 
+
 16   
+ 17 -def summarize_list(seq): 
+
 18      return list(map(summarize, seq)) 
+
 19   
+ 20 -def normalize_crlf(tree): 
+
 21      for elem in tree.getiterator(): 
+ 22          if elem.text: elem.text = elem.text.replace("\r\n", "\n") 
+ 23          if elem.tail: elem.tail = elem.tail.replace("\r\n", "\n") 
+
 24   
+ 25   
+ 26 -class EtreeElementPathTestCase(HelperTestCase): 
+
 27      etree = etree 
+ 28      from lxml import _elementpath 
+ 29   
+ 30 -    def test_cache(self): 
+
 31          self._elementpath._cache.clear() 
+ 32          el = self.etree.XML(b'<a><b><c/><c/></b></a>') 
+ 33          self.assertFalse(self._elementpath._cache) 
+ 34   
+ 35          self.assertTrue(el.findall('b/c')) 
+ 36          self.assertEqual(1, len(self._elementpath._cache)) 
+ 37          self.assertTrue(el.findall('b/c')) 
+ 38          self.assertEqual(1, len(self._elementpath._cache)) 
+ 39          self.assertFalse(el.findall('xxx')) 
+ 40          self.assertEqual(2, len(self._elementpath._cache)) 
+ 41          self.assertFalse(el.findall('xxx')) 
+ 42          self.assertEqual(2, len(self._elementpath._cache)) 
+ 43          self.assertTrue(el.findall('b/c')) 
+ 44          self.assertEqual(2, len(self._elementpath._cache)) 
+
 45   
+ 46 -    def _assert_tokens(self, tokens, path, namespaces=None): 
+
 47          self.assertEqual(tokens, list(self._elementpath.xpath_tokenizer(path, namespaces))) 
+
 48   
+ 49 -    def test_tokenizer(self): 
+
 50          assert_tokens = self._assert_tokens 
+ 51          assert_tokens( 
+ 52              [('/', '')], 
+ 53              '/', 
+ 54          ) 
+ 55          assert_tokens( 
+ 56              [('.', ''), ('/', ''), ('', 'a'), ('/', ''), ('', 'b'), ('/', ''), ('', 'c')], 
+ 57              './a/b/c', 
+ 58          ) 
+ 59          assert_tokens( 
+ 60              [('/', ''), ('', 'a'), ('/', ''), ('', 'b'), ('/', ''), ('', 'c')], 
+ 61              '/a/b/c', 
+ 62          ) 
+ 63          assert_tokens( 
+ 64              [('/', ''), ('', '{nsx}a'), ('/', ''), ('', '{nsy}b'), ('/', ''), ('', 'c')], 
+ 65              '/x:a/y:b/c', 
+ 66              {'x': 'nsx', 'y': 'nsy'}, 
+ 67          ) 
+ 68          assert_tokens( 
+ 69              [('/', ''), ('', '{nsx}a'), ('/', ''), ('', '{nsy}b'), ('/', ''), ('', '{nsnone}c')], 
+ 70              '/x:a/y:b/c', 
+ 71              {'x': 'nsx', 'y': 'nsy', None: 'nsnone'}, 
+ 72          ) 
+
 73   
+ 74 -    def test_tokenizer_predicates(self): 
+
 75          assert_tokens = self._assert_tokens 
+ 76          assert_tokens( 
+ 77              [('', 'a'), ('[', ''), ('', 'b'), (']', '')], 
+ 78              'a[b]', 
+ 79          ) 
+ 80          assert_tokens( 
+ 81              [('', 'a'), ('[', ''), ('', 'b'), ('=', ''), ('"abc"', ''), (']', '')], 
+ 82              'a[b="abc"]', 
+ 83          ) 
+ 84          assert_tokens( 
+ 85              [('', 'a'), ('[', ''), ('.', ''), ('', ''), ('=', ''), ('', ''), ('"abc"', ''), (']', '')], 
+ 86              'a[. = "abc"]', 
+ 87          ) 
+
 88   
+ 89 -    def test_xpath_tokenizer(self): 
+
 90          # Test the XPath tokenizer.  Copied from CPython's "test_xml_etree.py" 
+ 91          ElementPath = self._elementpath 
+ 92   
+ 93          def check(p, expected, namespaces=None): 
+ 94              self.assertEqual([op or tag 
+ 95                                for op, tag in ElementPath.xpath_tokenizer(p, namespaces)], 
+ 96                               expected) 
+
 97   
+ 98          # tests from the xml specification 
+ 99          check("*", ['*']) 
+100          check("text()", ['text', '()']) 
+101          check("@name", ['@', 'name']) 
+102          check("@*", ['@', '*']) 
+103          check("para[1]", ['para', '[', '1', ']']) 
+104          check("para[last()]", ['para', '[', 'last', '()', ']']) 
+105          check("*/para", ['*', '/', 'para']) 
+106          check("/doc/chapter[5]/section[2]", 
+107                ['/', 'doc', '/', 'chapter', '[', '5', ']', 
+108                 '/', 'section', '[', '2', ']']) 
+109          check("chapter//para", ['chapter', '//', 'para']) 
+110          check("//para", ['//', 'para']) 
+111          check("//olist/item", ['//', 'olist', '/', 'item']) 
+112          check(".", ['.']) 
+113          check(".//para", ['.', '//', 'para']) 
+114          check("..", ['..']) 
+115          check("../@lang", ['..', '/', '@', 'lang']) 
+116          check("chapter[title]", ['chapter', '[', 'title', ']']) 
+117          check("employee[@secretary and @assistant]", ['employee', 
+118                '[', '@', 'secretary', '', 'and', '', '@', 'assistant', ']']) 
+119   
+120          # additional tests 
+121          check("@{ns}attr", ['@', '{ns}attr']) 
+122          check("{http://spam}egg", ['{http://spam}egg']) 
+123          check("./spam.egg", ['.', '/', 'spam.egg']) 
+124          check(".//{http://spam}egg", ['.', '//', '{http://spam}egg']) 
+125   
+126          # wildcard tags 
+127          check("{ns}*", ['{ns}*']) 
+128          check("{}*", ['{}*']) 
+129          check("{*}tag", ['{*}tag']) 
+130          check("{*}*", ['{*}*']) 
+131          check(".//{*}tag", ['.', '//', '{*}tag']) 
+132   
+133          # namespace prefix resolution 
+134          check("./xsd:type", ['.', '/', '{http://www.w3.org/2001/XMLSchema}type'], 
+135                {'xsd': 'http://www.w3.org/2001/XMLSchema'}) 
+136          check("type", ['{http://www.w3.org/2001/XMLSchema}type'], 
+137                {'': 'http://www.w3.org/2001/XMLSchema'}) 
+138          check("@xsd:type", ['@', '{http://www.w3.org/2001/XMLSchema}type'], 
+139                {'xsd': 'http://www.w3.org/2001/XMLSchema'}) 
+140          check("@type", ['@', 'type'], 
+141                {'': 'http://www.w3.org/2001/XMLSchema'}) 
+142          check("@{*}type", ['@', '{*}type'], 
+143                {'': 'http://www.w3.org/2001/XMLSchema'}) 
+144          check("@{ns}attr", ['@', '{ns}attr'], 
+145                {'': 'http://www.w3.org/2001/XMLSchema', 
+146                 'ns': 'http://www.w3.org/2001/XMLSchema'}) 
+
147   
+148 -    def test_find(self): 
+
149          """ 
+150          Test find methods (including xpath syntax). 
+151          Originally copied from 'selftest.py'. 
+152          """ 
+153          elem = etree.XML(""" 
+154          <body> 
+155            <tag class='a'>text</tag> 
+156            <tag class='b' /> 
+157            <section> 
+158              <tag class='b' id='inner'>subtext</tag> 
+159            </section> 
+160          </body> 
+161          """) 
+162   
+163          self.assertEqual(elem.find("tag").tag, 
+164                           'tag') 
+165          self.assertEqual(etree.ElementTree(elem).find("tag").tag, 
+166                           'tag') 
+167          self.assertEqual(elem.find("section/tag").tag, 
+168                           'tag') 
+169          self.assertEqual(etree.ElementTree(elem).find("section/tag").tag, 
+170                           'tag') 
+171   
+172          self.assertEqual(elem.findtext("tag"), 
+173                           'text') 
+174          self.assertEqual(elem.findtext("tog"), 
+175                           None) 
+176          self.assertEqual(elem.findtext("tog", "default"), 
+177                           'default') 
+178          self.assertEqual(etree.ElementTree(elem).findtext("tag"), 
+179                           'text') 
+180          self.assertEqual(elem.findtext("section/tag"), 
+181                           'subtext') 
+182          self.assertEqual(etree.ElementTree(elem).findtext("section/tag"), 
+183                           'subtext') 
+184   
+185          self.assertEqual(summarize_list(elem.findall("tag")), 
+186                           ['tag', 'tag']) 
+187          self.assertEqual(summarize_list(elem.findall("*")), 
+188                           ['tag', 'tag', 'section']) 
+189          self.assertEqual(summarize_list(elem.findall(".//tag")), 
+190                           ['tag', 'tag', 'tag']) 
+191          self.assertEqual(summarize_list(elem.findall("section/tag")), 
+192                           ['tag']) 
+193          self.assertEqual(summarize_list(elem.findall("section//tag")), 
+194                           ['tag']) 
+195   
+196          self.assertEqual(summarize_list(elem.findall("section/*")), 
+197                           ['tag']) 
+198          self.assertEqual(summarize_list(elem.findall("section//*")), 
+199                           ['tag']) 
+200          self.assertEqual(summarize_list(elem.findall("section/.//*")), 
+201                           ['tag']) 
+202          self.assertEqual(summarize_list(elem.findall("*/*")), 
+203                           ['tag']) 
+204          self.assertEqual(summarize_list(elem.findall("*//*")), 
+205                           ['tag']) 
+206          self.assertEqual(summarize_list(elem.findall("*/tag")), 
+207                           ['tag']) 
+208          self.assertEqual(summarize_list(elem.findall("*/./tag")), 
+209                           ['tag']) 
+210          self.assertEqual(summarize_list(elem.findall("./tag")), 
+211                           ['tag', 'tag']) 
+212          self.assertEqual(summarize_list(elem.findall(".//tag")), 
+213                           ['tag', 'tag', 'tag']) 
+214          self.assertEqual(summarize_list(elem.findall("././tag")), 
+215                           ['tag', 'tag']) 
+216   
+217          self.assertEqual(summarize_list(elem.findall(".//tag[@class]")), 
+218                           ['tag', 'tag', 'tag']) 
+219          self.assertEqual(summarize_list(elem.findall(".//tag[ @class]")), 
+220                           ['tag', 'tag', 'tag']) 
+221          self.assertEqual(summarize_list(elem.findall(".//tag[@class ]")), 
+222                           ['tag', 'tag', 'tag']) 
+223          self.assertEqual(summarize_list(elem.findall(".//tag[  @class  ]")), 
+224                           ['tag', 'tag', 'tag']) 
+225          self.assertEqual(summarize_list(elem.findall(".//tag[@class='a']")), 
+226                           ['tag']) 
+227          self.assertEqual(summarize_list(elem.findall('.//tag[@class="a"]')), 
+228                           ['tag']) 
+229          self.assertEqual(summarize_list(elem.findall(".//tag[@class='b']")), 
+230                           ['tag', 'tag']) 
+231          self.assertEqual(summarize_list(elem.findall('.//tag[@class="b"]')), 
+232                           ['tag', 'tag']) 
+233          self.assertEqual(summarize_list(elem.findall('.//tag[@class = "b"]')), 
+234                           ['tag', 'tag']) 
+235          self.assertEqual(summarize_list(elem.findall(".//tag[@id]")), 
+236                           ['tag']) 
+237          self.assertEqual(summarize_list(elem.findall(".//tag[@class][@id]")), 
+238                           ['tag']) 
+239          self.assertEqual(summarize_list(elem.findall(".//section[tag]")), 
+240                           ['section']) 
+241          self.assertEqual(summarize_list(elem.findall(".//section[element]")), 
+242                           []) 
+243   
+244          self.assertEqual(summarize_list(elem.findall(".//section[tag='subtext']")), 
+245                           ['section']) 
+246          self.assertEqual(summarize_list(elem.findall(".//section[tag ='subtext']")), 
+247                           ['section']) 
+248          self.assertEqual(summarize_list(elem.findall(".//section[tag= 'subtext']")), 
+249                           ['section']) 
+250          self.assertEqual(summarize_list(elem.findall(".//section[tag = 'subtext']")), 
+251                           ['section']) 
+252          self.assertEqual(summarize_list(elem.findall(".//section[  tag   =   'subtext'  ]")), 
+253                           ['section']) 
+254          self.assertEqual(summarize_list(elem.findall(".//tag[.='subtext']")), 
+255                           ['tag']) 
+256          self.assertEqual(summarize_list(elem.findall(".//tag[. ='subtext']")), 
+257                           ['tag']) 
+258          self.assertEqual(summarize_list(elem.findall('.//tag[.= "subtext"]')), 
+259                           ['tag']) 
+260          self.assertEqual(summarize_list(elem.findall(".//tag[. = 'subtext']")), 
+261                           ['tag']) 
+262          self.assertEqual(summarize_list(elem.findall(".//tag[. = 'subtext ']")), 
+263                           []) 
+264          self.assertEqual(summarize_list(elem.findall(".//tag[.= ' subtext']")), 
+265                           []) 
+266   
+267          self.assertEqual(summarize_list(elem.findall("../tag")), 
+268                           []) 
+269          self.assertEqual(summarize_list(elem.findall("section/../tag")), 
+270                           ['tag', 'tag']) 
+271          self.assertEqual(summarize_list(etree.ElementTree(elem).findall("./tag")), 
+272                           ['tag', 'tag']) 
+273   
+274          # FIXME: ET's Path module handles this case incorrectly; this gives 
+275          # a warning in 1.3, and the behaviour will be modified in 1.4. 
+276          self.assertEqual(summarize_list(etree.ElementTree(elem).findall("/tag")), 
+277                           ['tag', 'tag']) 
+278   
+279          # duplicate section => 2x tag matches 
+280          elem[1] = deepcopy(elem[2]) 
+281          self.assertEqual(summarize_list(elem.findall(".//section[tag = 'subtext']")), 
+282                           ['section', 'section']) 
+283          self.assertEqual(summarize_list(elem.findall(".//tag[. = 'subtext']")), 
+284                           ['tag', 'tag']) 
+285          self.assertEqual(summarize_list(elem.findall(".//tag[@class][@id]")), 
+286                           ['tag', 'tag']) 
+
287   
+288   
+289  #class ElementTreeElementPathTestCase(EtreeElementPathTestCase): 
+290  #    import xml.etree.ElementTree as etree 
+291  #    import xml.etree.ElementPath as _elementpath 
+292   
+293   
+294 -def test_suite(): 
+
295      suite = unittest.TestSuite() 
+296      suite.addTests([unittest.makeSuite(EtreeElementPathTestCase)]) 
+297      #suite.addTests([unittest.makeSuite(ElementTreeElementPathTestCase)]) 
+298      return suite 
+
299   
+300   
+301  if __name__ == '__main__': 
+302      print('to test use test.py %s' % __file__) 
+303   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               EtreeElementPathTestCase
+
lxml.etree
lxml.etree
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+   1  # -*- coding: utf-8 -*- 
+   2   
+   3  """ 
+   4  Tests for the ElementTree API 
+   5   
+   6  Only test cases that apply equally well to etree and ElementTree 
+   7  belong here. Note that there is a second test module called test_io.py 
+   8  for IO related test cases. 
+   9  """ 
+  10   
+  11  import copy 
+  12  import io 
+  13  import operator 
+  14  import os 
+  15  import re 
+  16  import sys 
+  17  import textwrap 
+  18  import unittest 
+  19  from contextlib import contextmanager 
+  20  from functools import wraps, partial 
+  21  from itertools import islice 
+  22   
+  23  this_dir = os.path.dirname(__file__) 
+  24  if this_dir not in sys.path: 
+  25      sys.path.insert(0, this_dir) # needed for Py3 
+  26   
+  27  from common_imports import BytesIO, etree, HelperTestCase 
+  28  from common_imports import ElementTree, cElementTree, ET_VERSION, CET_VERSION 
+  29  from common_imports import filter_by_version, fileInTestDir, canonicalize, tmpfile 
+  30  from common_imports import _str, _bytes, unicode, next, IS_PYTHON2 
+  31   
+  32  if cElementTree is not None and (CET_VERSION <= (1,0,7) or sys.version_info[0] >= 3): 
+  33      cElementTree = None 
+  34   
+  35  if ElementTree is not None: 
+  36      print("Comparing with ElementTree %s" % getattr(ElementTree, "VERSION", "?")) 
+  37   
+  38  if cElementTree is not None: 
+  39      print("Comparing with cElementTree %s" % getattr(cElementTree, "VERSION", "?")) 
+  40   
+  41   
+  42 -def et_needs_pyversion(*version): 
+
  43      def wrap(method): 
+  44          @wraps(method) 
+  45          def testfunc(self, *args): 
+  46              if self.etree is not etree and sys.version_info < version: 
+  47                  raise unittest.SkipTest("requires ET in Python %s" % '.'.join(map(str, version))) 
+  48              return method(self, *args) 
+
  49          return testfunc 
+  50      return wrap 
+  51   
+  52   
+  53 -class _ETreeTestCaseBase(HelperTestCase): 
+
  54      etree = None 
+  55      required_versions_ET = {} 
+  56      required_versions_cET = {} 
+  57   
+  58 -    def XMLParser(self, **kwargs): 
+
  59          try: 
+  60              XMLParser = self.etree.XMLParser 
+  61          except AttributeError: 
+  62              assert 'ElementTree' in self.etree.__name__ 
+  63              XMLParser = self.etree.TreeBuilder 
+  64          return XMLParser(**kwargs) 
+
  65   
+  66      try: 
+  67          HelperTestCase.assertRegex 
+  68      except AttributeError: 
+  69 -        def assertRegex(self, *args, **kwargs): 
+
  70              return self.assertRegexpMatches(*args, **kwargs) 
+
  71   
+  72      @et_needs_pyversion(3, 6) 
+  73 -    def test_interface(self): 
+
  74          # Test element tree interface. 
+  75   
+  76          def check_string(string): 
+  77              len(string) 
+  78              for char in string: 
+  79                  self.assertEqual(len(char), 1, 
+  80                          msg="expected one-character string, got %r" % char) 
+  81              new_string = string + "" 
+  82              new_string = string + " " 
+  83              string[:0] 
+
  84   
+  85          def check_mapping(mapping): 
+  86              len(mapping) 
+  87              keys = mapping.keys() 
+  88              items = mapping.items() 
+  89              for key in keys: 
+  90                  item = mapping[key] 
+  91              mapping["key"] = "value" 
+  92              self.assertEqual(mapping["key"], "value", 
+  93                      msg="expected value string, got %r" % mapping["key"]) 
+
  94   
+  95          def check_element(element): 
+  96              self.assertTrue(self.etree.iselement(element), msg="not an element") 
+  97              direlem = dir(element) 
+  98              for attr in 'tag', 'attrib', 'text', 'tail': 
+  99                  self.assertTrue(hasattr(element, attr), 
+ 100                          msg='no %s member' % attr) 
+ 101                  self.assertIn(attr, direlem, 
+ 102                          msg='no %s visible by dir' % attr) 
+ 103   
+ 104              check_string(element.tag) 
+ 105              check_mapping(element.attrib) 
+ 106              if element.text is not None: 
+ 107                  check_string(element.text) 
+ 108              if element.tail is not None: 
+ 109                  check_string(element.tail) 
+ 110              for elem in element: 
+ 111                  check_element(elem) 
+ 112   
+ 113          element = self.etree.Element("tag") 
+ 114          check_element(element) 
+ 115          tree = self.etree.ElementTree(element) 
+ 116          check_element(tree.getroot()) 
+ 117          element = self.etree.Element(u"t\xe4g", key="value") 
+ 118          tree = self.etree.ElementTree(element) 
+ 119          # lxml and ET Py2: slightly different repr() 
+ 120          #self.assertRegex(repr(element), r"^<Element 't\xe4g' at 0x.*>$") 
+ 121          element = self.etree.Element("tag", key="value") 
+ 122   
+ 123          # Make sure all standard element methods exist. 
+ 124   
+ 125          def check_method(method): 
+ 126              self.assertTrue(hasattr(method, '__call__'), 
+ 127                      msg="%s not callable" % method) 
+ 128   
+ 129          check_method(element.append) 
+ 130          check_method(element.extend) 
+ 131          check_method(element.insert) 
+ 132          check_method(element.remove) 
+ 133          check_method(element.getchildren) 
+ 134          check_method(element.find) 
+ 135          check_method(element.iterfind) 
+ 136          check_method(element.findall) 
+ 137          check_method(element.findtext) 
+ 138          check_method(element.clear) 
+ 139          check_method(element.get) 
+ 140          check_method(element.set) 
+ 141          check_method(element.keys) 
+ 142          check_method(element.items) 
+ 143          check_method(element.iter) 
+ 144          check_method(element.itertext) 
+ 145          check_method(element.getiterator) 
+ 146   
+ 147          # These methods return an iterable. See bug 6472. 
+ 148   
+ 149          def check_iter(it): 
+ 150              check_method(it.next if IS_PYTHON2 else it.__next__) 
+ 151   
+ 152          check_iter(element.iterfind("tag")) 
+ 153          check_iter(element.iterfind("*")) 
+ 154          check_iter(tree.iterfind("tag")) 
+ 155          check_iter(tree.iterfind("*")) 
+ 156   
+ 157          # These aliases are provided: 
+ 158   
+ 159          # not an alias in lxml 
+ 160          #self.assertEqual(self.etree.XML, self.etree.fromstring) 
+ 161          self.assertEqual(self.etree.PI, self.etree.ProcessingInstruction) 
+ 162   
+ 163 -    def test_element(self): 
+
 164          for i in range(10): 
+ 165              e = self.etree.Element('foo') 
+ 166              self.assertEqual(e.tag, 'foo') 
+ 167              self.assertEqual(e.text, None) 
+ 168              self.assertEqual(e.tail, None) 
+
 169   
+ 170 -    def test_simple(self): 
+
 171          Element = self.etree.Element 
+ 172   
+ 173          root = Element('root') 
+ 174          root.append(Element('one')) 
+ 175          root.append(Element('two')) 
+ 176          root.append(Element('three')) 
+ 177          self.assertEqual(3, len(root)) 
+ 178          self.assertEqual('one', root[0].tag) 
+ 179          self.assertEqual('two', root[1].tag) 
+ 180          self.assertEqual('three', root[2].tag) 
+ 181          self.assertRaises(IndexError, operator.getitem, root, 3) 
+
 182   
+ 183      # test weird dictionary interaction leading to segfault previously 
+ 184 -    def test_weird_dict_interaction(self): 
+
 185          root = self.etree.Element('root') 
+ 186          self.assertEqual(root.tag, "root") 
+ 187          add = self.etree.ElementTree(file=BytesIO('<foo>Foo</foo>')) 
+ 188          self.assertEqual(add.getroot().tag, "foo") 
+ 189          self.assertEqual(add.getroot().text, "Foo") 
+ 190          root.append(self.etree.Element('baz')) 
+ 191          self.assertEqual(root.tag, "root") 
+ 192          self.assertEqual(root[0].tag, "baz") 
+
 193   
+ 194 -    def test_subelement(self): 
+
 195          Element = self.etree.Element 
+ 196          SubElement = self.etree.SubElement 
+ 197   
+ 198          root = Element('root') 
+ 199          SubElement(root, 'one') 
+ 200          SubElement(root, 'two') 
+ 201          SubElement(root, 'three') 
+ 202          self.assertEqual(3, len(root)) 
+ 203          self.assertEqual('one', root[0].tag) 
+ 204          self.assertEqual('two', root[1].tag) 
+ 205          self.assertEqual('three', root[2].tag) 
+
 206   
+ 207 -    def test_element_contains(self): 
+
 208          Element = self.etree.Element 
+ 209          SubElement = self.etree.SubElement 
+ 210   
+ 211          root1 = Element('root') 
+ 212          SubElement(root1, 'one') 
+ 213          self.assertTrue(root1[0] in root1) 
+ 214   
+ 215          root2 = Element('root') 
+ 216          SubElement(root2, 'two') 
+ 217          SubElement(root2, 'three') 
+ 218          self.assertTrue(root2[0] in root2) 
+ 219          self.assertTrue(root2[1] in root2) 
+ 220   
+ 221          self.assertFalse(root1[0] in root2) 
+ 222          self.assertFalse(root2[0] in root1) 
+ 223          self.assertFalse(None in root2) 
+
 224   
+ 225 -    def test_element_indexing_with_text(self): 
+
 226          ElementTree = self.etree.ElementTree 
+ 227   
+ 228          f = BytesIO('<doc>Test<one>One</one></doc>') 
+ 229          doc = ElementTree(file=f) 
+ 230          root = doc.getroot() 
+ 231          self.assertEqual(1, len(root)) 
+ 232          self.assertEqual('one', root[0].tag) 
+ 233          self.assertRaises(IndexError, operator.getitem, root, 1) 
+
 234   
+ 235 -    def test_element_indexing_with_text2(self): 
+
 236          ElementTree = self.etree.ElementTree 
+ 237   
+ 238          f = BytesIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>') 
+ 239          doc = ElementTree(file=f) 
+ 240          root = doc.getroot() 
+ 241          self.assertEqual(3, len(root)) 
+ 242          self.assertEqual('one', root[0].tag) 
+ 243          self.assertEqual('two', root[1].tag) 
+ 244          self.assertEqual('three', root[2].tag) 
+
 245   
+ 246 -    def test_element_indexing_only_text(self): 
+
 247          ElementTree = self.etree.ElementTree 
+ 248   
+ 249          f = BytesIO('<doc>Test</doc>') 
+ 250          doc = ElementTree(file=f) 
+ 251          root = doc.getroot() 
+ 252          self.assertEqual(0, len(root)) 
+
 253   
+ 254 -    def test_element_indexing_negative(self): 
+
 255          Element = self.etree.Element 
+ 256          SubElement = self.etree.SubElement 
+ 257          a = Element('a') 
+ 258          b = SubElement(a, 'b') 
+ 259          c = SubElement(a, 'c') 
+ 260          d = SubElement(a, 'd') 
+ 261          self.assertEqual(d, a[-1]) 
+ 262          self.assertEqual(c, a[-2]) 
+ 263          self.assertEqual(b, a[-3]) 
+ 264          self.assertRaises(IndexError, operator.getitem, a, -4) 
+ 265          a[-1] = e = Element('e') 
+ 266          self.assertEqual(e, a[-1]) 
+ 267          del a[-1] 
+ 268          self.assertEqual(2, len(a)) 
+
 269   
+ 270 -    def test_elementtree(self): 
+
 271          ElementTree = self.etree.ElementTree 
+ 272   
+ 273          f = BytesIO('<doc><one>One</one><two>Two</two></doc>') 
+ 274          doc = ElementTree(file=f) 
+ 275          root = doc.getroot() 
+ 276          self.assertEqual(2, len(root)) 
+ 277          self.assertEqual('one', root[0].tag) 
+ 278          self.assertEqual('two', root[1].tag) 
+
 279   
+ 280 -    def test_text(self): 
+
 281          ElementTree = self.etree.ElementTree 
+ 282   
+ 283          f = BytesIO('<doc>This is a text</doc>') 
+ 284          doc = ElementTree(file=f) 
+ 285          root = doc.getroot() 
+ 286          self.assertEqual('This is a text', root.text) 
+
 287   
+ 288 -    def test_text_empty(self): 
+
 289          ElementTree = self.etree.ElementTree 
+ 290   
+ 291          f = BytesIO('<doc></doc>') 
+ 292          doc = ElementTree(file=f) 
+ 293          root = doc.getroot() 
+ 294          self.assertEqual(None, root.text) 
+
 295   
+ 296 -    def test_text_other(self): 
+
 297          ElementTree = self.etree.ElementTree 
+ 298   
+ 299          f = BytesIO('<doc><one>One</one></doc>') 
+ 300          doc = ElementTree(file=f) 
+ 301          root = doc.getroot() 
+ 302          self.assertEqual(None, root.text) 
+ 303          self.assertEqual('One', root[0].text) 
+
 304   
+ 305 -    def test_text_escape_in(self): 
+
 306          ElementTree = self.etree.ElementTree 
+ 307   
+ 308          f = BytesIO('<doc>This is &gt; than a text</doc>') 
+ 309          doc = ElementTree(file=f) 
+ 310          root = doc.getroot() 
+ 311          self.assertEqual('This is > than a text', root.text) 
+
 312   
+ 313 -    def test_text_escape_out(self): 
+
 314          Element = self.etree.Element 
+ 315   
+ 316          a = Element("a") 
+ 317          a.text = "<>&" 
+ 318          self.assertXML(_bytes('<a>&lt;&gt;&amp;</a>'), 
+ 319                         a) 
+
 320   
+ 321 -    def test_text_escape_tostring(self): 
+
 322          tostring = self.etree.tostring 
+ 323          Element  = self.etree.Element 
+ 324   
+ 325          a = Element("a") 
+ 326          a.text = "<>&" 
+ 327          self.assertEqual(_bytes('<a>&lt;&gt;&amp;</a>'), 
+ 328                           tostring(a)) 
+
 329   
+ 330 -    def test_text_str_subclass(self): 
+
 331          Element = self.etree.Element 
+ 332   
+ 333          class strTest(str): 
+ 334              pass 
+
 335   
+ 336          a = Element("a") 
+ 337          a.text = strTest("text") 
+ 338          self.assertXML(_bytes('<a>text</a>'), 
+ 339                         a) 
+ 340   
+ 341 -    def test_tail(self): 
+
 342          ElementTree = self.etree.ElementTree 
+ 343   
+ 344          f = BytesIO('<doc>This is <i>mixed</i> content.</doc>') 
+ 345          doc = ElementTree(file=f) 
+ 346          root = doc.getroot() 
+ 347          self.assertEqual(1, len(root)) 
+ 348          self.assertEqual('This is ', root.text) 
+ 349          self.assertEqual(None, root.tail) 
+ 350          self.assertEqual('mixed', root[0].text) 
+ 351          self.assertEqual(' content.', root[0].tail) 
+
 352   
+ 353 -    def test_tail_str_subclass(self): 
+
 354          Element = self.etree.Element 
+ 355          SubElement = self.etree.SubElement 
+ 356   
+ 357          class strTest(str): 
+ 358              pass 
+
 359   
+ 360          a = Element("a") 
+ 361          SubElement(a, "t").tail = strTest("tail") 
+ 362          self.assertXML(_bytes('<a><t></t>tail</a>'), 
+ 363                         a) 
+ 364   
+ 365 -    def _test_del_tail(self): 
+
 366          # this is discouraged for ET compat, should not be tested... 
+ 367          XML = self.etree.XML 
+ 368   
+ 369          root = XML(_bytes('<doc>This is <i>mixed</i> content.</doc>')) 
+ 370          self.assertEqual(1, len(root)) 
+ 371          self.assertEqual('This is ', root.text) 
+ 372          self.assertEqual(None, root.tail) 
+ 373          self.assertEqual('mixed', root[0].text) 
+ 374          self.assertEqual(' content.', root[0].tail) 
+ 375   
+ 376          del root[0].tail 
+ 377   
+ 378          self.assertEqual(1, len(root)) 
+ 379          self.assertEqual('This is ', root.text) 
+ 380          self.assertEqual(None, root.tail) 
+ 381          self.assertEqual('mixed', root[0].text) 
+ 382          self.assertEqual(None, root[0].tail) 
+ 383   
+ 384          root[0].tail = "TAIL" 
+ 385   
+ 386          self.assertEqual(1, len(root)) 
+ 387          self.assertEqual('This is ', root.text) 
+ 388          self.assertEqual(None, root.tail) 
+ 389          self.assertEqual('mixed', root[0].text) 
+ 390          self.assertEqual('TAIL', root[0].tail) 
+
 391   
+ 392 -    def test_ElementTree(self): 
+
 393          Element = self.etree.Element 
+ 394          ElementTree = self.etree.ElementTree 
+ 395   
+ 396          el = Element('hoi') 
+ 397          doc = ElementTree(el) 
+ 398          root = doc.getroot() 
+ 399          self.assertEqual(None, root.text) 
+ 400          self.assertEqual('hoi', root.tag) 
+
 401   
+ 402 -    def test_attrib(self): 
+
 403          ElementTree = self.etree.ElementTree 
+ 404   
+ 405          f = BytesIO('<doc one="One" two="Two"/>') 
+ 406          doc = ElementTree(file=f) 
+ 407          root = doc.getroot() 
+ 408          self.assertEqual('One', root.attrib['one']) 
+ 409          self.assertEqual('Two', root.attrib['two']) 
+ 410          self.assertRaises(KeyError, operator.getitem, root.attrib, 'three') 
+
 411   
+ 412 -    def test_attrib_get(self): 
+
 413          ElementTree = self.etree.ElementTree 
+ 414   
+ 415          f = BytesIO('<doc one="One" two="Two"/>') 
+ 416          doc = ElementTree(file=f) 
+ 417          root = doc.getroot() 
+ 418          self.assertEqual('One', root.attrib.get('one')) 
+ 419          self.assertEqual('Two', root.attrib.get('two')) 
+ 420          self.assertEqual(None, root.attrib.get('three')) 
+ 421          self.assertEqual('foo', root.attrib.get('three', 'foo')) 
+
 422   
+ 423 -    def test_attrib_dict(self): 
+
 424          ElementTree = self.etree.ElementTree 
+ 425   
+ 426          f = BytesIO('<doc one="One" two="Two"/>') 
+ 427          doc = ElementTree(file=f) 
+ 428          root = doc.getroot() 
+ 429          attrib = dict(root.attrib) 
+ 430          self.assertEqual('One', attrib['one']) 
+ 431          self.assertEqual('Two', attrib['two']) 
+ 432          self.assertRaises(KeyError, operator.getitem, attrib, 'three') 
+
 433   
+ 434 -    def test_attrib_copy(self): 
+
 435          ElementTree = self.etree.ElementTree 
+ 436   
+ 437          f = BytesIO('<doc one="One" two="Two"/>') 
+ 438          doc = ElementTree(file=f) 
+ 439          root = doc.getroot() 
+ 440          attrib = copy.copy(root.attrib) 
+ 441          self.assertEqual('One', attrib['one']) 
+ 442          self.assertEqual('Two', attrib['two']) 
+ 443          self.assertRaises(KeyError, operator.getitem, attrib, 'three') 
+
 444   
+ 445 -    def test_attrib_deepcopy(self): 
+
 446          ElementTree = self.etree.ElementTree 
+ 447   
+ 448          f = BytesIO('<doc one="One" two="Two"/>') 
+ 449          doc = ElementTree(file=f) 
+ 450          root = doc.getroot() 
+ 451          attrib = copy.deepcopy(root.attrib) 
+ 452          self.assertEqual('One', attrib['one']) 
+ 453          self.assertEqual('Two', attrib['two']) 
+ 454          self.assertRaises(KeyError, operator.getitem, attrib, 'three') 
+
 455   
+ 456 -    def test_attributes_get(self): 
+
 457          ElementTree = self.etree.ElementTree 
+ 458   
+ 459          f = BytesIO('<doc one="One" two="Two"/>') 
+ 460          doc = ElementTree(file=f) 
+ 461          root = doc.getroot() 
+ 462          self.assertEqual('One', root.get('one')) 
+ 463          self.assertEqual('Two', root.get('two')) 
+ 464          self.assertEqual(None, root.get('three')) 
+ 465          self.assertEqual('foo', root.get('three', 'foo')) 
+
 466   
+ 467 -    def test_attrib_clear(self): 
+
 468          XML = self.etree.XML 
+ 469   
+ 470          root = XML(_bytes('<doc one="One" two="Two"/>')) 
+ 471          self.assertEqual('One', root.get('one')) 
+ 472          self.assertEqual('Two', root.get('two')) 
+ 473          root.attrib.clear() 
+ 474          self.assertEqual(None, root.get('one')) 
+ 475          self.assertEqual(None, root.get('two')) 
+
 476   
+ 477 -    def test_attrib_set_clear(self): 
+
 478          Element = self.etree.Element 
+ 479   
+ 480          root = Element("root", one="One") 
+ 481          root.set("two", "Two") 
+ 482          self.assertEqual('One', root.get('one')) 
+ 483          self.assertEqual('Two', root.get('two')) 
+ 484          root.attrib.clear() 
+ 485          self.assertEqual(None, root.get('one')) 
+ 486          self.assertEqual(None, root.get('two')) 
+
 487   
+ 488 -    def test_attrib_ns_clear(self): 
+
 489          Element = self.etree.Element 
+ 490          SubElement = self.etree.SubElement 
+ 491   
+ 492          attribNS = '{http://foo/bar}x' 
+ 493   
+ 494          parent = Element('parent') 
+ 495          parent.set(attribNS, 'a') 
+ 496          child = SubElement(parent, 'child') 
+ 497          child.set(attribNS, 'b') 
+ 498   
+ 499          self.assertEqual('a', parent.get(attribNS)) 
+ 500          self.assertEqual('b', child.get(attribNS)) 
+ 501   
+ 502          parent.clear() 
+ 503          self.assertEqual(None, parent.get(attribNS)) 
+ 504          self.assertEqual('b', child.get(attribNS)) 
+
 505   
+ 506 -    def test_attrib_pop(self): 
+
 507          ElementTree = self.etree.ElementTree 
+ 508   
+ 509          f = BytesIO('<doc one="One" two="Two"/>') 
+ 510          doc = ElementTree(file=f) 
+ 511          root = doc.getroot() 
+ 512          self.assertEqual('One', root.attrib['one']) 
+ 513          self.assertEqual('Two', root.attrib['two']) 
+ 514   
+ 515          self.assertEqual('One', root.attrib.pop('one')) 
+ 516   
+ 517          self.assertEqual(None, root.attrib.get('one')) 
+ 518          self.assertEqual('Two', root.attrib['two']) 
+
 519   
+ 520 -    def test_attrib_pop_unknown(self): 
+
 521          root = self.etree.XML(_bytes('<doc one="One" two="Two"/>')) 
+ 522          self.assertRaises(KeyError, root.attrib.pop, 'NONE') 
+ 523   
+ 524          self.assertEqual('One', root.attrib['one']) 
+ 525          self.assertEqual('Two', root.attrib['two']) 
+
 526   
+ 527 -    def test_attrib_pop_default(self): 
+
 528          root = self.etree.XML(_bytes('<doc one="One" two="Two"/>')) 
+ 529          self.assertEqual('Three', root.attrib.pop('three', 'Three')) 
+
 530   
+ 531 -    def test_attrib_pop_empty_default(self): 
+
 532          root = self.etree.XML(_bytes('<doc/>')) 
+ 533          self.assertEqual('Three', root.attrib.pop('three', 'Three')) 
+
 534   
+ 535 -    def test_attrib_pop_invalid_args(self): 
+
 536          root = self.etree.XML(_bytes('<doc one="One" two="Two"/>')) 
+ 537          self.assertRaises(TypeError, root.attrib.pop, 'One', None, None) 
+
 538   
+ 539 -    def test_attribute_update_dict(self): 
+
 540          XML = self.etree.XML 
+ 541   
+ 542          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 
+ 543          items = list(root.attrib.items()) 
+ 544          items.sort() 
+ 545          self.assertEqual( 
+ 546              [('alpha', 'Alpha'), ('beta', 'Beta')], 
+ 547              items) 
+ 548   
+ 549          root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}) 
+ 550   
+ 551          items = list(root.attrib.items()) 
+ 552          items.sort() 
+ 553          self.assertEqual( 
+ 554              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 
+ 555              items) 
+
 556   
+ 557 -    def test_attribute_update_sequence(self): 
+
 558          XML = self.etree.XML 
+ 559   
+ 560          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 
+ 561          items = list(root.attrib.items()) 
+ 562          items.sort() 
+ 563          self.assertEqual( 
+ 564              [('alpha', 'Alpha'), ('beta', 'Beta')], 
+ 565              items) 
+ 566   
+ 567          root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items()) 
+ 568   
+ 569          items = list(root.attrib.items()) 
+ 570          items.sort() 
+ 571          self.assertEqual( 
+ 572              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 
+ 573              items) 
+
 574   
+ 575 -    def test_attribute_update_iter(self): 
+
 576          XML = self.etree.XML 
+ 577   
+ 578          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 
+ 579          items = list(root.attrib.items()) 
+ 580          items.sort() 
+ 581          self.assertEqual( 
+ 582              [('alpha', 'Alpha'), ('beta', 'Beta')], 
+ 583              items) 
+ 584   
+ 585          root.attrib.update(iter({'alpha' : 'test', 'gamma' : 'Gamma'}.items())) 
+ 586   
+ 587          items = list(root.attrib.items()) 
+ 588          items.sort() 
+ 589          self.assertEqual( 
+ 590              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 
+ 591              items) 
+
 592   
+ 593 -    def test_attribute_update_attrib(self): 
+
 594          XML = self.etree.XML 
+ 595   
+ 596          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 
+ 597          items = list(root.attrib.items()) 
+ 598          items.sort() 
+ 599          self.assertEqual( 
+ 600              [('alpha', 'Alpha'), ('beta', 'Beta')], 
+ 601                                                    items) 
+ 602   
+ 603          other = XML(_bytes('<doc alpha="test" gamma="Gamma"/>')) 
+ 604          root.attrib.update(other.attrib) 
+ 605   
+ 606          items = list(root.attrib.items()) 
+ 607          items.sort() 
+ 608          self.assertEqual( 
+ 609              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 
+ 610                                                                       items) 
+
 611   
+ 612 -    def test_attribute_keys(self): 
+
 613          XML = self.etree.XML 
+ 614   
+ 615          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
+ 616          keys = list(root.attrib.keys()) 
+ 617          keys.sort() 
+ 618          self.assertEqual(['alpha', 'beta', 'gamma'], keys) 
+
 619   
+ 620 -    def test_attribute_keys2(self): 
+
 621          XML = self.etree.XML 
+ 622   
+ 623          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
+ 624          keys = list(root.keys()) 
+ 625          keys.sort() 
+ 626          self.assertEqual(['alpha', 'beta', 'gamma'], keys) 
+
 627   
+ 628 -    def test_attribute_items2(self): 
+
 629          XML = self.etree.XML 
+ 630   
+ 631          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
+ 632          items = list(root.items()) 
+ 633          items.sort() 
+ 634          self.assertEqual( 
+ 635              [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')], 
+ 636              items) 
+
 637   
+ 638 -    def test_attribute_keys_ns(self): 
+
 639          XML = self.etree.XML 
+ 640   
+ 641          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
+ 642          keys = list(root.keys()) 
+ 643          keys.sort() 
+ 644          self.assertEqual(['bar', '{http://ns.codespeak.net/test}baz'], 
+ 645                            keys) 
+
 646   
+ 647 -    def test_attribute_values(self): 
+
 648          XML = self.etree.XML 
+ 649   
+ 650          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
+ 651          values = list(root.attrib.values()) 
+ 652          values.sort() 
+ 653          self.assertEqual(['Alpha', 'Beta', 'Gamma'], values) 
+
 654   
+ 655 -    def test_attribute_values_ns(self): 
+
 656          XML = self.etree.XML 
+ 657   
+ 658          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
+ 659          values = list(root.attrib.values()) 
+ 660          values.sort() 
+ 661          self.assertEqual( 
+ 662              ['Bar', 'Baz'], values) 
+
 663   
+ 664 -    def test_attribute_items(self): 
+
 665          XML = self.etree.XML 
+ 666   
+ 667          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
+ 668          items = list(root.attrib.items()) 
+ 669          items.sort() 
+ 670          self.assertEqual([ 
+ 671              ('alpha', 'Alpha'), 
+ 672              ('beta', 'Beta'), 
+ 673              ('gamma', 'Gamma'), 
+ 674              ],  
+ 675              items) 
+
 676   
+ 677 -    def test_attribute_items_ns(self): 
+
 678          XML = self.etree.XML 
+ 679   
+ 680          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
+ 681          items = list(root.attrib.items()) 
+ 682          items.sort() 
+ 683          self.assertEqual( 
+ 684              [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 
+ 685              items) 
+
 686   
+ 687 -    def test_attribute_str(self): 
+
 688          XML = self.etree.XML 
+ 689   
+ 690          expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 
+ 691          alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 
+ 692   
+ 693          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
+ 694          try: 
+ 695              self.assertEqual(expected, str(root.attrib)) 
+ 696          except AssertionError: 
+ 697              self.assertEqual(alternative, str(root.attrib)) 
+
 698   
+ 699 -    def test_attribute_contains(self): 
+
 700          XML = self.etree.XML 
+ 701   
+ 702          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
+ 703          self.assertEqual( 
+ 704              True, 'bar' in root.attrib) 
+ 705          self.assertEqual( 
+ 706              False, 'baz' in root.attrib) 
+ 707          self.assertEqual( 
+ 708              False, 'hah' in root.attrib) 
+ 709          self.assertEqual( 
+ 710              True, 
+ 711              '{http://ns.codespeak.net/test}baz' in root.attrib) 
+
 712   
+ 713 -    def test_attribute_set(self): 
+
 714          Element = self.etree.Element 
+ 715   
+ 716          root = Element("root") 
+ 717          root.set("attr", "TEST") 
+ 718          self.assertEqual("TEST", root.get("attr")) 
+
 719   
+ 720 -    def test_attrib_as_attrib(self): 
+
 721          Element = self.etree.Element 
+ 722   
+ 723          root = Element("root") 
+ 724          root.set("attr", "TEST") 
+ 725          self.assertEqual("TEST", root.attrib["attr"]) 
+ 726   
+ 727          root2 = Element("root2", root.attrib) 
+ 728          self.assertEqual("TEST", root2.attrib["attr"]) 
+
 729   
+ 730 -    def test_attribute_iterator(self): 
+
 731          XML = self.etree.XML 
+ 732   
+ 733          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')) 
+ 734          result = [] 
+ 735          for key in root.attrib: 
+ 736              result.append(key) 
+ 737          result.sort() 
+ 738          self.assertEqual(['alpha', 'beta', 'gamma'], result) 
+
 739   
+ 740 -    def test_attribute_manipulation(self): 
+
 741          Element = self.etree.Element 
+ 742   
+ 743          a = Element('a') 
+ 744          a.attrib['foo'] = 'Foo' 
+ 745          a.attrib['bar'] = 'Bar' 
+ 746          self.assertEqual('Foo', a.attrib['foo']) 
+ 747          del a.attrib['foo'] 
+ 748          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
+
 749   
+ 750 -    def test_del_attribute_ns(self): 
+
 751          Element = self.etree.Element 
+ 752   
+ 753          a = Element('a') 
+ 754          a.attrib['{http://a/}foo'] = 'Foo' 
+ 755          a.attrib['{http://a/}bar'] = 'Bar' 
+ 756          self.assertEqual(None, a.get('foo')) 
+ 757          self.assertEqual('Foo', a.get('{http://a/}foo')) 
+ 758          self.assertEqual('Foo', a.attrib['{http://a/}foo']) 
+ 759   
+ 760          self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 
+ 761          self.assertEqual('Foo', a.attrib['{http://a/}foo']) 
+ 762   
+ 763          del a.attrib['{http://a/}foo'] 
+ 764          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
+
 765   
+ 766 -    def test_del_attribute_ns_parsed(self): 
+
 767          XML = self.etree.XML 
+ 768   
+ 769          a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />')) 
+ 770   
+ 771          self.assertEqual('Foo', a.attrib['foo']) 
+ 772          self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 
+ 773   
+ 774          del a.attrib['foo'] 
+ 775          self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 
+ 776          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
+ 777          self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 
+ 778   
+ 779          del a.attrib['{http://a/}foo'] 
+ 780          self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 
+ 781          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
+ 782   
+ 783          a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />')) 
+ 784   
+ 785          self.assertEqual('Foo', a.attrib['foo']) 
+ 786          self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 
+ 787   
+ 788          del a.attrib['foo'] 
+ 789          self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 
+ 790          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
+ 791   
+ 792          del a.attrib['{http://a/}foo'] 
+ 793          self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 
+ 794          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
+
 795   
+ 796 -    def test_XML(self): 
+
 797          XML = self.etree.XML 
+ 798   
+ 799          root = XML(_bytes('<doc>This is a text.</doc>')) 
+ 800          self.assertEqual(0, len(root)) 
+ 801          self.assertEqual('This is a text.', root.text) 
+
 802   
+ 803 -    def test_XMLID(self): 
+
 804          XMLID = self.etree.XMLID 
+ 805          XML   = self.etree.XML 
+ 806          xml_text = _bytes(''' 
+ 807          <document> 
+ 808            <h1 id="chapter1">...</h1> 
+ 809            <p id="note1" class="note">...</p> 
+ 810            <p>Regular paragraph.</p> 
+ 811            <p xml:id="xmlid">XML:ID paragraph.</p> 
+ 812            <p id="warn1" class="warning">...</p> 
+ 813          </document> 
+ 814          ''') 
+ 815   
+ 816          root, dic = XMLID(xml_text) 
+ 817          root2 = XML(xml_text) 
+ 818          self.assertEqual(self._writeElement(root), 
+ 819                            self._writeElement(root2)) 
+ 820          expected = { 
+ 821              "chapter1" : root[0], 
+ 822              "note1"    : root[1], 
+ 823              "warn1"    : root[4] 
+ 824              } 
+ 825          self.assertEqual(dic, expected) 
+
 826   
+ 827 -    def test_fromstring(self): 
+
 828          fromstring = self.etree.fromstring 
+ 829   
+ 830          root = fromstring('<doc>This is a text.</doc>') 
+ 831          self.assertEqual(0, len(root)) 
+ 832          self.assertEqual('This is a text.', root.text) 
+
 833   
+ 834      required_versions_ET['test_fromstringlist'] = (1,3) 
+ 835 -    def test_fromstringlist(self): 
+
 836          fromstringlist = self.etree.fromstringlist 
+ 837   
+ 838          root = fromstringlist(["<do", "c>T", "hi", "s is", 
+ 839                                 " a text.<", "/doc", ">"]) 
+ 840          self.assertEqual(0, len(root)) 
+ 841          self.assertEqual('This is a text.', root.text) 
+
 842   
+ 843      required_versions_ET['test_fromstringlist_characters'] = (1,3) 
+ 844 -    def test_fromstringlist_characters(self): 
+
 845          fromstringlist = self.etree.fromstringlist 
+ 846   
+ 847          root = fromstringlist(list('<doc>This is a text.</doc>')) 
+ 848          self.assertEqual(0, len(root)) 
+ 849          self.assertEqual('This is a text.', root.text) 
+
 850   
+ 851      required_versions_ET['test_fromstringlist_single'] = (1,3) 
+ 852 -    def test_fromstringlist_single(self): 
+
 853          fromstringlist = self.etree.fromstringlist 
+ 854   
+ 855          root = fromstringlist(['<doc>This is a text.</doc>']) 
+ 856          self.assertEqual(0, len(root)) 
+ 857          self.assertEqual('This is a text.', root.text) 
+
 858   
+ 859 -    def test_iselement(self): 
+
 860          iselement = self.etree.iselement 
+ 861          Element = self.etree.Element 
+ 862          ElementTree = self.etree.ElementTree 
+ 863          XML = self.etree.XML 
+ 864          Comment = self.etree.Comment 
+ 865          ProcessingInstruction = self.etree.ProcessingInstruction 
+ 866   
+ 867          el = Element('hoi') 
+ 868          self.assertTrue(iselement(el)) 
+ 869   
+ 870          el2 = XML(_bytes('<foo/>')) 
+ 871          self.assertTrue(iselement(el2)) 
+ 872   
+ 873          tree = ElementTree(element=Element('dag')) 
+ 874          self.assertTrue(not iselement(tree)) 
+ 875          self.assertTrue(iselement(tree.getroot())) 
+ 876   
+ 877          c = Comment('test') 
+ 878          self.assertTrue(iselement(c)) 
+ 879   
+ 880          p = ProcessingInstruction("test", "some text") 
+ 881          self.assertTrue(iselement(p)) 
+
 882   
+ 883 -    def test_iteration(self): 
+
 884          XML = self.etree.XML 
+ 885   
+ 886          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
+ 887          result = [] 
+ 888          for el in root: 
+ 889              result.append(el.tag) 
+ 890          self.assertEqual(['one', 'two', 'three'], result) 
+
 891   
+ 892 -    def test_iteration_empty(self): 
+
 893          XML = self.etree.XML 
+ 894   
+ 895          root = XML(_bytes('<doc></doc>')) 
+ 896          result = [] 
+ 897          for el in root: 
+ 898              result.append(el.tag) 
+ 899          self.assertEqual([], result) 
+
 900   
+ 901 -    def test_iteration_text_only(self): 
+
 902          XML = self.etree.XML 
+ 903   
+ 904          root = XML(_bytes('<doc>Text</doc>')) 
+ 905          result = [] 
+ 906          for el in root: 
+ 907              result.append(el.tag) 
+ 908          self.assertEqual([], result) 
+
 909   
+ 910 -    def test_iteration_set_tail_empty(self): 
+
 911          # this would cause a crash in the past 
+ 912          fromstring = self.etree.fromstring 
+ 913          root = fromstring('<html><p></p>x</html>') 
+ 914          for elem in root: 
+ 915              elem.tail = '' 
+
 916   
+ 917 -    def test_iteration_clear_tail(self): 
+
 918          # this would cause a crash in the past 
+ 919          fromstring = self.etree.fromstring 
+ 920          root = fromstring('<html><p></p>x</html>') 
+ 921          for elem in root: 
+ 922              elem.tail = None 
+
 923   
+ 924 -    def test_iteration_reversed(self): 
+
 925          XML = self.etree.XML 
+ 926          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
+ 927          result = [] 
+ 928          for el in reversed(root): 
+ 929              result.append(el.tag) 
+ 930          self.assertEqual(['three', 'two', 'one'], result) 
+
 931   
+ 932 -    def test_iteration_subelement(self): 
+
 933          XML = self.etree.XML 
+ 934   
+ 935          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
+ 936          result = [] 
+ 937          add = True 
+ 938          for el in root: 
+ 939              result.append(el.tag) 
+ 940              if add: 
+ 941                  self.etree.SubElement(root, 'four') 
+ 942                  add = False 
+ 943          self.assertEqual(['one', 'two', 'three', 'four'], result) 
+
 944   
+ 945 -    def test_iteration_del_child(self): 
+
 946          XML = self.etree.XML 
+ 947   
+ 948          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
+ 949          result = [] 
+ 950          for el in root: 
+ 951              result.append(el.tag) 
+ 952              del root[-1] 
+ 953          self.assertEqual(['one', 'two'], result) 
+
 954   
+ 955 -    def test_iteration_double(self): 
+
 956          XML = self.etree.XML 
+ 957   
+ 958          root = XML(_bytes('<doc><one/><two/></doc>')) 
+ 959          result = [] 
+ 960          for el0 in root: 
+ 961              result.append(el0.tag) 
+ 962              for el1 in root: 
+ 963                  result.append(el1.tag) 
+ 964          self.assertEqual(['one','one', 'two', 'two', 'one', 'two'], result) 
+
 965   
+ 966      required_versions_ET['test_itertext'] = (1,3) 
+ 967 -    def test_itertext(self): 
+
 968          # ET 1.3+ 
+ 969          XML = self.etree.XML 
+ 970          root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>")) 
+ 971   
+ 972          text = list(root.itertext()) 
+ 973          self.assertEqual(["RTEXT", "ATAIL", "CTEXT", "CTAIL"], 
+ 974                            text) 
+
 975   
+ 976      required_versions_ET['test_itertext_child'] = (1,3) 
+ 977 -    def test_itertext_child(self): 
+
 978          # ET 1.3+ 
+ 979          XML = self.etree.XML 
+ 980          root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>")) 
+ 981   
+ 982          text = list(root[2].itertext()) 
+ 983          self.assertEqual(["CTEXT"], 
+ 984                            text) 
+
 985   
+ 986 -    def test_findall(self): 
+
 987          XML = self.etree.XML 
+ 988          root = XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')) 
+ 989          self.assertEqual(len(list(root.findall("c"))), 1) 
+ 990          self.assertEqual(len(list(root.findall(".//c"))), 2) 
+ 991          self.assertEqual(len(list(root.findall(".//b"))), 3) 
+ 992          self.assertEqual(len(list(root.findall(".//b"))[0]), 1) 
+ 993          self.assertEqual(len(list(root.findall(".//b"))[1]), 0) 
+ 994          self.assertEqual(len(list(root.findall(".//b"))[2]), 0) 
+
 995   
+ 996 -    def test_findall_ns(self): 
+
 997          XML = self.etree.XML 
+ 998          root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')) 
+ 999          self.assertEqual(len(list(root.findall(".//{X}b"))), 2) 
+1000          self.assertEqual(len(list(root.findall(".//b"))), 3) 
+1001          self.assertEqual(len(list(root.findall("b"))), 2) 
+
1002   
+1003      @et_needs_pyversion(3, 8, 0, 'alpha', 4) 
+1004 -    def test_findall_wildcard(self): 
+
1005          def summarize_list(l): 
+1006              return [el.tag for el in l] 
+
1007   
+1008          root = self.etree.XML(''' 
+1009              <a xmlns:x="X" xmlns:y="Y"> 
+1010                  <x:b><c/></x:b> 
+1011                  <b/> 
+1012                  <c><x:b/><b/></c><y:b/> 
+1013              </a>''') 
+1014          root.append(self.etree.Comment('test')) 
+1015   
+1016          self.assertEqual(summarize_list(root.findall("{*}b")), 
+1017                           ['{X}b', 'b', '{Y}b']) 
+1018          self.assertEqual(summarize_list(root.findall("{*}c")), 
+1019                           ['c']) 
+1020          self.assertEqual(summarize_list(root.findall("{X}*")), 
+1021                           ['{X}b']) 
+1022          self.assertEqual(summarize_list(root.findall("{Y}*")), 
+1023                           ['{Y}b']) 
+1024          self.assertEqual(summarize_list(root.findall("{}*")), 
+1025                           ['b', 'c']) 
+1026          self.assertEqual(summarize_list(root.findall("{}b")),  # only for consistency 
+1027                           ['b']) 
+1028          self.assertEqual(summarize_list(root.findall("{}b")), 
+1029                           summarize_list(root.findall("b"))) 
+1030          self.assertEqual(summarize_list(root.findall("{*}*")), 
+1031                           ['{X}b', 'b', 'c', '{Y}b']) 
+1032          self.assertEqual(summarize_list(root.findall("{*}*") 
+1033                           + ([] if self.etree is etree else [root[-1]])), 
+1034                           summarize_list(root.findall("*"))) 
+1035   
+1036          self.assertEqual(summarize_list(root.findall(".//{*}b")), 
+1037                           ['{X}b', 'b', '{X}b', 'b', '{Y}b']) 
+1038          self.assertEqual(summarize_list(root.findall(".//{*}c")), 
+1039                           ['c', 'c']) 
+1040          self.assertEqual(summarize_list(root.findall(".//{X}*")), 
+1041                           ['{X}b', '{X}b']) 
+1042          self.assertEqual(summarize_list(root.findall(".//{Y}*")), 
+1043                           ['{Y}b']) 
+1044          self.assertEqual(summarize_list(root.findall(".//{}*")), 
+1045                           ['c', 'b', 'c', 'b']) 
+1046          self.assertEqual(summarize_list(root.findall(".//{}b")), 
+1047                           ['b', 'b']) 
+1048   
+1049 -    def test_element_with_attributes_keywords(self): 
+
1050          Element = self.etree.Element 
+1051   
+1052          el = Element('tag', foo='Foo', bar='Bar') 
+1053          self.assertEqual('Foo', el.attrib['foo']) 
+1054          self.assertEqual('Bar', el.attrib['bar']) 
+
1055   
+1056 -    def test_element_with_attributes(self): 
+
1057          Element = self.etree.Element 
+1058   
+1059          el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}) 
+1060          self.assertEqual('Foo', el.attrib['foo']) 
+1061          self.assertEqual('Bar', el.attrib['bar']) 
+
1062   
+1063 -    def test_element_with_attributes_extra(self): 
+
1064          Element = self.etree.Element 
+1065   
+1066          el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}, baz='Baz') 
+1067          self.assertEqual('Foo', el.attrib['foo']) 
+1068          self.assertEqual('Bar', el.attrib['bar']) 
+1069          self.assertEqual('Baz', el.attrib['baz']) 
+
1070   
+1071 -    def test_element_with_attributes_extra_duplicate(self): 
+
1072          Element = self.etree.Element 
+1073   
+1074          el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}, bar='Baz') 
+1075          self.assertEqual('Foo', el.attrib['foo']) 
+1076          self.assertEqual('Baz', el.attrib['bar']) 
+
1077   
+1078 -    def test_element_with_attributes_ns(self): 
+
1079          Element = self.etree.Element 
+1080   
+1081          el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 
+1082          self.assertEqual('Foo', el.attrib['{ns1}foo']) 
+1083          self.assertEqual('Bar', el.attrib['{ns2}bar']) 
+
1084   
+1085 -    def test_subelement_with_attributes(self): 
+
1086          Element =  self.etree.Element 
+1087          SubElement = self.etree.SubElement 
+1088   
+1089          el = Element('tag') 
+1090          SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 
+1091          self.assertEqual("Baz", el[0].attrib['baz']) 
+1092          self.assertEqual('Foo', el[0].attrib['foo']) 
+
1093   
+1094 -    def test_subelement_with_attributes_ns(self): 
+
1095          Element = self.etree.Element 
+1096          SubElement = self.etree.SubElement 
+1097   
+1098          el = Element('tag') 
+1099          SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 
+1100          self.assertEqual('Foo', el[0].attrib['{ns1}foo']) 
+1101          self.assertEqual('Bar', el[0].attrib['{ns2}bar']) 
+
1102   
+1103 -    def test_write(self): 
+
1104          ElementTree = self.etree.ElementTree 
+1105          XML = self.etree.XML 
+1106   
+1107          for i in range(10): 
+1108              f = BytesIO()  
+1109              root = XML(_bytes('<doc%s>This is a test.</doc%s>' % (i, i))) 
+1110              tree = ElementTree(element=root) 
+1111              tree.write(f) 
+1112              data = f.getvalue() 
+1113              self.assertEqual( 
+1114                  _bytes('<doc%s>This is a test.</doc%s>' % (i, i)), 
+1115                  canonicalize(data)) 
+
1116   
+1117      required_versions_ET['test_write_method_html'] = (1,3) 
+1118 -    def test_write_method_html(self): 
+
1119          ElementTree = self.etree.ElementTree 
+1120          Element = self.etree.Element 
+1121          SubElement = self.etree.SubElement 
+1122   
+1123          html = Element('html') 
+1124          body = SubElement(html, 'body') 
+1125          p = SubElement(body, 'p') 
+1126          p.text = "html" 
+1127          SubElement(p, 'br').tail = "test" 
+1128   
+1129          tree = ElementTree(element=html) 
+1130          f = BytesIO()  
+1131          tree.write(f, method="html") 
+1132          data = f.getvalue().replace(_bytes('\n'),_bytes('')) 
+1133   
+1134          self.assertEqual(_bytes('<html><body><p>html<br>test</p></body></html>'), 
+1135                            data) 
+
1136   
+1137      required_versions_ET['test_write_method_text'] = (1,3) 
+1138 -    def test_write_method_text(self): 
+
1139          ElementTree = self.etree.ElementTree 
+1140          Element = self.etree.Element 
+1141          SubElement = self.etree.SubElement 
+1142   
+1143          a = Element('a') 
+1144          a.text = "A" 
+1145          a.tail = "tail" 
+1146          b = SubElement(a, 'b') 
+1147          b.text = "B" 
+1148          b.tail = "TAIL" 
+1149          c = SubElement(a, 'c') 
+1150          c.text = "C" 
+1151   
+1152          tree = ElementTree(element=a) 
+1153          f = BytesIO()  
+1154          tree.write(f, method="text") 
+1155          data = f.getvalue() 
+1156   
+1157          self.assertEqual(_bytes('ABTAILCtail'), 
+1158                            data) 
+
1159   
+1160 -    def test_write_fail(self): 
+
1161          ElementTree = self.etree.ElementTree 
+1162          XML = self.etree.XML 
+1163   
+1164          tree = ElementTree( XML(_bytes('<doc>This is a test.</doc>')) ) 
+1165          self.assertRaises(IOError, tree.write, 
+1166                            "definitely////\\-\\nonexisting\\-\\////FILE") 
+
1167   
+1168      # this could trigger a crash, apparently because the document 
+1169      # reference was prematurely garbage collected 
+1170 -    def test_crash(self): 
+
1171          Element = self.etree.Element 
+1172   
+1173          element = Element('tag') 
+1174          for i in range(10): 
+1175              element.attrib['key'] = 'value' 
+1176              value = element.attrib['key'] 
+1177              self.assertEqual(value, 'value') 
+
1178   
+1179      # from doctest; for some reason this caused crashes too 
+1180 -    def test_write_ElementTreeDoctest(self): 
+
1181          Element = self.etree.Element 
+1182          ElementTree = self.etree.ElementTree 
+1183   
+1184          f = BytesIO() 
+1185          for i in range(10): 
+1186              element = Element('tag%s' % i) 
+1187              self._check_element(element) 
+1188              tree = ElementTree(element) 
+1189              tree.write(f) 
+1190              self._check_element_tree(tree) 
+
1191   
+1192 -    def test_subelement_reference(self): 
+
1193          Element = self.etree.Element 
+1194          SubElement = self.etree.SubElement 
+1195   
+1196          el = Element('foo') 
+1197          el2 = SubElement(el, 'bar') 
+1198          el3 = SubElement(el2, 'baz') 
+1199   
+1200          al = Element('foo2') 
+1201          al2 = SubElement(al, 'bar2') 
+1202          al3 = SubElement(al2, 'baz2') 
+1203   
+1204          # now move al2 into el 
+1205          el.append(al2) 
+1206   
+1207          # now change al3 directly 
+1208          al3.text = 'baz2-modified' 
+1209   
+1210          # it should have changed through this route too 
+1211          self.assertEqual( 
+1212              'baz2-modified', 
+1213              el[1][0].text) 
+
1214   
+1215 -    def test_set_text(self): 
+
1216          Element = self.etree.Element 
+1217          SubElement = self.etree.SubElement 
+1218   
+1219          a = Element('a') 
+1220          b = SubElement(a, 'b') 
+1221          a.text = 'hoi' 
+1222          self.assertEqual( 
+1223              'hoi', 
+1224              a.text) 
+1225          self.assertEqual( 
+1226              'b', 
+1227              a[0].tag) 
+
1228   
+1229 -    def test_set_text2(self): 
+
1230          Element = self.etree.Element 
+1231          SubElement = self.etree.SubElement 
+1232   
+1233          a = Element('a') 
+1234          a.text = 'hoi' 
+1235          b = SubElement(a ,'b') 
+1236          self.assertEqual( 
+1237              'hoi', 
+1238              a.text) 
+1239          self.assertEqual( 
+1240              'b', 
+1241              a[0].tag) 
+
1242   
+1243 -    def test_set_text_none(self): 
+
1244          Element = self.etree.Element 
+1245   
+1246          a = Element('a') 
+1247   
+1248          a.text = 'foo' 
+1249          a.text = None 
+1250   
+1251          self.assertEqual( 
+1252              None, 
+1253              a.text) 
+1254          self.assertXML(_bytes('<a></a>'), a) 
+
1255   
+1256 -    def test_set_text_empty(self): 
+
1257          Element = self.etree.Element 
+1258   
+1259          a = Element('a') 
+1260          self.assertEqual(None, a.text) 
+1261   
+1262          a.text = '' 
+1263          self.assertEqual('', a.text) 
+1264          self.assertXML(_bytes('<a></a>'), a) 
+
1265   
+1266 -    def test_tail1(self): 
+
1267          Element = self.etree.Element 
+1268          SubElement = self.etree.SubElement 
+1269   
+1270          a = Element('a') 
+1271          a.tail = 'dag' 
+1272          self.assertEqual('dag', 
+1273                            a.tail) 
+1274          b = SubElement(a, 'b') 
+1275          b.tail = 'hoi' 
+1276          self.assertEqual('hoi', 
+1277                            b.tail) 
+1278          self.assertEqual('dag', 
+1279                            a.tail) 
+
1280   
+1281 -    def test_tail_append(self): 
+
1282          Element = self.etree.Element 
+1283   
+1284          a = Element('a') 
+1285          b = Element('b') 
+1286          b.tail = 'b_tail' 
+1287          a.append(b) 
+1288          self.assertEqual('b_tail', 
+1289                            b.tail) 
+
1290   
+1291 -    def test_tail_set_twice(self): 
+
1292          Element = self.etree.Element 
+1293          SubElement = self.etree.SubElement 
+1294   
+1295          a = Element('a') 
+1296          b = SubElement(a, 'b') 
+1297          b.tail = 'foo' 
+1298          b.tail = 'bar' 
+1299          self.assertEqual('bar', 
+1300                            b.tail) 
+1301          self.assertXML(_bytes('<a><b></b>bar</a>'), a) 
+
1302   
+1303 -    def test_tail_set_none(self): 
+
1304          Element = self.etree.Element 
+1305          a = Element('a') 
+1306          a.tail = 'foo' 
+1307          a.tail = None 
+1308          self.assertEqual( 
+1309              None, 
+1310              a.tail) 
+1311          self.assertXML(_bytes('<a></a>'), a) 
+
1312   
+1313      required_versions_ET['test_extend'] = (1,3) 
+1314 -    def test_extend(self): 
+
1315          root = self.etree.Element('foo') 
+1316          for i in range(3): 
+1317              element = self.etree.SubElement(root, 'a%s' % i) 
+1318              element.text = "text%d" % i 
+1319              element.tail = "tail%d" % i 
+1320   
+1321          elements = [] 
+1322          for i in range(3): 
+1323              new_element = self.etree.Element("test%s" % i) 
+1324              new_element.text = "TEXT%s" % i 
+1325              new_element.tail = "TAIL%s" % i 
+1326              elements.append(new_element) 
+1327   
+1328          root.extend(elements) 
+1329   
+1330          self.assertEqual( 
+1331              ["a0", "a1", "a2", "test0", "test1", "test2"], 
+1332              [ el.tag for el in root ]) 
+1333          self.assertEqual( 
+1334              ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"], 
+1335              [ el.text for el in root ]) 
+1336          self.assertEqual( 
+1337              ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"], 
+1338              [ el.tail for el in root ]) 
+
1339   
+1340 -    def test_comment(self): 
+
1341          Element = self.etree.Element 
+1342          SubElement = self.etree.SubElement 
+1343          Comment = self.etree.Comment 
+1344   
+1345          a = Element('a') 
+1346          a.append(Comment('foo')) 
+1347          self.assertEqual(a[0].tag, Comment) 
+1348          self.assertEqual(a[0].text, 'foo') 
+
1349   
+1350      # ElementTree < 1.3 adds whitespace around comments 
+1351      required_versions_ET['test_comment_text'] = (1,3) 
+1352 -    def test_comment_text(self): 
+
1353          Element = self.etree.Element 
+1354          SubElement = self.etree.SubElement 
+1355          Comment = self.etree.Comment 
+1356          tostring = self.etree.tostring 
+1357   
+1358          a = Element('a') 
+1359          a.append(Comment('foo')) 
+1360          self.assertEqual(a[0].text, 'foo') 
+1361   
+1362          self.assertEqual( 
+1363              _bytes('<a><!--foo--></a>'), 
+1364              tostring(a)) 
+1365   
+1366          a[0].text = "TEST" 
+1367          self.assertEqual(a[0].text, 'TEST') 
+1368   
+1369          self.assertEqual( 
+1370              _bytes('<a><!--TEST--></a>'), 
+1371              tostring(a)) 
+
1372   
+1373      # ElementTree < 1.3 adds whitespace around comments 
+1374      required_versions_ET['test_comment_whitespace'] = (1,3) 
+1375 -    def test_comment_whitespace(self): 
+
1376          Element = self.etree.Element 
+1377          SubElement = self.etree.SubElement 
+1378          Comment = self.etree.Comment 
+1379          tostring = self.etree.tostring 
+1380   
+1381          a = Element('a') 
+1382          a.append(Comment(' foo  ')) 
+1383          self.assertEqual(a[0].text, ' foo  ') 
+1384          self.assertEqual( 
+1385              _bytes('<a><!-- foo  --></a>'), 
+1386              tostring(a)) 
+
1387   
+1388 -    def test_comment_nonsense(self): 
+
1389          Comment = self.etree.Comment 
+1390          c = Comment('foo') 
+1391          self.assertEqual({}, c.attrib) 
+1392          self.assertEqual([], list(c.keys())) 
+1393          self.assertEqual([], list(c.items())) 
+1394          self.assertEqual(None, c.get('hoi')) 
+1395          self.assertEqual(0, len(c)) 
+1396          # should not iterate 
+1397          for i in c: 
+1398              pass 
+
1399   
+1400 -    def test_pi(self): 
+
1401          # lxml.etree separates target and text 
+1402          Element = self.etree.Element 
+1403          SubElement = self.etree.SubElement 
+1404          ProcessingInstruction = self.etree.ProcessingInstruction 
+1405   
+1406          a = Element('a') 
+1407          a.append(ProcessingInstruction('foo', 'some more text')) 
+1408          self.assertEqual(a[0].tag, ProcessingInstruction) 
+1409          self.assertXML(_bytes("<a><?foo some more text?></a>"), 
+1410                         a) 
+
1411   
+1412 -    def test_processinginstruction(self): 
+
1413          # lxml.etree separates target and text 
+1414          Element = self.etree.Element 
+1415          SubElement = self.etree.SubElement 
+1416          ProcessingInstruction = self.etree.PI 
+1417   
+1418          a = Element('a') 
+1419          a.append(ProcessingInstruction('foo', 'some more text')) 
+1420          self.assertEqual(a[0].tag, ProcessingInstruction) 
+1421          self.assertXML(_bytes("<a><?foo some more text?></a>"), 
+1422                         a) 
+
1423   
+1424 -    def test_pi_nonsense(self): 
+
1425          ProcessingInstruction = self.etree.ProcessingInstruction 
+1426          pi = ProcessingInstruction('foo') 
+1427          self.assertEqual({}, pi.attrib) 
+1428          self.assertEqual([], list(pi.keys())) 
+1429          self.assertEqual([], list(pi.items())) 
+1430          self.assertEqual(None, pi.get('hoi')) 
+1431          self.assertEqual(0, len(pi)) 
+1432          # should not iterate 
+1433          for i in pi: 
+1434              pass 
+
1435   
+1436 -    def test_setitem(self): 
+
1437          Element = self.etree.Element 
+1438          SubElement = self.etree.SubElement 
+1439   
+1440          a = Element('a') 
+1441          b = SubElement(a, 'b') 
+1442          c = Element('c') 
+1443          a[0] = c 
+1444          self.assertEqual( 
+1445              c, 
+1446              a[0]) 
+1447          self.assertXML(_bytes('<a><c></c></a>'), 
+1448                         a) 
+1449          self.assertXML(_bytes('<b></b>'), 
+1450                         b) 
+
1451   
+1452 -    def test_setitem2(self): 
+
1453          Element = self.etree.Element 
+1454          SubElement = self.etree.SubElement 
+1455   
+1456          a = Element('a') 
+1457          for i in range(5): 
+1458              b = SubElement(a, 'b%s' % i) 
+1459              c = SubElement(b, 'c') 
+1460          for i in range(5): 
+1461              d = Element('d') 
+1462              e = SubElement(d, 'e') 
+1463              a[i] = d 
+1464          self.assertXML( 
+1465              _bytes('<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>'), 
+1466              a) 
+1467          self.assertXML(_bytes('<c></c>'), 
+1468                         c) 
+
1469   
+1470 -    def test_setitem_replace(self): 
+
1471          Element = self.etree.Element 
+1472          SubElement = self.etree.SubElement 
+1473   
+1474          a = Element('a') 
+1475          SubElement(a, 'b') 
+1476          d = Element('d') 
+1477          a[0] = d 
+1478          self.assertXML(_bytes('<a><d></d></a>'), a) 
+
1479   
+1480 -    def test_setitem_indexerror(self): 
+
1481          Element = self.etree.Element 
+1482          SubElement = self.etree.SubElement 
+1483   
+1484          a = Element('a') 
+1485          b = SubElement(a, 'b') 
+1486   
+1487          self.assertRaises(IndexError, operator.setitem, a, 1, Element('c')) 
+
1488   
+1489 -    def test_setitem_tail(self): 
+
1490          Element = self.etree.Element 
+1491          SubElement = self.etree.SubElement 
+1492   
+1493          a = Element('a') 
+1494          b = SubElement(a, 'b') 
+1495          b.tail = 'B2' 
+1496          c = Element('c') 
+1497          c.tail = 'C2' 
+1498   
+1499          a[0] = c 
+1500          self.assertXML( 
+1501              _bytes('<a><c></c>C2</a>'), 
+1502              a) 
+
1503   
+1504 -    def test_tag_write(self): 
+
1505          Element = self.etree.Element 
+1506          SubElement = self.etree.SubElement 
+1507   
+1508          a = Element('a') 
+1509          b = SubElement(a, 'b') 
+1510   
+1511          a.tag = 'c' 
+1512   
+1513          self.assertEqual( 
+1514              'c', 
+1515              a.tag) 
+1516   
+1517          self.assertXML( 
+1518              _bytes('<c><b></b></c>'), 
+1519              a) 
+
1520   
+1521 -    def test_tag_reset_ns(self): 
+
1522          Element = self.etree.Element 
+1523          SubElement = self.etree.SubElement 
+1524          tostring = self.etree.tostring 
+1525   
+1526          a = Element('{a}a') 
+1527          b1 = SubElement(a, '{a}b') 
+1528          b2 = SubElement(a, '{b}b') 
+1529   
+1530          self.assertEqual('{a}b',  b1.tag) 
+1531   
+1532          b1.tag = 'c' 
+1533   
+1534          # can't use C14N here! 
+1535          self.assertEqual('c', b1.tag) 
+1536          self.assertEqual(_bytes('<c'), tostring(b1)[:2]) 
+1537          self.assertTrue(_bytes('<c') in tostring(a)) 
+
1538   
+1539 -    def test_tag_reset_root_ns(self): 
+
1540          Element = self.etree.Element 
+1541          SubElement = self.etree.SubElement 
+1542          tostring = self.etree.tostring 
+1543   
+1544          a = Element('{a}a') 
+1545          b1 = SubElement(a, '{a}b') 
+1546          b2 = SubElement(a, '{b}b') 
+1547   
+1548          a.tag = 'c' 
+1549   
+1550          self.assertEqual( 
+1551              'c', 
+1552              a.tag) 
+1553   
+1554          # can't use C14N here! 
+1555          self.assertEqual('c',  a.tag) 
+1556          self.assertEqual(_bytes('<c'), tostring(a)[:2]) 
+
1557   
+1558 -    def test_tag_str_subclass(self): 
+
1559          Element = self.etree.Element 
+1560   
+1561          class strTest(str): 
+1562              pass 
+
1563   
+1564          a = Element("a") 
+1565          a.tag = strTest("TAG") 
+1566          self.assertXML(_bytes('<TAG></TAG>'), 
+1567                         a) 
+1568   
+1569 -    def test_delitem(self): 
+
1570          Element = self.etree.Element 
+1571          SubElement = self.etree.SubElement 
+1572   
+1573          a = Element('a') 
+1574          b = SubElement(a, 'b') 
+1575          c = SubElement(a, 'c') 
+1576          d = SubElement(a, 'd') 
+1577   
+1578          del a[1] 
+1579          self.assertXML( 
+1580              _bytes('<a><b></b><d></d></a>'), 
+1581              a) 
+1582   
+1583          del a[0] 
+1584          self.assertXML( 
+1585              _bytes('<a><d></d></a>'), 
+1586              a) 
+1587   
+1588          del a[0] 
+1589          self.assertXML( 
+1590              _bytes('<a></a>'), 
+1591              a) 
+1592          # move deleted element into other tree afterwards 
+1593          other = Element('other') 
+1594          other.append(c) 
+1595          self.assertXML( 
+1596              _bytes('<other><c></c></other>'), 
+1597              other) 
+
1598   
+1599 -    def test_del_insert(self): 
+
1600          Element = self.etree.Element 
+1601          SubElement = self.etree.SubElement 
+1602   
+1603          a = Element('a') 
+1604          b = SubElement(a, 'b') 
+1605          bs = SubElement(b, 'bs') 
+1606          c = SubElement(a, 'c') 
+1607          cs = SubElement(c, 'cs') 
+1608   
+1609          el = a[0] 
+1610          self.assertXML( 
+1611              _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'), 
+1612              a) 
+1613          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
+1614          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
+1615   
+1616          del a[0] 
+1617          self.assertXML( 
+1618              _bytes('<a><c><cs></cs></c></a>'), 
+1619              a) 
+1620          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
+1621          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
+1622   
+1623          a.insert(0, el) 
+1624          self.assertXML( 
+1625              _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'), 
+1626              a) 
+1627          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
+1628          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
+
1629   
+1630 -    def test_del_setitem(self): 
+
1631          Element = self.etree.Element 
+1632          SubElement = self.etree.SubElement 
+1633   
+1634          a = Element('a') 
+1635          b = SubElement(a, 'b') 
+1636          bs = SubElement(b, 'bs') 
+1637          c = SubElement(a, 'c') 
+1638          cs = SubElement(c, 'cs') 
+1639   
+1640          el = a[0] 
+1641          del a[0] 
+1642          a[0] = el 
+1643          self.assertXML( 
+1644              _bytes('<a><b><bs></bs></b></a>'), 
+1645              a) 
+1646          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
+1647          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
+
1648   
+1649 -    def test_del_setslice(self): 
+
1650          Element = self.etree.Element 
+1651          SubElement = self.etree.SubElement 
+1652   
+1653          a = Element('a') 
+1654          b = SubElement(a, 'b') 
+1655          bs = SubElement(b, 'bs') 
+1656          c = SubElement(a, 'c') 
+1657          cs = SubElement(c, 'cs') 
+1658   
+1659          el = a[0] 
+1660          del a[0] 
+1661          a[0:0] = [el] 
+1662          self.assertXML( 
+1663              _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'), 
+1664              a) 
+1665          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
+1666          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
+
1667   
+1668 -    def test_replace_slice_tail(self): 
+
1669          XML = self.etree.XML 
+1670          a = XML(_bytes('<a><b></b>B2<c></c>C2</a>')) 
+1671          b, c = a 
+1672   
+1673          a[:] = [] 
+1674   
+1675          self.assertEqual("B2", b.tail) 
+1676          self.assertEqual("C2", c.tail) 
+
1677   
+1678 -    def test_merge_namespaced_subtree_as_slice(self): 
+
1679          XML = self.etree.XML 
+1680          root = XML(_bytes( 
+1681              '<foo><bar xmlns:baz="http://huhu"><puh><baz:bump1 /><baz:bump2 /></puh></bar></foo>')) 
+1682          root[:] = root.findall('.//puh') # delete bar from hierarchy 
+1683   
+1684          # previously, this lost a namespace declaration on bump2 
+1685          result = self.etree.tostring(root) 
+1686          foo = self.etree.fromstring(result) 
+1687   
+1688          self.assertEqual('puh', foo[0].tag) 
+1689          self.assertEqual('{http://huhu}bump1', foo[0][0].tag) 
+1690          self.assertEqual('{http://huhu}bump2', foo[0][1].tag) 
+
1691   
+1692 -    def test_delitem_tail(self): 
+
1693          ElementTree = self.etree.ElementTree 
+1694          f = BytesIO('<a><b></b>B2<c></c>C2</a>') 
+1695          doc = ElementTree(file=f) 
+1696          a = doc.getroot() 
+1697          del a[0] 
+1698          self.assertXML( 
+1699              _bytes('<a><c></c>C2</a>'), 
+1700              a) 
+
1701   
+1702 -    def test_clear(self): 
+
1703          Element = self.etree.Element 
+1704   
+1705          a = Element('a') 
+1706          a.text = 'foo' 
+1707          a.tail = 'bar' 
+1708          a.set('hoi', 'dag') 
+1709          a.clear() 
+1710          self.assertEqual(None, a.text) 
+1711          self.assertEqual(None, a.tail) 
+1712          self.assertEqual(None, a.get('hoi')) 
+1713          self.assertEqual('a', a.tag) 
+
1714   
+1715 -    def test_clear_sub(self): 
+
1716          Element = self.etree.Element 
+1717          SubElement = self.etree.SubElement 
+1718   
+1719          a = Element('a') 
+1720          a.text = 'foo' 
+1721          a.tail = 'bar' 
+1722          a.set('hoi', 'dag') 
+1723          b = SubElement(a, 'b') 
+1724          c = SubElement(b, 'c') 
+1725          a.clear() 
+1726          self.assertEqual(None, a.text) 
+1727          self.assertEqual(None, a.tail) 
+1728          self.assertEqual(None, a.get('hoi')) 
+1729          self.assertEqual('a', a.tag) 
+1730          self.assertEqual(0, len(a)) 
+1731          self.assertXML(_bytes('<a></a>'), 
+1732                         a) 
+1733          self.assertXML(_bytes('<b><c></c></b>'), 
+1734                         b) 
+
1735   
+1736 -    def test_clear_tail(self): 
+
1737          ElementTree = self.etree.ElementTree 
+1738          f = BytesIO('<a><b></b>B2<c></c>C2</a>') 
+1739          doc = ElementTree(file=f) 
+1740          a = doc.getroot() 
+1741          a.clear() 
+1742          self.assertXML( 
+1743              _bytes('<a></a>'), 
+1744              a) 
+
1745   
+1746 -    def test_insert(self): 
+
1747          Element = self.etree.Element 
+1748          SubElement = self.etree.SubElement 
+1749   
+1750          a = Element('a') 
+1751          b = SubElement(a, 'b') 
+1752          c = SubElement(a, 'c') 
+1753          d = Element('d') 
+1754          a.insert(0, d) 
+1755   
+1756          self.assertEqual( 
+1757              d, 
+1758              a[0]) 
+1759   
+1760          self.assertXML( 
+1761              _bytes('<a><d></d><b></b><c></c></a>'), 
+1762              a) 
+1763   
+1764          e = Element('e') 
+1765          a.insert(2, e) 
+1766          self.assertEqual( 
+1767              e, 
+1768              a[2]) 
+1769          self.assertXML( 
+1770              _bytes('<a><d></d><b></b><e></e><c></c></a>'), 
+1771              a) 
+
1772   
+1773 -    def test_insert_name_interning(self): 
+
1774          # See GH#268 / LP#1773749. 
+1775          Element = self.etree.Element 
+1776          SubElement = self.etree.SubElement 
+1777   
+1778          # Use unique names to make sure they are new in the tag name dict. 
+1779          import uuid 
+1780          names = dict((k, 'tag-' + str(uuid.uuid4())) for k in 'abcde') 
+1781   
+1782          a = Element(names['a']) 
+1783          b = SubElement(a, names['b']) 
+1784          c = SubElement(a, names['c']) 
+1785          d = Element(names['d']) 
+1786          a.insert(0, d) 
+1787   
+1788          self.assertEqual( 
+1789              d, 
+1790              a[0]) 
+1791   
+1792          self.assertXML( 
+1793              _bytes('<%(a)s><%(d)s></%(d)s><%(b)s></%(b)s><%(c)s></%(c)s></%(a)s>' % names), 
+1794              a) 
+1795   
+1796          e = Element(names['e']) 
+1797          a.insert(2, e) 
+1798          self.assertEqual( 
+1799              e, 
+1800              a[2]) 
+1801          self.assertXML( 
+1802              _bytes('<%(a)s><%(d)s></%(d)s><%(b)s></%(b)s><%(e)s></%(e)s><%(c)s></%(c)s></%(a)s>' % names), 
+1803              a) 
+
1804   
+1805 -    def test_insert_beyond_index(self): 
+
1806          Element = self.etree.Element 
+1807          SubElement = self.etree.SubElement 
+1808   
+1809          a = Element('a') 
+1810          b = SubElement(a, 'b') 
+1811          c = Element('c') 
+1812   
+1813          a.insert(2, c) 
+1814          self.assertEqual( 
+1815              c, 
+1816              a[1]) 
+1817          self.assertXML( 
+1818              _bytes('<a><b></b><c></c></a>'), 
+1819              a) 
+
1820   
+1821 -    def test_insert_negative(self): 
+
1822          Element = self.etree.Element 
+1823          SubElement = self.etree.SubElement 
+1824   
+1825          a = Element('a') 
+1826          b = SubElement(a, 'b') 
+1827          c = SubElement(a, 'c') 
+1828   
+1829          d = Element('d') 
+1830          a.insert(-1, d) 
+1831          self.assertEqual( 
+1832              d, 
+1833              a[-2]) 
+1834          self.assertXML( 
+1835              _bytes('<a><b></b><d></d><c></c></a>'), 
+1836              a) 
+
1837   
+1838 -    def test_insert_tail(self): 
+
1839          Element = self.etree.Element 
+1840          SubElement = self.etree.SubElement 
+1841   
+1842          a = Element('a') 
+1843          b = SubElement(a, 'b') 
+1844   
+1845          c = Element('c') 
+1846          c.tail = 'C2' 
+1847   
+1848          a.insert(0, c) 
+1849          self.assertXML( 
+1850              _bytes('<a><c></c>C2<b></b></a>'), 
+1851              a) 
+
1852   
+1853 -    def test_remove(self): 
+
1854          Element = self.etree.Element 
+1855          SubElement = self.etree.SubElement 
+1856   
+1857          a = Element('a') 
+1858          b = SubElement(a, 'b') 
+1859          c = SubElement(a, 'c') 
+1860   
+1861          a.remove(b) 
+1862          self.assertEqual( 
+1863              c, 
+1864              a[0]) 
+1865          self.assertXML( 
+1866              _bytes('<a><c></c></a>'), 
+1867              a) 
+
1868   
+1869 -    def test_remove_ns(self): 
+
1870          Element = self.etree.Element 
+1871          SubElement = self.etree.SubElement 
+1872   
+1873          a = Element('{http://test}a') 
+1874          b = SubElement(a, '{http://test}b') 
+1875          c = SubElement(a, '{http://test}c') 
+1876   
+1877          a.remove(b) 
+1878          self.assertXML( 
+1879              _bytes('<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>'), 
+1880              a) 
+1881          self.assertXML( 
+1882              _bytes('<ns0:b xmlns:ns0="http://test"></ns0:b>'), 
+1883              b) 
+
1884   
+1885 -    def test_remove_nonexisting(self): 
+
1886          Element = self.etree.Element 
+1887          SubElement = self.etree.SubElement 
+1888   
+1889          a = Element('a') 
+1890          b = SubElement(a, 'b') 
+1891          c = SubElement(a, 'c') 
+1892          d = Element('d') 
+1893          self.assertRaises( 
+1894              ValueError, a.remove, d) 
+
1895   
+1896 -    def test_remove_tail(self): 
+
1897          Element = self.etree.Element 
+1898          SubElement = self.etree.SubElement 
+1899   
+1900          a = Element('a') 
+1901          b = SubElement(a, 'b') 
+1902          b.tail = 'b2' 
+1903          a.remove(b) 
+1904          self.assertXML( 
+1905              _bytes('<a></a>'), 
+1906              a) 
+1907          self.assertEqual('b2', b.tail) 
+
1908   
+1909 -    def test_remove_while_iterating(self): 
+
1910          # There is no guarantee that this "works", but it should 
+1911          # remove at least one child and not crash. 
+1912          Element = self.etree.Element 
+1913          SubElement = self.etree.SubElement 
+1914   
+1915          a = Element('a') 
+1916          SubElement(a, 'b') 
+1917          SubElement(a, 'c') 
+1918          SubElement(a, 'd') 
+1919          for el in a: 
+1920              a.remove(el) 
+1921          self.assertLess(len(a), 3) 
+
1922   
+1923 -    def test_getchildren(self): 
+
1924          Element = self.etree.Element 
+1925          SubElement = self.etree.SubElement 
+1926   
+1927          a = Element('a') 
+1928          b = SubElement(a, 'b') 
+1929          c = SubElement(a, 'c') 
+1930          d = SubElement(b, 'd') 
+1931          e = SubElement(c, 'e') 
+1932          self.assertXML( 
+1933              _bytes('<a><b><d></d></b><c><e></e></c></a>'), 
+1934              a) 
+1935          self.assertEqual( 
+1936              [b, c], 
+1937              a.getchildren()) 
+1938          self.assertEqual( 
+1939              [d], 
+1940              b.getchildren()) 
+1941          self.assertEqual( 
+1942              [], 
+1943              d.getchildren()) 
+
1944   
+1945 -    def test_makeelement(self): 
+
1946          Element = self.etree.Element 
+1947   
+1948          a = Element('a') 
+1949          b = a.makeelement('c', {'hoi':'dag'}) 
+1950          self.assertXML( 
+1951              _bytes('<c hoi="dag"></c>'), 
+1952              b) 
+
1953   
+1954      required_versions_ET['test_iter'] = (1,3) 
+1955 -    def test_iter(self): 
+
1956          Element = self.etree.Element 
+1957          SubElement = self.etree.SubElement 
+1958   
+1959          a = Element('a') 
+1960          b = SubElement(a, 'b') 
+1961          c = SubElement(a, 'c') 
+1962          d = SubElement(b, 'd') 
+1963          e = SubElement(c, 'e') 
+1964   
+1965          self.assertEqual( 
+1966              [a, b, d, c, e], 
+1967              list(a.iter())) 
+1968          self.assertEqual( 
+1969              [d], 
+1970              list(d.iter())) 
+
1971   
+1972 -    def test_iter_remove_tail(self): 
+
1973          Element = self.etree.Element 
+1974          SubElement = self.etree.SubElement 
+1975   
+1976          a = Element('a') 
+1977          a.text = 'a' 
+1978          a.tail = 'a1' * 100 
+1979          b = SubElement(a, 'b') 
+1980          b.text = 'b' 
+1981          b.tail = 'b1' * 100 
+1982          c = SubElement(a, 'c') 
+1983          c.text = 'c' 
+1984          c.tail = 'c1' * 100 
+1985          d = SubElement(b, 'd') 
+1986          d.text = 'd' 
+1987          d.tail = 'd1' * 100 
+1988          e = SubElement(c, 'e') 
+1989          e.text = 'e' 
+1990          e.tail = 'e1' * 100 
+1991   
+1992          for el in a.iter(): 
+1993              el.tail = None 
+1994          el = None 
+1995   
+1996          self.assertEqual( 
+1997              [None] * 5, 
+1998              [el.tail for el in a.iter()]) 
+
1999   
+2000 -    def test_getiterator(self): 
+
2001          Element = self.etree.Element 
+2002          SubElement = self.etree.SubElement 
+2003   
+2004          a = Element('a') 
+2005          b = SubElement(a, 'b') 
+2006          c = SubElement(a, 'c') 
+2007          d = SubElement(b, 'd') 
+2008          e = SubElement(c, 'e') 
+2009   
+2010          self.assertEqual( 
+2011              [a, b, d, c, e], 
+2012              list(a.getiterator())) 
+2013          self.assertEqual( 
+2014              [d], 
+2015              list(d.getiterator())) 
+
2016   
+2017 -    def test_getiterator_empty(self): 
+
2018          Element = self.etree.Element 
+2019          SubElement = self.etree.SubElement 
+2020   
+2021          a = Element('a') 
+2022          b = SubElement(a, 'b') 
+2023          c = SubElement(a, 'c') 
+2024          d = SubElement(b, 'd') 
+2025          e = SubElement(c, 'e') 
+2026   
+2027          self.assertEqual( 
+2028              [], 
+2029              list(a.getiterator('none'))) 
+2030          self.assertEqual( 
+2031              [], 
+2032              list(e.getiterator('none'))) 
+2033          self.assertEqual( 
+2034              [e], 
+2035              list(e.getiterator())) 
+
2036   
+2037 -    def test_getiterator_filter(self): 
+
2038          Element = self.etree.Element 
+2039          SubElement = self.etree.SubElement 
+2040   
+2041          a = Element('a') 
+2042          b = SubElement(a, 'b') 
+2043          c = SubElement(a, 'c') 
+2044          d = SubElement(b, 'd') 
+2045          e = SubElement(c, 'e') 
+2046   
+2047          self.assertEqual( 
+2048              [a], 
+2049              list(a.getiterator('a'))) 
+2050          a2 = SubElement(e, 'a') 
+2051          self.assertEqual( 
+2052              [a, a2], 
+2053              list(a.getiterator('a'))) 
+2054          self.assertEqual( 
+2055              [a2], 
+2056              list(c.getiterator('a'))) 
+
2057   
+2058 -    def test_getiterator_filter_all(self): 
+
2059          Element = self.etree.Element 
+2060          SubElement = self.etree.SubElement 
+2061   
+2062          a = Element('a') 
+2063          b = SubElement(a, 'b') 
+2064          c = SubElement(a, 'c') 
+2065          d = SubElement(b, 'd') 
+2066          e = SubElement(c, 'e') 
+2067   
+2068          self.assertEqual( 
+2069              [a, b, d, c, e], 
+2070              list(a.getiterator('*'))) 
+
2071   
+2072 -    def test_getiterator_filter_comment(self): 
+
2073          Element = self.etree.Element 
+2074          Comment = self.etree.Comment 
+2075          SubElement = self.etree.SubElement 
+2076   
+2077          a = Element('a') 
+2078          b = SubElement(a, 'b') 
+2079          comment_b = Comment("TEST-b") 
+2080          b.append(comment_b) 
+2081   
+2082          self.assertEqual( 
+2083              [comment_b], 
+2084              list(a.getiterator(Comment))) 
+2085   
+2086          comment_a = Comment("TEST-a") 
+2087          a.append(comment_a) 
+2088   
+2089          self.assertEqual( 
+2090              [comment_b, comment_a], 
+2091              list(a.getiterator(Comment))) 
+2092   
+2093          self.assertEqual( 
+2094              [comment_b], 
+2095              list(b.getiterator(Comment))) 
+
2096   
+2097 -    def test_getiterator_filter_pi(self): 
+
2098          Element = self.etree.Element 
+2099          PI = self.etree.ProcessingInstruction 
+2100          SubElement = self.etree.SubElement 
+2101   
+2102          a = Element('a') 
+2103          b = SubElement(a, 'b') 
+2104          pi_b = PI("TEST-b") 
+2105          b.append(pi_b) 
+2106   
+2107          self.assertEqual( 
+2108              [pi_b], 
+2109              list(a.getiterator(PI))) 
+2110   
+2111          pi_a = PI("TEST-a") 
+2112          a.append(pi_a) 
+2113   
+2114          self.assertEqual( 
+2115              [pi_b, pi_a], 
+2116              list(a.getiterator(PI))) 
+2117   
+2118          self.assertEqual( 
+2119              [pi_b], 
+2120              list(b.getiterator(PI))) 
+
2121   
+2122 -    def test_getiterator_with_text(self): 
+
2123          Element = self.etree.Element 
+2124          SubElement = self.etree.SubElement 
+2125   
+2126          a = Element('a') 
+2127          a.text = 'a' 
+2128          b = SubElement(a, 'b') 
+2129          b.text = 'b' 
+2130          b.tail = 'b1' 
+2131          c = SubElement(a, 'c') 
+2132          c.text = 'c' 
+2133          c.tail = 'c1' 
+2134          d = SubElement(b, 'd') 
+2135          d.text = 'd' 
+2136          d.tail = 'd1' 
+2137          e = SubElement(c, 'e') 
+2138          e.text = 'e' 
+2139          e.tail = 'e1' 
+2140   
+2141          self.assertEqual( 
+2142              [a, b, d, c, e], 
+2143              list(a.getiterator())) 
+
2144          #self.assertEqual( 
+2145          #    [d], 
+2146          #    list(d.getiterator())) 
+2147   
+2148 -    def test_getiterator_filter_with_text(self): 
+
2149          Element = self.etree.Element 
+2150          SubElement = self.etree.SubElement 
+2151   
+2152          a = Element('a') 
+2153          a.text = 'a' 
+2154          b = SubElement(a, 'b') 
+2155          b.text = 'b' 
+2156          b.tail = 'b1' 
+2157          c = SubElement(a, 'c') 
+2158          c.text = 'c' 
+2159          c.tail = 'c1' 
+2160          d = SubElement(b, 'd') 
+2161          d.text = 'd' 
+2162          d.tail = 'd1' 
+2163          e = SubElement(c, 'e') 
+2164          e.text = 'e' 
+2165          e.tail = 'e1' 
+2166   
+2167          self.assertEqual( 
+2168              [a], 
+2169              list(a.getiterator('a'))) 
+2170          a2 = SubElement(e, 'a') 
+2171          self.assertEqual( 
+2172              [a, a2], 
+2173              list(a.getiterator('a')))    
+2174          self.assertEqual( 
+2175              [a2], 
+2176              list(e.getiterator('a'))) 
+
2177   
+2178 -    def test_getslice(self): 
+
2179          Element = self.etree.Element 
+2180          SubElement = self.etree.SubElement 
+2181   
+2182          a = Element('a') 
+2183          b = SubElement(a, 'b') 
+2184          c = SubElement(a, 'c') 
+2185          d = SubElement(a, 'd') 
+2186   
+2187          self.assertEqual( 
+2188              [b, c], 
+2189              a[0:2]) 
+2190          self.assertEqual( 
+2191              [b, c, d], 
+2192              a[:]) 
+2193          self.assertEqual( 
+2194              [b, c, d], 
+2195              a[:10]) 
+2196          self.assertEqual( 
+2197              [b], 
+2198              a[0:1]) 
+2199          self.assertEqual( 
+2200              [], 
+2201              a[10:12]) 
+
2202   
+2203 -    def test_getslice_negative(self): 
+
2204          Element = self.etree.Element 
+2205          SubElement = self.etree.SubElement 
+2206   
+2207          a = Element('a') 
+2208          b = SubElement(a, 'b') 
+2209          c = SubElement(a, 'c') 
+2210          d = SubElement(a, 'd') 
+2211   
+2212          self.assertEqual( 
+2213              [d], 
+2214              a[-1:]) 
+2215          self.assertEqual( 
+2216              [c, d], 
+2217              a[-2:]) 
+2218          self.assertEqual( 
+2219              [c], 
+2220              a[-2:-1]) 
+2221          self.assertEqual( 
+2222              [b, c], 
+2223              a[-3:-1]) 
+2224          self.assertEqual( 
+2225              [b, c], 
+2226              a[-3:2]) 
+
2227   
+2228 -    def test_getslice_step(self): 
+
2229          Element = self.etree.Element 
+2230          SubElement = self.etree.SubElement 
+2231   
+2232          a = Element('a') 
+2233          b = SubElement(a, 'b') 
+2234          c = SubElement(a, 'c') 
+2235          d = SubElement(a, 'd') 
+2236          e = SubElement(a, 'e') 
+2237   
+2238          self.assertEqual( 
+2239              [e,d,c,b], 
+2240              a[::-1]) 
+2241          self.assertEqual( 
+2242              [b,d], 
+2243              a[::2]) 
+2244          self.assertEqual( 
+2245              [e,c], 
+2246              a[::-2]) 
+2247          self.assertEqual( 
+2248              [d,c], 
+2249              a[-2:0:-1]) 
+2250          self.assertEqual( 
+2251              [e], 
+2252              a[:1:-2]) 
+
2253   
+2254 -    def test_getslice_text(self): 
+
2255          ElementTree = self.etree.ElementTree 
+2256   
+2257          f = BytesIO('<a><b>B</b>B1<c>C</c>C1</a>') 
+2258          doc = ElementTree(file=f) 
+2259          a = doc.getroot() 
+2260          b = a[0] 
+2261          c = a[1] 
+2262          self.assertEqual( 
+2263              [b, c], 
+2264              a[:]) 
+2265          self.assertEqual( 
+2266              [b], 
+2267              a[0:1]) 
+2268          self.assertEqual( 
+2269              [c], 
+2270              a[1:]) 
+
2271   
+2272 -    def test_comment_getitem_getslice(self): 
+
2273          Element = self.etree.Element 
+2274          Comment = self.etree.Comment 
+2275          SubElement = self.etree.SubElement 
+2276   
+2277          a = Element('a') 
+2278          b = SubElement(a, 'b') 
+2279          foo = Comment('foo') 
+2280          a.append(foo) 
+2281          c = SubElement(a, 'c') 
+2282          self.assertEqual( 
+2283              [b, foo, c], 
+2284              a[:]) 
+2285          self.assertEqual( 
+2286              foo, 
+2287              a[1]) 
+2288          a[1] = new = Element('new') 
+2289          self.assertEqual( 
+2290              new, 
+2291              a[1]) 
+2292          self.assertXML( 
+2293              _bytes('<a><b></b><new></new><c></c></a>'), 
+2294              a) 
+
2295   
+2296 -    def test_delslice(self): 
+
2297          Element = self.etree.Element 
+2298          SubElement = self.etree.SubElement 
+2299   
+2300          a = Element('a') 
+2301          b = SubElement(a, 'b') 
+2302          c = SubElement(a, 'c') 
+2303          d = SubElement(a, 'd') 
+2304          e = SubElement(a, 'e') 
+2305   
+2306          del a[1:3] 
+2307          self.assertEqual( 
+2308              [b, e], 
+2309              list(a)) 
+
2310   
+2311 -    def test_delslice_negative1(self): 
+
2312          Element = self.etree.Element 
+2313          SubElement = self.etree.SubElement 
+2314   
+2315          a = Element('a') 
+2316          b = SubElement(a, 'b') 
+2317          c = SubElement(a, 'c') 
+2318          d = SubElement(a, 'd') 
+2319          e = SubElement(a, 'e') 
+2320   
+2321          del a[1:-1] 
+2322          self.assertEqual( 
+2323              [b, e], 
+2324              list(a)) 
+
2325   
+2326 -    def test_delslice_negative2(self): 
+
2327          Element = self.etree.Element 
+2328          SubElement = self.etree.SubElement 
+2329   
+2330          a = Element('a') 
+2331          b = SubElement(a, 'b') 
+2332          c = SubElement(a, 'c') 
+2333          d = SubElement(a, 'd') 
+2334          e = SubElement(a, 'e') 
+2335   
+2336          del a[-3:-1] 
+2337          self.assertEqual( 
+2338              [b, e], 
+2339              list(a)) 
+
2340   
+2341 -    def test_delslice_step(self): 
+
2342          Element = self.etree.Element 
+2343          SubElement = self.etree.SubElement 
+2344   
+2345          a = Element('a') 
+2346          b = SubElement(a, 'b') 
+2347          c = SubElement(a, 'c') 
+2348          d = SubElement(a, 'd') 
+2349          e = SubElement(a, 'e') 
+2350   
+2351          del a[1::2] 
+2352          self.assertEqual( 
+2353              [b, d], 
+2354              list(a)) 
+
2355   
+2356 -    def test_delslice_step_negative(self): 
+
2357          Element = self.etree.Element 
+2358          SubElement = self.etree.SubElement 
+2359   
+2360          a = Element('a') 
+2361          b = SubElement(a, 'b') 
+2362          c = SubElement(a, 'c') 
+2363          d = SubElement(a, 'd') 
+2364          e = SubElement(a, 'e') 
+2365   
+2366          del a[::-1] 
+2367          self.assertEqual( 
+2368              [], 
+2369              list(a)) 
+
2370   
+2371 -    def test_delslice_step_negative2(self): 
+
2372          Element = self.etree.Element 
+2373          SubElement = self.etree.SubElement 
+2374   
+2375          a = Element('a') 
+2376          b = SubElement(a, 'b') 
+2377          c = SubElement(a, 'c') 
+2378          d = SubElement(a, 'd') 
+2379          e = SubElement(a, 'e') 
+2380   
+2381          del a[::-2] 
+2382          self.assertEqual( 
+2383              [b, d], 
+2384              list(a)) 
+
2385   
+2386 -    def test_delslice_child_tail(self): 
+
2387          ElementTree = self.etree.ElementTree 
+2388          f = BytesIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>') 
+2389          doc = ElementTree(file=f) 
+2390          a = doc.getroot() 
+2391          del a[1:3] 
+2392          self.assertXML( 
+2393              _bytes('<a><b></b>B2<e></e>E2</a>'), 
+2394              a) 
+
2395   
+2396 -    def test_delslice_tail(self): 
+
2397          XML = self.etree.XML 
+2398          a = XML(_bytes('<a><b></b>B2<c></c>C2</a>')) 
+2399          b, c = a 
+2400   
+2401          del a[:] 
+2402   
+2403          self.assertEqual("B2", b.tail) 
+2404          self.assertEqual("C2", c.tail) 
+
2405   
+2406 -    def test_delslice_memory(self): 
+
2407          # this could trigger a crash 
+2408          Element = self.etree.Element 
+2409          SubElement = self.etree.SubElement 
+2410          a = Element('a') 
+2411          b = SubElement(a, 'b') 
+2412          c = SubElement(b, 'c') 
+2413          del b # no more reference to b 
+2414          del a[:] 
+2415          self.assertEqual('c', c.tag) 
+
2416   
+2417 -    def test_setslice(self): 
+
2418          Element = self.etree.Element 
+2419          SubElement = self.etree.SubElement 
+2420   
+2421          a = Element('a') 
+2422          b = SubElement(a, 'b') 
+2423          c = SubElement(a, 'c') 
+2424          d = SubElement(a, 'd') 
+2425   
+2426          e = Element('e') 
+2427          f = Element('f') 
+2428          g = Element('g') 
+2429   
+2430          s = [e, f, g] 
+2431          a[1:2] = s 
+2432          self.assertEqual( 
+2433              [b, e, f, g, d], 
+2434              list(a)) 
+
2435   
+2436 -    def test_setslice_all(self): 
+
2437          Element = self.etree.Element 
+2438          SubElement = self.etree.SubElement 
+2439   
+2440          a = Element('a') 
+2441          b = SubElement(a, 'b') 
+2442          c = SubElement(a, 'c') 
+2443   
+2444          e = Element('e') 
+2445          f = Element('f') 
+2446          g = Element('g') 
+2447   
+2448          s = [e, f, g] 
+2449          a[:] = s 
+2450          self.assertEqual( 
+2451              [e, f, g], 
+2452              list(a)) 
+
2453   
+2454 -    def test_setslice_all_empty(self): 
+
2455          Element = self.etree.Element 
+2456          SubElement = self.etree.SubElement 
+2457   
+2458          a = Element('a') 
+2459   
+2460          e = Element('e') 
+2461          f = Element('f') 
+2462          g = Element('g') 
+2463   
+2464          s = [e, f, g] 
+2465          a[:] = s 
+2466          self.assertEqual( 
+2467              [e, f, g], 
+2468              list(a)) 
+
2469   
+2470 -    def test_setslice_all_replace(self): 
+
2471          Element = self.etree.Element 
+2472          SubElement = self.etree.SubElement 
+2473   
+2474          a = Element('a') 
+2475          b = SubElement(a, 'b') 
+2476          c = SubElement(a, 'c') 
+2477          d = SubElement(a, 'd') 
+2478   
+2479          s = [b, c, d] 
+2480          a[:] = s 
+2481          self.assertEqual( 
+2482              [b, c, d], 
+2483              list(a)) 
+
2484   
+2485 -    def test_setslice_all_replace_reversed(self): 
+
2486          Element = self.etree.Element 
+2487          SubElement = self.etree.SubElement 
+2488   
+2489          a = Element('a') 
+2490          b = SubElement(a, 'b') 
+2491          c = SubElement(a, 'c') 
+2492          d = SubElement(a, 'd') 
+2493   
+2494          s = [d, c, b] 
+2495          a[:] = s 
+2496          self.assertEqual( 
+2497              [d, c, b], 
+2498              list(a)) 
+
2499   
+2500 -    def test_setslice_all_replace_reversed_ns1(self): 
+
2501          Element = self.etree.Element 
+2502          SubElement = self.etree.SubElement 
+2503   
+2504          a = Element('{ns}a') 
+2505          b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'}) 
+2506          c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'}) 
+2507          d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'}) 
+2508   
+2509          s = [d, c, b] 
+2510          a[:] = s 
+2511          self.assertEqual( 
+2512              [d, c, b], 
+2513              list(a)) 
+2514          self.assertEqual( 
+2515              ['{ns}d', '{ns}c', '{ns}b'], 
+2516              [ child.tag for child in a ]) 
+2517   
+2518          self.assertEqual( 
+2519              [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']], 
+2520              [ list(child.attrib.keys()) for child in a ]) 
+
2521   
+2522 -    def test_setslice_all_replace_reversed_ns2(self): 
+
2523          Element = self.etree.Element 
+2524          SubElement = self.etree.SubElement 
+2525   
+2526          a = Element('{ns}a') 
+2527          b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'}) 
+2528          c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'}) 
+2529          d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'}) 
+2530   
+2531          s = [d, c, b] 
+2532          a[:] = s 
+2533          self.assertEqual( 
+2534              [d, c, b], 
+2535              list(a)) 
+2536          self.assertEqual( 
+2537              ['{ns3}d', '{ns2}c', '{ns1}b'], 
+2538              [ child.tag for child in a ]) 
+2539   
+2540          self.assertEqual( 
+2541              [['{ns}a3'], ['{ns}a2'], ['{ns}a1']], 
+2542              [ list(child.attrib.keys()) for child in a ]) 
+
2543   
+2544 -    def test_setslice_end(self): 
+
2545          Element = self.etree.Element 
+2546          SubElement = self.etree.SubElement 
+2547   
+2548          a = Element('a') 
+2549          b = SubElement(a, 'b') 
+2550          c = SubElement(a, 'c') 
+2551   
+2552          e = Element('e') 
+2553          f = Element('f') 
+2554          g = Element('g') 
+2555          h = Element('h') 
+2556   
+2557          s = [e, f] 
+2558          a[99:] = s 
+2559          self.assertEqual( 
+2560              [b, c, e, f], 
+2561              list(a)) 
+2562   
+2563          s = [g, h] 
+2564          a[:0] = s 
+2565          self.assertEqual( 
+2566              [g, h, b, c, e, f], 
+2567              list(a)) 
+
2568   
+2569 -    def test_setslice_end_exact(self): 
+
2570          Element = self.etree.Element 
+2571          SubElement = self.etree.SubElement 
+2572   
+2573          a = Element('a') 
+2574          b = SubElement(a, 'b') 
+2575          c = SubElement(a, 'c') 
+2576          d = SubElement(a, 'd') 
+2577   
+2578          e = Element('e') 
+2579          f = Element('f') 
+2580          g = Element('g') 
+2581   
+2582          s = [e, f, g] 
+2583          a[3:] = s 
+2584          self.assertEqual( 
+2585              [b, c, d, e, f, g], 
+2586              list(a)) 
+
2587   
+2588 -    def test_setslice_single(self): 
+
2589          Element = self.etree.Element 
+2590          SubElement = self.etree.SubElement 
+2591   
+2592          a = Element('a') 
+2593          b = SubElement(a, 'b') 
+2594          c = SubElement(a, 'c') 
+2595   
+2596          e = Element('e') 
+2597          f = Element('f') 
+2598   
+2599          s = [e] 
+2600          a[0:1] = s 
+2601          self.assertEqual( 
+2602              [e, c], 
+2603              list(a)) 
+2604   
+2605          s = [f] 
+2606          a[1:2] = s 
+2607          self.assertEqual( 
+2608              [e, f], 
+2609              list(a)) 
+
2610   
+2611 -    def test_setslice_tail(self): 
+
2612          ElementTree = self.etree.ElementTree 
+2613          Element = self.etree.Element 
+2614          f = BytesIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>') 
+2615          doc = ElementTree(file=f) 
+2616          a = doc.getroot() 
+2617          x = Element('x') 
+2618          y = Element('y') 
+2619          z = Element('z') 
+2620          x.tail = 'X2' 
+2621          y.tail = 'Y2' 
+2622          z.tail = 'Z2' 
+2623          a[1:3] = [x, y, z] 
+2624          self.assertXML( 
+2625              _bytes('<a><b></b>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>'), 
+2626              a) 
+
2627   
+2628 -    def test_setslice_negative(self): 
+
2629          Element = self.etree.Element 
+2630          SubElement = self.etree.SubElement 
+2631   
+2632          a = Element('a') 
+2633          b = SubElement(a, 'b') 
+2634          c = SubElement(a, 'c') 
+2635          d = SubElement(a, 'd') 
+2636   
+2637          x = Element('x') 
+2638          y = Element('y') 
+2639   
+2640          a[1:-1] = [x, y] 
+2641          self.assertEqual( 
+2642              [b, x, y, d], 
+2643              list(a)) 
+
2644   
+2645 -    def test_setslice_negative2(self): 
+
2646          Element = self.etree.Element 
+2647          SubElement = self.etree.SubElement 
+2648   
+2649          a = Element('a') 
+2650          b = SubElement(a, 'b') 
+2651          c = SubElement(a, 'c') 
+2652          d = SubElement(a, 'd') 
+2653   
+2654          x = Element('x') 
+2655          y = Element('y') 
+2656   
+2657          a[1:-2] = [x, y] 
+2658          self.assertEqual( 
+2659              [b, x, y, c, d], 
+2660              list(a)) 
+
2661   
+2662 -    def test_setslice_empty(self): 
+
2663          Element = self.etree.Element 
+2664   
+2665          a = Element('a') 
+2666   
+2667          b = Element('b') 
+2668          c = Element('c') 
+2669   
+2670          a[:] = [b, c] 
+2671          self.assertEqual( 
+2672              [b, c], 
+2673              list(a)) 
+
2674   
+2675 -    def test_tail_elementtree_root(self): 
+
2676          Element = self.etree.Element 
+2677          ElementTree = self.etree.ElementTree 
+2678   
+2679          a = Element('a') 
+2680          a.tail = 'A2' 
+2681          t = ElementTree(element=a) 
+2682          self.assertEqual('A2', 
+2683                            a.tail) 
+
2684   
+2685 -    def test_elementtree_getiterator(self): 
+
2686          Element = self.etree.Element 
+2687          SubElement = self.etree.SubElement 
+2688          ElementTree = self.etree.ElementTree 
+2689   
+2690          a = Element('a') 
+2691          b = SubElement(a, 'b') 
+2692          c = SubElement(a, 'c') 
+2693          d = SubElement(b, 'd') 
+2694          e = SubElement(c, 'e') 
+2695          t = ElementTree(element=a) 
+2696   
+2697          self.assertEqual( 
+2698              [a, b, d, c, e], 
+2699              list(t.getiterator())) 
+
2700   
+2701 -    def test_elementtree_getiterator_filter(self): 
+
2702          Element = self.etree.Element 
+2703          SubElement = self.etree.SubElement 
+2704          ElementTree = self.etree.ElementTree 
+2705          a = Element('a') 
+2706          b = SubElement(a, 'b') 
+2707          c = SubElement(a, 'c') 
+2708          d = SubElement(b, 'd') 
+2709          e = SubElement(c, 'e') 
+2710          t = ElementTree(element=a) 
+2711   
+2712          self.assertEqual( 
+2713              [a], 
+2714              list(t.getiterator('a'))) 
+2715          a2 = SubElement(e, 'a') 
+2716          self.assertEqual( 
+2717              [a, a2], 
+2718              list(t.getiterator('a'))) 
+
2719   
+2720 -    def test_ns_access(self): 
+
2721          ElementTree = self.etree.ElementTree 
+2722          ns = 'http://xml.infrae.com/1' 
+2723          f = BytesIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 
+2724          t = ElementTree(file=f) 
+2725          a = t.getroot() 
+2726          self.assertEqual('{%s}a' % ns, 
+2727                            a.tag) 
+2728          self.assertEqual('{%s}b' % ns, 
+2729                            a[0].tag) 
+
2730   
+2731 -    def test_ns_access2(self): 
+
2732          ElementTree = self.etree.ElementTree 
+2733          ns = 'http://xml.infrae.com/1' 
+2734          ns2 = 'http://xml.infrae.com/2' 
+2735          f = BytesIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 
+2736          t = ElementTree(file=f) 
+2737          a = t.getroot() 
+2738          self.assertEqual('{%s}a' % ns, 
+2739                            a.tag) 
+2740          self.assertEqual('{%s}b' % ns, 
+2741                            a[0].tag) 
+2742          self.assertEqual('{%s}b' % ns2, 
+2743                            a[1].tag) 
+
2744   
+2745 -    def test_ns_setting(self): 
+
2746          Element = self.etree.Element 
+2747          SubElement = self.etree.SubElement 
+2748          ns = 'http://xml.infrae.com/1' 
+2749          ns2 = 'http://xml.infrae.com/2' 
+2750          a = Element('{%s}a' % ns) 
+2751          b = SubElement(a, '{%s}b' % ns2) 
+2752          c = SubElement(a, '{%s}c' % ns) 
+2753          self.assertEqual('{%s}a' % ns, 
+2754                            a.tag) 
+2755          self.assertEqual('{%s}b' % ns2, 
+2756                            b.tag) 
+2757          self.assertEqual('{%s}c' % ns, 
+2758                            c.tag) 
+2759          self.assertEqual('{%s}a' % ns, 
+2760                            a.tag) 
+2761          self.assertEqual('{%s}b' % ns2, 
+2762                            b.tag) 
+2763          self.assertEqual('{%s}c' % ns, 
+2764                            c.tag) 
+
2765   
+2766 -    def test_ns_tag_parse(self): 
+
2767          Element = self.etree.Element 
+2768          SubElement = self.etree.SubElement 
+2769          ElementTree = self.etree.ElementTree 
+2770   
+2771          ns = 'http://xml.infrae.com/1' 
+2772          ns2 = 'http://xml.infrae.com/2' 
+2773          f = BytesIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b><b></b></a>' % (ns, ns2)) 
+2774          t = ElementTree(file=f) 
+2775   
+2776          a = t.getroot() 
+2777          self.assertEqual('{%s}a' % ns, 
+2778                            a.tag) 
+2779          self.assertEqual('{%s}b' % ns2, 
+2780                            a[0].tag) 
+2781          self.assertEqual('{%s}b' % ns, 
+2782                            a[1].tag) 
+
2783   
+2784 -    def test_ns_attr(self): 
+
2785          Element = self.etree.Element 
+2786          ns = 'http://xml.infrae.com/1' 
+2787          ns2 = 'http://xml.infrae.com/2' 
+2788          a = Element('a') 
+2789          a.set('{%s}foo' % ns, 'Foo') 
+2790          a.set('{%s}bar' % ns2, 'Bar') 
+2791          self.assertEqual( 
+2792              'Foo', 
+2793              a.get('{%s}foo' % ns)) 
+2794          self.assertEqual( 
+2795              'Bar', 
+2796              a.get('{%s}bar' % ns2)) 
+2797          try: 
+2798              self.assertXML( 
+2799                  _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2)), 
+2800                  a) 
+2801          except AssertionError: 
+2802              self.assertXML( 
+2803                  _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns)), 
+2804                  a) 
+
2805   
+2806 -    def test_ns_move(self): 
+
2807          Element = self.etree.Element 
+2808          one = self.etree.fromstring( 
+2809              _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 
+2810          baz = one[0][0] 
+2811   
+2812          two = Element('root') 
+2813          two.append(baz) 
+2814          # removing the originating document could cause a crash/error before 
+2815          # as namespace is not moved along with it 
+2816          del one, baz 
+2817          self.assertEqual('{http://a.b.c}baz', two[0].tag) 
+
2818   
+2819 -    def test_ns_decl_tostring(self): 
+
2820          tostring = self.etree.tostring 
+2821          root = self.etree.XML( 
+2822              _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 
+2823          baz = root[0][0] 
+2824   
+2825          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 
+2826                              tostring(baz)) 
+2827          self.assertEqual([_bytes("http://a.b.c")], nsdecl) 
+
2828   
+2829 -    def test_ns_decl_tostring_default(self): 
+
2830          tostring = self.etree.tostring 
+2831          root = self.etree.XML( 
+2832              _bytes('<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')) 
+2833          baz = root[0][0] 
+2834   
+2835          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 
+2836                              tostring(baz)) 
+2837          self.assertEqual([_bytes("http://a.b.c")], nsdecl) 
+
2838   
+2839 -    def test_ns_decl_tostring_root(self): 
+
2840          tostring = self.etree.tostring 
+2841          root = self.etree.XML( 
+2842              _bytes('<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')) 
+2843          baz = root[0][0] 
+2844   
+2845          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 
+2846                              tostring(baz)) 
+2847   
+2848          self.assertEqual([_bytes("http://a.b.c")], nsdecl) 
+
2849   
+2850 -    def test_ns_decl_tostring_element(self): 
+
2851          Element = self.etree.Element 
+2852          SubElement = self.etree.SubElement 
+2853   
+2854          root = Element("foo") 
+2855          bar = SubElement(root, "{http://a.b.c}bar") 
+2856          baz = SubElement(bar, "{http://a.b.c}baz") 
+2857   
+2858          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 
+2859                              self.etree.tostring(baz)) 
+2860   
+2861          self.assertEqual([_bytes("http://a.b.c")], nsdecl) 
+
2862   
+2863 -    def test_attribute_xmlns_move(self): 
+
2864          Element = self.etree.Element 
+2865   
+2866          root = Element('element') 
+2867   
+2868          subelement = Element('subelement', 
+2869                               {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 
+2870          self.assertEqual(1, len(subelement.attrib)) 
+2871          self.assertEqual( 
+2872              "foo", 
+2873              subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 
+2874   
+2875          root.append(subelement) 
+2876          self.assertEqual(1, len(subelement.attrib)) 
+2877          self.assertEqual( 
+2878              list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()), 
+2879              list(subelement.attrib.items())) 
+2880          self.assertEqual( 
+2881              "foo", 
+2882              subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 
+
2883   
+2884 -    def test_namespaces_after_serialize(self): 
+
2885          parse = self.etree.parse 
+2886          tostring = self.etree.tostring 
+2887   
+2888          ns_href = "http://a.b.c" 
+2889          one = parse( 
+2890              BytesIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 
+2891          baz = one.getroot()[0][0] 
+2892   
+2893          parsed = parse(BytesIO( tostring(baz) )).getroot() 
+2894          self.assertEqual('{%s}baz' % ns_href, parsed.tag) 
+
2895   
+2896 -    def test_attribute_namespace_roundtrip(self): 
+
2897          fromstring = self.etree.fromstring 
+2898          tostring = self.etree.tostring 
+2899   
+2900          ns_href = "http://a.b.c" 
+2901          xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 
+2902                  ns_href,ns_href)) 
+2903          root = fromstring(xml) 
+2904          self.assertEqual('test', root[0].get('{%s}a' % ns_href)) 
+2905   
+2906          xml2 = tostring(root) 
+2907          self.assertTrue(_bytes(':a=') in xml2, xml2) 
+2908   
+2909          root2 = fromstring(xml2) 
+2910          self.assertEqual('test', root2[0].get('{%s}a' % ns_href)) 
+
2911   
+2912 -    def test_attribute_namespace_roundtrip_replaced(self): 
+
2913          fromstring = self.etree.fromstring 
+2914          tostring = self.etree.tostring 
+2915   
+2916          ns_href = "http://a.b.c" 
+2917          xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 
+2918                  ns_href,ns_href)) 
+2919          root = fromstring(xml) 
+2920          self.assertEqual('test', root[0].get('{%s}a' % ns_href)) 
+2921   
+2922          root[0].set('{%s}a' % ns_href, 'TEST') 
+2923   
+2924          xml2 = tostring(root) 
+2925          self.assertTrue(_bytes(':a=') in xml2, xml2) 
+2926   
+2927          root2 = fromstring(xml2) 
+2928          self.assertEqual('TEST', root2[0].get('{%s}a' % ns_href)) 
+
2929   
+2930      required_versions_ET['test_register_namespace'] = (1,3) 
+2931 -    def test_register_namespace(self): 
+
2932          # ET 1.3+ 
+2933          Element = self.etree.Element 
+2934          prefix = 'TESTPREFIX' 
+2935          namespace = 'http://seriously.unknown/namespace/URI' 
+2936   
+2937          el = Element('{%s}test' % namespace) 
+2938          self.assertEqual(_bytes('<ns0:test xmlns:ns0="%s"></ns0:test>' % namespace), 
+2939              self._writeElement(el)) 
+2940   
+2941          self.etree.register_namespace(prefix, namespace) 
+2942          el = Element('{%s}test' % namespace) 
+2943          self.assertEqual(_bytes('<%s:test xmlns:%s="%s"></%s:test>' % ( 
+2944              prefix, prefix, namespace, prefix)), 
+2945              self._writeElement(el)) 
+2946   
+2947          self.assertRaises(ValueError, self.etree.register_namespace, 'ns25', namespace) 
+
2948   
+2949 -    def test_tostring(self): 
+
2950          tostring = self.etree.tostring 
+2951          Element = self.etree.Element 
+2952          SubElement = self.etree.SubElement 
+2953   
+2954          a = Element('a') 
+2955          b = SubElement(a, 'b') 
+2956          c = SubElement(a, 'c') 
+2957   
+2958          self.assertEqual(_bytes('<a><b></b><c></c></a>'), 
+2959                            canonicalize(tostring(a))) 
+
2960   
+2961 -    def test_tostring_element(self): 
+
2962          tostring = self.etree.tostring 
+2963          Element = self.etree.Element 
+2964          SubElement = self.etree.SubElement 
+2965   
+2966          a = Element('a') 
+2967          b = SubElement(a, 'b') 
+2968          c = SubElement(a, 'c') 
+2969          d = SubElement(c, 'd') 
+2970          self.assertEqual(_bytes('<b></b>'), 
+2971                            canonicalize(tostring(b))) 
+2972          self.assertEqual(_bytes('<c><d></d></c>'), 
+2973                            canonicalize(tostring(c))) 
+
2974   
+2975 -    def test_tostring_element_tail(self): 
+
2976          tostring = self.etree.tostring 
+2977          Element = self.etree.Element 
+2978          SubElement = self.etree.SubElement 
+2979   
+2980          a = Element('a') 
+2981          b = SubElement(a, 'b') 
+2982          c = SubElement(a, 'c') 
+2983          d = SubElement(c, 'd') 
+2984          b.tail = 'Foo' 
+2985   
+2986          self.assertTrue(tostring(b) == _bytes('<b/>Foo') or 
+2987                       tostring(b) == _bytes('<b />Foo')) 
+
2988   
+2989      required_versions_ET['test_tostring_method_html'] = (1,3) 
+2990 -    def test_tostring_method_html(self): 
+
2991          tostring = self.etree.tostring 
+2992          Element = self.etree.Element 
+2993          SubElement = self.etree.SubElement 
+2994   
+2995          html = Element('html') 
+2996          body = SubElement(html, 'body') 
+2997          p = SubElement(body, 'p') 
+2998          p.text = "html" 
+2999          SubElement(p, 'br').tail = "test" 
+3000   
+3001          self.assertEqual(_bytes('<html><body><p>html<br>test</p></body></html>'), 
+3002                            tostring(html, method="html")) 
+
3003   
+3004      required_versions_ET['test_tostring_method_text'] = (1,3) 
+3005 -    def test_tostring_method_text(self): 
+
3006          tostring = self.etree.tostring 
+3007          Element = self.etree.Element 
+3008          SubElement = self.etree.SubElement 
+3009   
+3010          a = Element('a') 
+3011          a.text = "A" 
+3012          a.tail = "tail" 
+3013          b = SubElement(a, 'b') 
+3014          b.text = "B" 
+3015          b.tail = "TAIL" 
+3016          c = SubElement(a, 'c') 
+3017          c.text = "C" 
+3018   
+3019          self.assertEqual(_bytes('ABTAILCtail'), 
+3020                            tostring(a, method="text")) 
+
3021   
+3022 -    def test_iterparse(self): 
+
3023          iterparse = self.etree.iterparse 
+3024          f = BytesIO('<a><b></b><c/></a>') 
+3025   
+3026          iterator = iterparse(f) 
+3027          self.assertEqual(None, 
+3028                            iterator.root) 
+3029          events = list(iterator) 
+3030          root = iterator.root 
+3031          self.assertEqual( 
+3032              [('end', root[0]), ('end', root[1]), ('end', root)], 
+3033              events) 
+
3034   
+3035 -    def test_iterparse_incomplete(self): 
+
3036          iterparse = self.etree.iterparse 
+3037          f = BytesIO('<a><b></b><c/></a>') 
+3038   
+3039          iterator = iterparse(f) 
+3040          self.assertEqual(None, 
+3041                            iterator.root) 
+3042          event, element = next(iter(iterator)) 
+3043          self.assertEqual('end', event) 
+3044          self.assertEqual('b', element.tag) 
+
3045   
+3046 -    def test_iterparse_file(self): 
+
3047          iterparse = self.etree.iterparse 
+3048          iterator = iterparse(fileInTestDir("test.xml")) 
+3049          self.assertEqual(None, 
+3050                            iterator.root) 
+3051          events = list(iterator) 
+3052          root = iterator.root 
+3053          self.assertEqual( 
+3054              [('end', root[0]), ('end', root)], 
+3055              events) 
+
3056   
+3057 -    def test_iterparse_start(self): 
+
3058          iterparse = self.etree.iterparse 
+3059          f = BytesIO('<a><b></b><c/></a>') 
+3060   
+3061          iterator = iterparse(f, events=('start',)) 
+3062          events = list(iterator) 
+3063          root = iterator.root 
+3064          self.assertEqual( 
+3065              [('start', root), ('start', root[0]), ('start', root[1])], 
+3066              events) 
+
3067   
+3068 -    def test_iterparse_start_end(self): 
+
3069          iterparse = self.etree.iterparse 
+3070          f = BytesIO('<a><b></b><c/></a>') 
+3071   
+3072          iterator = iterparse(f, events=('start','end')) 
+3073          events = list(iterator) 
+3074          root = iterator.root 
+3075          self.assertEqual( 
+3076              [('start', root), ('start', root[0]), ('end', root[0]), 
+3077               ('start', root[1]), ('end', root[1]), ('end', root)], 
+3078              events) 
+
3079   
+3080 -    def test_iterparse_clear(self): 
+
3081          iterparse = self.etree.iterparse 
+3082          f = BytesIO('<a><b></b><c/></a>') 
+3083   
+3084          iterator = iterparse(f) 
+3085          for event, elem in iterator: 
+3086              elem.clear() 
+3087   
+3088          root = iterator.root 
+3089          self.assertEqual(0, 
+3090                            len(root)) 
+
3091   
+3092 -    def test_iterparse_large(self): 
+
3093          iterparse = self.etree.iterparse 
+3094          CHILD_COUNT = 12345 
+3095          f = BytesIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT)) 
+3096   
+3097          i = 0 
+3098          for key in iterparse(f): 
+3099              event, element = key 
+3100              i += 1 
+3101          self.assertEqual(i, CHILD_COUNT + 1) 
+
3102   
+3103 -    def test_iterparse_set_ns_attribute(self): 
+
3104          iterparse = self.etree.iterparse 
+3105          f = BytesIO('<a xmlns="http://ns1/"><b><c xmlns="http://ns2/"/></b></a>') 
+3106   
+3107          attr_name = '{http://testns/}bla' 
+3108          events = [] 
+3109          iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 
+3110          for event, elem in iterator: 
+3111              events.append(event) 
+3112              if event == 'start': 
+3113                  if elem.tag != '{http://ns1/}a': 
+3114                      elem.set(attr_name, 'value') 
+3115   
+3116          self.assertEqual( 
+3117              ['start-ns', 'start', 'start', 'start-ns', 'start', 
+3118               'end', 'end-ns', 'end', 'end', 'end-ns'], 
+3119              events) 
+3120   
+3121          root = iterator.root 
+3122          self.assertEqual( 
+3123              None, 
+3124              root.get(attr_name)) 
+3125          self.assertEqual( 
+3126              'value', 
+3127              root[0].get(attr_name)) 
+
3128   
+3129 -    def test_iterparse_only_end_ns(self): 
+
3130          iterparse = self.etree.iterparse 
+3131          f = BytesIO('<a xmlns="http://ns1/"><b><c xmlns="http://ns2/"/></b></a>') 
+3132   
+3133          attr_name = '{http://testns/}bla' 
+3134          events = [] 
+3135          iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 
+3136          for event, elem in iterator: 
+3137              events.append(event) 
+3138              if event == 'start': 
+3139                  if elem.tag != '{http://ns1/}a': 
+3140                      elem.set(attr_name, 'value') 
+3141   
+3142          self.assertEqual( 
+3143              ['start-ns', 'start', 'start', 'start-ns', 'start', 
+3144               'end', 'end-ns', 'end', 'end', 'end-ns'], 
+3145              events) 
+3146   
+3147          root = iterator.root 
+3148          self.assertEqual( 
+3149              None, 
+3150              root.get(attr_name)) 
+3151          self.assertEqual( 
+3152              'value', 
+3153              root[0].get(attr_name)) 
+
3154   
+3155 -    def test_iterparse_getiterator(self): 
+
3156          iterparse = self.etree.iterparse 
+3157          f = BytesIO('<a><b><d/></b><c/></a>') 
+3158   
+3159          counts = [] 
+3160          for event, elem in iterparse(f): 
+3161              counts.append(len(list(elem.getiterator()))) 
+3162          self.assertEqual( 
+3163              [1,2,1,4], 
+3164              counts) 
+
3165   
+3166 -    def test_iterparse_move_elements(self): 
+
3167          iterparse = self.etree.iterparse 
+3168          f = BytesIO('<a><b><d/></b><c/></a>') 
+3169   
+3170          for event, node in etree.iterparse(f): pass 
+3171   
+3172          root = etree.Element('new_root', {}) 
+3173          root[:] = node[:] 
+3174   
+3175          self.assertEqual( 
+3176              ['b', 'c'], 
+3177              [ el.tag for el in root ]) 
+
3178   
+3179 -    def test_iterparse_cdata(self): 
+
3180          tostring = self.etree.tostring 
+3181          f = BytesIO('<root><![CDATA[test]]></root>') 
+3182          context = self.etree.iterparse(f) 
+3183          content = [ el.text for event,el in context ] 
+3184   
+3185          self.assertEqual(['test'], content) 
+3186          self.assertEqual(_bytes('<root>test</root>'), 
+3187                            tostring(context.root)) 
+
3188   
+3189 -    def test_parse_file(self): 
+
3190          parse = self.etree.parse 
+3191          # from file 
+3192          tree = parse(fileInTestDir('test.xml')) 
+3193          self.assertXML( 
+3194              _bytes('<a><b></b></a>'), 
+3195              tree.getroot()) 
+
3196   
+3197 -    def test_parse_file_nonexistent(self): 
+
3198          parse = self.etree.parse 
+3199          self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))   
+
3200   
+3201 -    def test_parse_error_none(self): 
+
3202          parse = self.etree.parse 
+3203          self.assertRaises(TypeError, parse, None) 
+
3204   
+3205      required_versions_ET['test_parse_error'] = (1,3) 
+3206 -    def test_parse_error(self): 
+
3207          # ET < 1.3 raises ExpatError 
+3208          parse = self.etree.parse 
+3209          f = BytesIO('<a><b></c></b></a>') 
+3210          self.assertRaises(SyntaxError, parse, f) 
+3211          f.close() 
+
3212   
+3213      required_versions_ET['test_parse_error_from_file'] = (1,3) 
+3214 -    def test_parse_error_from_file(self): 
+
3215          parse = self.etree.parse 
+3216          # from file 
+3217          f = open(fileInTestDir('test_broken.xml'), 'rb') 
+3218          self.assertRaises(SyntaxError, parse, f) 
+3219          f.close() 
+
3220   
+3221 -    def test_parse_file_object(self): 
+
3222          parse = self.etree.parse 
+3223          # from file object 
+3224          f = open(fileInTestDir('test.xml'), 'rb') 
+3225          tree = parse(f) 
+3226          f.close() 
+3227          self.assertXML( 
+3228              _bytes('<a><b></b></a>'), 
+3229              tree.getroot()) 
+
3230   
+3231 -    def test_parse_stringio(self): 
+
3232          parse = self.etree.parse 
+3233          f = BytesIO('<a><b></b></a>') 
+3234          tree = parse(f) 
+3235          f.close() 
+3236          self.assertXML( 
+3237              _bytes('<a><b></b></a>'), 
+3238              tree.getroot() 
+3239             ) 
+
3240   
+3241 -    def test_parse_cdata(self): 
+
3242          tostring = self.etree.tostring 
+3243          root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>')) 
+3244   
+3245          self.assertEqual('test', root.text) 
+3246          self.assertEqual(_bytes('<root>test</root>'), 
+3247                            tostring(root)) 
+
3248   
+3249 -    def test_parse_with_encoding(self): 
+
3250          # this can fail in libxml2 <= 2.6.22 
+3251          parse = self.etree.parse 
+3252          tree = parse(BytesIO('<?xml version="1.0" encoding="ascii"?><html/>')) 
+3253          self.assertXML(_bytes('<html></html>'), 
+3254                         tree.getroot()) 
+
3255   
+3256 -    def test_encoding(self): 
+
3257          Element = self.etree.Element 
+3258   
+3259          a = Element('a') 
+3260          a.text = _str('Søk på nettet') 
+3261          self.assertXML( 
+3262              _str('<a>Søk på nettet</a>').encode('UTF-8'), 
+3263              a, 'utf-8') 
+
3264   
+3265 -    def test_encoding_exact(self): 
+
3266          ElementTree = self.etree.ElementTree 
+3267          Element = self.etree.Element 
+3268   
+3269          a = Element('a') 
+3270          a.text = _str('Søk på nettet') 
+3271   
+3272          f = BytesIO() 
+3273          tree = ElementTree(element=a) 
+3274          tree.write(f, encoding='utf-8') 
+3275          self.assertEqual(_str('<a>Søk på nettet</a>').encode('UTF-8'), 
+3276                            f.getvalue().replace(_bytes('\n'),_bytes(''))) 
+
3277   
+3278 -    def test_parse_file_encoding(self): 
+
3279          parse = self.etree.parse 
+3280          # from file 
+3281          tree = parse(fileInTestDir('test-string.xml')) 
+3282          self.assertXML( 
+3283              _str('<a>Søk på nettet</a>').encode('UTF-8'), 
+3284              tree.getroot(), 'UTF-8') 
+
3285   
+3286 -    def test_parse_file_object_encoding(self): 
+
3287          parse = self.etree.parse 
+3288          # from file object 
+3289          f = open(fileInTestDir('test-string.xml'), 'rb') 
+3290          tree = parse(f) 
+3291          f.close() 
+3292          self.assertXML( 
+3293              _str('<a>Søk på nettet</a>').encode('UTF-8'), 
+3294              tree.getroot(), 'UTF-8') 
+
3295   
+3296 -    def test_encoding_8bit_latin1(self): 
+
3297          ElementTree = self.etree.ElementTree 
+3298          Element = self.etree.Element 
+3299   
+3300          a = Element('a') 
+3301          a.text = _str('Søk på nettet') 
+3302   
+3303          f = BytesIO() 
+3304          tree = ElementTree(element=a) 
+3305          tree.write(f, encoding='iso-8859-1') 
+3306          result = f.getvalue() 
+3307          declaration = _bytes("<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>") 
+3308          self.assertEncodingDeclaration(result, _bytes('iso-8859-1')) 
+3309          result = result.split(_bytes('?>'), 1)[-1].replace(_bytes('\n'),_bytes('')) 
+3310          self.assertEqual(_str('<a>Søk på nettet</a>').encode('iso-8859-1'), 
+3311                            result) 
+
3312   
+3313      required_versions_ET['test_parse_encoding_8bit_explicit'] = (1,3) 
+3314 -    def test_parse_encoding_8bit_explicit(self): 
+
3315          XMLParser = self.XMLParser 
+3316   
+3317          text = _str('Søk på nettet') 
+3318          xml_latin1 = (_str('<a>%s</a>') % text).encode('iso-8859-1') 
+3319   
+3320          self.assertRaises(self.etree.ParseError, 
+3321                            self.etree.parse, 
+3322                            BytesIO(xml_latin1)) 
+3323   
+3324          tree = self.etree.parse(BytesIO(xml_latin1), 
+3325                                  XMLParser(encoding="iso-8859-1")) 
+3326          a = tree.getroot() 
+3327          self.assertEqual(a.text, text) 
+
3328   
+3329      required_versions_ET['test_parse_encoding_8bit_override'] = (1,3) 
+3330 -    def test_parse_encoding_8bit_override(self): 
+
3331          XMLParser = self.XMLParser 
+3332   
+3333          text = _str('Søk på nettet') 
+3334          wrong_declaration = _str("<?xml version='1.0' encoding='UTF-8'?>") 
+3335          xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 
+3336                        ).encode('iso-8859-1') 
+3337   
+3338          self.assertRaises(self.etree.ParseError, 
+3339                            self.etree.parse, 
+3340                            BytesIO(xml_latin1)) 
+3341   
+3342          tree = self.etree.parse(BytesIO(xml_latin1), 
+3343                                  XMLParser(encoding="iso-8859-1")) 
+3344          a = tree.getroot() 
+3345          self.assertEqual(a.text, text) 
+
3346   
+3347 -    def _test_wrong_unicode_encoding(self): 
+
3348          # raise error on wrong encoding declaration in unicode strings 
+3349          XML = self.etree.XML 
+3350          test_utf = (_str('<?xml version="1.0" encoding="iso-8859-1"?>') + 
+3351                      _str('<a>Søk på nettet</a>')) 
+3352          self.assertRaises(SyntaxError, XML, test_utf) 
+
3353   
+3354 -    def test_encoding_write_default_encoding(self): 
+
3355          ElementTree = self.etree.ElementTree 
+3356          Element = self.etree.Element 
+3357   
+3358          a = Element('a') 
+3359          a.text = _str('Søk på nettet') 
+3360   
+3361          f = BytesIO() 
+3362          tree = ElementTree(element=a) 
+3363          tree.write(f) 
+3364          data = f.getvalue().replace(_bytes('\n'),_bytes('')) 
+3365          self.assertEqual( 
+3366              _str('<a>Søk på nettet</a>').encode('ASCII', 'xmlcharrefreplace'), 
+3367              data) 
+
3368   
+3369 -    def test_encoding_tostring(self): 
+
3370          Element = self.etree.Element 
+3371          tostring = self.etree.tostring 
+3372   
+3373          a = Element('a') 
+3374          a.text = _str('Søk på nettet') 
+3375          self.assertEqual(_str('<a>Søk på nettet</a>').encode('UTF-8'), 
+3376                           tostring(a, encoding='utf-8')) 
+
3377   
+3378 -    def test_encoding_tostring_unknown(self): 
+
3379          Element = self.etree.Element 
+3380          tostring = self.etree.tostring 
+3381   
+3382          a = Element('a') 
+3383          a.text = _str('Søk på nettet') 
+3384          self.assertRaises(LookupError, tostring, a, 
+3385                            encoding='Invalid Encoding') 
+
3386   
+3387 -    def test_encoding_tostring_sub(self): 
+
3388          Element = self.etree.Element 
+3389          SubElement = self.etree.SubElement 
+3390          tostring = self.etree.tostring 
+3391   
+3392          a = Element('a') 
+3393          b = SubElement(a, 'b') 
+3394          b.text = _str('Søk på nettet') 
+3395          self.assertEqual(_str('<b>Søk på nettet</b>').encode('UTF-8'), 
+3396                           tostring(b, encoding='utf-8')) 
+
3397   
+3398 -    def test_encoding_tostring_sub_tail(self): 
+
3399          Element = self.etree.Element 
+3400          SubElement = self.etree.SubElement 
+3401          tostring = self.etree.tostring 
+3402   
+3403          a = Element('a') 
+3404          b = SubElement(a, 'b') 
+3405          b.text = _str('Søk på nettet') 
+3406          b.tail = _str('Søk') 
+3407          self.assertEqual(_str('<b>Søk på nettet</b>Søk').encode('UTF-8'), 
+3408                           tostring(b, encoding='utf-8')) 
+
3409   
+3410 -    def test_encoding_tostring_default_encoding(self): 
+
3411          Element = self.etree.Element 
+3412          SubElement = self.etree.SubElement 
+3413          tostring = self.etree.tostring 
+3414   
+3415          a = Element('a') 
+3416          a.text = _str('Søk på nettet') 
+3417   
+3418          expected = _bytes('<a>S&#248;k p&#229; nettet</a>') 
+3419          self.assertEqual( 
+3420              expected, 
+3421              tostring(a)) 
+
3422   
+3423 -    def test_encoding_sub_tostring_default_encoding(self): 
+
3424          Element = self.etree.Element 
+3425          SubElement = self.etree.SubElement 
+3426          tostring = self.etree.tostring 
+3427   
+3428          a = Element('a') 
+3429          b = SubElement(a, 'b') 
+3430          b.text = _str('Søk på nettet') 
+3431   
+3432          expected = _bytes('<b>S&#248;k p&#229; nettet</b>') 
+3433          self.assertEqual( 
+3434              expected, 
+3435              tostring(b)) 
+
3436   
+3437 -    def test_encoding_8bit_xml(self): 
+
3438          utext = _str('Søk på nettet') 
+3439          uxml = _str('<p>%s</p>') % utext 
+3440          prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 
+3441          isoxml = prologue + uxml.encode('iso-8859-1') 
+3442          tree = self.etree.XML(isoxml) 
+3443          self.assertEqual(utext, tree.text) 
+
3444   
+3445 -    def test_encoding_utf8_bom(self): 
+
3446          utext = _str('Søk på nettet') 
+3447          uxml = (_str('<?xml version="1.0" encoding="UTF-8"?>') + 
+3448                  _str('<p>%s</p>') % utext) 
+3449          bom = _bytes('\\xEF\\xBB\\xBF').decode("unicode_escape").encode("latin1") 
+3450          xml = bom + uxml.encode("utf-8") 
+3451          tree = etree.XML(xml) 
+3452          self.assertEqual(utext, tree.text) 
+
3453   
+3454 -    def test_encoding_8bit_parse_stringio(self): 
+
3455          utext = _str('Søk på nettet') 
+3456          uxml = _str('<p>%s</p>') % utext 
+3457          prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 
+3458          isoxml = prologue + uxml.encode('iso-8859-1') 
+3459          el = self.etree.parse(BytesIO(isoxml)).getroot() 
+3460          self.assertEqual(utext, el.text) 
+
3461   
+3462 -    def test_deepcopy_elementtree(self): 
+
3463          Element = self.etree.Element 
+3464          ElementTree = self.etree.ElementTree 
+3465   
+3466          a = Element('a') 
+3467          a.text = "Foo" 
+3468          atree = ElementTree(a) 
+3469   
+3470          btree = copy.deepcopy(atree) 
+3471          self.assertEqual("Foo", atree.getroot().text) 
+3472          self.assertEqual("Foo", btree.getroot().text) 
+3473          self.assertFalse(btree is atree) 
+3474          self.assertFalse(btree.getroot() is atree.getroot()) 
+
3475   
+3476 -    def test_deepcopy(self): 
+
3477          Element = self.etree.Element 
+3478   
+3479          a = Element('a') 
+3480          a.text = 'Foo' 
+3481   
+3482          b = copy.deepcopy(a) 
+3483          self.assertEqual('Foo', b.text) 
+3484   
+3485          b.text = 'Bar' 
+3486          self.assertEqual('Bar', b.text) 
+3487          self.assertEqual('Foo', a.text) 
+3488   
+3489          del a 
+3490          self.assertEqual('Bar', b.text) 
+
3491   
+3492 -    def test_deepcopy_tail(self): 
+
3493          Element = self.etree.Element 
+3494   
+3495          a = Element('a') 
+3496          a.tail = 'Foo' 
+3497   
+3498          b = copy.deepcopy(a) 
+3499          self.assertEqual('Foo', b.tail) 
+3500   
+3501          b.tail = 'Bar' 
+3502          self.assertEqual('Bar', b.tail) 
+3503          self.assertEqual('Foo', a.tail) 
+3504   
+3505          del a 
+3506          self.assertEqual('Bar', b.tail) 
+
3507   
+3508 -    def test_deepcopy_subelement(self): 
+
3509          Element = self.etree.Element 
+3510          SubElement = self.etree.SubElement 
+3511   
+3512          root = Element('root') 
+3513          a = SubElement(root, 'a') 
+3514          a.text = 'FooText' 
+3515          a.tail = 'FooTail' 
+3516   
+3517          b = copy.deepcopy(a) 
+3518          self.assertEqual('FooText', b.text) 
+3519          self.assertEqual('FooTail', b.tail) 
+3520   
+3521          b.text = 'BarText' 
+3522          b.tail = 'BarTail' 
+3523          self.assertEqual('BarTail', b.tail) 
+3524          self.assertEqual('FooTail', a.tail) 
+3525          self.assertEqual('BarText', b.text) 
+3526          self.assertEqual('FooText', a.text) 
+3527   
+3528          del a 
+3529          self.assertEqual('BarTail', b.tail) 
+3530          self.assertEqual('BarText', b.text) 
+
3531   
+3532 -    def test_deepcopy_namespaces(self): 
+
3533          root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns"> 
+3534          <parent><node t:foo="bar" /></parent> 
+3535          </doc>''')) 
+3536          self.assertEqual( 
+3537              root[0][0].get('{tns}foo'), 
+3538              copy.deepcopy(root[0])[0].get('{tns}foo') ) 
+3539          self.assertEqual( 
+3540              root[0][0].get('{tns}foo'), 
+3541              copy.deepcopy(root[0][0]).get('{tns}foo') ) 
+
3542   
+3543 -    def test_deepcopy_append(self): 
+
3544          # previously caused a crash 
+3545          Element = self.etree.Element 
+3546          tostring = self.etree.tostring 
+3547   
+3548          a = Element('a') 
+3549          b = copy.deepcopy(a) 
+3550          a.append( Element('C') ) 
+3551          b.append( Element('X') ) 
+3552   
+3553          self.assertEqual(_bytes('<a><C/></a>'), 
+3554                            tostring(a).replace(_bytes(' '), _bytes(''))) 
+3555          self.assertEqual(_bytes('<a><X/></a>'), 
+3556                            tostring(b).replace(_bytes(' '), _bytes(''))) 
+
3557   
+3558 -    def test_deepcopy_comment(self): 
+
3559          # previously caused a crash 
+3560          # not supported by ET < 1.3! 
+3561          Comment = self.etree.Comment 
+3562   
+3563          a = Comment("ONE") 
+3564          b = copy.deepcopy(a) 
+3565          b.text = "ANOTHER" 
+3566   
+3567          self.assertEqual('ONE',     a.text) 
+3568          self.assertEqual('ANOTHER', b.text) 
+
3569   
+3570 -    def test_shallowcopy(self): 
+
3571          Element = self.etree.Element 
+3572   
+3573          a = Element('a') 
+3574          a.text = 'Foo' 
+3575   
+3576          b = copy.copy(a) 
+3577          self.assertEqual('Foo', b.text) 
+3578   
+3579          b.text = 'Bar' 
+3580          self.assertEqual('Bar', b.text) 
+3581          self.assertEqual('Foo', a.text) 
+
3582          # XXX ElementTree will share nodes, but lxml.etree won't.. 
+3583   
+3584 -    def test_shallowcopy_elementtree(self): 
+
3585          Element = self.etree.Element 
+3586          ElementTree = self.etree.ElementTree 
+3587   
+3588          a = Element('a') 
+3589          a.text = 'Foo' 
+3590          atree = ElementTree(a) 
+3591   
+3592          btree = copy.copy(atree) 
+3593          self.assertFalse(btree is atree) 
+3594          self.assertTrue(btree.getroot() is atree.getroot()) 
+3595          self.assertEqual('Foo', atree.getroot().text) 
+
3596   
+3597 -    def _test_element_boolean(self): 
+
3598          # deprecated as of ET 1.3/lxml 2.0 
+3599          etree = self.etree 
+3600          e = etree.Element('foo') 
+3601          self.assertEqual(False, bool(e)) 
+3602          etree.SubElement(e, 'bar') 
+3603          self.assertEqual(True, bool(e)) 
+3604          e = etree.Element('foo') 
+3605          e.text = 'hey' 
+3606          self.assertEqual(False, bool(e)) 
+3607          e = etree.Element('foo') 
+3608          e.tail = 'bar' 
+3609          self.assertEqual(False, bool(e)) 
+3610          e = etree.Element('foo') 
+3611          e.set('bar', 'Bar') 
+3612          self.assertEqual(False, bool(e)) 
+
3613   
+3614 -    def test_multiple_elementrees(self): 
+
3615          etree = self.etree 
+3616   
+3617          a = etree.Element('a') 
+3618          b = etree.SubElement(a, 'b') 
+3619   
+3620          t = etree.ElementTree(a) 
+3621          self.assertEqual(self._rootstring(t), _bytes('<a><b/></a>')) 
+3622   
+3623          t1 = etree.ElementTree(a) 
+3624          self.assertEqual(self._rootstring(t1), _bytes('<a><b/></a>')) 
+3625          self.assertEqual(self._rootstring(t),  _bytes('<a><b/></a>')) 
+3626   
+3627          t2 = etree.ElementTree(b) 
+3628          self.assertEqual(self._rootstring(t2), _bytes('<b/>')) 
+3629          self.assertEqual(self._rootstring(t1), _bytes('<a><b/></a>')) 
+3630          self.assertEqual(self._rootstring(t),  _bytes('<a><b/></a>')) 
+
3631   
+3632 -    def test_qname(self): 
+
3633          etree = self.etree 
+3634          qname = etree.QName('myns', 'a') 
+3635          a1 = etree.Element(qname) 
+3636          a2 = etree.SubElement(a1, qname) 
+3637          self.assertEqual(a1.tag, "{myns}a") 
+3638          self.assertEqual(a2.tag, "{myns}a") 
+
3639   
+3640 -    def test_qname_cmp(self): 
+
3641          etree = self.etree 
+3642          qname1 = etree.QName('myns', 'a') 
+3643          qname2 = etree.QName('myns', 'a') 
+3644          self.assertEqual(qname1, "{myns}a") 
+3645          self.assertEqual("{myns}a", qname2) 
+3646          self.assertEqual(qname1, qname1) 
+3647          self.assertEqual(qname1, qname2) 
+
3648   
+3649 -    def test_qname_attribute_getset(self): 
+
3650          etree = self.etree 
+3651          qname = etree.QName('myns', 'a') 
+3652   
+3653          a = etree.Element(qname) 
+3654          a.set(qname, "value") 
+3655   
+3656          self.assertEqual(a.get(qname), "value") 
+3657          self.assertEqual(a.get("{myns}a"), "value") 
+
3658   
+3659 -    def test_qname_attrib(self): 
+
3660          etree = self.etree 
+3661          qname = etree.QName('myns', 'a') 
+3662   
+3663          a = etree.Element(qname) 
+3664          a.attrib[qname] = "value" 
+3665   
+3666          self.assertEqual(a.attrib[qname], "value") 
+3667          self.assertEqual(a.attrib.get(qname), "value") 
+3668   
+3669          self.assertEqual(a.attrib["{myns}a"], "value") 
+3670          self.assertEqual(a.attrib.get("{myns}a"), "value") 
+
3671   
+3672 -    def test_qname_attribute_resolve(self): 
+
3673          etree = self.etree 
+3674          qname = etree.QName('http://myns', 'a') 
+3675          a = etree.Element(qname) 
+3676          a.set(qname, qname) 
+3677   
+3678          self.assertXML( 
+3679              _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 
+3680              a) 
+
3681   
+3682 -    def test_qname_attribute_resolve_new(self): 
+
3683          etree = self.etree 
+3684          qname = etree.QName('http://myns', 'a') 
+3685          a = etree.Element('a') 
+3686          a.set('a', qname) 
+3687   
+3688          self.assertXML( 
+3689              _bytes('<a xmlns:ns0="http://myns" a="ns0:a"></a>'), 
+3690              a) 
+
3691   
+3692 -    def test_qname_attrib_resolve(self): 
+
3693          etree = self.etree 
+3694          qname = etree.QName('http://myns', 'a') 
+3695          a = etree.Element(qname) 
+3696          a.attrib[qname] = qname 
+3697   
+3698          self.assertXML( 
+3699              _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 
+3700              a) 
+
3701   
+3702 -    def test_parser_version(self): 
+
3703          etree = self.etree 
+3704          parser = etree.XMLParser() 
+3705          if hasattr(parser, "version"): 
+3706              # ElementTree 1.3+, cET 
+3707              self.assertTrue(re.match("[^ ]+ [0-9.]+", parser.version)) 
+
3708   
+3709      # feed parser interface 
+3710   
+3711 -    def test_feed_parser_bytes(self): 
+
3712          parser = self.XMLParser() 
+3713   
+3714          parser.feed(_bytes('<?xml version=')) 
+3715          parser.feed(_bytes('"1.0"?><ro')) 
+3716          parser.feed(_bytes('ot><')) 
+3717          parser.feed(_bytes('a test="works"/')) 
+3718          parser.feed(_bytes('></root')) 
+3719          parser.feed(_bytes('>')) 
+3720   
+3721          root = parser.close() 
+3722   
+3723          self.assertEqual(root.tag, "root") 
+3724          self.assertEqual(root[0].tag, "a") 
+3725          self.assertEqual(root[0].get("test"), "works") 
+
3726   
+3727 -    def test_feed_parser_unicode(self): 
+
3728          parser = self.XMLParser() 
+3729   
+3730          parser.feed(_str('<ro')) 
+3731          parser.feed(_str('ot><')) 
+3732          parser.feed(_str('a test="works"/')) 
+3733          parser.feed(_str('></root')) 
+3734          parser.feed(_str('>')) 
+3735   
+3736          root = parser.close() 
+3737   
+3738          self.assertEqual(root.tag, "root") 
+3739          self.assertEqual(root[0].tag, "a") 
+3740          self.assertEqual(root[0].get("test"), "works") 
+
3741   
+3742      required_versions_ET['test_feed_parser_error_close_empty'] = (1,3) 
+3743 -    def test_feed_parser_error_close_empty(self): 
+
3744          ParseError = self.etree.ParseError 
+3745          parser = self.XMLParser() 
+3746          self.assertRaises(ParseError, parser.close) 
+
3747   
+3748      required_versions_ET['test_feed_parser_error_close_incomplete'] = (1,3) 
+3749 -    def test_feed_parser_error_close_incomplete(self): 
+
3750          ParseError = self.etree.ParseError 
+3751          parser = self.XMLParser() 
+3752   
+3753          parser.feed('<?xml version=') 
+3754          parser.feed('"1.0"?><ro') 
+3755   
+3756          self.assertRaises(ParseError, parser.close) 
+
3757   
+3758      required_versions_ET['test_feed_parser_error_broken'] = (1,3) 
+3759 -    def test_feed_parser_error_broken(self): 
+
3760          ParseError = self.etree.ParseError 
+3761          parser = self.XMLParser() 
+3762   
+3763          parser.feed('<?xml version=') 
+3764          parser.feed('"1.0"?><ro') 
+3765          try: 
+3766              parser.feed('<><><><><><><') 
+3767          except ParseError: 
+3768              # can raise, but not required before close() 
+3769              pass 
+3770   
+3771          self.assertRaises(ParseError, parser.close) 
+
3772   
+3773      required_versions_ET['test_feed_parser_error_position'] = (1,3) 
+3774 -    def test_feed_parser_error_position(self): 
+
3775          ParseError = self.etree.ParseError 
+3776          parser = self.XMLParser() 
+3777          try: 
+3778              parser.close() 
+3779          except ParseError: 
+3780              e = sys.exc_info()[1] 
+3781              self.assertNotEqual(None, e.code) 
+3782              self.assertNotEqual(0, e.code) 
+3783              self.assertTrue(isinstance(e.position, tuple)) 
+3784              self.assertTrue(e.position >= (0, 0)) 
+
3785   
+3786      # parser target interface 
+3787   
+3788      required_versions_ET['test_parser_target_property'] = (1,3) 
+3789 -    def test_parser_target_property(self): 
+
3790          class Target(object): 
+3791              pass 
+
3792   
+3793          target = Target() 
+3794          parser = self.XMLParser(target=target) 
+3795   
+3796          self.assertEqual(target, parser.target) 
+3797   
+3798 -    def test_parser_target_tag(self): 
+
3799          assertEqual = self.assertEqual 
+3800          assertFalse  = self.assertFalse 
+3801   
+3802          events = [] 
+3803          class Target(object): 
+3804              def start(self, tag, attrib): 
+3805                  events.append("start") 
+3806                  assertFalse(attrib) 
+3807                  assertEqual("TAG", tag) 
+
3808              def end(self, tag): 
+3809                  events.append("end") 
+3810                  assertEqual("TAG", tag) 
+3811              def close(self): 
+3812                  return "DONE" 
+3813   
+3814          parser = self.XMLParser(target=Target()) 
+3815   
+3816          parser.feed("<TAG/>") 
+3817          done = parser.close() 
+3818   
+3819          self.assertEqual("DONE", done) 
+3820          self.assertEqual(["start", "end"], events) 
+3821   
+3822 -    def test_parser_target_error_in_start(self): 
+
3823          assertEqual = self.assertEqual 
+3824   
+3825          events = [] 
+3826          class Target(object): 
+3827              def start(self, tag, attrib): 
+3828                  events.append("start") 
+3829                  assertEqual("TAG", tag) 
+3830                  raise ValueError("TEST") 
+
3831              def end(self, tag): 
+3832                  events.append("end") 
+3833                  assertEqual("TAG", tag) 
+3834              def close(self): 
+3835                  return "DONE" 
+3836   
+3837          parser = self.XMLParser(target=Target()) 
+3838   
+3839          try: 
+3840              parser.feed("<TAG/>") 
+3841          except ValueError: 
+3842              self.assertTrue('TEST' in str(sys.exc_info()[1])) 
+3843          else: 
+3844              self.assertTrue(False) 
+3845          if 'lxml' in self.etree.__name__: 
+3846              self.assertEqual(["start"], events) 
+3847          else: 
+3848              # cElementTree calls end() as well 
+3849              self.assertTrue("start" in events) 
+3850   
+3851 -    def test_parser_target_error_in_end(self): 
+
3852          assertEqual = self.assertEqual 
+3853   
+3854          events = [] 
+3855          class Target(object): 
+3856              def start(self, tag, attrib): 
+3857                  events.append("start") 
+3858                  assertEqual("TAG", tag) 
+
3859              def end(self, tag): 
+3860                  events.append("end") 
+3861                  assertEqual("TAG", tag) 
+3862                  raise ValueError("TEST") 
+3863              def close(self): 
+3864                  return "DONE" 
+3865   
+3866          parser = self.XMLParser(target=Target()) 
+3867   
+3868          try: 
+3869              parser.feed("<TAG/>") 
+3870          except ValueError: 
+3871              self.assertTrue('TEST' in str(sys.exc_info()[1])) 
+3872          else: 
+3873              self.assertTrue(False) 
+3874          self.assertEqual(["start", "end"], events) 
+3875   
+3876 -    def test_parser_target_error_in_close(self): 
+
3877          assertEqual = self.assertEqual 
+3878   
+3879          events = [] 
+3880          class Target(object): 
+3881              def start(self, tag, attrib): 
+3882                  events.append("start") 
+3883                  assertEqual("TAG", tag) 
+
3884              def end(self, tag): 
+3885                  events.append("end") 
+3886                  assertEqual("TAG", tag) 
+3887              def close(self): 
+3888                  raise ValueError("TEST") 
+3889   
+3890          parser = self.XMLParser(target=Target()) 
+3891   
+3892          try: 
+3893              parser.feed("<TAG/>") 
+3894              parser.close() 
+3895          except ValueError: 
+3896              self.assertTrue('TEST' in str(sys.exc_info()[1])) 
+3897          else: 
+3898              self.assertTrue(False) 
+3899          self.assertEqual(["start", "end"], events) 
+3900   
+3901 -    def test_parser_target_error_in_start_and_close(self): 
+
3902          assertEqual = self.assertEqual 
+3903   
+3904          events = [] 
+3905          class Target(object): 
+3906              def start(self, tag, attrib): 
+3907                  events.append("start") 
+3908                  assertEqual("TAG", tag) 
+3909                  raise IndexError("TEST-IE") 
+
3910              def end(self, tag): 
+3911                  events.append("end") 
+3912                  assertEqual("TAG", tag) 
+3913              def close(self): 
+3914                  raise ValueError("TEST-VE") 
+3915   
+3916          parser = self.XMLParser(target=Target()) 
+3917   
+3918          try: 
+3919              parser.feed("<TAG/>") 
+3920              parser.close() 
+3921          except IndexError: 
+3922              if 'lxml' in self.etree.__name__: 
+3923                  # we try not to swallow the initial exception in Py2 
+3924                  self.assertTrue(sys.version_info[0] < 3) 
+3925              self.assertTrue('TEST-IE' in str(sys.exc_info()[1])) 
+3926          except ValueError: 
+3927              if 'lxml' in self.etree.__name__: 
+3928                  self.assertTrue(sys.version_info[0] >= 3) 
+3929              self.assertTrue('TEST-VE' in str(sys.exc_info()[1])) 
+3930          else: 
+3931              self.assertTrue(False) 
+3932   
+3933          if 'lxml' in self.etree.__name__: 
+3934              self.assertEqual(["start"], events) 
+3935          else: 
+3936              # cElementTree calls end() as well 
+3937              self.assertTrue("start" in events) 
+3938   
+3939 -    def test_elementtree_parser_target(self): 
+
3940          assertEqual = self.assertEqual 
+3941          assertFalse  = self.assertFalse 
+3942          Element = self.etree.Element 
+3943   
+3944          events = [] 
+3945          class Target(object): 
+3946              def start(self, tag, attrib): 
+3947                  events.append("start") 
+3948                  assertFalse(attrib) 
+3949                  assertEqual("TAG", tag) 
+
3950              def end(self, tag): 
+3951                  events.append("end") 
+3952                  assertEqual("TAG", tag) 
+3953              def close(self): 
+3954                  return Element("DONE") 
+3955   
+3956          parser = self.XMLParser(target=Target()) 
+3957          tree = self.etree.ElementTree() 
+3958          tree.parse(BytesIO("<TAG/>"), parser=parser) 
+3959   
+3960          self.assertEqual("DONE", tree.getroot().tag) 
+3961          self.assertEqual(["start", "end"], events) 
+3962   
+3963 -    def test_parser_target_attrib(self): 
+
3964          assertEqual = self.assertEqual 
+3965   
+3966          events = [] 
+3967          class Target(object): 
+3968              def start(self, tag, attrib): 
+3969                  events.append("start-" + tag) 
+3970                  for name, value in attrib.items(): 
+3971                      assertEqual(tag + name, value) 
+
3972              def end(self, tag): 
+3973                  events.append("end-" + tag) 
+3974              def close(self): 
+3975                  return "DONE" 
+3976   
+3977          parser = self.XMLParser(target=Target()) 
+3978   
+3979          parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>') 
+3980          done = parser.close() 
+3981   
+3982          self.assertEqual("DONE", done) 
+3983          self.assertEqual(["start-root", "start-sub", "end-sub", "end-root"], 
+3984                            events) 
+3985   
+3986 -    def test_parser_target_data(self): 
+
3987          events = [] 
+3988          class Target(object): 
+3989              def start(self, tag, attrib): 
+3990                  events.append("start-" + tag) 
+
3991              def end(self, tag): 
+3992                  events.append("end-" + tag) 
+3993              def data(self, data): 
+3994                  events.append("data-" + data) 
+3995              def close(self): 
+3996                  return "DONE" 
+3997   
+3998          parser = self.XMLParser(target=Target()) 
+3999   
+4000          parser.feed('<root>A<sub/>B</root>') 
+4001          done = parser.close() 
+4002   
+4003          self.assertEqual("DONE", done) 
+4004          self.assertEqual(["start-root", "data-A", "start-sub", 
+4005                             "end-sub", "data-B", "end-root"], 
+4006                            events) 
+4007   
+4008 -    def test_parser_target_entity(self): 
+
4009          events = [] 
+4010          class Target(object): 
+4011              def __init__(self): 
+4012                  self._data = [] 
+
4013              def _flush_data(self): 
+4014                  if self._data: 
+4015                      events.append("data-" + ''.join(self._data)) 
+4016                      del self._data[:] 
+4017              def start(self, tag, attrib): 
+4018                  self._flush_data() 
+4019                  events.append("start-" + tag) 
+4020              def end(self, tag): 
+4021                  self._flush_data() 
+4022                  events.append("end-" + tag) 
+4023              def data(self, data): 
+4024                  self._data.append(data) 
+4025              def close(self): 
+4026                  self._flush_data() 
+4027                  return "DONE" 
+4028   
+4029          parser = self.XMLParser(target=Target()) 
+4030   
+4031          dtd = ''' 
+4032              <!DOCTYPE root [ 
+4033              <!ELEMENT root (sub*)> 
+4034              <!ELEMENT sub (#PCDATA)> 
+4035              <!ENTITY ent "an entity"> 
+4036          ]> 
+4037          ''' 
+4038          parser.feed(dtd+'<root><sub/><sub>this is &ent;</sub><sub/></root>') 
+4039          done = parser.close() 
+4040   
+4041          self.assertEqual("DONE", done) 
+4042          self.assertEqual(["start-root", "start-sub", "end-sub", "start-sub", 
+4043                             "data-this is an entity", 
+4044                             "end-sub", "start-sub", "end-sub", "end-root"], 
+4045                            events) 
+4046   
+4047      required_versions_ET['test_parser_target_entity_unknown'] = (1,3) 
+4048 -    def test_parser_target_entity_unknown(self): 
+
4049          events = [] 
+4050          class Target(object): 
+4051              def __init__(self): 
+4052                  self._data = [] 
+
4053              def _flush_data(self): 
+4054                  if self._data: 
+4055                      events.append("data-" + ''.join(self._data)) 
+4056                      del self._data[:] 
+4057              def start(self, tag, attrib): 
+4058                  self._flush_data() 
+4059                  events.append("start-" + tag) 
+4060              def end(self, tag): 
+4061                  self._flush_data() 
+4062                  events.append("end-" + tag) 
+4063              def data(self, data): 
+4064                  self._data.append(data) 
+4065              def close(self): 
+4066                  self._flush_data() 
+4067                  return "DONE" 
+4068   
+4069          parser = self.XMLParser(target=Target()) 
+4070   
+4071          def feed(): 
+4072              parser.feed('<root><sub/><sub>some &ent;</sub><sub/></root>') 
+4073              parser.close() 
+4074   
+4075          self.assertRaises(self.etree.ParseError, feed) 
+4076   
+4077      @et_needs_pyversion(3, 8, 0, 'alpha', 4) 
+4078 -    def test_parser_target_start_end_ns(self): 
+
4079          class Builder(list): 
+4080              def start(self, tag, attrib): 
+4081                  self.append(("start", tag)) 
+
4082              def end(self, tag): 
+4083                  self.append(("end", tag)) 
+4084              def data(self, text): 
+4085                  pass 
+4086              def pi(self, target, data): 
+4087                  self.append(("pi", target, data)) 
+4088              def comment(self, data): 
+4089                  self.append(("comment", data)) 
+4090              def start_ns(self, prefix, uri): 
+4091                  self.append(("start-ns", prefix, uri)) 
+4092              def end_ns(self, prefix): 
+4093                  self.append(("end-ns", prefix)) 
+4094   
+4095          builder = Builder() 
+4096          parser = self.etree.XMLParser(target=builder) 
+4097          parser.feed(textwrap.dedent("""\ 
+4098              <?pi data?> 
+4099              <!-- comment --> 
+4100              <root xmlns='namespace'> 
+4101                 <element key='value'>text</element> 
+4102                 <element>text</element>tail 
+4103                 <empty-element/> 
+4104              </root> 
+4105              """)) 
+4106          self.assertEqual(builder, [ 
+4107                  ('pi', 'pi', 'data'), 
+4108                  ('comment', ' comment '), 
+4109                  ('start-ns', '', 'namespace'), 
+4110                  ('start', '{namespace}root'), 
+4111                  ('start', '{namespace}element'), 
+4112                  ('end', '{namespace}element'), 
+4113                  ('start', '{namespace}element'), 
+4114                  ('end', '{namespace}element'), 
+4115                  ('start', '{namespace}empty-element'), 
+4116                  ('end', '{namespace}empty-element'), 
+4117                  ('end', '{namespace}root'), 
+4118                  ('end-ns', ''), 
+4119              ]) 
+4120   
+4121      @et_needs_pyversion(3, 8, 0, 'alpha', 4) 
+4122 -    def test_parser_target_end_ns(self): 
+
4123          class Builder(list): 
+4124              def end_ns(self, prefix): 
+4125                  self.append(("end-ns", prefix)) 
+
4126   
+4127          builder = Builder() 
+4128          parser = self.etree.XMLParser(target=builder) 
+4129          parser.feed(textwrap.dedent("""\ 
+4130              <?pi data?> 
+4131              <!-- comment --> 
+4132              <root xmlns='namespace' xmlns:p='pns'> 
+4133                 <element key='value'>text</element> 
+4134                 <p:element>text</p:element>tail 
+4135                 <empty-element/> 
+4136              </root> 
+4137              """)) 
+4138          self.assertEqual(builder, [ 
+4139                  ('end-ns', 'p'), 
+4140                  ('end-ns', ''), 
+4141              ]) 
+4142   
+4143 -    def test_treebuilder(self): 
+
4144          builder = self.etree.TreeBuilder() 
+4145          el = builder.start("root", {'a':'A', 'b':'B'}) 
+4146          self.assertEqual("root", el.tag) 
+4147          self.assertEqual({'a':'A', 'b':'B'}, el.attrib) 
+4148          builder.data("ROOTTEXT") 
+4149          el = builder.start("child", {'x':'X', 'y':'Y'}) 
+4150          self.assertEqual("child", el.tag) 
+4151          self.assertEqual({'x':'X', 'y':'Y'}, el.attrib) 
+4152          builder.data("CHILDTEXT") 
+4153          el = builder.end("child") 
+4154          self.assertEqual("child", el.tag) 
+4155          self.assertEqual({'x':'X', 'y':'Y'}, el.attrib) 
+4156          self.assertEqual("CHILDTEXT", el.text) 
+4157          self.assertEqual(None, el.tail) 
+4158          builder.data("CHILDTAIL") 
+4159          root = builder.end("root") 
+4160   
+4161          self.assertEqual("root", root.tag) 
+4162          self.assertEqual("ROOTTEXT", root.text) 
+4163          self.assertEqual("CHILDTEXT", root[0].text) 
+4164          self.assertEqual("CHILDTAIL", root[0].tail) 
+
4165   
+4166 -    def test_treebuilder_target(self): 
+
4167          parser = self.XMLParser(target=self.etree.TreeBuilder()) 
+4168          parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 
+4169          root = parser.close() 
+4170   
+4171          self.assertEqual("root", root.tag) 
+4172          self.assertEqual("ROOTTEXT", root.text) 
+4173          self.assertEqual("CHILDTEXT", root[0].text) 
+4174          self.assertEqual("CHILDTAIL", root[0].tail) 
+
4175   
+4176      @et_needs_pyversion(3, 8, 0, 'alpha', 4) 
+4177 -    def test_treebuilder_comment(self): 
+
4178          ET = self.etree 
+4179          b = ET.TreeBuilder() 
+4180          self.assertEqual(b.comment('ctext').tag, ET.Comment) 
+4181          self.assertEqual(b.comment('ctext').text, 'ctext') 
+4182   
+4183          b = ET.TreeBuilder(comment_factory=ET.Comment) 
+4184          self.assertEqual(b.comment('ctext').tag, ET.Comment) 
+4185          self.assertEqual(b.comment('ctext').text, 'ctext') 
+
4186   
+4187          #b = ET.TreeBuilder(comment_factory=len) 
+4188          #self.assertEqual(b.comment('ctext'), len('ctext')) 
+4189   
+4190      @et_needs_pyversion(3, 8, 0, 'alpha', 4) 
+4191 -    def test_treebuilder_pi(self): 
+
4192          ET = self.etree 
+4193          is_lxml = ET.__name__ == 'lxml.etree' 
+4194   
+4195          b = ET.TreeBuilder() 
+4196          self.assertEqual(b.pi('target', None).tag, ET.PI) 
+4197          if is_lxml: 
+4198              self.assertEqual(b.pi('target', None).target, 'target') 
+4199          else: 
+4200              self.assertEqual(b.pi('target', None).text, 'target') 
+4201   
+4202          b = ET.TreeBuilder(pi_factory=ET.PI) 
+4203          self.assertEqual(b.pi('target').tag, ET.PI) 
+4204          if is_lxml: 
+4205              self.assertEqual(b.pi('target').target, "target") 
+4206          else: 
+4207              self.assertEqual(b.pi('target').text, "target") 
+4208          self.assertEqual(b.pi('pitarget', ' text ').tag, ET.PI) 
+4209          if is_lxml: 
+4210              self.assertEqual(b.pi('pitarget', ' text ').target, "pitarget") 
+4211              self.assertEqual(b.pi('pitarget', ' text ').text, " text ") 
+4212          else: 
+4213              self.assertEqual(b.pi('pitarget', ' text ').text, "pitarget  text ") 
+
4214   
+4215          #b = ET.TreeBuilder(pi_factory=lambda target, text: (len(target), text)) 
+4216          #self.assertEqual(b.pi('target'), (len('target'), None)) 
+4217          #self.assertEqual(b.pi('pitarget', ' text '), (len('pitarget'), ' text ')) 
+4218   
+4219 -    def test_late_tail(self): 
+
4220          # Issue #37399: The tail of an ignored comment could overwrite the text before it. 
+4221          ET = self.etree 
+4222          class TreeBuilderSubclass(ET.TreeBuilder): 
+4223              pass 
+
4224   
+4225          if ET.__name__ == 'lxml.etree': 
+4226              def assert_content(a): 
+4227                  self.assertEqual(a.text, "text") 
+4228                  self.assertEqual(a[0].tail, "tail") 
+4229          else: 
+4230              def assert_content(a): 
+4231                  self.assertEqual(a.text, "texttail") 
+4232   
+4233          xml = "<a>text<!-- comment -->tail</a>" 
+4234          a = ET.fromstring(xml) 
+4235          assert_content(a) 
+4236   
+4237          parser = ET.XMLParser(target=TreeBuilderSubclass()) 
+4238          parser.feed(xml) 
+4239          a = parser.close() 
+4240          assert_content(a) 
+4241   
+4242          xml = "<a>text<?pi data?>tail</a>" 
+4243          a = ET.fromstring(xml) 
+4244          assert_content(a) 
+4245   
+4246          xml = "<a>text<?pi data?>tail</a>" 
+4247          parser = ET.XMLParser(target=TreeBuilderSubclass()) 
+4248          parser.feed(xml) 
+4249          a = parser.close() 
+4250          assert_content(a) 
+4251   
+4252      @et_needs_pyversion(3, 8, 0, 'alpha', 4) 
+4253 -    def test_late_tail_mix_pi_comments(self): 
+
4254          # Issue #37399: The tail of an ignored comment could overwrite the text before it. 
+4255          # Test appending tails to comments/pis. 
+4256          ET = self.etree 
+4257          class TreeBuilderSubclass(ET.TreeBuilder): 
+4258              pass 
+
4259   
+4260          xml = "<a>text<?pi1?> <!-- comment -->\n<?pi2?>tail</a>" 
+4261          parser = ET.XMLParser(target=ET.TreeBuilder(insert_comments=True, insert_pis=False)) 
+4262          parser.feed(xml) 
+4263          a = parser.close() 
+4264          self.assertEqual(a[0].text, ' comment ') 
+4265          self.assertEqual(a[0].tail, '\ntail') 
+4266          self.assertEqual(a.text, "text ") 
+4267   
+4268          parser = ET.XMLParser(target=TreeBuilderSubclass(insert_comments=True, insert_pis=False)) 
+4269          parser.feed(xml) 
+4270          a = parser.close() 
+4271          self.assertEqual(a[0].text, ' comment ') 
+4272          self.assertEqual(a[0].tail, '\ntail') 
+4273          self.assertEqual(a.text, "text ") 
+4274   
+4275          xml = "<a>text<!-- comment -->\n<?pi data?>tail</a>" 
+4276          parser = ET.XMLParser(target=ET.TreeBuilder(insert_pis=True, insert_comments=False)) 
+4277          parser.feed(xml) 
+4278          a = parser.close() 
+4279          self.assertEqual(a[0].text[-4:], 'data') 
+4280          self.assertEqual(a[0].tail, 'tail') 
+4281          self.assertEqual(a.text, "text\n") 
+4282   
+4283          parser = ET.XMLParser(target=TreeBuilderSubclass(insert_pis=True, insert_comments=False)) 
+4284          parser.feed(xml) 
+4285          a = parser.close() 
+4286          self.assertEqual(a[0].text[-4:], 'data') 
+4287          self.assertEqual(a[0].tail, 'tail') 
+4288          self.assertEqual(a.text, "text\n") 
+4289   
+4290      # helper methods 
+4291   
+4292 -    def _writeElement(self, element, encoding='us-ascii'): 
+
4293          """Write out element for comparison. 
+4294          """ 
+4295          data = self.etree.tostring(element, encoding=encoding) 
+4296          return canonicalize(data) 
+
4297   
+4298 -    def _writeElementFile(self, element, encoding='us-ascii'): 
+
4299          """Write out element for comparison, using real file. 
+4300          """ 
+4301          ElementTree = self.etree.ElementTree 
+4302          with tmpfile() as filename: 
+4303              with open(filename, 'wb') as f: 
+4304                  tree = ElementTree(element=element) 
+4305                  tree.write(f, encoding=encoding) 
+4306              with open(filename, 'rb') as f: 
+4307                  data = f.read() 
+4308          return canonicalize(data) 
+
4309   
+4310 -    def assertXML(self, expected, element, encoding='us-ascii'): 
+
4311          """Writes element out and checks whether it is expected. 
+4312   
+4313          Does this two ways; once using BytesIO, once using a real file. 
+4314          """ 
+4315          if isinstance(expected, unicode): 
+4316              expected = expected.encode(encoding) 
+4317          self.assertEqual(expected, self._writeElement(element, encoding)) 
+4318          self.assertEqual(expected, self._writeElementFile(element, encoding)) 
+
4319   
+4320 -    def assertEncodingDeclaration(self, result, encoding): 
+
4321          "Checks if the result XML byte string specifies the encoding." 
+4322          enc_re = r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']" 
+4323          if isinstance(result, str): 
+4324              has_encoding = re.compile(enc_re).match 
+4325          else: 
+4326              has_encoding = re.compile(_bytes(enc_re)).match 
+4327          self.assertTrue(has_encoding(result)) 
+4328          result_encoding = has_encoding(result).group(1) 
+4329          self.assertEqual(result_encoding.upper(), encoding.upper()) 
+
4330   
+4331 -    def _rootstring(self, tree): 
+
4332          return self.etree.tostring(tree.getroot()).replace( 
+4333              _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes('')) 
+
4334   
+4335 -    def _check_element_tree(self, tree): 
+
4336          self._check_element(tree.getroot()) 
+
4337   
+4338 -    def _check_element(self, element): 
+
4339          self.assertTrue(hasattr(element, 'tag')) 
+4340          self.assertTrue(hasattr(element, 'attrib')) 
+4341          self.assertTrue(hasattr(element, 'text')) 
+4342          self.assertTrue(hasattr(element, 'tail')) 
+4343          self._check_string(element.tag) 
+4344          self._check_mapping(element.attrib) 
+4345          if element.text is not None: 
+4346              self._check_string(element.text) 
+4347          if element.tail is not None: 
+4348              self._check_string(element.tail) 
+
4349   
+4350 -    def _check_string(self, string): 
+
4351          len(string) 
+4352          for char in string: 
+4353              self.assertEqual(1, len(char)) 
+4354          new_string = string + "" 
+4355          new_string = string + " " 
+4356          string[:0] 
+
4357   
+4358 -    def _check_mapping(self, mapping): 
+
4359          len(mapping) 
+4360          keys = mapping.keys() 
+4361          values = mapping.values() 
+4362          items = mapping.items() 
+4363          for key in keys: 
+4364              item = mapping[key] 
+4365          mapping["key"] = "value" 
+4366          self.assertEqual("value", mapping["key"]) 
+
4367   
+4368   
+4369 -class _ElementSlicingTest(unittest.TestCase): 
+
4370      etree = None 
+4371   
+4372 -    def _elem_tags(self, elemlist): 
+
4373          return [e.tag for e in elemlist] 
+
4374   
+4375 -    def _subelem_tags(self, elem): 
+
4376          return self._elem_tags(list(elem)) 
+
4377   
+4378 -    def _make_elem_with_children(self, numchildren): 
+
4379          """Create an Element with a tag 'a', with the given amount of children 
+4380             named 'a0', 'a1' ... and so on. 
+4381   
+4382          """ 
+4383          e = self.etree.Element('a') 
+4384          for i in range(numchildren): 
+4385              self.etree.SubElement(e, 'a%s' % i) 
+4386          return e 
+
4387   
+4388 -    def test_getslice_single_index(self): 
+
4389          e = self._make_elem_with_children(10) 
+4390   
+4391          self.assertEqual(e[1].tag, 'a1') 
+4392          self.assertEqual(e[-2].tag, 'a8') 
+4393   
+4394          self.assertRaises(IndexError, lambda: e[12]) 
+4395          self.assertRaises(IndexError, lambda: e[-12]) 
+
4396   
+4397 -    def test_getslice_range(self): 
+
4398          e = self._make_elem_with_children(6) 
+4399   
+4400          self.assertEqual(self._elem_tags(e[3:]), ['a3', 'a4', 'a5']) 
+4401          self.assertEqual(self._elem_tags(e[3:6]), ['a3', 'a4', 'a5']) 
+4402          self.assertEqual(self._elem_tags(e[3:16]), ['a3', 'a4', 'a5']) 
+4403          self.assertEqual(self._elem_tags(e[3:5]), ['a3', 'a4']) 
+4404          self.assertEqual(self._elem_tags(e[3:-1]), ['a3', 'a4']) 
+4405          self.assertEqual(self._elem_tags(e[:2]), ['a0', 'a1']) 
+
4406   
+4407 -    def test_getslice_steps(self): 
+
4408          e = self._make_elem_with_children(10) 
+4409   
+4410          self.assertEqual(self._elem_tags(e[8:10:1]), ['a8', 'a9']) 
+4411          self.assertEqual(self._elem_tags(e[::3]), ['a0', 'a3', 'a6', 'a9']) 
+4412          self.assertEqual(self._elem_tags(e[::8]), ['a0', 'a8']) 
+4413          self.assertEqual(self._elem_tags(e[1::8]), ['a1', 'a9']) 
+4414          self.assertEqual(self._elem_tags(e[3::sys.maxsize]), ['a3']) 
+4415          self.assertEqual(self._elem_tags(e[3::sys.maxsize<<64]), ['a3']) 
+
4416   
+4417 -    def test_getslice_negative_steps(self): 
+
4418          e = self._make_elem_with_children(4) 
+4419   
+4420          self.assertEqual(self._elem_tags(e[::-1]), ['a3', 'a2', 'a1', 'a0']) 
+4421          self.assertEqual(self._elem_tags(e[::-2]), ['a3', 'a1']) 
+4422          self.assertEqual(self._elem_tags(e[3::-sys.maxsize]), ['a3']) 
+4423          self.assertEqual(self._elem_tags(e[3::-sys.maxsize-1]), ['a3']) 
+4424          self.assertEqual(self._elem_tags(e[3::-sys.maxsize<<64]), ['a3']) 
+
4425   
+4426 -    def test_delslice(self): 
+
4427          e = self._make_elem_with_children(4) 
+4428          del e[0:2] 
+4429          self.assertEqual(self._subelem_tags(e), ['a2', 'a3']) 
+4430   
+4431          e = self._make_elem_with_children(4) 
+4432          del e[0:] 
+4433          self.assertEqual(self._subelem_tags(e), []) 
+4434   
+4435          e = self._make_elem_with_children(4) 
+4436          del e[::-1] 
+4437          self.assertEqual(self._subelem_tags(e), []) 
+4438   
+4439          e = self._make_elem_with_children(4) 
+4440          del e[::-2] 
+4441          self.assertEqual(self._subelem_tags(e), ['a0', 'a2']) 
+4442   
+4443          e = self._make_elem_with_children(4) 
+4444          del e[1::2] 
+4445          self.assertEqual(self._subelem_tags(e), ['a0', 'a2']) 
+4446   
+4447          e = self._make_elem_with_children(2) 
+4448          del e[::2] 
+4449          self.assertEqual(self._subelem_tags(e), ['a1']) 
+
4450   
+4451 -    def test_setslice_single_index(self): 
+
4452          e = self._make_elem_with_children(4) 
+4453          e[1] = self.etree.Element('b') 
+4454          self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3']) 
+4455   
+4456          e[-2] = self.etree.Element('c') 
+4457          self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3']) 
+4458   
+4459          with self.assertRaises(IndexError): 
+4460              e[5] = self.etree.Element('d') 
+4461          with self.assertRaises(IndexError): 
+4462              e[-5] = self.etree.Element('d') 
+4463          self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3']) 
+
4464   
+4465 -    def test_setslice_range(self): 
+
4466          e = self._make_elem_with_children(4) 
+4467          e[1:3] = [self.etree.Element('b%s' % i) for i in range(2)] 
+4468          self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'a3']) 
+4469   
+4470          e = self._make_elem_with_children(4) 
+4471          e[1:3] = [self.etree.Element('b')] 
+4472          self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a3']) 
+4473   
+4474          e = self._make_elem_with_children(4) 
+4475          e[1:3] = [self.etree.Element('b%s' % i) for i in range(3)] 
+4476          self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'b2', 'a3']) 
+
4477   
+4478 -    def test_setslice_steps(self): 
+
4479          e = self._make_elem_with_children(6) 
+4480          e[1:5:2] = [self.etree.Element('b%s' % i) for i in range(2)] 
+4481          self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'a2', 'b1', 'a4', 'a5']) 
+4482   
+4483          e = self._make_elem_with_children(6) 
+4484          with self.assertRaises(ValueError): 
+4485              e[1:5:2] = [self.etree.Element('b')] 
+4486          with self.assertRaises(ValueError): 
+4487              e[1:5:2] = [self.etree.Element('b%s' % i) for i in range(3)] 
+4488          with self.assertRaises(ValueError): 
+4489              e[1:5:2] = [] 
+4490          self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3', 'a4', 'a5']) 
+4491   
+4492          e = self._make_elem_with_children(4) 
+4493          e[1::sys.maxsize] = [self.etree.Element('b')] 
+4494          self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3']) 
+4495          e[1::sys.maxsize<<64] = [self.etree.Element('c')] 
+4496          self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3']) 
+
4497   
+4498 -    def test_setslice_negative_steps(self): 
+
4499          e = self._make_elem_with_children(4) 
+4500          e[2:0:-1] = [self.etree.Element('b%s' % i) for i in range(2)] 
+4501          self.assertEqual(self._subelem_tags(e), ['a0', 'b1', 'b0', 'a3']) 
+4502   
+4503          e = self._make_elem_with_children(4) 
+4504          with self.assertRaises(ValueError): 
+4505              e[2:0:-1] = [self.etree.Element('b')] 
+4506          with self.assertRaises(ValueError): 
+4507              e[2:0:-1] = [self.etree.Element('b%s' % i) for i in range(3)] 
+4508          with self.assertRaises(ValueError): 
+4509              e[2:0:-1] = [] 
+4510          self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3']) 
+4511   
+4512          e = self._make_elem_with_children(4) 
+4513          e[1::-sys.maxsize] = [self.etree.Element('b')] 
+4514          self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3']) 
+4515          e[1::-sys.maxsize-1] = [self.etree.Element('c')] 
+4516          self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3']) 
+4517          e[1::-sys.maxsize<<64] = [self.etree.Element('d')] 
+4518          self.assertEqual(self._subelem_tags(e), ['a0', 'd', 'a2', 'a3']) 
+
4519   
+4520   
+4521 -class _XMLPullParserTest(unittest.TestCase): 
+
4522      etree = None 
+4523   
+4524 -    def _close_and_return_root(self, parser): 
+
4525          if 'ElementTree' in self.etree.__name__: 
+4526              # ElementTree's API is a bit unwieldy in Py3.4 
+4527              root = parser._close_and_return_root() 
+4528          else: 
+4529              root = parser.close() 
+4530          return root 
+
4531   
+4532 -    def _feed(self, parser, data, chunk_size=None): 
+
4533          if chunk_size is None: 
+4534              parser.feed(data) 
+4535          else: 
+4536              for i in range(0, len(data), chunk_size): 
+4537                  parser.feed(data[i:i+chunk_size]) 
+
4538   
+4539 -    def assert_events(self, parser, expected, max_events=None): 
+
4540          self.assertEqual( 
+4541              [(event, (elem.tag, elem.text)) 
+4542               for event, elem in islice(parser.read_events(), max_events)], 
+4543              expected) 
+
4544   
+4545 -    def assert_event_tuples(self, parser, expected, max_events=None): 
+
4546          self.assertEqual( 
+4547              list(islice(parser.read_events(), max_events)), 
+4548              expected) 
+
4549   
+4550 -    def assert_event_tags(self, parser, expected, max_events=None): 
+
4551          events = islice(parser.read_events(), max_events) 
+4552          self.assertEqual([(action, elem.tag) for action, elem in events], 
+4553                           expected) 
+
4554   
+4555 -    def test_simple_xml(self): 
+
4556          for chunk_size in (None, 1, 5): 
+4557              #with self.subTest(chunk_size=chunk_size): 
+4558                  parser = self.etree.XMLPullParser() 
+4559                  self.assert_event_tags(parser, []) 
+4560                  self._feed(parser, "<!-- comment -->\n", chunk_size) 
+4561                  self.assert_event_tags(parser, []) 
+4562                  self._feed(parser, 
+4563                             "<root>\n  <element key='value'>text</element", 
+4564                             chunk_size) 
+4565                  self.assert_event_tags(parser, []) 
+4566                  self._feed(parser, ">\n", chunk_size) 
+4567                  self.assert_event_tags(parser, [('end', 'element')]) 
+4568                  self._feed(parser, "<element>text</element>tail\n", chunk_size) 
+4569                  self._feed(parser, "<empty-element/>\n", chunk_size) 
+4570                  self.assert_event_tags(parser, [ 
+4571                      ('end', 'element'), 
+4572                      ('end', 'empty-element'), 
+4573                      ]) 
+4574                  self._feed(parser, "</root>\n", chunk_size) 
+4575                  self.assert_event_tags(parser, [('end', 'root')]) 
+4576                  root = self._close_and_return_root(parser) 
+4577                  self.assertEqual(root.tag, 'root') 
+
4578   
+4579 -    def test_feed_while_iterating(self): 
+
4580          parser = self.etree.XMLPullParser() 
+4581          it = parser.read_events() 
+4582          self._feed(parser, "<root>\n  <element key='value'>text</element>\n") 
+4583          action, elem = next(it) 
+4584          self.assertEqual((action, elem.tag), ('end', 'element')) 
+4585          self._feed(parser, "</root>\n") 
+4586          action, elem = next(it) 
+4587          self.assertEqual((action, elem.tag), ('end', 'root')) 
+4588          with self.assertRaises(StopIteration): 
+4589              next(it) 
+
4590   
+4591 -    def test_simple_xml_with_ns(self): 
+
4592          parser = self.etree.XMLPullParser() 
+4593          self.assert_event_tags(parser, []) 
+4594          self._feed(parser, "<!-- comment -->\n") 
+4595          self.assert_event_tags(parser, []) 
+4596          self._feed(parser, "<root xmlns='namespace'>\n") 
+4597          self.assert_event_tags(parser, []) 
+4598          self._feed(parser, "<element key='value'>text</element") 
+4599          self.assert_event_tags(parser, []) 
+4600          self._feed(parser, ">\n") 
+4601          self.assert_event_tags(parser, [('end', '{namespace}element')]) 
+4602          self._feed(parser, "<element>text</element>tail\n") 
+4603          self._feed(parser, "<empty-element/>\n") 
+4604          self.assert_event_tags(parser, [ 
+4605              ('end', '{namespace}element'), 
+4606              ('end', '{namespace}empty-element'), 
+4607              ]) 
+4608          self._feed(parser, "</root>\n") 
+4609          self.assert_event_tags(parser, [('end', '{namespace}root')]) 
+4610          root = self._close_and_return_root(parser) 
+4611          self.assertEqual(root.tag, '{namespace}root') 
+
4612   
+4613 -    def test_ns_events(self): 
+
4614          parser = self.etree.XMLPullParser(events=('start-ns', 'end-ns')) 
+4615          self._feed(parser, "<!-- comment -->\n") 
+4616          self._feed(parser, "<root xmlns='namespace'>\n") 
+4617          self.assertEqual( 
+4618              list(parser.read_events()), 
+4619              [('start-ns', ('', 'namespace'))]) 
+4620          self._feed(parser, "<element key='value'>text</element") 
+4621          self._feed(parser, ">\n") 
+4622          self._feed(parser, "<element>text</element>tail\n") 
+4623          self._feed(parser, "<empty-element/>\n") 
+4624          self._feed(parser, "</root>\n") 
+4625          self.assertEqual(list(parser.read_events()), [('end-ns', None)]) 
+4626          parser.close() 
+
4627   
+4628 -    def test_ns_events_end_ns_only(self): 
+
4629          parser = self.etree.XMLPullParser(events=['end-ns']) 
+4630          self._feed(parser, "<!-- comment -->\n") 
+4631          self._feed(parser, "<root xmlns='namespace' xmlns:a='abc' xmlns:b='xyz'>\n") 
+4632          self.assertEqual(list(parser.read_events()), []) 
+4633          self._feed(parser, "<a:element key='value'>text</a:element") 
+4634          self._feed(parser, ">\n") 
+4635          self._feed(parser, "<b:element>text</b:element>tail\n") 
+4636          self._feed(parser, "<empty-element/>\n") 
+4637          self.assertEqual(list(parser.read_events()), []) 
+4638          self._feed(parser, "</root>\n") 
+4639          self.assertEqual(list(parser.read_events()), [ 
+4640              ('end-ns', None), 
+4641              ('end-ns', None), 
+4642              ('end-ns', None), 
+4643          ]) 
+4644          parser.close() 
+
4645   
+4646      @et_needs_pyversion(3,8) 
+4647 -    def test_ns_events_start(self): 
+
4648          parser = self.etree.XMLPullParser(events=('start-ns', 'start', 'end')) 
+4649          self._feed(parser, "<tag xmlns='abc' xmlns:p='xyz'>\n") 
+4650          self.assert_event_tuples(parser, [ 
+4651              ('start-ns', ('', 'abc')), 
+4652              ('start-ns', ('p', 'xyz')), 
+4653          ], max_events=2) 
+4654          self.assert_event_tags(parser, [ 
+4655              ('start', '{abc}tag'), 
+4656          ], max_events=1) 
+4657   
+4658          self._feed(parser, "<child />\n") 
+4659          self.assert_event_tags(parser, [ 
+4660              ('start', '{abc}child'), 
+4661              ('end', '{abc}child'), 
+4662          ]) 
+4663   
+4664          self._feed(parser, "</tag>\n") 
+4665          parser.close() 
+4666          self.assert_event_tags(parser, [ 
+4667              ('end', '{abc}tag'), 
+4668          ]) 
+
4669   
+4670      @et_needs_pyversion(3,8) 
+4671 -    def test_ns_events_start_end(self): 
+
4672          parser = self.etree.XMLPullParser(events=('start-ns', 'start', 'end', 'end-ns')) 
+4673          self._feed(parser, "<tag xmlns='abc' xmlns:p='xyz'>\n") 
+4674          self.assert_event_tuples(parser, [ 
+4675              ('start-ns', ('', 'abc')), 
+4676              ('start-ns', ('p', 'xyz')), 
+4677          ], max_events=2) 
+4678          self.assert_event_tags(parser, [ 
+4679              ('start', '{abc}tag'), 
+4680          ], max_events=1) 
+4681   
+4682          self._feed(parser, "<child />\n") 
+4683          self.assert_event_tags(parser, [ 
+4684              ('start', '{abc}child'), 
+4685              ('end', '{abc}child'), 
+4686          ]) 
+4687   
+4688          self._feed(parser, "</tag>\n") 
+4689          parser.close() 
+4690          self.assert_event_tags(parser, [ 
+4691              ('end', '{abc}tag'), 
+4692          ], max_events=1) 
+4693          self.assert_event_tuples(parser, [ 
+4694              ('end-ns', None), 
+4695              ('end-ns', None), 
+4696          ]) 
+
4697   
+4698 -    def test_events(self): 
+
4699          parser = self.etree.XMLPullParser(events=()) 
+4700          self._feed(parser, "<root/>\n") 
+4701          self.assert_event_tags(parser, []) 
+4702   
+4703          parser = self.etree.XMLPullParser(events=('start', 'end')) 
+4704          self._feed(parser, "<!-- text here -->\n") 
+4705          self.assert_events(parser, []) 
+4706   
+4707          parser = self.etree.XMLPullParser(events=('start', 'end')) 
+4708          self._feed(parser, "<root>\n") 
+4709          self.assert_event_tags(parser, [('start', 'root')]) 
+4710          self._feed(parser, "<element key='value'>text</element") 
+4711          self.assert_event_tags(parser, [('start', 'element')]) 
+4712          self._feed(parser, ">\n") 
+4713          self.assert_event_tags(parser, [('end', 'element')]) 
+4714          self._feed(parser, 
+4715                     "<element xmlns='foo'>text<empty-element/></element>tail\n") 
+4716          self.assert_event_tags(parser, [ 
+4717              ('start', '{foo}element'), 
+4718              ('start', '{foo}empty-element'), 
+4719              ('end', '{foo}empty-element'), 
+4720              ('end', '{foo}element'), 
+4721              ]) 
+4722          self._feed(parser, "</root>") 
+4723          root = self._close_and_return_root(parser) 
+4724          self.assert_event_tags(parser, [('end', 'root')]) 
+4725          self.assertEqual(root.tag, 'root') 
+4726   
+4727          parser = self.etree.XMLPullParser(events=('start',)) 
+4728          self._feed(parser, "<!-- comment -->\n") 
+4729          self.assert_event_tags(parser, []) 
+4730          self._feed(parser, "<root>\n") 
+4731          self.assert_event_tags(parser, [('start', 'root')]) 
+4732          self._feed(parser, "<element key='value'>text</element") 
+4733          self.assert_event_tags(parser, [('start', 'element')]) 
+4734          self._feed(parser, ">\n") 
+4735          self.assert_event_tags(parser, []) 
+4736          self._feed(parser, 
+4737                     "<element xmlns='foo'>text<empty-element/></element>tail\n") 
+4738          self.assert_event_tags(parser, [ 
+4739              ('start', '{foo}element'), 
+4740              ('start', '{foo}empty-element'), 
+4741              ]) 
+4742          self._feed(parser, "</root>") 
+4743          root = self._close_and_return_root(parser) 
+4744          self.assertEqual(root.tag, 'root') 
+
4745   
+4746      @et_needs_pyversion(3, 8, 0, 'alpha', 4) 
+4747 -    def test_events_comment(self): 
+
4748          parser = self.etree.XMLPullParser(events=('start', 'comment', 'end')) 
+4749          self._feed(parser, "<!-- text here -->\n") 
+4750          self.assert_events(parser, [('comment', (self.etree.Comment, ' text here '))]) 
+4751          self._feed(parser, "<!-- more text here -->\n") 
+4752          self.assert_events(parser, [('comment', (self.etree.Comment, ' more text here '))]) 
+4753          self._feed(parser, "<root-tag>text") 
+4754          self.assert_event_tags(parser, [('start', 'root-tag')]) 
+4755          self._feed(parser, "<!-- inner comment-->\n") 
+4756          self.assert_events(parser, [('comment', (self.etree.Comment, ' inner comment'))]) 
+4757          self._feed(parser, "</root-tag>\n") 
+4758          self.assert_event_tags(parser, [('end', 'root-tag')]) 
+4759          self._feed(parser, "<!-- outer comment -->\n") 
+4760          self.assert_events(parser, [('comment', (self.etree.Comment, ' outer comment '))]) 
+4761   
+4762          parser = self.etree.XMLPullParser(events=('comment',)) 
+4763          self._feed(parser, "<!-- text here -->\n") 
+4764          self.assert_events(parser, [('comment', (self.etree.Comment, ' text here '))]) 
+
4765   
+4766      @et_needs_pyversion(3, 8, 0, 'alpha', 4) 
+4767 -    def test_events_pi(self): 
+
4768          # Note: lxml's PIs have target+text, ET's PIs have both in "text" 
+4769          parser = self.etree.XMLPullParser(events=('start', 'pi', 'end')) 
+4770          self._feed(parser, "<?pitarget?>\n") 
+4771          self.assert_event_tags(parser, [('pi', self.etree.PI)]) 
+4772          parser = self.etree.XMLPullParser(events=('pi',)) 
+4773          self._feed(parser, "<?pitarget some text ?>\n") 
+4774          self.assert_event_tags(parser, [('pi', self.etree.PI)]) 
+
4775   
+4776 -    def test_events_sequence(self): 
+
4777          # Test that events can be some sequence that's not just a tuple or list 
+4778          eventset = {'end', 'start'} 
+4779          parser = self.etree.XMLPullParser(events=eventset) 
+4780          self._feed(parser, "<foo>bar</foo>") 
+4781          self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')]) 
+4782   
+4783          class DummyIter(object): 
+4784              def __init__(self): 
+4785                  self.events = iter(['start', 'end', 'start-ns']) 
+
4786              def __iter__(self): 
+4787                  return self 
+
4788              def __next__(self): 
+4789                  return next(self.events) 
+4790              def next(self): 
+4791                  return next(self.events) 
+4792   
+4793          parser = self.etree.XMLPullParser(events=DummyIter()) 
+4794          self._feed(parser, "<foo>bar</foo>") 
+4795          self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')]) 
+4796   
+4797 -    def test_unknown_event(self): 
+
4798          with self.assertRaises(ValueError): 
+4799              self.etree.XMLPullParser(events=('start', 'end', 'bogus')) 
+
4800   
+4801   
+4802 -class _C14NTest(unittest.TestCase): 
+
4803      etree = None 
+4804      maxDiff = None 
+4805   
+4806      if not hasattr(unittest.TestCase, 'subTest'): 
+4807          @contextmanager 
+4808 -        def subTest(self, name, **kwargs): 
+
4809              try: 
+4810                  yield 
+4811              except unittest.SkipTest: 
+4812                  raise 
+4813              except Exception as e: 
+4814                  print("Subtest {} failed: {}".format(name, e)) 
+4815                  raise 
+
4816   
+4817 -    def _canonicalize(self, input_file, **options): 
+
4818          return self.etree.canonicalize(from_file=input_file, **options) 
+
4819   
+4820      # 
+4821      # simple roundtrip tests (from c14n.py) 
+4822   
+4823 -    def c14n_roundtrip(self, xml, **options): 
+
4824          return self.etree.canonicalize(xml, **options) 
+
4825   
+4826 -    def test_simple_roundtrip(self): 
+
4827          c14n_roundtrip = self.c14n_roundtrip 
+4828          # Basics 
+4829          self.assertEqual(c14n_roundtrip("<doc/>"), '<doc></doc>') 
+4830          self.assertEqual(c14n_roundtrip("<doc xmlns='uri'/>"), # FIXME 
+4831                  '<doc xmlns="uri"></doc>') 
+4832          self.assertEqual(c14n_roundtrip("<prefix:doc xmlns:prefix='uri'/>"), 
+4833              '<prefix:doc xmlns:prefix="uri"></prefix:doc>') 
+4834          self.assertEqual(c14n_roundtrip("<doc xmlns:prefix='uri'><prefix:bar/></doc>"), 
+4835              '<doc><prefix:bar xmlns:prefix="uri"></prefix:bar></doc>') 
+4836          self.assertEqual(c14n_roundtrip("<elem xmlns:wsu='http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/' />"), 
+4837              '<elem></elem>') 
+4838   
+4839          # C14N spec 
+4840          self.assertEqual(c14n_roundtrip("<doc>Hello, world!<!-- Comment 1 --></doc>"), 
+4841              '<doc>Hello, world!</doc>') 
+4842          self.assertEqual(c14n_roundtrip("<value>&#x32;</value>"), 
+4843              '<value>2</value>') 
+4844          self.assertEqual(c14n_roundtrip('<compute><![CDATA[value>"0" && value<"10" ?"valid":"error"]]></compute>'), 
+4845              '<compute>value&gt;"0" &amp;&amp; value&lt;"10" ?"valid":"error"</compute>') 
+4846          self.assertEqual(c14n_roundtrip('''<compute expr='value>"0" &amp;&amp; value&lt;"10" ?"valid":"error"'>valid</compute>'''), 
+4847              '<compute expr="value>&quot;0&quot; &amp;&amp; value&lt;&quot;10&quot; ?&quot;valid&quot;:&quot;error&quot;">valid</compute>') 
+4848          self.assertEqual(c14n_roundtrip("<norm attr=' &apos;   &#x20;&#13;&#xa;&#9;   &apos; '/>"), 
+4849              '<norm attr=" \'    &#xD;&#xA;&#x9;   \' "></norm>') 
+4850          self.assertEqual(c14n_roundtrip("<normNames attr='   A   &#x20;&#13;&#xa;&#9;   B   '/>"), 
+4851              '<normNames attr="   A    &#xD;&#xA;&#x9;   B   "></normNames>') 
+4852          self.assertEqual(c14n_roundtrip("<normId id=' &apos;   &#x20;&#13;&#xa;&#9;   &apos; '/>"), 
+4853              '<normId id=" \'    &#xD;&#xA;&#x9;   \' "></normId>') 
+
4854   
+4855          # fragments from PJ's tests 
+4856          #self.assertEqual(c14n_roundtrip("<doc xmlns:x='http://example.com/x' xmlns='http://example.com/default'><b y:a1='1' xmlns='http://example.com/default' a3='3' xmlns:y='http://example.com/y' y:a2='2'/></doc>"), 
+4857          #'<doc xmlns:x="http://example.com/x"><b xmlns:y="http://example.com/y" a3="3" y:a1="1" y:a2="2"></b></doc>') 
+4858   
+4859 -    def test_c14n_exclusion(self): 
+
4860          c14n_roundtrip = self.c14n_roundtrip 
+4861          xml = textwrap.dedent("""\ 
+4862          <root xmlns:x="http://example.com/x"> 
+4863              <a x:attr="attrx"> 
+4864                  <b>abtext</b> 
+4865              </a> 
+4866              <b>btext</b> 
+4867              <c> 
+4868                  <x:d>dtext</x:d> 
+4869              </c> 
+4870          </root> 
+4871          """) 
+4872          self.assertEqual( 
+4873              c14n_roundtrip(xml, strip_text=True), 
+4874              '<root>' 
+4875              '<a xmlns:x="http://example.com/x" x:attr="attrx"><b>abtext</b></a>' 
+4876              '<b>btext</b>' 
+4877              '<c><x:d xmlns:x="http://example.com/x">dtext</x:d></c>' 
+4878              '</root>') 
+4879          self.assertEqual( 
+4880              c14n_roundtrip(xml, strip_text=True, exclude_attrs=['{http://example.com/x}attr']), 
+4881              '<root>' 
+4882              '<a><b>abtext</b></a>' 
+4883              '<b>btext</b>' 
+4884              '<c><x:d xmlns:x="http://example.com/x">dtext</x:d></c>' 
+4885              '</root>') 
+4886          self.assertEqual( 
+4887              c14n_roundtrip(xml, strip_text=True, exclude_tags=['{http://example.com/x}d']), 
+4888              '<root>' 
+4889              '<a xmlns:x="http://example.com/x" x:attr="attrx"><b>abtext</b></a>' 
+4890              '<b>btext</b>' 
+4891              '<c></c>' 
+4892              '</root>') 
+4893          self.assertEqual( 
+4894              c14n_roundtrip(xml, strip_text=True, exclude_attrs=['{http://example.com/x}attr'], 
+4895                             exclude_tags=['{http://example.com/x}d']), 
+4896              '<root>' 
+4897              '<a><b>abtext</b></a>' 
+4898              '<b>btext</b>' 
+4899              '<c></c>' 
+4900              '</root>') 
+4901          self.assertEqual( 
+4902              c14n_roundtrip(xml, strip_text=True, exclude_tags=['a', 'b']), 
+4903              '<root>' 
+4904              '<c><x:d xmlns:x="http://example.com/x">dtext</x:d></c>' 
+4905              '</root>') 
+4906          self.assertEqual( 
+4907              c14n_roundtrip(xml, exclude_tags=['a', 'b']), 
+4908              '<root>\n' 
+4909              '    \n' 
+4910              '    \n' 
+4911              '    <c>\n' 
+4912              '        <x:d xmlns:x="http://example.com/x">dtext</x:d>\n' 
+4913              '    </c>\n' 
+4914              '</root>') 
+4915          self.assertEqual( 
+4916              c14n_roundtrip(xml, strip_text=True, exclude_tags=['{http://example.com/x}d', 'b']), 
+4917              '<root>' 
+4918              '<a xmlns:x="http://example.com/x" x:attr="attrx"></a>' 
+4919              '<c></c>' 
+4920              '</root>') 
+4921          self.assertEqual( 
+4922              c14n_roundtrip(xml, exclude_tags=['{http://example.com/x}d', 'b']), 
+4923              '<root>\n' 
+4924              '    <a xmlns:x="http://example.com/x" x:attr="attrx">\n' 
+4925              '        \n' 
+4926              '    </a>\n' 
+4927              '    \n' 
+4928              '    <c>\n' 
+4929              '        \n' 
+4930              '    </c>\n' 
+4931              '</root>') 
+
4932   
+4933      # 
+4934      # basic method=c14n tests from the c14n 2.0 specification.  uses 
+4935      # test files under xmltestdata/c14n-20. 
+4936   
+4937      # note that this uses generated C14N versions of the standard ET.write 
+4938      # output, not roundtripped C14N (see above). 
+4939   
+4940 -    def test_xml_c14n2(self): 
+
4941          datadir = os.path.join(os.path.dirname(__file__), "c14n-20") 
+4942          full_path = partial(os.path.join, datadir) 
+4943   
+4944          files = [filename[:-4] for filename in sorted(os.listdir(datadir)) 
+4945                   if filename.endswith('.xml')] 
+4946          input_files = [ 
+4947              filename for filename in files 
+4948              if filename.startswith('in') 
+4949          ] 
+4950          configs = { 
+4951              filename: { 
+4952                  # <c14n2:PrefixRewrite>sequential</c14n2:PrefixRewrite> 
+4953                  option.tag.split('}')[-1]: ((option.text or '').strip(), option) 
+4954                  for option in self.etree.parse(full_path(filename) + ".xml").getroot() 
+4955              } 
+4956              for filename in files 
+4957              if filename.startswith('c14n') 
+4958          } 
+4959   
+4960          tests = { 
+4961              input_file: [ 
+4962                  (filename, configs[filename.rsplit('_', 1)[-1]]) 
+4963                  for filename in files 
+4964                  if filename.startswith('out_%s_' % input_file) 
+4965                  and filename.rsplit('_', 1)[-1] in configs 
+4966              ] 
+4967              for input_file in input_files 
+4968          } 
+4969   
+4970          # Make sure we found all test cases. 
+4971          self.assertEqual(30, len([ 
+4972              output_file for output_files in tests.values() 
+4973              for output_file in output_files])) 
+4974   
+4975          def get_option(config, option_name, default=None): 
+4976              return config.get(option_name, (default, ()))[0] 
+
4977   
+4978          for input_file, output_files in tests.items(): 
+4979              for output_file, config in output_files: 
+4980                  keep_comments = get_option( 
+4981                      config, 'IgnoreComments') == 'true'  # no, it's right :) 
+4982                  strip_text = get_option( 
+4983                      config, 'TrimTextNodes') == 'true' 
+4984                  rewrite_prefixes = get_option( 
+4985                      config, 'PrefixRewrite') == 'sequential' 
+4986                  if 'QNameAware' in config: 
+4987                      qattrs = [ 
+4988                          "{%s}%s" % (el.get('NS'), el.get('Name')) 
+4989                          for el in config['QNameAware'][1].findall( 
+4990                              '{http://www.w3.org/2010/xml-c14n2}QualifiedAttr') 
+4991                      ] 
+4992                      qtags = [ 
+4993                          "{%s}%s" % (el.get('NS'), el.get('Name')) 
+4994                          for el in config['QNameAware'][1].findall( 
+4995                              '{http://www.w3.org/2010/xml-c14n2}Element') 
+4996                      ] 
+4997                  else: 
+4998                      qtags = qattrs = None 
+4999   
+5000                  # Build subtest description from config. 
+5001                  config_descr = ','.join( 
+5002                      "%s=%s" % (name, value or ','.join(c.tag.split('}')[-1] for c in children)) 
+5003                      for name, (value, children) in sorted(config.items()) 
+5004                  ) 
+5005   
+5006                  with self.subTest("{}({})".format(output_file, config_descr)): 
+5007                      if input_file == 'inNsRedecl' and not rewrite_prefixes: 
+5008                          self.skipTest( 
+5009                              "Redeclared namespace handling is not supported in {}".format( 
+5010                                  output_file)) 
+5011                      if input_file == 'inNsSuperfluous' and not rewrite_prefixes: 
+5012                          self.skipTest( 
+5013                              "Redeclared namespace handling is not supported in {}".format( 
+5014                                  output_file)) 
+5015                      if 'QNameAware' in config and config['QNameAware'][1].find( 
+5016                              '{http://www.w3.org/2010/xml-c14n2}XPathElement') is not None: 
+5017                          self.skipTest( 
+5018                              "QName rewriting in XPath text is not supported in {}".format( 
+5019                                  output_file)) 
+5020   
+5021                      f = full_path(input_file + ".xml") 
+5022                      if input_file == 'inC14N5': 
+5023                          # Hack: avoid setting up external entity resolution in the parser. 
+5024                          with open(full_path('world.txt'), 'rb') as entity_file: 
+5025                              with open(f, 'rb') as f: 
+5026                                  f = io.BytesIO(f.read().replace(b'&ent2;', entity_file.read().strip())) 
+5027   
+5028                      text = self._canonicalize( 
+5029                          f, 
+5030                          with_comments=keep_comments, 
+5031                          strip_text=strip_text, 
+5032                          rewrite_prefixes=rewrite_prefixes, 
+5033                          qname_aware_tags=qtags, qname_aware_attrs=qattrs) 
+5034   
+5035                      with io.open(full_path(output_file + ".xml"), 'r', encoding='utf8') as f: 
+5036                          expected = f.read() 
+5037                      if input_file == 'inC14N3' and self.etree is not etree: 
+5038                          # FIXME: cET resolves default attributes but ET does not! 
+5039                          expected = expected.replace(' attr="default"', '') 
+5040                          text = text.replace(' attr="default"', '') 
+5041                      self.assertEqual(expected, text) 
+
5042   
+5043   
+5044  if etree: 
+5045 -    class ETreeTestCase(_ETreeTestCaseBase): 
+
5046          etree = etree 
+
5047   
+5048 -    class ETreePullTestCase(_XMLPullParserTest): 
+
5049          etree = etree 
+
5050   
+5051 -    class ETreeElementSlicingTest(_ElementSlicingTest): 
+
5052          etree = etree 
+
5053   
+5054 -    class ETreeC14NTest(_C14NTest): 
+
5055          etree = etree 
+
5056   
+5057 -    class ETreeC14N2WriteTest(ETreeC14NTest): 
+
5058 -        def _canonicalize(self, input_file, with_comments=True, strip_text=False, 
+5059                            rewrite_prefixes=False, qname_aware_tags=None, qname_aware_attrs=None, 
+5060                            **options): 
+
5061              if rewrite_prefixes or qname_aware_attrs or qname_aware_tags: 
+5062                  self.skipTest("C14N 2.0 feature not supported with ElementTree.write()") 
+5063   
+5064              parser = self.etree.XMLParser(attribute_defaults=True, collect_ids=False) 
+5065              tree = self.etree.parse(input_file, parser) 
+5066              out = io.BytesIO() 
+5067              tree.write( 
+5068                  out, method='c14n2', 
+5069                  with_comments=with_comments, strip_text=strip_text, 
+5070                  **options) 
+5071              return out.getvalue().decode('utf8') 
+
5072   
+5073 -    class ETreeC14N2TostringTest(ETreeC14NTest): 
+
5074 -        def _canonicalize(self, input_file, with_comments=True, strip_text=False, 
+5075                            rewrite_prefixes=False, qname_aware_tags=None, qname_aware_attrs=None, 
+5076                            **options): 
+
5077              if rewrite_prefixes or qname_aware_attrs or qname_aware_tags: 
+5078                  self.skipTest("C14N 2.0 feature not supported with ElementTree.tostring()") 
+5079   
+5080              parser = self.etree.XMLParser(attribute_defaults=True, collect_ids=False) 
+5081              tree = self.etree.parse(input_file, parser) 
+5082              return self.etree.tostring( 
+5083                  tree, method='c14n2', 
+5084                  with_comments=with_comments, strip_text=strip_text, 
+5085                  **options).decode('utf8') 
+
5086   
+5087   
+5088  if ElementTree: 
+5089 -    class ElementTreeTestCase(_ETreeTestCaseBase): 
+
5090          etree = ElementTree 
+5091   
+5092          @classmethod 
+5093 -        def setUpClass(cls): 
+
5094              import warnings 
+5095              # ElementTree warns about getiterator() in recent Pythons 
+5096              warnings.filterwarnings( 
+5097                  'ignore', 
+5098                  r'This method will be removed.*\.iter\(\).*instead', 
+5099                  PendingDeprecationWarning) 
+
5100   
+5101      filter_by_version( 
+5102          ElementTreeTestCase, 
+5103          ElementTreeTestCase.required_versions_ET, ET_VERSION) 
+5104   
+5105      if hasattr(ElementTree, 'XMLPullParser'): 
+5106 -        class ElementTreePullTestCase(_XMLPullParserTest): 
+
5107              etree = ElementTree 
+
5108      else: 
+5109          ElementTreePullTestCase = None 
+5110   
+5111      if hasattr(ElementTree, 'canonicalize'): 
+5112 -        class ElementTreeC14NTest(_C14NTest): 
+
5113              etree = ElementTree 
+
5114      else: 
+5115          ElementTreeC14NTest = None 
+5116   
+5117 -    class ElementTreeElementSlicingTest(_ElementSlicingTest): 
+
5118          etree = ElementTree 
+
5119   
+5120   
+5121  if cElementTree: 
+5122 -    class CElementTreeTestCase(_ETreeTestCaseBase): 
+
5123          etree = cElementTree 
+
5124   
+5125      filter_by_version( 
+5126          CElementTreeTestCase, 
+5127          CElementTreeTestCase.required_versions_cET, CET_VERSION) 
+5128   
+5129 -    class CElementTreeElementSlicingTest(_ElementSlicingTest): 
+
5130          etree = cElementTree 
+
5131   
+5132   
+5133 -def test_suite(): 
+
5134      suite = unittest.TestSuite() 
+5135      if etree: 
+5136          suite.addTests([unittest.makeSuite(ETreeTestCase)]) 
+5137          suite.addTests([unittest.makeSuite(ETreePullTestCase)]) 
+5138          suite.addTests([unittest.makeSuite(ETreeElementSlicingTest)]) 
+5139          suite.addTests([unittest.makeSuite(ETreeC14NTest)]) 
+5140          suite.addTests([unittest.makeSuite(ETreeC14N2WriteTest)]) 
+5141          suite.addTests([unittest.makeSuite(ETreeC14N2TostringTest)]) 
+5142      if ElementTree: 
+5143          suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 
+5144          if ElementTreePullTestCase: 
+5145              suite.addTests([unittest.makeSuite(ElementTreePullTestCase)]) 
+5146          if ElementTreeC14NTest: 
+5147              suite.addTests([unittest.makeSuite(ElementTreeC14NTest)]) 
+5148          suite.addTests([unittest.makeSuite(ElementTreeElementSlicingTest)]) 
+5149      if cElementTree: 
+5150          suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 
+5151          suite.addTests([unittest.makeSuite(CElementTreeElementSlicingTest)]) 
+5152      return suite 
+
5153   
+5154  if __name__ == '__main__': 
+5155      print('to test use test.py %s' % __file__) 
+5156   
+
+            object --+        
+                     |        
+unittest.case.TestCase --+    
+                         |    
+       _ElementSlicingTest --+
+                             |
+                            CElementTreeElementSlicingTest
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+               _ETreeTestCaseBase --+
+                                    |
+                                   CElementTreeTestCase
+
+            object --+            
+                     |            
+unittest.case.TestCase --+        
+                         |        
+                 _C14NTest --+    
+                             |    
+                 ETreeC14NTest --+
+                                 |
+                                ETreeC14N2TostringTest
+
+            object --+            
+                     |            
+unittest.case.TestCase --+        
+                         |        
+                 _C14NTest --+    
+                             |    
+                 ETreeC14NTest --+
+                                 |
+                                ETreeC14N2WriteTest
+
+            object --+        
+                     |        
+unittest.case.TestCase --+    
+                         |    
+                 _C14NTest --+
+                             |
+                            ETreeC14NTest
+
lxml.etree
lxml.etree
+            object --+        
+                     |        
+unittest.case.TestCase --+    
+                         |    
+       _ElementSlicingTest --+
+                             |
+                            ETreeElementSlicingTest
+
lxml.etree
lxml.etree
+            object --+        
+                     |        
+unittest.case.TestCase --+    
+                         |    
+        _XMLPullParserTest --+
+                             |
+                            ETreePullTestCase
+
lxml.etree
lxml.etree
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+               _ETreeTestCaseBase --+
+                                    |
+                                   ETreeTestCase
+
lxml.etree
lxml.etree
+            object --+        
+                     |        
+unittest.case.TestCase --+    
+                         |    
+       _ElementSlicingTest --+
+                             |
+                            ElementTreeElementSlicingTest
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+               _ETreeTestCaseBase --+
+                                    |
+                                   ElementTreeTestCase
+
+            object --+    
+                     |    
+unittest.case.TestCase --+
+                         |
+                        _C14NTest
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               _ETreeTestCaseBase
+
+{'test_comment_text': (1, 3),
+ 'test_comment_whitespace': (1, 3),
+ 'test_extend': (1, 3),
+ 'test_feed_parser_error_broken': (1, 3),
+ 'test_feed_parser_error_close_empty': (1, 3),
+ 'test_feed_parser_error_close_incomplete': (1, 3),
+ 'test_feed_parser_error_position': (1, 3),
+ 'test_fromstringlist': (1, 3),
+...
+
+            object --+    
+                     |    
+unittest.case.TestCase --+
+                         |
+                        _ElementSlicingTest
+
+            object --+    
+                     |    
+unittest.case.TestCase --+
+                         |
+                        _XMLPullParserTest
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+ 1  # -*- coding: utf-8 -*- 
+ 2  import unittest, doctest 
+ 3   
+ 4  # These tests check that error handling in the Pyrex code is 
+ 5  # complete. 
+ 6  # It is likely that if there are errors, instead of failing the code 
+ 7  # will simply crash. 
+ 8   
+ 9  import sys, gc, os.path 
+10  from lxml import etree 
+11   
+12  this_dir = os.path.dirname(__file__) 
+13  if this_dir not in sys.path: 
+14      sys.path.insert(0, this_dir) # needed for Py3 
+15   
+16  from common_imports import HelperTestCase 
+17   
+18   
+19 -class ErrorTestCase(HelperTestCase): 
+
20      etree = etree 
+21   
+22 -    def test_bad_element(self): 
+
23          # attrib argument of Element() should be a dictionary, so if 
+24          # we pass a string we should get an error. 
+25          self.assertRaises(TypeError, self.etree.Element, 'a', 'b') 
+
26   
+27 -    def test_empty_parse(self): 
+
28          self.assertRaises(etree.XMLSyntaxError, etree.fromstring, '') 
+
29   
+30 -    def test_element_cyclic_gc_none(self): 
+
31          # test if cyclic reference can crash etree 
+32          Element = self.etree.Element 
+33          getrefcount = sys.getrefcount 
+34   
+35          # must disable tracing as it could change the refcounts 
+36          trace_func = sys.gettrace() 
+37          try: 
+38              sys.settrace(None) 
+39              gc.collect() 
+40   
+41              count = getrefcount(None) 
+42   
+43              l = [Element('name'), Element('name')] 
+44              l.append(l) 
+45   
+46              del l 
+47              gc.collect() 
+48              count = getrefcount(None) - count 
+49   
+50              self.assertEqual(count, 0) 
+51          finally: 
+52              sys.settrace(trace_func) 
+
53   
+54 -    def test_xmlsyntaxerror_has_info(self): 
+
55          broken_xml_name = 'test_broken.xml' 
+56          broken_xml_path = os.path.join(this_dir, broken_xml_name) 
+57          fail_msg = 'test_broken.xml should raise an etree.XMLSyntaxError' 
+58          try: 
+59              etree.parse(broken_xml_path) 
+60          except etree.XMLSyntaxError as e: 
+61              # invariant 
+62              self.assertEqual(e.position, (e.lineno, e.offset + 1), 'position and lineno/offset out of sync') 
+63              # SyntaxError info derived from file & contents 
+64              self.assertTrue(e.filename.endswith(broken_xml_name), 'filename must be preserved') 
+65              self.assertEqual(e.lineno, 1) 
+66              self.assertEqual(e.offset, 10) 
+67          except Exception as e: 
+68              self.fail('{0}, not {1}'.format(fail_msg, type(e))) 
+69          else: 
+70              self.fail('test_broken.xml should raise an etree.XMLSyntaxError') 
+
71   
+72   
+73 -def test_suite(): 
+
74      suite = unittest.TestSuite() 
+75      suite.addTests([unittest.makeSuite(ErrorTestCase)]) 
+76      return suite 
+
77   
+78  if __name__ == '__main__': 
+79      print('to test use test.py %s' % __file__) 
+80   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ErrorTestCase
+
lxml.etree
lxml.etree
+   1  # -*- coding: utf-8 -*- 
+   2   
+   3  """ 
+   4  Tests specific to the extended etree API 
+   5   
+   6  Tests that apply to the general ElementTree API should go into 
+   7  test_elementtree 
+   8  """ 
+   9   
+  10  from __future__ import absolute_import 
+  11   
+  12  from collections import OrderedDict 
+  13  import os.path 
+  14  import unittest 
+  15  import copy 
+  16  import sys 
+  17  import re 
+  18  import gc 
+  19  import operator 
+  20  import textwrap 
+  21  import zlib 
+  22  import gzip 
+  23   
+  24  from .common_imports import etree, StringIO, BytesIO, HelperTestCase 
+  25  from .common_imports import fileInTestDir, fileUrlInTestDir, read_file, path2url, tmpfile 
+  26  from .common_imports import SillyFileLike, LargeFileLikeUnicode, doctest, make_doctest 
+  27  from .common_imports import canonicalize, _str, _bytes 
+  28   
+  29  print(""" 
+  30  TESTED VERSION: %s""" % etree.__version__ + """ 
+  31      Python:           %r""" % (sys.version_info,) + """ 
+  32      lxml.etree:       %r""" % (etree.LXML_VERSION,) + """ 
+  33      libxml used:      %r""" % (etree.LIBXML_VERSION,) + """ 
+  34      libxml compiled:  %r""" % (etree.LIBXML_COMPILED_VERSION,) + """ 
+  35      libxslt used:     %r""" % (etree.LIBXSLT_VERSION,) + """ 
+  36      libxslt compiled: %r""" % (etree.LIBXSLT_COMPILED_VERSION,) + """ 
+  37      FS encoding:      %s""" % (sys.getfilesystemencoding(),) + """ 
+  38      Default encoding: %s""" % (sys.getdefaultencoding(),) + """ 
+  39      Max Unicode:      %s""" % (sys.maxunicode,) + """ 
+  40  """) 
+  41   
+  42  try: 
+  43      _unicode = unicode 
+  44  except NameError: 
+  45      # Python 3 
+  46      _unicode = str 
+  47   
+  48   
+  49 -class ETreeOnlyTestCase(HelperTestCase): 
+
  50      """Tests only for etree, not ElementTree""" 
+  51      etree = etree 
+  52   
+  53 -    def test_version(self): 
+
  54          self.assertTrue(isinstance(etree.__version__, _unicode)) 
+  55          self.assertTrue(isinstance(etree.LXML_VERSION, tuple)) 
+  56          self.assertEqual(len(etree.LXML_VERSION), 4) 
+  57          self.assertTrue(isinstance(etree.LXML_VERSION[0], int)) 
+  58          self.assertTrue(isinstance(etree.LXML_VERSION[1], int)) 
+  59          self.assertTrue(isinstance(etree.LXML_VERSION[2], int)) 
+  60          self.assertTrue(isinstance(etree.LXML_VERSION[3], int)) 
+  61          self.assertTrue(etree.__version__.startswith( 
+  62              str(etree.LXML_VERSION[0]))) 
+
  63   
+  64 -    def test_c_api(self): 
+
  65          if hasattr(self.etree, '__pyx_capi__'): 
+  66              # newer Pyrex compatible C-API 
+  67              self.assertTrue(isinstance(self.etree.__pyx_capi__, dict)) 
+  68              self.assertTrue(len(self.etree.__pyx_capi__) > 0) 
+  69          else: 
+  70              # older C-API mechanism 
+  71              self.assertTrue(hasattr(self.etree, '_import_c_api')) 
+
  72   
+  73 -    def test_include_paths(self): 
+
  74          import lxml 
+  75          includes = lxml.get_include() 
+  76          self.assertTrue(includes) 
+  77          self.assertTrue(len(includes) >= 2) 
+  78          self.assertTrue(os.path.join(os.path.dirname(lxml.__file__), 'includes') in includes, 
+  79                          includes) 
+
  80   
+  81 -    def test_element_names(self): 
+
  82          Element = self.etree.Element 
+  83          el = Element('name') 
+  84          self.assertEqual(el.tag, 'name') 
+  85          el = Element('{}name') 
+  86          self.assertEqual(el.tag, 'name') 
+
  87   
+  88 -    def test_element_name_empty(self): 
+
  89          Element = self.etree.Element 
+  90          el = Element('name') 
+  91          self.assertRaises(ValueError, Element, '{}') 
+  92          self.assertRaises(ValueError, setattr, el, 'tag', '{}') 
+  93   
+  94          self.assertRaises(ValueError, Element, '{test}') 
+  95          self.assertRaises(ValueError, setattr, el, 'tag', '{test}') 
+
  96   
+  97 -    def test_element_name_colon(self): 
+
  98          Element = self.etree.Element 
+  99          self.assertRaises(ValueError, Element, 'p:name') 
+ 100          self.assertRaises(ValueError, Element, '{test}p:name') 
+ 101   
+ 102          el = Element('name') 
+ 103          self.assertRaises(ValueError, setattr, el, 'tag', 'p:name') 
+
 104   
+ 105 -    def test_element_name_quote(self): 
+
 106          Element = self.etree.Element 
+ 107          self.assertRaises(ValueError, Element, "p'name") 
+ 108          self.assertRaises(ValueError, Element, 'p"name') 
+ 109   
+ 110          self.assertRaises(ValueError, Element, "{test}p'name") 
+ 111          self.assertRaises(ValueError, Element, '{test}p"name') 
+ 112   
+ 113          el = Element('name') 
+ 114          self.assertRaises(ValueError, setattr, el, 'tag', "p'name") 
+ 115          self.assertRaises(ValueError, setattr, el, 'tag', 'p"name') 
+
 116   
+ 117 -    def test_element_name_space(self): 
+
 118          Element = self.etree.Element 
+ 119          self.assertRaises(ValueError, Element, ' name ') 
+ 120          self.assertRaises(ValueError, Element, 'na me') 
+ 121          self.assertRaises(ValueError, Element, '{test} name') 
+ 122   
+ 123          el = Element('name') 
+ 124          self.assertRaises(ValueError, setattr, el, 'tag', ' name ') 
+
 125   
+ 126 -    def test_subelement_name_empty(self): 
+
 127          Element = self.etree.Element 
+ 128          SubElement = self.etree.SubElement 
+ 129   
+ 130          el = Element('name') 
+ 131          self.assertRaises(ValueError, SubElement, el, '{}') 
+ 132          self.assertRaises(ValueError, SubElement, el, '{test}') 
+
 133   
+ 134 -    def test_subelement_name_colon(self): 
+
 135          Element = self.etree.Element 
+ 136          SubElement = self.etree.SubElement 
+ 137   
+ 138          el = Element('name') 
+ 139          self.assertRaises(ValueError, SubElement, el, 'p:name') 
+ 140          self.assertRaises(ValueError, SubElement, el, '{test}p:name') 
+
 141   
+ 142 -    def test_subelement_name_quote(self): 
+
 143          Element = self.etree.Element 
+ 144          SubElement = self.etree.SubElement 
+ 145   
+ 146          el = Element('name') 
+ 147          self.assertRaises(ValueError, SubElement, el, "p'name") 
+ 148          self.assertRaises(ValueError, SubElement, el, "{test}p'name") 
+ 149   
+ 150          self.assertRaises(ValueError, SubElement, el, 'p"name') 
+ 151          self.assertRaises(ValueError, SubElement, el, '{test}p"name') 
+
 152   
+ 153 -    def test_subelement_name_space(self): 
+
 154          Element = self.etree.Element 
+ 155          SubElement = self.etree.SubElement 
+ 156   
+ 157          el = Element('name') 
+ 158          self.assertRaises(ValueError, SubElement, el, ' name ') 
+ 159          self.assertRaises(ValueError, SubElement, el, 'na me') 
+ 160          self.assertRaises(ValueError, SubElement, el, '{test} name') 
+
 161   
+ 162 -    def test_subelement_attribute_invalid(self): 
+
 163          Element = self.etree.Element 
+ 164          SubElement = self.etree.SubElement 
+ 165   
+ 166          el = Element('name') 
+ 167          self.assertRaises(ValueError, SubElement, el, 'name', {'a b c' : 'abc'}) 
+ 168          self.assertRaises(ValueError, SubElement, el, 'name', {'a' : 'a\0\n'}) 
+ 169          self.assertEqual(0, len(el)) 
+
 170   
+ 171 -    def test_qname_empty(self): 
+
 172          QName = self.etree.QName 
+ 173          self.assertRaises(ValueError, QName, '') 
+ 174          self.assertRaises(ValueError, QName, None) 
+ 175          self.assertRaises(ValueError, QName, None, None) 
+ 176          self.assertRaises(ValueError, QName, 'test', '') 
+
 177   
+ 178 -    def test_qname_none(self): 
+
 179          QName = self.etree.QName 
+ 180          q = QName(None, 'TAG') 
+ 181          self.assertEqual('TAG', q) 
+ 182          self.assertEqual('TAG', q.localname) 
+ 183          self.assertEqual(None, q.namespace) 
+
 184   
+ 185 -    def test_qname_colon(self): 
+
 186          QName = self.etree.QName 
+ 187          self.assertRaises(ValueError, QName, 'p:name') 
+ 188          self.assertRaises(ValueError, QName, 'test', 'p:name') 
+
 189   
+ 190 -    def test_qname_space(self): 
+
 191          QName = self.etree.QName 
+ 192          self.assertRaises(ValueError, QName, ' name ') 
+ 193          self.assertRaises(ValueError, QName, 'na me') 
+ 194          self.assertRaises(ValueError, QName, 'test', ' name') 
+
 195   
+ 196 -    def test_qname_namespace_localname(self): 
+
 197          # ET doesn't have namespace/localname properties on QNames 
+ 198          QName = self.etree.QName 
+ 199          namespace, localname = 'http://myns', 'a' 
+ 200          qname = QName(namespace, localname) 
+ 201          self.assertEqual(namespace, qname.namespace) 
+ 202          self.assertEqual(localname, qname.localname) 
+
 203   
+ 204 -    def test_qname_element(self): 
+
 205          # ET doesn't have namespace/localname properties on QNames 
+ 206          QName = self.etree.QName 
+ 207          qname1 = QName('http://myns', 'a') 
+ 208          a = self.etree.Element(qname1, nsmap={'p' : 'http://myns'}) 
+ 209   
+ 210          qname2 = QName(a) 
+ 211          self.assertEqual(a.tag, qname1.text) 
+ 212          self.assertEqual(a.tag, qname1) 
+ 213          self.assertEqual(qname1.text, qname2.text) 
+ 214          self.assertEqual(qname1, qname2.text) 
+ 215          self.assertEqual(qname1.text, qname2) 
+ 216          self.assertEqual(qname1, qname2) 
+
 217   
+ 218 -    def test_qname_text_resolve(self): 
+
 219          # ET doesn't resove QNames as text values 
+ 220          etree = self.etree 
+ 221          qname = etree.QName('http://myns', 'a') 
+ 222          a = etree.Element(qname, nsmap={'p' : 'http://myns'}) 
+ 223          a.text = qname 
+ 224   
+ 225          self.assertEqual("p:a", a.text) 
+
 226   
+ 227 -    def test_nsmap_prefix_invalid(self): 
+
 228          etree = self.etree 
+ 229          self.assertRaises(ValueError, 
+ 230                            etree.Element, "root", nsmap={'"' : 'testns'}) 
+ 231          self.assertRaises(ValueError, 
+ 232                            etree.Element, "root", nsmap={'&' : 'testns'}) 
+ 233          self.assertRaises(ValueError, 
+ 234                            etree.Element, "root", nsmap={'a:b' : 'testns'}) 
+
 235   
+ 236 -    def test_clear_keep_tail(self): 
+
 237          XML = self.etree.XML 
+ 238          tostring = self.etree.tostring 
+ 239          a = XML('<a aa="A"><b ba="B">B1</b>B2<c ca="C">C1</c>C2</a>') 
+ 240          a[0].clear(keep_tail=True) 
+ 241          self.assertEqual(_bytes('<a aa="A"><b/>B2<c ca="C">C1</c>C2</a>'), tostring(a)) 
+
 242   
+ 243 -    def test_attribute_has_key(self): 
+
 244          # ET in Py 3.x has no "attrib.has_key()" method 
+ 245          XML = self.etree.XML 
+ 246   
+ 247          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
+ 248          self.assertEqual( 
+ 249              True, root.attrib.has_key('bar')) 
+ 250          self.assertEqual( 
+ 251              False, root.attrib.has_key('baz')) 
+ 252          self.assertEqual( 
+ 253              False, root.attrib.has_key('hah')) 
+ 254          self.assertEqual( 
+ 255              True, 
+ 256              root.attrib.has_key('{http://ns.codespeak.net/test}baz')) 
+
 257   
+ 258 -    def test_attribute_set(self): 
+
 259          Element = self.etree.Element 
+ 260          root = Element("root") 
+ 261          root.set("attr", "TEST") 
+ 262          self.assertEqual("TEST", root.get("attr")) 
+
 263   
+ 264 -    def test_attribute_set_nonstring(self): 
+
 265          # ElementTree accepts arbitrary attribute values 
+ 266          # lxml.etree allows only strings 
+ 267          Element = self.etree.Element 
+ 268   
+ 269          root = Element("root") 
+ 270          root.set("attr", "TEST") 
+ 271          self.assertEqual("TEST", root.get("attr")) 
+ 272          self.assertRaises(TypeError, root.set, "newattr", 5) 
+
 273   
+ 274 -    def test_attrib_and_keywords(self): 
+
 275          Element = self.etree.Element 
+ 276   
+ 277          root = Element("root") 
+ 278          root.set("attr", "TEST") 
+ 279          self.assertEqual("TEST", root.attrib["attr"]) 
+ 280   
+ 281          root2 = Element("root2", root.attrib, attr2='TOAST') 
+ 282          self.assertEqual("TEST", root2.attrib["attr"]) 
+ 283          self.assertEqual("TOAST", root2.attrib["attr2"]) 
+ 284          self.assertEqual(None, root.attrib.get("attr2")) 
+
 285   
+ 286 -    def test_attrib_order(self): 
+
 287          Element = self.etree.Element 
+ 288   
+ 289          keys = ["attr%d" % i for i in range(12, 4, -1)] 
+ 290          values = ["TEST-%d" % i for i in range(12, 4, -1)] 
+ 291          items = list(zip(keys, values)) 
+ 292   
+ 293          root = Element("root") 
+ 294          for key, value in items: 
+ 295              root.set(key, value) 
+ 296          self.assertEqual(keys, root.attrib.keys()) 
+ 297          self.assertEqual(values, root.attrib.values()) 
+ 298   
+ 299          attr_order = [ 
+ 300              ('attr_99', 'TOAST-1'), 
+ 301              ('attr_98', 'TOAST-2'), 
+ 302          ] 
+ 303          ordered_dict_types = [OrderedDict, lambda x:x] 
+ 304          if sys.version_info >= (3, 6): 
+ 305              ordered_dict_types.append(dict) 
+ 306          else: 
+ 307              # Keyword arguments are not ordered in Py<3.6, and thus get sorted. 
+ 308              attr_order.sort() 
+ 309          attr_order += items 
+ 310          expected_keys = [attr[0] for attr in attr_order] 
+ 311          expected_values = [attr[1] for attr in attr_order] 
+ 312          expected_items = list(zip(expected_keys, expected_values)) 
+ 313   
+ 314          for dict_type in ordered_dict_types: 
+ 315              root2 = Element("root2", dict_type(root.attrib), 
+ 316                              attr_99='TOAST-1', attr_98='TOAST-2') 
+ 317   
+ 318              try: 
+ 319                  self.assertSequenceEqual(expected_keys, root2.attrib.keys()) 
+ 320                  self.assertSequenceEqual(expected_values, root2.attrib.values()) 
+ 321                  self.assertSequenceEqual(expected_items, root2.attrib.items()) 
+ 322              except AssertionError as exc: 
+ 323                  exc.args = ("Order of '%s': %s" % (dict_type.__name__, exc.args[0]),) + exc.args[1:] 
+ 324                  raise 
+ 325   
+ 326          self.assertEqual(keys, root.attrib.keys()) 
+ 327          self.assertEqual(values, root.attrib.values()) 
+
 328   
+ 329 -    def test_attribute_set_invalid(self): 
+
 330          # ElementTree accepts arbitrary attribute values 
+ 331          # lxml.etree allows only strings, or None for (html5) boolean attributes 
+ 332          Element = self.etree.Element 
+ 333          root = Element("root") 
+ 334          self.assertRaises(TypeError, root.set, "newattr", 5) 
+ 335          self.assertRaises(TypeError, root.set, "newattr", object) 
+ 336          self.assertRaises(TypeError, root.set, "newattr", None) 
+ 337          self.assertRaises(TypeError, root.set, "newattr") 
+
 338   
+ 339 -    def test_strip_attributes(self): 
+
 340          XML = self.etree.XML 
+ 341          xml = _bytes('<test a="5" b="10" c="20"><x a="4" b="2"/></test>') 
+ 342   
+ 343          root = XML(xml) 
+ 344          self.etree.strip_attributes(root, 'a') 
+ 345          self.assertEqual(_bytes('<test b="10" c="20"><x b="2"></x></test>'), 
+ 346                            self._writeElement(root)) 
+ 347   
+ 348          root = XML(xml) 
+ 349          self.etree.strip_attributes(root, 'b', 'c') 
+ 350          self.assertEqual(_bytes('<test a="5"><x a="4"></x></test>'), 
+ 351                            self._writeElement(root)) 
+
 352   
+ 353 -    def test_strip_attributes_ns(self): 
+
 354          XML = self.etree.XML 
+ 355          xml = _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20" n:a="5"><x a="4" n:b="2"/></test>') 
+ 356   
+ 357          root = XML(xml) 
+ 358          self.etree.strip_attributes(root, 'a') 
+ 359          self.assertEqual( 
+ 360              _bytes('<test xmlns:n="http://test/ns" b="10" c="20" n:a="5"><x n:b="2"></x></test>'), 
+ 361              self._writeElement(root)) 
+ 362   
+ 363          root = XML(xml) 
+ 364          self.etree.strip_attributes(root, '{http://test/ns}a', 'c') 
+ 365          self.assertEqual( 
+ 366              _bytes('<test xmlns:n="http://test/ns" a="6" b="10"><x a="4" n:b="2"></x></test>'), 
+ 367              self._writeElement(root)) 
+ 368   
+ 369          root = XML(xml) 
+ 370          self.etree.strip_attributes(root, '{http://test/ns}*') 
+ 371          self.assertEqual( 
+ 372              _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20"><x a="4"></x></test>'), 
+ 373              self._writeElement(root)) 
+
 374   
+ 375 -    def test_strip_elements(self): 
+
 376          XML = self.etree.XML 
+ 377          xml = _bytes('<test><a><b><c/></b></a><x><a><b/><c/></a></x></test>') 
+ 378   
+ 379          root = XML(xml) 
+ 380          self.etree.strip_elements(root, 'a') 
+ 381          self.assertEqual(_bytes('<test><x></x></test>'), 
+ 382                            self._writeElement(root)) 
+ 383   
+ 384          root = XML(xml) 
+ 385          self.etree.strip_elements(root, 'b', 'c', 'X', 'Y', 'Z') 
+ 386          self.assertEqual(_bytes('<test><a></a><x><a></a></x></test>'), 
+ 387                            self._writeElement(root)) 
+ 388   
+ 389          root = XML(xml) 
+ 390          self.etree.strip_elements(root, 'c') 
+ 391          self.assertEqual(_bytes('<test><a><b></b></a><x><a><b></b></a></x></test>'), 
+ 392                            self._writeElement(root)) 
+
 393   
+ 394 -    def test_strip_elements_ns(self): 
+
 395          XML = self.etree.XML 
+ 396          xml = _bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"/>C</b>BT</n:a>AT<x>X<a>A<b xmlns="urn:a"/>BT<c xmlns="urn:x"/>CT</a>AT</x>XT</test>') 
+ 397   
+ 398          root = XML(xml) 
+ 399          self.etree.strip_elements(root, 'a') 
+ 400          self.assertEqual(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X</x>XT</test>'), 
+ 401                            self._writeElement(root)) 
+ 402   
+ 403          root = XML(xml) 
+ 404          self.etree.strip_elements(root, '{urn:a}b', 'c') 
+ 405          self.assertEqual(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 
+ 406                            self._writeElement(root)) 
+ 407   
+ 408          root = XML(xml) 
+ 409          self.etree.strip_elements(root, '{urn:a}*', 'c') 
+ 410          self.assertEqual(_bytes('<test>TEST<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 
+ 411                            self._writeElement(root)) 
+ 412   
+ 413          root = XML(xml) 
+ 414          self.etree.strip_elements(root, '{urn:a}*', 'c', with_tail=False) 
+ 415          self.assertEqual(_bytes('<test>TESTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 
+ 416                            self._writeElement(root)) 
+
 417   
+ 418 -    def test_strip_tags(self): 
+
 419          XML = self.etree.XML 
+ 420          xml = _bytes('<test>TEST<a>A<b>B<c/>CT</b>BT</a>AT<x>X<a>A<b/>BT<c/>CT</a>AT</x>XT</test>') 
+ 421   
+ 422          root = XML(xml) 
+ 423          self.etree.strip_tags(root, 'a') 
+ 424          self.assertEqual(_bytes('<test>TESTA<b>B<c></c>CT</b>BTAT<x>XA<b></b>BT<c></c>CTAT</x>XT</test>'), 
+ 425                            self._writeElement(root)) 
+ 426   
+ 427          root = XML(xml) 
+ 428          self.etree.strip_tags(root, 'b', 'c', 'X', 'Y', 'Z') 
+ 429          self.assertEqual(_bytes('<test>TEST<a>ABCTBT</a>AT<x>X<a>ABTCT</a>AT</x>XT</test>'), 
+ 430                            self._writeElement(root)) 
+ 431   
+ 432          root = XML(xml) 
+ 433          self.etree.strip_tags(root, 'c') 
+ 434          self.assertEqual(_bytes('<test>TEST<a>A<b>BCT</b>BT</a>AT<x>X<a>A<b></b>BTCT</a>AT</x>XT</test>'), 
+ 435                            self._writeElement(root)) 
+
 436   
+ 437 -    def test_strip_tags_pi_comment(self): 
+
 438          XML = self.etree.XML 
+ 439          PI = self.etree.ProcessingInstruction 
+ 440          Comment = self.etree.Comment 
+ 441          xml = _bytes('<!--comment1-->\n<?PI1?>\n<test>TEST<!--comment2-->XT<?PI2?></test>\n<!--comment3-->\n<?PI1?>') 
+ 442   
+ 443          root = XML(xml) 
+ 444          self.etree.strip_tags(root, PI) 
+ 445          self.assertEqual(_bytes('<!--comment1-->\n<?PI1?>\n<test>TEST<!--comment2-->XT</test>\n<!--comment3-->\n<?PI1?>'), 
+ 446                            self._writeElement(root)) 
+ 447   
+ 448          root = XML(xml) 
+ 449          self.etree.strip_tags(root, Comment) 
+ 450          self.assertEqual(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT<?PI2?></test>\n<!--comment3-->\n<?PI1?>'), 
+ 451                            self._writeElement(root)) 
+ 452   
+ 453          root = XML(xml) 
+ 454          self.etree.strip_tags(root, PI, Comment) 
+ 455          self.assertEqual(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT</test>\n<!--comment3-->\n<?PI1?>'), 
+ 456                            self._writeElement(root)) 
+ 457   
+ 458          root = XML(xml) 
+ 459          self.etree.strip_tags(root, Comment, PI) 
+ 460          self.assertEqual(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT</test>\n<!--comment3-->\n<?PI1?>'), 
+ 461                            self._writeElement(root)) 
+
 462   
+ 463 -    def test_strip_tags_pi_comment_all(self): 
+
 464          XML = self.etree.XML 
+ 465          ElementTree = self.etree.ElementTree 
+ 466          PI = self.etree.ProcessingInstruction 
+ 467          Comment = self.etree.Comment 
+ 468          xml = _bytes('<!--comment1-->\n<?PI1?>\n<test>TEST<!--comment2-->XT<?PI2?></test>\n<!--comment3-->\n<?PI1?>') 
+ 469   
+ 470          root = XML(xml) 
+ 471          self.etree.strip_tags(ElementTree(root), PI) 
+ 472          self.assertEqual(_bytes('<!--comment1-->\n<test>TEST<!--comment2-->XT</test>\n<!--comment3-->'), 
+ 473                            self._writeElement(root)) 
+ 474   
+ 475          root = XML(xml) 
+ 476          self.etree.strip_tags(ElementTree(root), Comment) 
+ 477          self.assertEqual(_bytes('<?PI1?>\n<test>TESTXT<?PI2?></test>\n<?PI1?>'), 
+ 478                            self._writeElement(root)) 
+ 479   
+ 480          root = XML(xml) 
+ 481          self.etree.strip_tags(ElementTree(root), PI, Comment) 
+ 482          self.assertEqual(_bytes('<test>TESTXT</test>'), 
+ 483                            self._writeElement(root)) 
+ 484   
+ 485          root = XML(xml) 
+ 486          self.etree.strip_tags(ElementTree(root), Comment, PI) 
+ 487          self.assertEqual(_bytes('<test>TESTXT</test>'), 
+ 488                            self._writeElement(root)) 
+
 489   
+ 490 -    def test_strip_tags_doc_style(self): 
+
 491          XML = self.etree.XML 
+ 492          xml = _bytes(''' 
+ 493          <div> 
+ 494              <div> 
+ 495                  I like <strong>sheep</strong>. 
+ 496                  <br/> 
+ 497                  I like lots of <strong>sheep</strong>. 
+ 498                  <br/> 
+ 499                  Click <a href="http://www.sheep.com">here</a> 
+ 500                   for <a href="http://www.sheep.com">those</a> sheep. 
+ 501                  <br/> 
+ 502              </div> 
+ 503          </div> 
+ 504          '''.strip()) 
+ 505   
+ 506          root = XML(xml) 
+ 507          self.etree.strip_tags(root, 'a') 
+ 508          self.assertEqual(re.sub(_bytes('</?a[^>]*>'), _bytes(''), xml).replace(_bytes('<br/>'), _bytes('<br></br>')), 
+ 509                            self._writeElement(root)) 
+ 510   
+ 511          root = XML(xml) 
+ 512          self.etree.strip_tags(root, 'a', 'br') 
+ 513          self.assertEqual(re.sub(_bytes('</?a[^>]*>'), _bytes(''), 
+ 514                                   re.sub(_bytes('<br[^>]*>'), _bytes(''), xml)), 
+ 515                            self._writeElement(root)) 
+
 516   
+ 517 -    def test_strip_tags_ns(self): 
+
 518          XML = self.etree.XML 
+ 519          xml = _bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"/>CT</b>BT</n:a>AT<x>X<a>A<b xmlns="urn:a"/>BT<c xmlns="urn:x"/>CT</a>AT</x>XT</test>') 
+ 520   
+ 521          root = XML(xml) 
+ 522          self.etree.strip_tags(root, 'a') 
+ 523          self.assertEqual(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>CT</b>BT</n:a>AT<x>XA<b xmlns="urn:a"></b>BT<c xmlns="urn:x"></c>CTAT</x>XT</test>'), 
+ 524                            self._writeElement(root)) 
+ 525   
+ 526          root = XML(xml) 
+ 527          self.etree.strip_tags(root, '{urn:a}b', 'c') 
+ 528          self.assertEqual(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>CT</b>BT</n:a>AT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 
+ 529                            self._writeElement(root)) 
+ 530   
+ 531          root = XML(xml) 
+ 532          self.etree.strip_tags(root, '{urn:a}*', 'c') 
+ 533          self.assertEqual(_bytes('<test>TESTA<b>B<c xmlns="urn:c"></c>CT</b>BTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'), 
+ 534                            self._writeElement(root)) 
+
 535   
+ 536 -    def test_strip_tags_and_remove(self): 
+
 537          # previously crashed 
+ 538          HTML = self.etree.HTML 
+ 539          root = HTML(_bytes('<div><h1>title</h1> <b>foo</b> <p>boo</p></div>'))[0][0] 
+ 540          self.assertEqual(_bytes('<div><h1>title</h1> <b>foo</b> <p>boo</p></div>'), 
+ 541                            self.etree.tostring(root)) 
+ 542          self.etree.strip_tags(root, 'b') 
+ 543          self.assertEqual(_bytes('<div><h1>title</h1> foo <p>boo</p></div>'), 
+ 544                            self.etree.tostring(root)) 
+ 545          root.remove(root[0]) 
+ 546          self.assertEqual(_bytes('<div><p>boo</p></div>'), 
+ 547                            self.etree.tostring(root)) 
+
 548   
+ 549 -    def test_pi(self): 
+
 550          # lxml.etree separates target and text 
+ 551          Element = self.etree.Element 
+ 552          SubElement = self.etree.SubElement 
+ 553          ProcessingInstruction = self.etree.ProcessingInstruction 
+ 554   
+ 555          a = Element('a') 
+ 556          a.append(ProcessingInstruction('foo', 'some more text')) 
+ 557          self.assertEqual(a[0].target, 'foo') 
+ 558          self.assertEqual(a[0].text, 'some more text') 
+
 559   
+ 560 -    def test_pi_parse(self): 
+
 561          XML = self.etree.XML 
+ 562          root = XML(_bytes("<test><?mypi my test ?></test>")) 
+ 563          self.assertEqual(root[0].target, "mypi") 
+ 564          self.assertEqual(root[0].text, "my test ") 
+
 565   
+ 566 -    def test_pi_pseudo_attributes_get(self): 
+
 567          XML = self.etree.XML 
+ 568          root = XML(_bytes("<test><?mypi my='1' test=\" abc \" quotes=\"' '\" only names ?></test>")) 
+ 569          self.assertEqual(root[0].target, "mypi") 
+ 570          self.assertEqual(root[0].get('my'), "1") 
+ 571          self.assertEqual(root[0].get('test'), " abc ") 
+ 572          self.assertEqual(root[0].get('quotes'), "' '") 
+ 573          self.assertEqual(root[0].get('only'), None) 
+ 574          self.assertEqual(root[0].get('names'), None) 
+ 575          self.assertEqual(root[0].get('nope'), None) 
+
 576   
+ 577 -    def test_pi_pseudo_attributes_attrib(self): 
+
 578          XML = self.etree.XML 
+ 579          root = XML(_bytes("<test><?mypi my='1' test=\" abc \" quotes=\"' '\" only names ?></test>")) 
+ 580          self.assertEqual(root[0].target, "mypi") 
+ 581          self.assertEqual(root[0].attrib['my'], "1") 
+ 582          self.assertEqual(root[0].attrib['test'], " abc ") 
+ 583          self.assertEqual(root[0].attrib['quotes'], "' '") 
+ 584          self.assertRaises(KeyError, root[0].attrib.__getitem__, 'only') 
+ 585          self.assertRaises(KeyError, root[0].attrib.__getitem__, 'names') 
+ 586          self.assertRaises(KeyError, root[0].attrib.__getitem__, 'nope') 
+
 587   
+ 588 -    def test_deepcopy_pi(self): 
+
 589          # previously caused a crash 
+ 590          ProcessingInstruction = self.etree.ProcessingInstruction 
+ 591           
+ 592          a = ProcessingInstruction("PI", "ONE") 
+ 593          b = copy.deepcopy(a) 
+ 594          b.text = "ANOTHER" 
+ 595   
+ 596          self.assertEqual('ONE',     a.text) 
+ 597          self.assertEqual('ANOTHER', b.text) 
+
 598   
+ 599 -    def test_deepcopy_elementtree_pi(self): 
+
 600          XML = self.etree.XML 
+ 601          tostring = self.etree.tostring 
+ 602          root = XML(_bytes("<?mypi my test ?><test/><!--comment -->")) 
+ 603          tree1 = self.etree.ElementTree(root) 
+ 604          self.assertEqual(_bytes("<?mypi my test ?><test/><!--comment -->"), 
+ 605                            tostring(tree1)) 
+ 606   
+ 607          tree2 = copy.deepcopy(tree1) 
+ 608          self.assertEqual(_bytes("<?mypi my test ?><test/><!--comment -->"), 
+ 609                            tostring(tree2)) 
+ 610   
+ 611          root2 = copy.deepcopy(tree1.getroot()) 
+ 612          self.assertEqual(_bytes("<test/>"), 
+ 613                            tostring(root2)) 
+
 614   
+ 615 -    def test_deepcopy_elementtree_dtd(self): 
+
 616          XML = self.etree.XML 
+ 617          tostring = self.etree.tostring 
+ 618          xml = _bytes('<!DOCTYPE test [\n<!ENTITY entity "tasty">\n]>\n<test/>') 
+ 619          root = XML(xml) 
+ 620          tree1 = self.etree.ElementTree(root) 
+ 621          self.assertEqual(xml, tostring(tree1)) 
+ 622   
+ 623          tree2 = copy.deepcopy(tree1) 
+ 624          self.assertEqual(xml, tostring(tree2)) 
+ 625   
+ 626          root2 = copy.deepcopy(tree1.getroot()) 
+ 627          self.assertEqual(_bytes("<test/>"), 
+ 628                            tostring(root2)) 
+
 629   
+ 630 -    def test_deepcopy_pi_dtd(self): 
+
 631          XML = self.etree.XML 
+ 632          tostring = self.etree.tostring 
+ 633          xml = _bytes('<!-- comment --><!DOCTYPE test [\n<!ENTITY entity "tasty">\n]>\n<test/>') 
+ 634          root = XML(xml) 
+ 635          tree1 = self.etree.ElementTree(root) 
+ 636          self.assertEqual(xml, tostring(tree1)) 
+ 637   
+ 638          tree2 = copy.deepcopy(tree1) 
+ 639          self.assertEqual(xml, tostring(tree2)) 
+
 640   
+ 641 -    def test_parse_remove_comments(self): 
+
 642          fromstring = self.etree.fromstring 
+ 643          tostring = self.etree.tostring 
+ 644          XMLParser = self.etree.XMLParser 
+ 645   
+ 646          xml = _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 
+ 647          parser = XMLParser(remove_comments=True) 
+ 648          root = fromstring(xml, parser) 
+ 649          self.assertEqual( 
+ 650              _bytes('<a><b><c/></b></a>'), 
+ 651              tostring(root)) 
+
 652   
+ 653 -    def test_parse_remove_pis(self): 
+
 654          parse = self.etree.parse 
+ 655          tostring = self.etree.tostring 
+ 656          XMLParser = self.etree.XMLParser 
+ 657   
+ 658          xml = _bytes('<?test?><a><?A?><b><?B?><c/></b><?C?></a><?tail?>') 
+ 659   
+ 660          f = BytesIO(xml) 
+ 661          tree = parse(f) 
+ 662          self.assertEqual( 
+ 663              xml, 
+ 664              tostring(tree)) 
+ 665   
+ 666          parser = XMLParser(remove_pis=True) 
+ 667          tree = parse(f, parser) 
+ 668          self.assertEqual( 
+ 669              _bytes('<a><b><c/></b></a>'), 
+ 670              tostring(tree)) 
+
 671   
+ 672 -    def test_parse_parser_type_error(self): 
+
 673          # ET raises IOError only 
+ 674          parse = self.etree.parse 
+ 675          self.assertRaises(TypeError, parse, 'notthere.xml', object()) 
+
 676   
+ 677 -    def test_iterparse_tree_comments(self): 
+
 678          # ET removes comments 
+ 679          iterparse = self.etree.iterparse 
+ 680          tostring = self.etree.tostring 
+ 681   
+ 682          f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 
+ 683          events = list(iterparse(f)) 
+ 684          root = events[-1][1] 
+ 685          self.assertEqual(3, len(events)) 
+ 686          self.assertEqual( 
+ 687              _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'), 
+ 688              tostring(root)) 
+
 689   
+ 690 -    def test_iterparse_comments(self): 
+
 691          # ET removes comments 
+ 692          iterparse = self.etree.iterparse 
+ 693          tostring = self.etree.tostring 
+ 694   
+ 695          def name(event, el): 
+ 696              if event == 'comment': 
+ 697                  return el.text 
+ 698              else: 
+ 699                  return el.tag 
+
 700   
+ 701          f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 
+ 702          events = list(iterparse(f, events=('end', 'comment'))) 
+ 703          root = events[-1][1] 
+ 704          self.assertEqual(6, len(events)) 
+ 705          self.assertEqual(['A', ' B ', 'c', 'b', 'C', 'a'], 
+ 706                            [ name(*item) for item in events ]) 
+ 707          self.assertEqual( 
+ 708              _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'), 
+ 709              tostring(root)) 
+
 710   
+ 711 -    def test_iterparse_pis(self): 
+
 712          # ET removes pis 
+ 713          iterparse = self.etree.iterparse 
+ 714          tostring = self.etree.tostring 
+ 715          ElementTree = self.etree.ElementTree 
+ 716   
+ 717          def name(event, el): 
+ 718              if event == 'pi': 
+ 719                  return el.target, el.text 
+ 720              else: 
+ 721                  return el.tag 
+
 722   
+ 723          f = BytesIO('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>') 
+ 724          events = list(iterparse(f, events=('end', 'pi'))) 
+ 725          root = events[-2][1] 
+ 726          self.assertEqual(8, len(events)) 
+ 727          self.assertEqual([('pia','a'), ('pib','b'), ('pic','c'), 'c', 'b', 
+ 728                             ('pid','d'), 'a', ('pie','e')], 
+ 729                            [ name(*item) for item in events ]) 
+ 730          self.assertEqual( 
+ 731              _bytes('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>'), 
+ 732              tostring(ElementTree(root))) 
+ 733   
+ 734 -    def test_iterparse_remove_comments(self): 
+
 735          iterparse = self.etree.iterparse 
+ 736          tostring = self.etree.tostring 
+ 737   
+ 738          f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>') 
+ 739          events = list(iterparse(f, remove_comments=True, 
+ 740                                  events=('end', 'comment'))) 
+ 741          root = events[-1][1] 
+ 742          self.assertEqual(3, len(events)) 
+ 743          self.assertEqual(['c', 'b', 'a'], 
+ 744                            [ el.tag for (event, el) in events ]) 
+ 745          self.assertEqual( 
+ 746              _bytes('<a><b><c/></b></a>'), 
+ 747              tostring(root)) 
+
 748   
+ 749 -    def test_iterparse_broken(self): 
+
 750          iterparse = self.etree.iterparse 
+ 751          f = BytesIO('<a><b><c/></a>') 
+ 752          # ET raises ExpatError, lxml raises XMLSyntaxError 
+ 753          self.assertRaises(self.etree.XMLSyntaxError, list, iterparse(f)) 
+
 754   
+ 755 -    def test_iterparse_broken_recover(self): 
+
 756          iterparse = self.etree.iterparse 
+ 757          f = BytesIO('<a><b><c/></a>') 
+ 758          it = iterparse(f, events=('start', 'end'), recover=True) 
+ 759          events = [(ev, el.tag) for ev, el in it] 
+ 760          root = it.root 
+ 761          self.assertTrue(root is not None) 
+ 762   
+ 763          self.assertEqual(1, events.count(('start', 'a'))) 
+ 764          self.assertEqual(1, events.count(('end', 'a'))) 
+ 765   
+ 766          self.assertEqual(1, events.count(('start', 'b'))) 
+ 767          self.assertEqual(1, events.count(('end', 'b'))) 
+ 768   
+ 769          self.assertEqual(1, events.count(('start', 'c'))) 
+ 770          self.assertEqual(1, events.count(('end', 'c'))) 
+
 771   
+ 772 -    def test_iterparse_broken_multi_recover(self): 
+
 773          iterparse = self.etree.iterparse 
+ 774          f = BytesIO('<a><b><c/></d><b><c/></a></b>') 
+ 775          it = iterparse(f, events=('start', 'end'), recover=True) 
+ 776          events = [(ev, el.tag) for ev, el in it] 
+ 777          root = it.root 
+ 778          self.assertTrue(root is not None) 
+ 779   
+ 780          self.assertEqual(1, events.count(('start', 'a'))) 
+ 781          self.assertEqual(1, events.count(('end', 'a'))) 
+ 782   
+ 783          self.assertEqual(2, events.count(('start', 'b'))) 
+ 784          self.assertEqual(2, events.count(('end', 'b'))) 
+ 785   
+ 786          self.assertEqual(2, events.count(('start', 'c'))) 
+ 787          self.assertEqual(2, events.count(('end', 'c'))) 
+
 788   
+ 789 -    def test_iterparse_strip(self): 
+
 790          iterparse = self.etree.iterparse 
+ 791          f = BytesIO(""" 
+ 792                 <a>  \n \n  <b> b test </b>  \n 
+ 793   
+ 794                 \n\t <c> \n </c> </a>  \n """) 
+ 795          iterator = iterparse(f, remove_blank_text=True) 
+ 796          text = [ (element.text, element.tail) 
+ 797                   for event, element in iterator ] 
+ 798          self.assertEqual( 
+ 799              [(" b test ", None), (" \n ", None), (None, None)], 
+ 800              text) 
+
 801   
+ 802 -    def test_iterparse_tag(self): 
+
 803          iterparse = self.etree.iterparse 
+ 804          f = BytesIO('<a><b><d/></b><c/></a>') 
+ 805   
+ 806          iterator = iterparse(f, tag="b", events=('start', 'end')) 
+ 807          events = list(iterator) 
+ 808          root = iterator.root 
+ 809          self.assertEqual( 
+ 810              [('start', root[0]), ('end', root[0])], 
+ 811              events) 
+
 812   
+ 813 -    def test_iterparse_tag_all(self): 
+
 814          iterparse = self.etree.iterparse 
+ 815          f = BytesIO('<a><b><d/></b><c/></a>') 
+ 816   
+ 817          iterator = iterparse(f, tag="*", events=('start', 'end')) 
+ 818          events = list(iterator) 
+ 819          self.assertEqual( 
+ 820              8, 
+ 821              len(events)) 
+
 822   
+ 823 -    def test_iterparse_tag_ns(self): 
+
 824          iterparse = self.etree.iterparse 
+ 825          f = BytesIO('<a xmlns="urn:test:1"><b><d/></b><c/></a>') 
+ 826   
+ 827          iterator = iterparse(f, tag="{urn:test:1}b", events=('start', 'end')) 
+ 828          events = list(iterator) 
+ 829          root = iterator.root 
+ 830          self.assertEqual( 
+ 831              [('start', root[0]), ('end', root[0])], 
+ 832              events) 
+
 833   
+ 834 -    def test_iterparse_tag_ns_empty(self): 
+
 835          iterparse = self.etree.iterparse 
+ 836          f = BytesIO('<a><b><d/></b><c/></a>') 
+ 837          iterator = iterparse(f, tag="{}b", events=('start', 'end')) 
+ 838          events = list(iterator) 
+ 839          root = iterator.root 
+ 840          self.assertEqual( 
+ 841              [('start', root[0]), ('end', root[0])], 
+ 842              events) 
+ 843   
+ 844          f = BytesIO('<a xmlns="urn:test:1"><b><d/></b><c/></a>') 
+ 845          iterator = iterparse(f, tag="{}b", events=('start', 'end')) 
+ 846          events = list(iterator) 
+ 847          root = iterator.root 
+ 848          self.assertEqual([], events) 
+
 849   
+ 850 -    def test_iterparse_tag_ns_all(self): 
+
 851          iterparse = self.etree.iterparse 
+ 852          f = BytesIO('<a xmlns="urn:test:1"><b><d/></b><c/></a>') 
+ 853          iterator = iterparse(f, tag="{urn:test:1}*", events=('start', 'end')) 
+ 854          events = list(iterator) 
+ 855          self.assertEqual(8, len(events)) 
+
 856   
+ 857 -    def test_iterparse_tag_ns_empty_all(self): 
+
 858          iterparse = self.etree.iterparse 
+ 859          f = BytesIO('<a xmlns="urn:test:1"><b><d/></b><c/></a>') 
+ 860          iterator = iterparse(f, tag="{}*", events=('start', 'end')) 
+ 861          events = list(iterator) 
+ 862          self.assertEqual([], events) 
+ 863   
+ 864          f = BytesIO('<a><b><d/></b><c/></a>') 
+ 865          iterator = iterparse(f, tag="{}*", events=('start', 'end')) 
+ 866          events = list(iterator) 
+ 867          self.assertEqual(8, len(events)) 
+
 868   
+ 869 -    def test_iterparse_encoding_error(self): 
+
 870          text = _str('Søk på nettet') 
+ 871          wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 
+ 872          xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 
+ 873                        ).encode('iso-8859-1') 
+ 874   
+ 875          self.assertRaises(self.etree.ParseError, 
+ 876                            list, self.etree.iterparse(BytesIO(xml_latin1))) 
+
 877   
+ 878 -    def test_iterparse_encoding_8bit_override(self): 
+
 879          text = _str('Søk på nettet', encoding="UTF-8") 
+ 880          wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>" 
+ 881          xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 
+ 882                        ).encode('iso-8859-1') 
+ 883   
+ 884          iterator = self.etree.iterparse(BytesIO(xml_latin1), 
+ 885                                          encoding="iso-8859-1") 
+ 886          self.assertEqual(1, len(list(iterator))) 
+ 887   
+ 888          a = iterator.root 
+ 889          self.assertEqual(a.text, text) 
+
 890   
+ 891 -    def test_iterparse_keep_cdata(self): 
+
 892          tostring = self.etree.tostring 
+ 893          f = BytesIO('<root><![CDATA[test]]></root>') 
+ 894          context = self.etree.iterparse(f, strip_cdata=False) 
+ 895          content = [ el.text for event,el in context ] 
+ 896   
+ 897          self.assertEqual(['test'], content) 
+ 898          self.assertEqual(_bytes('<root><![CDATA[test]]></root>'), 
+ 899                            tostring(context.root)) 
+
 900   
+ 901 -    def test_parser_encoding_unknown(self): 
+
 902          self.assertRaises( 
+ 903              LookupError, self.etree.XMLParser, encoding="hopefully unknown") 
+
 904   
+ 905 -    def test_parser_encoding(self): 
+
 906          self.etree.XMLParser(encoding="ascii") 
+ 907          self.etree.XMLParser(encoding="utf-8") 
+ 908          self.etree.XMLParser(encoding="iso-8859-1") 
+
 909   
+ 910 -    def test_feed_parser_recover(self): 
+
 911          parser = self.etree.XMLParser(recover=True) 
+ 912   
+ 913          parser.feed('<?xml version=') 
+ 914          parser.feed('"1.0"?><ro') 
+ 915          parser.feed('ot><') 
+ 916          parser.feed('a test="works"') 
+ 917          parser.feed('><othertag/></root') # <a> not closed! 
+ 918          parser.feed('>') 
+ 919   
+ 920          root = parser.close() 
+ 921   
+ 922          self.assertEqual(root.tag, "root") 
+ 923          self.assertEqual(len(root), 1) 
+ 924          self.assertEqual(root[0].tag, "a") 
+ 925          self.assertEqual(root[0].get("test"), "works") 
+ 926          self.assertEqual(len(root[0]), 1) 
+ 927          self.assertEqual(root[0][0].tag, "othertag") 
+
 928          # FIXME: would be nice to get some errors logged ... 
+ 929          #self.assertTrue(len(parser.error_log) > 0, "error log is empty") 
+ 930   
+ 931 -    def test_feed_parser_recover_no_id_dict(self): 
+
 932          # test that recover mode plays nicely with the no-id-dict setup 
+ 933          parser = self.etree.XMLParser(recover=True, collect_ids=False) 
+ 934   
+ 935          parser.feed('<?xml version=') 
+ 936          parser.feed('"1.0"?><ro') 
+ 937          parser.feed('ot xml:id="123"><') 
+ 938          parser.feed('a test="works" xml:id=') 
+ 939          parser.feed('"321"><othertag/></root') # <a> not closed! 
+ 940          parser.feed('>') 
+ 941   
+ 942          root = parser.close() 
+ 943   
+ 944          self.assertEqual(root.tag, "root") 
+ 945          self.assertEqual(len(root), 1) 
+ 946          self.assertEqual(root[0].tag, "a") 
+ 947          self.assertEqual(root[0].get("test"), "works") 
+ 948          self.assertEqual(root[0].attrib, { 
+ 949              'test': 'works', 
+ 950              '{http://www.w3.org/XML/1998/namespace}id': '321'}) 
+ 951          self.assertEqual(len(root[0]), 1) 
+ 952          self.assertEqual(root[0][0].tag, "othertag") 
+
 953          # FIXME: would be nice to get some errors logged ... 
+ 954          #self.assertTrue(len(parser.error_log) > 0, "error log is empty") 
+ 955   
+ 956 -    def test_elementtree_parser_target_type_error(self): 
+
 957          assertEqual = self.assertEqual 
+ 958          assertFalse  = self.assertFalse 
+ 959   
+ 960          events = [] 
+ 961          class Target(object): 
+ 962              def start(self, tag, attrib): 
+ 963                  events.append("start") 
+ 964                  assertFalse(attrib) 
+ 965                  assertEqual("TAG", tag) 
+
 966              def end(self, tag): 
+ 967                  events.append("end") 
+ 968                  assertEqual("TAG", tag) 
+ 969              def close(self): 
+ 970                  return "DONE" # no Element! 
+ 971   
+ 972          parser = self.etree.XMLParser(target=Target()) 
+ 973          tree = self.etree.ElementTree() 
+ 974   
+ 975          self.assertRaises(TypeError, 
+ 976                            tree.parse, BytesIO("<TAG/>"), parser=parser) 
+ 977          self.assertEqual(["start", "end"], events) 
+ 978   
+ 979 -    def test_parser_target_feed_exception(self): 
+
 980          # ET doesn't call .close() on errors 
+ 981          events = [] 
+ 982          class Target(object): 
+ 983              def start(self, tag, attrib): 
+ 984                  events.append("start-" + tag) 
+
 985              def end(self, tag): 
+ 986                  events.append("end-" + tag) 
+ 987                  if tag == 'a': 
+ 988                      raise ValueError("dead and gone") 
+ 989              def data(self, data): 
+ 990                  events.append("data-" + data) 
+ 991              def close(self): 
+ 992                  events.append("close") 
+ 993                  return "DONE" 
+ 994   
+ 995          parser = self.etree.XMLParser(target=Target()) 
+ 996   
+ 997          try: 
+ 998              parser.feed(_bytes('<root>A<a>ca</a>B</root>')) 
+ 999              done = parser.close() 
+1000              self.fail("error expected, but parsing succeeded") 
+1001          except ValueError: 
+1002              done = 'value error received as expected' 
+1003   
+1004          self.assertEqual(["start-root", "data-A", "start-a", 
+1005                             "data-ca", "end-a", "close"], 
+1006                            events) 
+1007   
+1008 -    def test_parser_target_fromstring_exception(self): 
+
1009          # ET doesn't call .close() on errors 
+1010          events = [] 
+1011          class Target(object): 
+1012              def start(self, tag, attrib): 
+1013                  events.append("start-" + tag) 
+
1014              def end(self, tag): 
+1015                  events.append("end-" + tag) 
+1016                  if tag == 'a': 
+1017                      raise ValueError("dead and gone") 
+1018              def data(self, data): 
+1019                  events.append("data-" + data) 
+1020              def close(self): 
+1021                  events.append("close") 
+1022                  return "DONE" 
+1023   
+1024          parser = self.etree.XMLParser(target=Target()) 
+1025   
+1026          try: 
+1027              done = self.etree.fromstring(_bytes('<root>A<a>ca</a>B</root>'), 
+1028                                           parser=parser) 
+1029              self.fail("error expected, but parsing succeeded") 
+1030          except ValueError: 
+1031              done = 'value error received as expected' 
+1032   
+1033          self.assertEqual(["start-root", "data-A", "start-a", 
+1034                            "data-ca", "end-a", "close"], 
+1035                           events) 
+1036   
+1037 -    def test_parser_target_feed_no_id_dict(self): 
+
1038          # test that target parsing works nicely with the no-id-hash setup 
+1039          events = [] 
+1040          class Target(object): 
+1041              def start(self, tag, attrib): 
+1042                  events.append("start-" + tag) 
+
1043              def end(self, tag): 
+1044                  events.append("end-" + tag) 
+1045              def data(self, data): 
+1046                  events.append("data-" + data) 
+1047              def comment(self, text): 
+1048                  events.append("comment-" + text) 
+1049              def close(self): 
+1050                  return "DONE" 
+1051   
+1052          parser = self.etree.XMLParser(target=Target(), collect_ids=False) 
+1053   
+1054          parser.feed(_bytes('<!--a--><root xml:id="123">A<!--b-->')) 
+1055          parser.feed(_bytes('<sub xml:id="321"/>B</root>')) 
+1056          done = parser.close() 
+1057   
+1058          self.assertEqual("DONE", done) 
+1059          self.assertEqual(["comment-a", "start-root", "data-A", "comment-b", 
+1060                            "start-sub", "end-sub", "data-B", "end-root"], 
+1061                           events) 
+1062   
+1063 -    def test_parser_target_comment(self): 
+
1064          events = [] 
+1065          class Target(object): 
+1066              def start(self, tag, attrib): 
+1067                  events.append("start-" + tag) 
+
1068              def end(self, tag): 
+1069                  events.append("end-" + tag) 
+1070              def data(self, data): 
+1071                  events.append("data-" + data) 
+1072              def comment(self, text): 
+1073                  events.append("comment-" + text) 
+1074              def close(self): 
+1075                  return "DONE" 
+1076   
+1077          parser = self.etree.XMLParser(target=Target()) 
+1078   
+1079          parser.feed(_bytes('<!--a--><root>A<!--b--><sub/><!--c-->B</root><!--d-->')) 
+1080          done = parser.close() 
+1081   
+1082          self.assertEqual("DONE", done) 
+1083          self.assertEqual(["comment-a", "start-root", "data-A", "comment-b", 
+1084                             "start-sub", "end-sub", "comment-c", "data-B", 
+1085                             "end-root", "comment-d"], 
+1086                            events) 
+1087   
+1088 -    def test_parser_target_pi(self): 
+
1089          events = [] 
+1090          class Target(object): 
+1091              def start(self, tag, attrib): 
+1092                  events.append("start-" + tag) 
+
1093              def end(self, tag): 
+1094                  events.append("end-" + tag) 
+1095              def data(self, data): 
+1096                  events.append("data-" + data) 
+1097              def pi(self, target, data): 
+1098                  events.append("pi-" + target + "-" + data) 
+1099              def close(self): 
+1100                  return "DONE" 
+1101   
+1102          parser = self.etree.XMLParser(target=Target()) 
+1103   
+1104          parser.feed(_bytes('<?test a?><root>A<?test b?>B</root><?test c?>')) 
+1105          done = parser.close() 
+1106   
+1107          self.assertEqual("DONE", done) 
+1108          self.assertEqual(["pi-test-a", "start-root", "data-A", "pi-test-b", 
+1109                             "data-B", "end-root", "pi-test-c"], 
+1110                            events) 
+1111   
+1112 -    def test_parser_target_cdata(self): 
+
1113          events = [] 
+1114          class Target(object): 
+1115              def start(self, tag, attrib): 
+1116                  events.append("start-" + tag) 
+
1117              def end(self, tag): 
+1118                  events.append("end-" + tag) 
+1119              def data(self, data): 
+1120                  events.append("data-" + data) 
+1121              def close(self): 
+1122                  return "DONE" 
+1123   
+1124          parser = self.etree.XMLParser(target=Target(), 
+1125                                        strip_cdata=False) 
+1126   
+1127          parser.feed(_bytes('<root>A<a><![CDATA[ca]]></a>B</root>')) 
+1128          done = parser.close() 
+1129   
+1130          self.assertEqual("DONE", done) 
+1131          self.assertEqual(["start-root", "data-A", "start-a", 
+1132                             "data-ca", "end-a", "data-B", "end-root"], 
+1133                            events) 
+1134   
+1135 -    def test_parser_target_recover(self): 
+
1136          events = [] 
+1137          class Target(object): 
+1138              def start(self, tag, attrib): 
+1139                  events.append("start-" + tag) 
+
1140              def end(self, tag): 
+1141                  events.append("end-" + tag) 
+1142              def data(self, data): 
+1143                  events.append("data-" + data) 
+1144              def close(self): 
+1145                  events.append("close") 
+1146                  return "DONE" 
+1147   
+1148          parser = self.etree.XMLParser(target=Target(), 
+1149                                        recover=True) 
+1150   
+1151          parser.feed(_bytes('<root>A<a>ca</a>B</not-root>')) 
+1152          done = parser.close() 
+1153   
+1154          self.assertEqual("DONE", done) 
+1155          self.assertEqual(["start-root", "data-A", "start-a", 
+1156                             "data-ca", "end-a", "data-B", 
+1157                             "end-root", "close"], 
+1158                            events) 
+1159   
+1160 -    def test_iterwalk_tag(self): 
+
1161          iterwalk = self.etree.iterwalk 
+1162          root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>')) 
+1163   
+1164          iterator = iterwalk(root, tag="b", events=('start', 'end')) 
+1165          events = list(iterator) 
+1166          self.assertEqual( 
+1167              [('start', root[0]), ('end', root[0])], 
+1168              events) 
+
1169   
+1170 -    def test_iterwalk_tag_all(self): 
+
1171          iterwalk = self.etree.iterwalk 
+1172          root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>')) 
+1173   
+1174          iterator = iterwalk(root, tag="*", events=('start', 'end')) 
+1175          events = list(iterator) 
+1176          self.assertEqual( 
+1177              8, 
+1178              len(events)) 
+
1179   
+1180 -    def test_iterwalk(self): 
+
1181          iterwalk = self.etree.iterwalk 
+1182          root = self.etree.XML(_bytes('<a><b></b><c/></a>')) 
+1183   
+1184          events = list(iterwalk(root)) 
+1185          self.assertEqual( 
+1186              [('end', root[0]), ('end', root[1]), ('end', root)], 
+1187              events) 
+
1188   
+1189 -    def test_iterwalk_comments_root_element(self): 
+
1190          iterwalk = self.etree.iterwalk 
+1191          root = self.etree.XML( 
+1192              b'<!--C0--><a><!--Ca--><b><!--Cb--></b><!--Cc--><c/></a><!--C99-->') 
+1193   
+1194          iterator = iterwalk(root, events=('start', 'end', 'comment')) 
+1195          events = list(iterator) 
+1196          self.assertEqual( 
+1197              [('start', root), ('comment', root[0]), 
+1198               ('start', root[1]), ('comment', root[1][0]), ('end', root[1]), 
+1199               ('comment', root[2]), ('start', root[3]), ('end', root[3]), 
+1200               ('end', root), 
+1201               ], 
+1202              events) 
+
1203   
+1204 -    def test_iterwalk_comments_tree(self): 
+
1205          iterwalk = self.etree.iterwalk 
+1206          root = self.etree.XML( 
+1207              b'<!--C0--><a><!--Ca--><b><!--Cb--></b><!--Cc--><c/></a><!--C99-->') 
+1208   
+1209          iterator = iterwalk(self.etree.ElementTree(root), events=('start', 'end', 'comment')) 
+1210          events = list(iterator) 
+1211          self.assertEqual( 
+1212              [('comment', root.getprevious()), 
+1213               ('start', root), ('comment', root[0]),  # <a> 
+1214               ('start', root[1]), ('comment', root[1][0]), ('end', root[1]),  # <b> 
+1215               ('comment', root[2]), ('start', root[3]), ('end', root[3]),  # <c> 
+1216               ('end', root), ('comment', root.getnext()), 
+1217               ], 
+1218              events) 
+
1219   
+1220 -    def test_iterwalk_pis_root_element(self): 
+
1221          iterwalk = self.etree.iterwalk 
+1222          root = self.etree.XML( 
+1223              b'<?C0?><a><?Ca?><b><?Cb?></b><?Cc?><c/></a><?C99?>') 
+1224   
+1225          iterator = iterwalk(root, events=('start', 'end', 'pi')) 
+1226          events = list(iterator) 
+1227          self.assertEqual( 
+1228              [('start', root), ('pi', root[0]), 
+1229               ('start', root[1]), ('pi', root[1][0]), ('end', root[1]), 
+1230               ('pi', root[2]), ('start', root[3]), ('end', root[3]), 
+1231               ('end', root), 
+1232               ], 
+1233              events) 
+
1234   
+1235 -    def test_iterwalk_pis_tree(self): 
+
1236          iterwalk = self.etree.iterwalk 
+1237          root = self.etree.XML( 
+1238              b'<?C0?><a><?Ca?><b><?Cb?></b><?Cc?><c/></a><?C99?>') 
+1239   
+1240          iterator = iterwalk(self.etree.ElementTree(root), events=('start', 'end', 'pi')) 
+1241          events = list(iterator) 
+1242          self.assertEqual( 
+1243              [('pi', root.getprevious()), 
+1244               ('start', root), ('pi', root[0]),  # <a> 
+1245               ('start', root[1]), ('pi', root[1][0]), ('end', root[1]),  # <b> 
+1246               ('pi', root[2]), ('start', root[3]), ('end', root[3]),  # <c> 
+1247               ('end', root), ('pi', root.getnext()), 
+1248               ], 
+1249              events) 
+
1250   
+1251 -    def test_iterwalk_pis_comments_tree(self): 
+
1252          iterwalk = self.etree.iterwalk 
+1253          root = self.etree.XML( 
+1254              b'<!--C0--><?C0?><!--C1--><a><?Ca?><b><!--Cb--></b><?Cc?><c/></a><!--C99--><?C99?>') 
+1255   
+1256          iterator = iterwalk(self.etree.ElementTree(root), events=('start', 'end', 'pi', 'comment')) 
+1257          events = list(iterator) 
+1258          self.assertEqual( 
+1259              [('comment', root.getprevious().getprevious().getprevious()), 
+1260               ('pi', root.getprevious().getprevious()), 
+1261               ('comment', root.getprevious()), 
+1262               ('start', root), ('pi', root[0]),  # <a> 
+1263               ('start', root[1]), ('comment', root[1][0]), ('end', root[1]),  # <b> 
+1264               ('pi', root[2]), ('start', root[3]), ('end', root[3]),  # <c> 
+1265               ('end', root), ('comment', root.getnext()), ('pi', root.getnext().getnext()), 
+1266               ], 
+1267              events) 
+
1268   
+1269 -    def test_iterwalk_pis_comments_tree_no_events(self): 
+
1270          iterwalk = self.etree.iterwalk 
+1271          root = self.etree.XML( 
+1272              b'<!--C0--><?C0?><!--C1--><a><?Ca?><b><!--Cb--></b><?Cc?><c/></a><!--C99--><?C99?>') 
+1273   
+1274          iterator = iterwalk(self.etree.ElementTree(root), events=('start', 'end')) 
+1275          events = list(iterator) 
+1276          self.assertEqual( 
+1277              [('start', root),  # <a> 
+1278               ('start', root[1]), ('end', root[1]),  # <b> 
+1279               ('start', root[3]), ('end', root[3]),  # <c> 
+1280               ('end', root), 
+1281               ], 
+1282              events) 
+
1283   
+1284 -    def test_iterwalk_start(self): 
+
1285          iterwalk = self.etree.iterwalk 
+1286          root = self.etree.XML(_bytes('<a><b></b><c/></a>')) 
+1287   
+1288          iterator = iterwalk(root, events=('start',)) 
+1289          events = list(iterator) 
+1290          self.assertEqual( 
+1291              [('start', root), ('start', root[0]), ('start', root[1])], 
+1292              events) 
+
1293   
+1294 -    def test_iterwalk_start_end(self): 
+
1295          iterwalk = self.etree.iterwalk 
+1296          root = self.etree.XML(_bytes('<a><b></b><c/></a>')) 
+1297   
+1298          iterator = iterwalk(root, events=('start','end')) 
+1299          events = list(iterator) 
+1300          self.assertEqual( 
+1301              [('start', root), ('start', root[0]), ('end', root[0]), 
+1302               ('start', root[1]), ('end', root[1]), ('end', root)], 
+1303              events) 
+
1304   
+1305 -    def test_iterwalk_start_tags(self): 
+
1306          iterwalk = self.etree.iterwalk 
+1307          root = self.etree.XML(_bytes('<a><b></b><c/><b><d/></b></a>')) 
+1308   
+1309          iterator = iterwalk(root, events=('start',), tag='b') 
+1310          events = list(iterator) 
+1311          self.assertEqual( 
+1312              [('start', root[0]), ('start', root[2])], 
+1313              events) 
+
1314   
+1315 -    def test_iterwalk_start_end_tags(self): 
+
1316          iterwalk = self.etree.iterwalk 
+1317          root = self.etree.XML(_bytes('<a><b></b><c/><b><d/></b></a>')) 
+1318   
+1319          iterator = iterwalk(root, events=('start', 'end'), tag='b') 
+1320          events = list(iterator) 
+1321          self.assertEqual( 
+1322              [('start', root[0]), ('end', root[0]), ('start', root[2]), ('end', root[2])], 
+1323              events) 
+
1324   
+1325 -    def test_iterwalk_start_end_tags_with_root(self): 
+
1326          iterwalk = self.etree.iterwalk 
+1327          root = self.etree.XML(_bytes('<a><b></b><c/><b><d/></b></a>')) 
+1328   
+1329          iterator = iterwalk(root, events=('start', 'end'), tag=('b', 'a')) 
+1330          events = list(iterator) 
+1331          self.assertEqual( 
+1332              [('start', root), 
+1333               ('start', root[0]), ('end', root[0]), 
+1334               ('start', root[2]), ('end', root[2]), 
+1335               ('end', root), 
+1336               ], 
+1337              events) 
+
1338   
+1339 -    def test_iterwalk_clear(self): 
+
1340          iterwalk = self.etree.iterwalk 
+1341          root = self.etree.XML(_bytes('<a><b></b><c/></a>')) 
+1342   
+1343          iterator = iterwalk(root) 
+1344          for event, elem in iterator: 
+1345              elem.clear() 
+1346   
+1347          self.assertEqual(0, 
+1348                            len(root)) 
+
1349   
+1350 -    def test_iterwalk_attrib_ns(self): 
+
1351          iterwalk = self.etree.iterwalk 
+1352          root = self.etree.XML(_bytes('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>')) 
+1353   
+1354          attr_name = '{testns}bla' 
+1355          events = [] 
+1356          iterator = iterwalk(root, events=('start','end','start-ns','end-ns')) 
+1357          for event, elem in iterator: 
+1358              events.append(event) 
+1359              if event == 'start': 
+1360                  if elem.tag != '{ns1}a': 
+1361                      elem.set(attr_name, 'value') 
+1362   
+1363          self.assertEqual( 
+1364              ['start-ns', 'start', 'start', 'start-ns', 'start', 
+1365               'end', 'end-ns', 'end', 'end', 'end-ns'], 
+1366              events) 
+1367   
+1368          self.assertEqual( 
+1369              None, 
+1370              root.get(attr_name)) 
+1371          self.assertEqual( 
+1372              'value', 
+1373              root[0].get(attr_name)) 
+
1374   
+1375 -    def test_iterwalk_end_skip(self): 
+
1376          iterwalk = self.etree.iterwalk 
+1377          root = self.etree.XML(_bytes('<a><b><c/></b><d><e/></d></a>')) 
+1378   
+1379          iterator = iterwalk(root) 
+1380          tags = [] 
+1381          for event, elem in iterator: 
+1382              tags.append(elem.tag) 
+1383              # requesting a skip after an 'end' event should never have an effect 
+1384              iterator.skip_subtree() 
+1385   
+1386          self.assertEqual(['c', 'b', 'e', 'd', 'a'], tags) 
+
1387   
+1388 -    def test_iterwalk_start_end_skip(self): 
+
1389          iterwalk = self.etree.iterwalk 
+1390          root = self.etree.XML(_bytes('<a><b><c/></b><d><e/></d></a>')) 
+1391   
+1392          iterator = iterwalk(root, events=('start', 'end')) 
+1393          tags = [] 
+1394          for event, elem in iterator: 
+1395              tags.append((event, elem.tag)) 
+1396              if elem.tag in ('b', 'e'): 
+1397                  # skipping should only have an effect on 'start', not on 'end' 
+1398                  iterator.skip_subtree() 
+1399   
+1400          self.assertEqual( 
+1401              [('start', 'a'), 
+1402               ('start', 'b'), ('end', 'b'),  # ignored child 'c' 
+1403               ('start', 'd'), 
+1404               ('start', 'e'), ('end', 'e'), 
+1405               ('end', 'd'), 
+1406               ('end', 'a')], 
+1407              tags) 
+
1408   
+1409 -    def test_iterwalk_ns_skip(self): 
+
1410          iterwalk = self.etree.iterwalk 
+1411          root = self.etree.XML(_bytes( 
+1412              '<a xmlns="ns1"><b xmlns="nsb"><c xmlns="ns2"/></b><d xmlns="ns2"><e/></d></a>')) 
+1413   
+1414          events = [] 
+1415          iterator = iterwalk(root, events=('start','start-ns','end-ns')) 
+1416          for event, elem in iterator: 
+1417              if event in ('start-ns', 'end-ns'): 
+1418                  events.append((event, elem)) 
+1419                  if event == 'start-ns' and elem == ('', 'nsb'): 
+1420                      events.append('skip') 
+1421                      iterator.skip_subtree() 
+1422              else: 
+1423                  events.append((event, elem.tag)) 
+1424   
+1425          self.assertEqual( 
+1426              [('start-ns', ('', 'ns1')), 
+1427               ('start', '{ns1}a'), 
+1428               ('start-ns', ('', 'nsb')), 
+1429               'skip', 
+1430               ('start', '{nsb}b'), 
+1431               ('end-ns', None), 
+1432               ('start-ns', ('', 'ns2')), 
+1433               ('start', '{ns2}d'), 
+1434               ('start', '{ns2}e'), 
+1435               ('end-ns', None), 
+1436               ('end-ns', None) 
+1437               ], 
+1438              events) 
+
1439   
+1440 -    def test_iterwalk_getiterator(self): 
+
1441          iterwalk = self.etree.iterwalk 
+1442          root = self.etree.XML(_bytes('<a><b><d/></b><c/></a>')) 
+1443   
+1444          counts = [] 
+1445          for event, elem in iterwalk(root): 
+1446              counts.append(len(list(elem.getiterator()))) 
+1447          self.assertEqual( 
+1448              [1,2,1,4], 
+1449              counts) 
+
1450   
+1451 -    def test_itertext_comment_pi(self): 
+
1452          # https://bugs.launchpad.net/lxml/+bug/1844674 
+1453          XML = self.etree.XML 
+1454          root = XML(_bytes( 
+1455              "<root>RTEXT<a></a>ATAIL<b/><!-- COMMENT -->CTAIL<?PI PITEXT?> PITAIL </root>" 
+1456          )) 
+1457   
+1458          text = list(root.itertext()) 
+1459          self.assertEqual(["RTEXT", "ATAIL", "CTAIL", " PITAIL "], 
+1460                            text) 
+
1461   
+1462 -    def test_resolve_string_dtd(self): 
+
1463          parse = self.etree.parse 
+1464          parser = self.etree.XMLParser(dtd_validation=True) 
+1465          assertEqual = self.assertEqual 
+1466          test_url = _str("__nosuch.dtd") 
+1467   
+1468          class MyResolver(self.etree.Resolver): 
+1469              def resolve(self, url, id, context): 
+1470                  assertEqual(url, test_url) 
+1471                  return self.resolve_string( 
+1472                      _str('''<!ENTITY myentity "%s"> 
+1473                          <!ELEMENT doc ANY>''') % url, context) 
+
1474   
+1475          parser.resolvers.add(MyResolver()) 
+1476   
+1477          xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 
+1478          tree = parse(StringIO(xml), parser) 
+1479          root = tree.getroot() 
+1480          self.assertEqual(root.text, test_url) 
+1481   
+1482 -    def test_resolve_bytes_dtd(self): 
+
1483          parse = self.etree.parse 
+1484          parser = self.etree.XMLParser(dtd_validation=True) 
+1485          assertEqual = self.assertEqual 
+1486          test_url = _str("__nosuch.dtd") 
+1487   
+1488          class MyResolver(self.etree.Resolver): 
+1489              def resolve(self, url, id, context): 
+1490                  assertEqual(url, test_url) 
+1491                  return self.resolve_string( 
+1492                      (_str('''<!ENTITY myentity "%s"> 
+1493                               <!ELEMENT doc ANY>''') % url).encode('utf-8'), 
+1494                      context) 
+
1495   
+1496          parser.resolvers.add(MyResolver()) 
+1497   
+1498          xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 
+1499          tree = parse(StringIO(xml), parser) 
+1500          root = tree.getroot() 
+1501          self.assertEqual(root.text, test_url) 
+1502   
+1503 -    def test_resolve_filelike_dtd(self): 
+
1504          parse = self.etree.parse 
+1505          parser = self.etree.XMLParser(dtd_validation=True) 
+1506          assertEqual = self.assertEqual 
+1507          test_url = _str("__nosuch.dtd") 
+1508   
+1509          class MyResolver(self.etree.Resolver): 
+1510              def resolve(self, url, id, context): 
+1511                  assertEqual(url, test_url) 
+1512                  return self.resolve_file( 
+1513                      SillyFileLike( 
+1514                          _str('''<!ENTITY myentity "%s"> 
+1515                          <!ELEMENT doc ANY>''') % url), context) 
+
1516   
+1517          parser.resolvers.add(MyResolver()) 
+1518   
+1519          xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 
+1520          tree = parse(StringIO(xml), parser) 
+1521          root = tree.getroot() 
+1522          self.assertEqual(root.text, test_url) 
+1523   
+1524 -    def test_resolve_filename_dtd(self): 
+
1525          parse = self.etree.parse 
+1526          parser = self.etree.XMLParser(attribute_defaults=True) 
+1527          assertEqual = self.assertEqual 
+1528          test_url = _str("__nosuch.dtd") 
+1529   
+1530          class MyResolver(self.etree.Resolver): 
+1531              def resolve(self, url, id, context): 
+1532                  assertEqual(url, test_url) 
+1533                  return self.resolve_filename( 
+1534                      fileInTestDir('test.dtd'), context) 
+
1535   
+1536          parser.resolvers.add(MyResolver()) 
+1537   
+1538          xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url 
+1539          tree = parse(StringIO(xml), parser) 
+1540          root = tree.getroot() 
+1541          self.assertEqual( 
+1542              root.attrib,    {'default': 'valueA'}) 
+1543          self.assertEqual( 
+1544              root[0].attrib, {'default': 'valueB'}) 
+1545   
+1546 -    def test_resolve_filename_dtd_relative(self): 
+
1547          parse = self.etree.parse 
+1548          parser = self.etree.XMLParser(attribute_defaults=True) 
+1549          assertEqual = self.assertEqual 
+1550          test_url = _str("__nosuch.dtd") 
+1551   
+1552          class MyResolver(self.etree.Resolver): 
+1553              def resolve(self, url, id, context): 
+1554                  expected = fileUrlInTestDir(test_url) 
+1555                  url = url.replace('file://', 'file:')  # depends on libxml2 version 
+1556                  expected = expected.replace('file://', 'file:') 
+1557                  assertEqual(url, expected) 
+1558                  return self.resolve_filename( 
+1559                      fileUrlInTestDir('test.dtd'), context) 
+
1560   
+1561          parser.resolvers.add(MyResolver()) 
+1562   
+1563          xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url 
+1564          tree = parse(StringIO(xml), parser, 
+1565                       base_url=fileUrlInTestDir('__test.xml')) 
+1566          root = tree.getroot() 
+1567          self.assertEqual( 
+1568              root.attrib,    {'default': 'valueA'}) 
+1569          self.assertEqual( 
+1570              root[0].attrib, {'default': 'valueB'}) 
+1571   
+1572 -    def test_resolve_file_dtd(self): 
+
1573          parse = self.etree.parse 
+1574          parser = self.etree.XMLParser(attribute_defaults=True) 
+1575          assertEqual = self.assertEqual 
+1576          test_url = _str("__nosuch.dtd") 
+1577   
+1578          class MyResolver(self.etree.Resolver): 
+1579              def resolve(self, url, id, context): 
+1580                  assertEqual(url, test_url) 
+1581                  return self.resolve_file( 
+1582                      open(fileInTestDir('test.dtd'), 'rb'), context) 
+
1583   
+1584          parser.resolvers.add(MyResolver()) 
+1585   
+1586          xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url 
+1587          tree = parse(StringIO(xml), parser) 
+1588          root = tree.getroot() 
+1589          self.assertEqual( 
+1590              root.attrib,    {'default': 'valueA'}) 
+1591          self.assertEqual( 
+1592              root[0].attrib, {'default': 'valueB'}) 
+1593   
+1594 -    def test_resolve_empty(self): 
+
1595          parse = self.etree.parse 
+1596          parser = self.etree.XMLParser(load_dtd=True) 
+1597          assertEqual = self.assertEqual 
+1598          test_url = _str("__nosuch.dtd") 
+1599   
+1600          class check(object): 
+1601              resolved = False 
+
1602   
+1603          class MyResolver(self.etree.Resolver): 
+1604              def resolve(self, url, id, context): 
+1605                  assertEqual(url, test_url) 
+1606                  check.resolved = True 
+1607                  return self.resolve_empty(context) 
+1608   
+1609          parser.resolvers.add(MyResolver()) 
+1610   
+1611          xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url 
+1612          self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser) 
+1613          self.assertTrue(check.resolved) 
+1614   
+1615 -    def test_resolve_error(self): 
+
1616          parse = self.etree.parse 
+1617          parser = self.etree.XMLParser(dtd_validation=True) 
+1618   
+1619          class _LocalException(Exception): 
+1620              pass 
+
1621   
+1622          class MyResolver(self.etree.Resolver): 
+1623              def resolve(self, url, id, context): 
+1624                  raise _LocalException 
+1625   
+1626          parser.resolvers.add(MyResolver()) 
+1627   
+1628          xml = '<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>' 
+1629          self.assertRaises(_LocalException, parse, BytesIO(xml), parser) 
+1630   
+1631 -    def test_entity_parse(self): 
+
1632          parse = self.etree.parse 
+1633          tostring = self.etree.tostring 
+1634          parser = self.etree.XMLParser(resolve_entities=False) 
+1635          Entity = self.etree.Entity 
+1636   
+1637          xml = _bytes('<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>') 
+1638          tree = parse(BytesIO(xml), parser) 
+1639          root = tree.getroot() 
+1640          self.assertEqual(root[0].tag, Entity) 
+1641          self.assertEqual(root[0].text, "&myentity;") 
+1642          self.assertEqual(root[0].tail, None) 
+1643          self.assertEqual(root[0].name, "myentity") 
+1644   
+1645          self.assertEqual(_bytes('<doc>&myentity;</doc>'), 
+1646                            tostring(root)) 
+
1647   
+1648 -    def test_entity_restructure(self): 
+
1649          xml = _bytes('''<!DOCTYPE root [ <!ENTITY nbsp "&#160;"> ]> 
+1650              <root> 
+1651                <child1/> 
+1652                <child2/> 
+1653                <child3>&nbsp;</child3> 
+1654              </root>''') 
+1655   
+1656          parser = self.etree.XMLParser(resolve_entities=False) 
+1657          root = etree.fromstring(xml, parser) 
+1658          self.assertEqual([ el.tag for el in root ], 
+1659                            ['child1', 'child2', 'child3']) 
+1660   
+1661          root[0] = root[-1] 
+1662          self.assertEqual([ el.tag for el in root ], 
+1663                            ['child3', 'child2']) 
+1664          self.assertEqual(root[0][0].text, '&nbsp;') 
+1665          self.assertEqual(root[0][0].name, 'nbsp') 
+
1666   
+1667 -    def test_entity_append(self): 
+
1668          Entity = self.etree.Entity 
+1669          Element = self.etree.Element 
+1670          tostring = self.etree.tostring 
+1671   
+1672          root = Element("root") 
+1673          root.append( Entity("test") ) 
+1674   
+1675          self.assertEqual(root[0].tag, Entity) 
+1676          self.assertEqual(root[0].text, "&test;") 
+1677          self.assertEqual(root[0].tail, None) 
+1678          self.assertEqual(root[0].name, "test") 
+1679   
+1680          self.assertEqual(_bytes('<root>&test;</root>'), 
+1681                            tostring(root)) 
+
1682   
+1683 -    def test_entity_append_parsed(self): 
+
1684          Entity = self.etree.Entity 
+1685          Element = self.etree.Element 
+1686          parser = self.etree.XMLParser(resolve_entities=False) 
+1687          entity = self.etree.XML('''<!DOCTYPE data [ 
+1688          <!ENTITY a "a"> 
+1689          <!ENTITY b "&a;"> 
+1690          ]> 
+1691          <data>&b;</data> 
+1692          ''', parser) 
+1693   
+1694          el = Element('test') 
+1695          el.append(entity) 
+1696          self.assertEqual(el.tag, 'test') 
+1697          self.assertEqual(el[0].tag, 'data') 
+1698          self.assertEqual(el[0][0].tag, Entity) 
+1699          self.assertEqual(el[0][0].name, 'b') 
+
1700   
+1701 -    def test_entity_values(self): 
+
1702          Entity = self.etree.Entity 
+1703          self.assertEqual(Entity("test").text, '&test;') 
+1704          self.assertEqual(Entity("#17683").text, '&#17683;') 
+1705          self.assertEqual(Entity("#x1768").text, '&#x1768;') 
+1706          self.assertEqual(Entity("#x98AF").text, '&#x98AF;') 
+
1707   
+1708 -    def test_entity_error(self): 
+
1709          Entity = self.etree.Entity 
+1710          self.assertRaises(ValueError, Entity, 'a b c') 
+1711          self.assertRaises(ValueError, Entity, 'a,b') 
+1712          self.assertRaises(ValueError, Entity, 'a\0b') 
+1713          self.assertRaises(ValueError, Entity, '#abc') 
+1714          self.assertRaises(ValueError, Entity, '#xxyz') 
+
1715   
+1716 -    def test_cdata(self): 
+
1717          CDATA = self.etree.CDATA 
+1718          Element = self.etree.Element 
+1719          tostring = self.etree.tostring 
+1720   
+1721          root = Element("root") 
+1722          root.text = CDATA('test') 
+1723   
+1724          self.assertEqual('test', 
+1725                            root.text) 
+1726          self.assertEqual(_bytes('<root><![CDATA[test]]></root>'), 
+1727                            tostring(root)) 
+
1728   
+1729 -    def test_cdata_tail(self): 
+
1730          CDATA = self.etree.CDATA 
+1731          Element = self.etree.Element 
+1732          SubElement = self.etree.SubElement 
+1733          tostring = self.etree.tostring 
+1734   
+1735          root = Element("root") 
+1736          child = SubElement(root, 'child') 
+1737          child.tail = CDATA('test') 
+1738   
+1739          self.assertEqual('test', child.tail) 
+1740          self.assertEqual(_bytes('<root><child/><![CDATA[test]]></root>'), 
+1741                           tostring(root)) 
+1742   
+1743          root = Element("root") 
+1744          root.tail = CDATA('test') 
+1745   
+1746          self.assertEqual('test', root.tail) 
+1747          self.assertEqual(_bytes('<root/><![CDATA[test]]>'), 
+1748                           tostring(root)) 
+
1749   
+1750 -    def test_cdata_type(self): 
+
1751          CDATA = self.etree.CDATA 
+1752          Element = self.etree.Element 
+1753          root = Element("root") 
+1754   
+1755          root.text = CDATA("test") 
+1756          self.assertEqual('test', root.text) 
+1757   
+1758          root.text = CDATA(_str("test")) 
+1759          self.assertEqual('test', root.text) 
+1760   
+1761          self.assertRaises(TypeError, CDATA, 1) 
+
1762   
+1763 -    def test_cdata_errors(self): 
+
1764          CDATA = self.etree.CDATA 
+1765          Element = self.etree.Element 
+1766   
+1767          root = Element("root") 
+1768          cdata = CDATA('test') 
+1769   
+1770          self.assertRaises(TypeError, 
+1771                            root.set, 'attr', cdata) 
+1772          self.assertRaises(TypeError, 
+1773                            operator.setitem, root.attrib, 'attr', cdata) 
+
1774   
+1775 -    def test_cdata_parser(self): 
+
1776          tostring = self.etree.tostring 
+1777          parser = self.etree.XMLParser(strip_cdata=False) 
+1778          root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser) 
+1779   
+1780          self.assertEqual('test', root.text) 
+1781          self.assertEqual(_bytes('<root><![CDATA[test]]></root>'), 
+1782                            tostring(root)) 
+
1783   
+1784 -    def test_cdata_xpath(self): 
+
1785          tostring = self.etree.tostring 
+1786          parser = self.etree.XMLParser(strip_cdata=False) 
+1787          root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser) 
+1788          self.assertEqual(_bytes('<root><![CDATA[test]]></root>'), 
+1789                            tostring(root)) 
+1790   
+1791          self.assertEqual(['test'], root.xpath('//text()')) 
+
1792   
+1793      # TypeError in etree, AssertionError in ElementTree; 
+1794 -    def test_setitem_assert(self): 
+
1795          Element = self.etree.Element 
+1796          SubElement = self.etree.SubElement 
+1797   
+1798          a = Element('a') 
+1799          b = SubElement(a, 'b') 
+1800           
+1801          self.assertRaises(TypeError, 
+1802                            a.__setitem__, 0, 'foo') 
+
1803   
+1804 -    def test_append_error(self): 
+
1805          Element = self.etree.Element 
+1806          root = Element('root') 
+1807          # raises AssertionError in ElementTree 
+1808          self.assertRaises(TypeError, root.append, None) 
+1809          self.assertRaises(TypeError, root.extend, [None]) 
+1810          self.assertRaises(TypeError, root.extend, [Element('one'), None]) 
+1811          self.assertEqual('one', root[0].tag) 
+
1812   
+1813 -    def test_append_recursive_error(self): 
+
1814          Element = self.etree.Element 
+1815          SubElement = self.etree.SubElement 
+1816          root = Element('root') 
+1817          self.assertRaises(ValueError, root.append, root) 
+1818          child = SubElement(root, 'child') 
+1819          self.assertRaises(ValueError, child.append, root) 
+1820          child2 = SubElement(child, 'child2') 
+1821          self.assertRaises(ValueError, child2.append, root) 
+1822          self.assertRaises(ValueError, child2.append, child) 
+1823          self.assertEqual('child2', root[0][0].tag) 
+
1824   
+1825 -    def test_addnext(self): 
+
1826          Element = self.etree.Element 
+1827          SubElement = self.etree.SubElement 
+1828          root = Element('root') 
+1829          SubElement(root, 'a') 
+1830          SubElement(root, 'b') 
+1831   
+1832          self.assertEqual(['a', 'b'], 
+1833                            [c.tag for c in root]) 
+1834          root[1].addnext(root[0]) 
+1835          self.assertEqual(['b', 'a'], 
+1836                            [c.tag for c in root]) 
+
1837   
+1838 -    def test_addprevious(self): 
+
1839          Element = self.etree.Element 
+1840          SubElement = self.etree.SubElement 
+1841          root = Element('root') 
+1842          SubElement(root, 'a') 
+1843          SubElement(root, 'b') 
+1844   
+1845          self.assertEqual(['a', 'b'], 
+1846                            [c.tag for c in root]) 
+1847          root[0].addprevious(root[1]) 
+1848          self.assertEqual(['b', 'a'], 
+1849                            [c.tag for c in root]) 
+
1850   
+1851 -    def test_addnext_cycle(self): 
+
1852          Element = self.etree.Element 
+1853          SubElement = self.etree.SubElement 
+1854          root = Element('root') 
+1855          a = SubElement(root, 'a') 
+1856          b = SubElement(a, 'b') 
+1857          # appending parent as sibling is forbidden 
+1858          self.assertRaises(ValueError, b.addnext, a) 
+1859          self.assertEqual(['a'], [c.tag for c in root]) 
+1860          self.assertEqual(['b'], [c.tag for c in a]) 
+
1861   
+1862 -    def test_addprevious_cycle(self): 
+
1863          Element = self.etree.Element 
+1864          SubElement = self.etree.SubElement 
+1865          root = Element('root') 
+1866          a = SubElement(root, 'a') 
+1867          b = SubElement(a, 'b') 
+1868          # appending parent as sibling is forbidden 
+1869          self.assertRaises(ValueError, b.addprevious, a) 
+1870          self.assertEqual(['a'], [c.tag for c in root]) 
+1871          self.assertEqual(['b'], [c.tag for c in a]) 
+
1872   
+1873 -    def test_addnext_cycle_long(self): 
+
1874          Element = self.etree.Element 
+1875          SubElement = self.etree.SubElement 
+1876          root = Element('root') 
+1877          a = SubElement(root, 'a') 
+1878          b = SubElement(a, 'b') 
+1879          c = SubElement(b, 'c') 
+1880          # appending parent as sibling is forbidden 
+1881          self.assertRaises(ValueError, c.addnext, a) 
+
1882   
+1883 -    def test_addprevious_cycle_long(self): 
+
1884          Element = self.etree.Element 
+1885          SubElement = self.etree.SubElement 
+1886          root = Element('root') 
+1887          a = SubElement(root, 'a') 
+1888          b = SubElement(a, 'b') 
+1889          c = SubElement(b, 'c') 
+1890          # appending parent as sibling is forbidden 
+1891          self.assertRaises(ValueError, c.addprevious, a) 
+
1892   
+1893 -    def test_addprevious_noops(self): 
+
1894          Element = self.etree.Element 
+1895          SubElement = self.etree.SubElement 
+1896          root = Element('root') 
+1897          a = SubElement(root, 'a') 
+1898          b = SubElement(root, 'b') 
+1899          a.addprevious(a) 
+1900          self.assertEqual('a', root[0].tag) 
+1901          self.assertEqual('b', root[1].tag) 
+1902          b.addprevious(b) 
+1903          self.assertEqual('a', root[0].tag) 
+1904          self.assertEqual('b', root[1].tag) 
+1905          b.addprevious(a) 
+1906          self.assertEqual('a', root[0].tag) 
+1907          self.assertEqual('b', root[1].tag) 
+
1908   
+1909 -    def test_addnext_noops(self): 
+
1910          Element = self.etree.Element 
+1911          SubElement = self.etree.SubElement 
+1912          root = Element('root') 
+1913          a = SubElement(root, 'a') 
+1914          b = SubElement(root, 'b') 
+1915          a.addnext(a) 
+1916          self.assertEqual('a', root[0].tag) 
+1917          self.assertEqual('b', root[1].tag) 
+1918          b.addnext(b) 
+1919          self.assertEqual('a', root[0].tag) 
+1920          self.assertEqual('b', root[1].tag) 
+1921          a.addnext(b) 
+1922          self.assertEqual('a', root[0].tag) 
+1923          self.assertEqual('b', root[1].tag) 
+
1924   
+1925 -    def test_addnext_root(self): 
+
1926          Element = self.etree.Element 
+1927          a = Element('a') 
+1928          b = Element('b') 
+1929          self.assertRaises(TypeError, a.addnext, b) 
+
1930   
+1931 -    def test_addprevious_pi(self): 
+
1932          Element = self.etree.Element 
+1933          SubElement = self.etree.SubElement 
+1934          PI = self.etree.PI 
+1935          root = Element('root') 
+1936          SubElement(root, 'a') 
+1937          pi = PI('TARGET', 'TEXT') 
+1938          pi.tail = "TAIL" 
+1939   
+1940          self.assertEqual(_bytes('<root><a></a></root>'), 
+1941                            self._writeElement(root)) 
+1942          root[0].addprevious(pi) 
+1943          self.assertEqual(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'), 
+1944                            self._writeElement(root)) 
+
1945   
+1946 -    def test_addprevious_root_pi(self): 
+
1947          Element = self.etree.Element 
+1948          PI = self.etree.PI 
+1949          root = Element('root') 
+1950          pi = PI('TARGET', 'TEXT') 
+1951          pi.tail = "TAIL" 
+1952   
+1953          self.assertEqual(_bytes('<root></root>'), 
+1954                            self._writeElement(root)) 
+1955          root.addprevious(pi) 
+1956          self.assertEqual(_bytes('<?TARGET TEXT?>\n<root></root>'), 
+1957                            self._writeElement(root)) 
+
1958   
+1959 -    def test_addnext_pi(self): 
+
1960          Element = self.etree.Element 
+1961          SubElement = self.etree.SubElement 
+1962          PI = self.etree.PI 
+1963          root = Element('root') 
+1964          SubElement(root, 'a') 
+1965          pi = PI('TARGET', 'TEXT') 
+1966          pi.tail = "TAIL" 
+1967   
+1968          self.assertEqual(_bytes('<root><a></a></root>'), 
+1969                            self._writeElement(root)) 
+1970          root[0].addnext(pi) 
+1971          self.assertEqual(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'), 
+1972                            self._writeElement(root)) 
+
1973   
+1974 -    def test_addnext_root_pi(self): 
+
1975          Element = self.etree.Element 
+1976          PI = self.etree.PI 
+1977          root = Element('root') 
+1978          pi = PI('TARGET', 'TEXT') 
+1979          pi.tail = "TAIL" 
+1980   
+1981          self.assertEqual(_bytes('<root></root>'), 
+1982                            self._writeElement(root)) 
+1983          root.addnext(pi) 
+1984          self.assertEqual(_bytes('<root></root>\n<?TARGET TEXT?>'), 
+1985                            self._writeElement(root)) 
+
1986   
+1987 -    def test_addnext_comment(self): 
+
1988          Element = self.etree.Element 
+1989          SubElement = self.etree.SubElement 
+1990          Comment = self.etree.Comment 
+1991          root = Element('root') 
+1992          SubElement(root, 'a') 
+1993          comment = Comment('TEXT ') 
+1994          comment.tail = "TAIL" 
+1995   
+1996          self.assertEqual(_bytes('<root><a></a></root>'), 
+1997                            self._writeElement(root)) 
+1998          root[0].addnext(comment) 
+1999          self.assertEqual(_bytes('<root><a></a><!--TEXT -->TAIL</root>'), 
+2000                            self._writeElement(root)) 
+
2001   
+2002 -    def test_addnext_root_comment(self): 
+
2003          Element = self.etree.Element 
+2004          Comment = self.etree.Comment 
+2005          root = Element('root') 
+2006          comment = Comment('TEXT ') 
+2007          comment.tail = "TAIL" 
+2008   
+2009          self.assertEqual(_bytes('<root></root>'), 
+2010                            self._writeElement(root)) 
+2011          root.addnext(comment) 
+2012          self.assertEqual(_bytes('<root></root>\n<!--TEXT -->'), 
+2013                            self._writeElement(root)) 
+
2014   
+2015 -    def test_addprevious_comment(self): 
+
2016          Element = self.etree.Element 
+2017          SubElement = self.etree.SubElement 
+2018          Comment = self.etree.Comment 
+2019          root = Element('root') 
+2020          SubElement(root, 'a') 
+2021          comment = Comment('TEXT ') 
+2022          comment.tail = "TAIL" 
+2023   
+2024          self.assertEqual(_bytes('<root><a></a></root>'), 
+2025                            self._writeElement(root)) 
+2026          root[0].addprevious(comment) 
+2027          self.assertEqual(_bytes('<root><!--TEXT -->TAIL<a></a></root>'), 
+2028                            self._writeElement(root)) 
+
2029   
+2030 -    def test_addprevious_root_comment(self): 
+
2031          Element = self.etree.Element 
+2032          Comment = self.etree.Comment 
+2033          root = Element('root') 
+2034          comment = Comment('TEXT ') 
+2035          comment.tail = "TAIL" 
+2036   
+2037          self.assertEqual(_bytes('<root></root>'), 
+2038                            self._writeElement(root)) 
+2039          root.addprevious(comment) 
+2040          self.assertEqual(_bytes('<!--TEXT -->\n<root></root>'), 
+2041                            self._writeElement(root)) 
+
2042   
+2043      # ET's Elements have items() and key(), but not values() 
+2044 -    def test_attribute_values(self): 
+
2045          XML = self.etree.XML 
+2046           
+2047          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
+2048          values = root.values() 
+2049          values.sort() 
+2050          self.assertEqual(['Alpha', 'Beta', 'Gamma'], values) 
+
2051   
+2052      # gives error in ElementTree 
+2053 -    def test_comment_empty(self): 
+
2054          Element = self.etree.Element 
+2055          Comment = self.etree.Comment 
+2056   
+2057          a = Element('a') 
+2058          a.append(Comment()) 
+2059          self.assertEqual( 
+2060              _bytes('<a><!----></a>'), 
+2061              self._writeElement(a)) 
+
2062   
+2063      # ElementTree ignores comments 
+2064 -    def test_comment_parse_empty(self): 
+
2065          ElementTree = self.etree.ElementTree 
+2066          tostring = self.etree.tostring 
+2067   
+2068          xml = _bytes('<a><b/><!----><c/></a>') 
+2069          f = BytesIO(xml) 
+2070          doc = ElementTree(file=f) 
+2071          a = doc.getroot() 
+2072          self.assertEqual( 
+2073              '', 
+2074              a[1].text) 
+2075          self.assertEqual( 
+2076              xml, 
+2077              tostring(a)) 
+
2078   
+2079      # ElementTree ignores comments 
+2080 -    def test_comment_no_proxy_yet(self): 
+
2081          ElementTree = self.etree.ElementTree 
+2082           
+2083          f = BytesIO('<a><b></b><!-- hoi --><c></c></a>') 
+2084          doc = ElementTree(file=f) 
+2085          a = doc.getroot() 
+2086          self.assertEqual( 
+2087              ' hoi ', 
+2088              a[1].text) 
+
2089   
+2090      # does not raise an exception in ElementTree 
+2091 -    def test_comment_immutable(self): 
+
2092          Element = self.etree.Element 
+2093          Comment = self.etree.Comment 
+2094   
+2095          c = Comment() 
+2096          el = Element('myel') 
+2097   
+2098          self.assertRaises(TypeError, c.append, el) 
+2099          self.assertRaises(TypeError, c.insert, 0, el) 
+2100          self.assertRaises(TypeError, c.set, "myattr", "test") 
+
2101   
+2102 -    def test_comment_immutable_attrib(self): 
+
2103          c = self.etree.Comment() 
+2104          self.assertEqual(0, len(c.attrib)) 
+2105   
+2106          self.assertFalse(c.attrib.__contains__('nope')) 
+2107          self.assertFalse('nope' in c.attrib) 
+2108          self.assertFalse('nope' in c.attrib.keys()) 
+2109          self.assertFalse('nope' in c.attrib.values()) 
+2110          self.assertFalse(('nope', 'huhu') in c.attrib.items()) 
+2111   
+2112          self.assertEqual([], list(c.attrib)) 
+2113          self.assertEqual([], list(c.attrib.keys())) 
+2114          self.assertEqual([], list(c.attrib.items())) 
+2115          self.assertEqual([], list(c.attrib.values())) 
+2116          self.assertEqual([], list(c.attrib.iterkeys())) 
+2117          self.assertEqual([], list(c.attrib.iteritems())) 
+2118          self.assertEqual([], list(c.attrib.itervalues())) 
+2119   
+2120          self.assertEqual('HUHU', c.attrib.pop('nope', 'HUHU')) 
+2121          self.assertRaises(KeyError, c.attrib.pop, 'nope') 
+2122   
+2123          self.assertRaises(KeyError, c.attrib.__getitem__, 'only') 
+2124          self.assertRaises(KeyError, c.attrib.__getitem__, 'names') 
+2125          self.assertRaises(KeyError, c.attrib.__getitem__, 'nope') 
+2126          self.assertRaises(KeyError, c.attrib.__setitem__, 'nope', 'yep') 
+2127          self.assertRaises(KeyError, c.attrib.__delitem__, 'nope') 
+
2128   
+2129      # test passing 'None' to dump() 
+2130 -    def test_dump_none(self): 
+
2131          self.assertRaises(TypeError, self.etree.dump, None) 
+
2132   
+2133 -    def test_prefix(self): 
+
2134          ElementTree = self.etree.ElementTree 
+2135           
+2136          f = BytesIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>') 
+2137          doc = ElementTree(file=f) 
+2138          a = doc.getroot() 
+2139          self.assertEqual( 
+2140              None, 
+2141              a.prefix) 
+2142          self.assertEqual( 
+2143              'foo', 
+2144              a[0].prefix) 
+
2145   
+2146 -    def test_prefix_default_ns(self): 
+
2147          ElementTree = self.etree.ElementTree 
+2148           
+2149          f = BytesIO('<a xmlns="http://www.infrae.com/ns/1"><b/></a>') 
+2150          doc = ElementTree(file=f) 
+2151          a = doc.getroot() 
+2152          self.assertEqual( 
+2153              None, 
+2154              a.prefix) 
+2155          self.assertEqual( 
+2156              None, 
+2157              a[0].prefix) 
+
2158   
+2159 -    def test_getparent(self): 
+
2160          Element = self.etree.Element 
+2161          SubElement = self.etree.SubElement 
+2162   
+2163          a = Element('a') 
+2164          b = SubElement(a, 'b') 
+2165          c = SubElement(a, 'c') 
+2166          d = SubElement(b, 'd') 
+2167          self.assertEqual( 
+2168              None, 
+2169              a.getparent()) 
+2170          self.assertEqual( 
+2171              a, 
+2172              b.getparent()) 
+2173          self.assertEqual( 
+2174              b.getparent(), 
+2175              c.getparent()) 
+2176          self.assertEqual( 
+2177              b, 
+2178              d.getparent()) 
+
2179   
+2180 -    def test_iterchildren(self): 
+
2181          XML = self.etree.XML 
+2182           
+2183          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
+2184          result = [] 
+2185          for el in root.iterchildren(): 
+2186              result.append(el.tag) 
+2187          self.assertEqual(['one', 'two', 'three'], result) 
+
2188   
+2189 -    def test_iterchildren_reversed(self): 
+
2190          XML = self.etree.XML 
+2191           
+2192          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
+2193          result = [] 
+2194          for el in root.iterchildren(reversed=True): 
+2195              result.append(el.tag) 
+2196          self.assertEqual(['three', 'two', 'one'], result) 
+
2197   
+2198 -    def test_iterchildren_tag(self): 
+
2199          XML = self.etree.XML 
+2200           
+2201          root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) 
+2202          result = [] 
+2203          for el in root.iterchildren(tag='two'): 
+2204              result.append(el.text) 
+2205          self.assertEqual(['Two', 'Bla'], result) 
+
2206   
+2207 -    def test_iterchildren_tag_posarg(self): 
+
2208          XML = self.etree.XML 
+2209   
+2210          root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) 
+2211          result = [] 
+2212          for el in root.iterchildren('two'): 
+2213              result.append(el.text) 
+2214          self.assertEqual(['Two', 'Bla'], result) 
+
2215   
+2216 -    def test_iterchildren_tag_reversed(self): 
+
2217          XML = self.etree.XML 
+2218           
+2219          root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')) 
+2220          result = [] 
+2221          for el in root.iterchildren(reversed=True, tag='two'): 
+2222              result.append(el.text) 
+2223          self.assertEqual(['Bla', 'Two'], result) 
+
2224   
+2225 -    def test_iterchildren_tag_multiple(self): 
+
2226          XML = self.etree.XML 
+2227   
+2228          root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two><three/></doc>')) 
+2229          result = [] 
+2230          for el in root.iterchildren(tag=['two', 'three']): 
+2231              result.append(el.text) 
+2232          self.assertEqual(['Two', 'Bla', None], result) 
+
2233   
+2234 -    def test_iterchildren_tag_multiple_posarg(self): 
+
2235          XML = self.etree.XML 
+2236   
+2237          root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two><three/></doc>')) 
+2238          result = [] 
+2239          for el in root.iterchildren('two', 'three'): 
+2240              result.append(el.text) 
+2241          self.assertEqual(['Two', 'Bla', None], result) 
+
2242   
+2243 -    def test_iterchildren_tag_multiple_reversed(self): 
+
2244          XML = self.etree.XML 
+2245   
+2246          root = XML(_bytes('<doc><one/><two>Two</two>Hm<two>Bla</two><three/></doc>')) 
+2247          result = [] 
+2248          for el in root.iterchildren(reversed=True, tag=['two', 'three']): 
+2249              result.append(el.text) 
+2250          self.assertEqual([None, 'Bla', 'Two'], result) 
+
2251   
+2252 -    def test_iterancestors(self): 
+
2253          Element    = self.etree.Element 
+2254          SubElement = self.etree.SubElement 
+2255   
+2256          a = Element('a') 
+2257          b = SubElement(a, 'b') 
+2258          c = SubElement(a, 'c') 
+2259          d = SubElement(b, 'd') 
+2260          self.assertEqual( 
+2261              [], 
+2262              list(a.iterancestors())) 
+2263          self.assertEqual( 
+2264              [a], 
+2265              list(b.iterancestors())) 
+2266          self.assertEqual( 
+2267              [a], 
+2268              list(c.iterancestors())) 
+2269          self.assertEqual( 
+2270              [b, a], 
+2271              list(d.iterancestors())) 
+
2272   
+2273 -    def test_iterancestors_tag(self): 
+
2274          Element    = self.etree.Element 
+2275          SubElement = self.etree.SubElement 
+2276   
+2277          a = Element('a') 
+2278          b = SubElement(a, 'b') 
+2279          c = SubElement(a, 'c') 
+2280          d = SubElement(b, 'd') 
+2281          self.assertEqual( 
+2282              [a], 
+2283              list(d.iterancestors('a'))) 
+2284          self.assertEqual( 
+2285              [a], 
+2286              list(d.iterancestors(tag='a'))) 
+2287   
+2288          self.assertEqual( 
+2289              [b, a], 
+2290              list(d.iterancestors('*'))) 
+2291          self.assertEqual( 
+2292              [b, a], 
+2293              list(d.iterancestors(tag='*'))) 
+
2294   
+2295 -    def test_iterancestors_tag_multiple(self): 
+
2296          Element    = self.etree.Element 
+2297          SubElement = self.etree.SubElement 
+2298   
+2299          a = Element('a') 
+2300          b = SubElement(a, 'b') 
+2301          c = SubElement(a, 'c') 
+2302          d = SubElement(b, 'd') 
+2303          self.assertEqual( 
+2304              [b, a], 
+2305              list(d.iterancestors(tag=('a', 'b')))) 
+2306          self.assertEqual( 
+2307              [b, a], 
+2308              list(d.iterancestors('a', 'b'))) 
+2309   
+2310          self.assertEqual( 
+2311              [], 
+2312              list(d.iterancestors(tag=('w', 'x', 'y', 'z')))) 
+2313          self.assertEqual( 
+2314              [], 
+2315              list(d.iterancestors('w', 'x', 'y', 'z'))) 
+2316   
+2317          self.assertEqual( 
+2318              [], 
+2319              list(d.iterancestors(tag=('d', 'x')))) 
+2320          self.assertEqual( 
+2321              [], 
+2322              list(d.iterancestors('d', 'x'))) 
+2323   
+2324          self.assertEqual( 
+2325              [b, a], 
+2326              list(d.iterancestors(tag=('b', '*')))) 
+2327          self.assertEqual( 
+2328              [b, a], 
+2329              list(d.iterancestors('b', '*'))) 
+2330   
+2331          self.assertEqual( 
+2332              [b], 
+2333              list(d.iterancestors(tag=('b', 'c')))) 
+2334          self.assertEqual( 
+2335              [b], 
+2336              list(d.iterancestors('b', 'c'))) 
+
2337   
+2338 -    def test_iterdescendants(self): 
+
2339          Element = self.etree.Element 
+2340          SubElement = self.etree.SubElement 
+2341   
+2342          a = Element('a') 
+2343          b = SubElement(a, 'b') 
+2344          c = SubElement(a, 'c') 
+2345          d = SubElement(b, 'd') 
+2346          e = SubElement(c, 'e') 
+2347   
+2348          self.assertEqual( 
+2349              [b, d, c, e], 
+2350              list(a.iterdescendants())) 
+2351          self.assertEqual( 
+2352              [], 
+2353              list(d.iterdescendants())) 
+
2354   
+2355 -    def test_iterdescendants_tag(self): 
+
2356          Element = self.etree.Element 
+2357          SubElement = self.etree.SubElement 
+2358   
+2359          a = Element('a') 
+2360          b = SubElement(a, 'b') 
+2361          c = SubElement(a, 'c') 
+2362          d = SubElement(b, 'd') 
+2363          e = SubElement(c, 'e') 
+2364   
+2365          self.assertEqual( 
+2366              [], 
+2367              list(a.iterdescendants('a'))) 
+2368          self.assertEqual( 
+2369              [], 
+2370              list(a.iterdescendants(tag='a'))) 
+2371   
+2372          a2 = SubElement(e, 'a') 
+2373          self.assertEqual( 
+2374              [a2], 
+2375              list(a.iterdescendants('a'))) 
+2376   
+2377          self.assertEqual( 
+2378              [a2], 
+2379              list(c.iterdescendants('a'))) 
+2380          self.assertEqual( 
+2381              [a2], 
+2382              list(c.iterdescendants(tag='a'))) 
+
2383   
+2384 -    def test_iterdescendants_tag_multiple(self): 
+
2385          Element = self.etree.Element 
+2386          SubElement = self.etree.SubElement 
+2387   
+2388          a = Element('a') 
+2389          b = SubElement(a, 'b') 
+2390          c = SubElement(a, 'c') 
+2391          d = SubElement(b, 'd') 
+2392          e = SubElement(c, 'e') 
+2393   
+2394          self.assertEqual( 
+2395              [b, e], 
+2396              list(a.iterdescendants(tag=('a', 'b', 'e')))) 
+2397          self.assertEqual( 
+2398              [b, e], 
+2399              list(a.iterdescendants('a', 'b', 'e'))) 
+2400   
+2401          a2 = SubElement(e, 'a') 
+2402          self.assertEqual( 
+2403              [b, a2], 
+2404              list(a.iterdescendants(tag=('a', 'b')))) 
+2405          self.assertEqual( 
+2406              [b, a2], 
+2407              list(a.iterdescendants('a', 'b'))) 
+2408   
+2409          self.assertEqual( 
+2410              [], 
+2411              list(c.iterdescendants(tag=('x', 'y', 'z')))) 
+2412          self.assertEqual( 
+2413              [], 
+2414              list(c.iterdescendants('x', 'y', 'z'))) 
+2415   
+2416          self.assertEqual( 
+2417              [b, d, c, e, a2], 
+2418              list(a.iterdescendants(tag=('x', 'y', 'z', '*')))) 
+2419          self.assertEqual( 
+2420              [b, d, c, e, a2], 
+2421              list(a.iterdescendants('x', 'y', 'z', '*'))) 
+
2422   
+2423 -    def test_getroottree(self): 
+
2424          Element = self.etree.Element 
+2425          SubElement = self.etree.SubElement 
+2426   
+2427          a = Element('a') 
+2428          b = SubElement(a, 'b') 
+2429          c = SubElement(a, 'c') 
+2430          d = SubElement(b, 'd') 
+2431          self.assertEqual( 
+2432              a, 
+2433              a.getroottree().getroot()) 
+2434          self.assertEqual( 
+2435              a, 
+2436              b.getroottree().getroot()) 
+2437          self.assertEqual( 
+2438              a, 
+2439              d.getroottree().getroot()) 
+
2440   
+2441 -    def test_getnext(self): 
+
2442          Element    = self.etree.Element 
+2443          SubElement = self.etree.SubElement 
+2444   
+2445          a = Element('a') 
+2446          b = SubElement(a, 'b') 
+2447          c = SubElement(a, 'c') 
+2448          self.assertEqual( 
+2449              None, 
+2450              a.getnext()) 
+2451          self.assertEqual( 
+2452              c, 
+2453              b.getnext()) 
+2454          self.assertEqual( 
+2455              None, 
+2456              c.getnext()) 
+
2457   
+2458 -    def test_getprevious(self): 
+
2459          Element    = self.etree.Element 
+2460          SubElement = self.etree.SubElement 
+2461   
+2462          a = Element('a') 
+2463          b = SubElement(a, 'b') 
+2464          c = SubElement(a, 'c') 
+2465          d = SubElement(b, 'd') 
+2466          self.assertEqual( 
+2467              None, 
+2468              a.getprevious()) 
+2469          self.assertEqual( 
+2470              b, 
+2471              c.getprevious()) 
+2472          self.assertEqual( 
+2473              None, 
+2474              b.getprevious()) 
+
2475   
+2476 -    def test_itersiblings(self): 
+
2477          Element    = self.etree.Element 
+2478          SubElement = self.etree.SubElement 
+2479   
+2480          a = Element('a') 
+2481          b = SubElement(a, 'b') 
+2482          c = SubElement(a, 'c') 
+2483          d = SubElement(b, 'd') 
+2484          self.assertEqual( 
+2485              [], 
+2486              list(a.itersiblings())) 
+2487          self.assertEqual( 
+2488              [c], 
+2489              list(b.itersiblings())) 
+2490          self.assertEqual( 
+2491              [], 
+2492              list(c.itersiblings())) 
+2493          self.assertEqual( 
+2494              [b], 
+2495              list(c.itersiblings(preceding=True))) 
+2496          self.assertEqual( 
+2497              [], 
+2498              list(b.itersiblings(preceding=True))) 
+
2499   
+2500 -    def test_itersiblings_tag(self): 
+
2501          Element    = self.etree.Element 
+2502          SubElement = self.etree.SubElement 
+2503   
+2504          a = Element('a') 
+2505          b = SubElement(a, 'b') 
+2506          c = SubElement(a, 'c') 
+2507          d = SubElement(b, 'd') 
+2508          self.assertEqual( 
+2509              [], 
+2510              list(a.itersiblings(tag='XXX'))) 
+2511          self.assertEqual( 
+2512              [c], 
+2513              list(b.itersiblings(tag='c'))) 
+2514          self.assertEqual( 
+2515              [c], 
+2516              list(b.itersiblings(tag='*'))) 
+2517          self.assertEqual( 
+2518              [b], 
+2519              list(c.itersiblings(preceding=True, tag='b'))) 
+2520          self.assertEqual( 
+2521              [], 
+2522              list(c.itersiblings(preceding=True, tag='c'))) 
+
2523   
+2524 -    def test_itersiblings_tag_multiple(self): 
+
2525          Element    = self.etree.Element 
+2526          SubElement = self.etree.SubElement 
+2527   
+2528          a = Element('a') 
+2529          b = SubElement(a, 'b') 
+2530          c = SubElement(a, 'c') 
+2531          d = SubElement(b, 'd') 
+2532          e = SubElement(a, 'e') 
+2533          self.assertEqual( 
+2534              [], 
+2535              list(a.itersiblings(tag=('XXX', 'YYY')))) 
+2536          self.assertEqual( 
+2537              [c, e], 
+2538              list(b.itersiblings(tag=('c', 'd', 'e')))) 
+2539          self.assertEqual( 
+2540              [b], 
+2541              list(c.itersiblings(preceding=True, tag=('b', 'b', 'c', 'd')))) 
+2542          self.assertEqual( 
+2543              [c, b], 
+2544              list(e.itersiblings(preceding=True, tag=('c', '*')))) 
+
2545   
+2546 -    def test_parseid(self): 
+
2547          parseid = self.etree.parseid 
+2548          XML     = self.etree.XML 
+2549          xml_text = _bytes(''' 
+2550          <!DOCTYPE document [ 
+2551          <!ELEMENT document (h1,p)*> 
+2552          <!ELEMENT h1 (#PCDATA)> 
+2553          <!ATTLIST h1 myid ID #REQUIRED> 
+2554          <!ELEMENT p  (#PCDATA)> 
+2555          <!ATTLIST p  someid ID #REQUIRED> 
+2556          ]> 
+2557          <document> 
+2558            <h1 myid="chapter1">...</h1> 
+2559            <p id="note1" class="note">...</p> 
+2560            <p>Regular paragraph.</p> 
+2561            <p xml:id="xmlid">XML:ID paragraph.</p> 
+2562            <p someid="warn1" class="warning">...</p> 
+2563          </document> 
+2564          ''') 
+2565   
+2566          tree, dic = parseid(BytesIO(xml_text)) 
+2567          root = tree.getroot() 
+2568          root2 = XML(xml_text) 
+2569          self.assertEqual(self._writeElement(root), 
+2570                            self._writeElement(root2)) 
+2571          expected = { 
+2572              "chapter1" : root[0], 
+2573              "xmlid"    : root[3], 
+2574              "warn1"    : root[4] 
+2575              } 
+2576          self.assertTrue("chapter1" in dic) 
+2577          self.assertTrue("warn1" in dic) 
+2578          self.assertTrue("xmlid" in dic) 
+2579          self._checkIDDict(dic, expected) 
+
2580   
+2581 -    def test_XMLDTDID(self): 
+
2582          XMLDTDID = self.etree.XMLDTDID 
+2583          XML      = self.etree.XML 
+2584          xml_text = _bytes(''' 
+2585          <!DOCTYPE document [ 
+2586          <!ELEMENT document (h1,p)*> 
+2587          <!ELEMENT h1 (#PCDATA)> 
+2588          <!ATTLIST h1 myid ID #REQUIRED> 
+2589          <!ELEMENT p  (#PCDATA)> 
+2590          <!ATTLIST p  someid ID #REQUIRED> 
+2591          ]> 
+2592          <document> 
+2593            <h1 myid="chapter1">...</h1> 
+2594            <p id="note1" class="note">...</p> 
+2595            <p>Regular paragraph.</p> 
+2596            <p xml:id="xmlid">XML:ID paragraph.</p> 
+2597            <p someid="warn1" class="warning">...</p> 
+2598          </document> 
+2599          ''') 
+2600   
+2601          root, dic = XMLDTDID(xml_text) 
+2602          root2 = XML(xml_text) 
+2603          self.assertEqual(self._writeElement(root), 
+2604                            self._writeElement(root2)) 
+2605          expected = { 
+2606              "chapter1" : root[0], 
+2607              "xmlid"    : root[3], 
+2608              "warn1"    : root[4] 
+2609              } 
+2610          self.assertTrue("chapter1" in dic) 
+2611          self.assertTrue("warn1" in dic) 
+2612          self.assertTrue("xmlid" in dic) 
+2613          self._checkIDDict(dic, expected) 
+
2614   
+2615 -    def test_XMLDTDID_empty(self): 
+
2616          XMLDTDID = self.etree.XMLDTDID 
+2617          XML      = self.etree.XML 
+2618          xml_text = _bytes(''' 
+2619          <document> 
+2620            <h1 myid="chapter1">...</h1> 
+2621            <p id="note1" class="note">...</p> 
+2622            <p>Regular paragraph.</p> 
+2623            <p someid="warn1" class="warning">...</p> 
+2624          </document> 
+2625          ''') 
+2626   
+2627          root, dic = XMLDTDID(xml_text) 
+2628          root2 = XML(xml_text) 
+2629          self.assertEqual(self._writeElement(root), 
+2630                            self._writeElement(root2)) 
+2631          expected = {} 
+2632          self._checkIDDict(dic, expected) 
+
2633   
+2634 -    def test_XMLDTDID_no_id_dict(self): 
+
2635          XMLDTDID = self.etree.XMLDTDID 
+2636          XML      = self.etree.XML 
+2637          xml_text = _bytes(''' 
+2638          <!DOCTYPE document [ 
+2639          <!ELEMENT document (h1,p)*> 
+2640          <!ELEMENT h1 (#PCDATA)> 
+2641          <!ATTLIST h1 myid ID #REQUIRED> 
+2642          <!ELEMENT p  (#PCDATA)> 
+2643          <!ATTLIST p  someid ID #REQUIRED> 
+2644          ]> 
+2645          <document> 
+2646            <h1 myid="chapter1">...</h1> 
+2647            <p id="note1" class="note">...</p> 
+2648            <p>Regular paragraph.</p> 
+2649            <p xml:id="xmlid">XML:ID paragraph.</p> 
+2650            <p someid="warn1" class="warning">...</p> 
+2651          </document> 
+2652          ''') 
+2653   
+2654          parser = etree.XMLParser(collect_ids=False) 
+2655          root, dic = XMLDTDID(xml_text, parser=parser) 
+2656          root2 = XML(xml_text) 
+2657          self.assertEqual(self._writeElement(root), 
+2658                           self._writeElement(root2)) 
+2659          self.assertFalse(dic) 
+2660          self._checkIDDict(dic, {}) 
+
2661   
+2662 -    def _checkIDDict(self, dic, expected): 
+
2663          self.assertEqual(len(dic), 
+2664                            len(expected)) 
+2665          self.assertEqual(sorted(dic.items()), 
+2666                            sorted(expected.items())) 
+2667          if sys.version_info < (3,): 
+2668              self.assertEqual(sorted(dic.iteritems()), 
+2669                                sorted(expected.iteritems())) 
+2670          self.assertEqual(sorted(dic.keys()), 
+2671                            sorted(expected.keys())) 
+2672          if sys.version_info < (3,): 
+2673              self.assertEqual(sorted(dic.iterkeys()), 
+2674                                sorted(expected.iterkeys())) 
+2675          if sys.version_info < (3,): 
+2676              self.assertEqual(sorted(dic.values()), 
+2677                                sorted(expected.values())) 
+2678              self.assertEqual(sorted(dic.itervalues()), 
+2679                                sorted(expected.itervalues())) 
+
2680   
+2681 -    def test_register_namespace_xml(self): 
+
2682          self.assertRaises(ValueError, self.etree.register_namespace, 
+2683                            "XML", "http://www.w3.org/XML/1998/namespace") 
+2684          self.assertRaises(ValueError, self.etree.register_namespace, 
+2685                            "xml", "http://www.w3.org/XML/2345") 
+2686          self.etree.register_namespace("xml", "http://www.w3.org/XML/1998/namespace")  # ok 
+
2687   
+2688 -    def test_namespaces(self): 
+
2689          etree = self.etree 
+2690   
+2691          r = {'foo': 'http://ns.infrae.com/foo'} 
+2692          e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 
+2693          self.assertEqual( 
+2694              'foo', 
+2695              e.prefix) 
+2696          self.assertEqual( 
+2697              _bytes('<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>'), 
+2698              self._writeElement(e)) 
+
2699           
+2700 -    def test_namespaces_default(self): 
+
2701          etree = self.etree 
+2702   
+2703          r = {None: 'http://ns.infrae.com/foo'} 
+2704          e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 
+2705          self.assertEqual( 
+2706              None, 
+2707              e.prefix) 
+2708          self.assertEqual( 
+2709              '{http://ns.infrae.com/foo}bar', 
+2710              e.tag) 
+2711          self.assertEqual( 
+2712              _bytes('<bar xmlns="http://ns.infrae.com/foo"></bar>'), 
+2713              self._writeElement(e)) 
+
2714   
+2715 -    def test_namespaces_default_and_other(self): 
+
2716          etree = self.etree 
+2717   
+2718          r = {None: 'http://ns.infrae.com/foo', 'p': 'http://test/'} 
+2719          e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 
+2720          self.assertEqual(None, e.prefix) 
+2721          self.assertEqual('{http://ns.infrae.com/foo}bar', e.tag) 
+2722          self.assertEqual( 
+2723              _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:p="http://test/"></bar>'), 
+2724              self._writeElement(e)) 
+
2725   
+2726 -    def test_namespaces_default_and_attr(self): 
+
2727          etree = self.etree 
+2728   
+2729          r = {None: 'http://ns.infrae.com/foo', 
+2730               'hoi': 'http://ns.infrae.com/hoi'} 
+2731          e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 
+2732          e.set('{http://ns.infrae.com/hoi}test', 'value') 
+2733          self.assertEqual( 
+2734              _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>'), 
+2735              self._writeElement(e)) 
+
2736   
+2737 -    def test_attribute_keeps_namespace_prefix_on_merge(self): 
+
2738          etree = self.etree 
+2739   
+2740          root = etree.Element('{http://test/ns}root', 
+2741                               nsmap={None: 'http://test/ns'}) 
+2742          sub = etree.Element('{http://test/ns}sub', 
+2743                              nsmap={'test': 'http://test/ns'}) 
+2744   
+2745          sub.attrib['{http://test/ns}attr'] = 'value' 
+2746          self.assertEqual(sub.attrib['{http://test/ns}attr'], 'value') 
+2747          self.assertEqual( 
+2748              _bytes('<test:sub xmlns:test="http://test/ns" test:attr="value"/>'), 
+2749              etree.tostring(sub)) 
+2750   
+2751          root.append(sub) 
+2752          self.assertEqual( 
+2753              _bytes('<root xmlns="http://test/ns">' 
+2754                     '<sub xmlns:test="http://test/ns" test:attr="value"/>' 
+2755                     '</root>'), 
+2756              etree.tostring(root)) 
+
2757   
+2758 -    def test_attribute_keeps_namespace_prefix_on_merge_with_nons(self): 
+
2759          etree = self.etree 
+2760   
+2761          root = etree.Element('root') 
+2762          sub = etree.Element('{http://test/ns}sub', 
+2763                              nsmap={'test': 'http://test/ns'}) 
+2764   
+2765          sub.attrib['{http://test/ns}attr'] = 'value' 
+2766          self.assertEqual(sub.attrib['{http://test/ns}attr'], 'value') 
+2767          self.assertEqual( 
+2768              _bytes('<test:sub xmlns:test="http://test/ns" test:attr="value"/>'), 
+2769              etree.tostring(sub)) 
+2770   
+2771          root.append(sub) 
+2772          self.assertEqual( 
+2773              _bytes('<root>' 
+2774                     '<test:sub xmlns:test="http://test/ns" test:attr="value"/>' 
+2775                     '</root>'), 
+2776              etree.tostring(root)) 
+
2777   
+2778 -    def test_attribute_gets_namespace_prefix_on_merge_with_nons(self): 
+
2779          etree = self.etree 
+2780   
+2781          root = etree.Element('root') 
+2782          sub = etree.Element('{http://test/ns}sub', 
+2783                              nsmap={None: 'http://test/ns'}) 
+2784   
+2785          sub.attrib['{http://test/ns}attr'] = 'value' 
+2786          self.assertEqual(sub.attrib['{http://test/ns}attr'], 'value') 
+2787          self.assertEqual( 
+2788              _bytes('<sub xmlns="http://test/ns" ' 
+2789                     'xmlns:ns0="http://test/ns" ns0:attr="value"/>'), 
+2790              etree.tostring(sub)) 
+2791   
+2792          root.append(sub) 
+2793          self.assertEqual( 
+2794              _bytes('<root>' 
+2795                     '<sub xmlns="http://test/ns"' 
+2796                     ' xmlns:ns0="http://test/ns" ns0:attr="value"/>' 
+2797                     '</root>'), 
+2798              etree.tostring(root)) 
+
2799   
+2800 -    def test_attribute_gets_namespace_prefix_on_merge(self): 
+
2801          etree = self.etree 
+2802   
+2803          root = etree.Element('{http://test/ns}root', 
+2804                               nsmap={'test': 'http://test/ns', 
+2805                                      None: 'http://test/ns'}) 
+2806          sub = etree.Element('{http://test/ns}sub', 
+2807                              nsmap={None: 'http://test/ns'}) 
+2808   
+2809          sub.attrib['{http://test/ns}attr'] = 'value' 
+2810          self.assertEqual(sub.attrib['{http://test/ns}attr'], 'value') 
+2811          self.assertEqual( 
+2812              _bytes('<sub xmlns="http://test/ns" ' 
+2813                     'xmlns:ns0="http://test/ns" ns0:attr="value"/>'), 
+2814              etree.tostring(sub)) 
+2815   
+2816          root.append(sub) 
+2817          self.assertEqual( 
+2818              _bytes('<test:root xmlns:test="http://test/ns" xmlns="http://test/ns">' 
+2819                     '<test:sub test:attr="value"/>' 
+2820                     '</test:root>'), 
+2821              etree.tostring(root)) 
+
2822   
+2823 -    def test_namespaces_elementtree(self): 
+
2824          etree = self.etree 
+2825          r = {None: 'http://ns.infrae.com/foo', 
+2826               'hoi': 'http://ns.infrae.com/hoi'}  
+2827          e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r) 
+2828          tree = etree.ElementTree(element=e) 
+2829          etree.SubElement(e, '{http://ns.infrae.com/hoi}x') 
+2830          self.assertEqual( 
+2831              _bytes('<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>'), 
+2832              self._writeElement(e)) 
+
2833   
+2834 -    def test_namespaces_default_copy_element(self): 
+
2835          etree = self.etree 
+2836   
+2837          r = {None: 'http://ns.infrae.com/foo'} 
+2838          e1 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 
+2839          e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 
+2840   
+2841          e1.append(e2) 
+2842   
+2843          self.assertEqual( 
+2844              None, 
+2845              e1.prefix) 
+2846          self.assertEqual( 
+2847              None, 
+2848              e1[0].prefix) 
+2849          self.assertEqual( 
+2850              '{http://ns.infrae.com/foo}bar', 
+2851              e1.tag) 
+2852          self.assertEqual( 
+2853              '{http://ns.infrae.com/foo}bar', 
+2854              e1[0].tag) 
+
2855   
+2856 -    def test_namespaces_copy_element(self): 
+
2857          etree = self.etree 
+2858   
+2859          r = {None: 'http://ns.infrae.com/BAR'} 
+2860          e1 = etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r) 
+2861          e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 
+2862   
+2863          e1.append(e2) 
+2864   
+2865          self.assertEqual( 
+2866              None, 
+2867              e1.prefix) 
+2868          self.assertNotEqual( 
+2869              None, 
+2870              e2.prefix) 
+2871          self.assertEqual( 
+2872              '{http://ns.infrae.com/BAR}bar', 
+2873              e1.tag) 
+2874          self.assertEqual( 
+2875              '{http://ns.infrae.com/foo}bar', 
+2876              e2.tag) 
+
2877   
+2878 -    def test_namespaces_reuse_after_move(self): 
+
2879          ns_href = "http://a.b.c" 
+2880          one = self.etree.fromstring( 
+2881              _bytes('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 
+2882          baz = one[0][0] 
+2883   
+2884          two = self.etree.fromstring( 
+2885              _bytes('<root xmlns:ns="%s"/>' % ns_href)) 
+2886          two.append(baz) 
+2887          del one # make sure the source document is deallocated 
+2888   
+2889          self.assertEqual('{%s}baz' % ns_href, baz.tag) 
+2890          self.assertEqual( 
+2891              _bytes('<root xmlns:ns="%s"><ns:baz/></root>' % ns_href), 
+2892              self.etree.tostring(two)) 
+
2893   
+2894 -    def test_namespace_cleanup(self): 
+
2895          xml = _bytes( 
+2896              '<foo xmlns="F" xmlns:x="x">' 
+2897              '<bar xmlns:ns="NS" xmlns:b="b" xmlns="B">' 
+2898              '<ns:baz/>' 
+2899              '</bar></foo>' 
+2900          ) 
+2901          root = self.etree.fromstring(xml) 
+2902          self.assertEqual(xml, self.etree.tostring(root)) 
+2903          self.etree.cleanup_namespaces(root) 
+2904          self.assertEqual( 
+2905              _bytes('<foo xmlns="F"><bar xmlns:ns="NS" xmlns="B"><ns:baz/></bar></foo>'), 
+2906              self.etree.tostring(root)) 
+
2907   
+2908 -    def test_namespace_cleanup_attributes(self): 
+
2909          xml = _bytes( 
+2910              '<foo xmlns="F" xmlns:x="X" xmlns:a="A">' 
+2911              '<bar xmlns:ns="NS" xmlns:b="b" xmlns="B">' 
+2912              '<ns:baz a:test="attr"/>' 
+2913              '</bar></foo>' 
+2914          ) 
+2915          root = self.etree.fromstring(xml) 
+2916          self.assertEqual(xml, self.etree.tostring(root)) 
+2917          self.etree.cleanup_namespaces(root) 
+2918          self.assertEqual( 
+2919              _bytes('<foo xmlns="F" xmlns:a="A">' 
+2920                     '<bar xmlns:ns="NS" xmlns="B">' 
+2921                     '<ns:baz a:test="attr"/>' 
+2922                     '</bar></foo>'), 
+2923              self.etree.tostring(root)) 
+
2924   
+2925 -    def test_namespace_cleanup_many(self): 
+
2926          xml = ('<n12:foo ' + 
+2927                 ' '.join('xmlns:n{n}="NS{n}"'.format(n=i) for i in range(100)) + 
+2928                 '><n68:a/></n12:foo>').encode('utf8') 
+2929          root = self.etree.fromstring(xml) 
+2930          self.assertEqual(xml, self.etree.tostring(root)) 
+2931          self.etree.cleanup_namespaces(root) 
+2932          self.assertEqual( 
+2933              b'<n12:foo xmlns:n12="NS12" xmlns:n68="NS68"><n68:a/></n12:foo>', 
+2934              self.etree.tostring(root)) 
+
2935   
+2936 -    def test_namespace_cleanup_deep(self): 
+
2937          xml = ('<root>' + 
+2938                 ''.join('<a xmlns:n{n}="NS{n}">'.format(n=i) for i in range(100)) + 
+2939                 '<n64:x/>' + '</a>'*100 + '</root>').encode('utf8') 
+2940          root = self.etree.fromstring(xml) 
+2941          self.assertEqual(xml, self.etree.tostring(root)) 
+2942          self.etree.cleanup_namespaces(root) 
+2943          self.assertEqual( 
+2944              b'<root>' + b'<a>'*64 + b'<a xmlns:n64="NS64">' + b'<a>'*35 + 
+2945              b'<n64:x/>' + b'</a>'*100 + b'</root>', 
+2946              self.etree.tostring(root)) 
+
2947   
+2948 -    def test_namespace_cleanup_deep_to_top(self): 
+
2949          xml = ('<root>' + 
+2950                 ''.join('<a xmlns:n{n}="NS{n}">'.format(n=i) for i in range(100)) + 
+2951                 '<n64:x xmlns:a="A" a:attr="X"/>' + 
+2952                 '</a>'*100 + 
+2953                 '</root>').encode('utf8') 
+2954          root = self.etree.fromstring(xml) 
+2955          self.assertEqual(xml, self.etree.tostring(root)) 
+2956          self.etree.cleanup_namespaces(root, top_nsmap={'n64': 'NS64'}) 
+2957          self.assertEqual( 
+2958              b'<root xmlns:n64="NS64">' + b'<a>'*100 + 
+2959              b'<n64:x xmlns:a="A" a:attr="X"/>' + b'</a>'*100 + b'</root>', 
+2960              self.etree.tostring(root)) 
+
2961   
+2962 -    def test_namespace_cleanup_keep_prefixes(self): 
+
2963          xml = ('<root xmlns:n64="NS64" xmlns:foo="FOO" xmlns:unused1="UNUSED" xmlns:no="NO">' 
+2964                 '<a xmlns:unused2="UNUSED"><n64:x xmlns:a="A" a:attr="X"/></a>' 
+2965                 '<foo>foo:bar</foo>' 
+2966                 '</root>').encode('utf8') 
+2967          root = self.etree.fromstring(xml) 
+2968          self.assertEqual(xml, self.etree.tostring(root)) 
+2969          self.etree.cleanup_namespaces(root, keep_ns_prefixes=['foo']) 
+2970          self.assertEqual( 
+2971              b'<root xmlns:n64="NS64" xmlns:foo="FOO">' 
+2972              b'<a><n64:x xmlns:a="A" a:attr="X"/></a>' 
+2973              b'<foo>foo:bar</foo>' 
+2974              b'</root>', 
+2975              self.etree.tostring(root)) 
+
2976   
+2977 -    def test_namespace_cleanup_keep_prefixes_top(self): 
+
2978          xml = ('<root xmlns:n64="NS64" xmlns:unused1="UNUSED" xmlns:no="NO">' 
+2979                 '<sub xmlns:foo="FOO">' 
+2980                 '<a xmlns:unused2="UNUSED"><n64:x xmlns:a="A" a:attr="X"/></a>' 
+2981                 '<foo>foo:bar</foo>' 
+2982                 '</sub>' 
+2983                 '</root>').encode('utf8') 
+2984          root = self.etree.fromstring(xml) 
+2985          self.assertEqual(xml, self.etree.tostring(root)) 
+2986          self.etree.cleanup_namespaces( 
+2987              root, 
+2988              top_nsmap={'foo': 'FOO', 'unused1': 'UNUSED'}, 
+2989              keep_ns_prefixes=['foo']) 
+2990          self.assertEqual( 
+2991              b'<root xmlns:n64="NS64" xmlns:foo="FOO">' 
+2992              b'<sub>' 
+2993              b'<a><n64:x xmlns:a="A" a:attr="X"/></a>' 
+2994              b'<foo>foo:bar</foo>' 
+2995              b'</sub>' 
+2996              b'</root>', 
+2997              self.etree.tostring(root)) 
+
2998   
+2999 -    def test_element_nsmap(self): 
+
3000          etree = self.etree 
+3001   
+3002          r = {None: 'http://ns.infrae.com/foo', 
+3003               'hoi': 'http://ns.infrae.com/hoi'} 
+3004          e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r) 
+3005          self.assertEqual( 
+3006              r, 
+3007              e.nsmap) 
+
3008   
+3009 -    def test_subelement_nsmap(self): 
+
3010          etree = self.etree 
+3011   
+3012          re = {None: 'http://ns.infrae.com/foo', 
+3013               'hoi': 'http://ns.infrae.com/hoi'} 
+3014          e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re) 
+3015   
+3016          rs = {None: 'http://ns.infrae.com/honk', 
+3017               'top': 'http://ns.infrae.com/top'} 
+3018          s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs) 
+3019   
+3020          r = re.copy() 
+3021          r.update(rs) 
+3022          self.assertEqual(re, e.nsmap) 
+3023          self.assertEqual(r,  s.nsmap) 
+
3024   
+3025 -    def test_html_prefix_nsmap(self): 
+
3026          etree = self.etree 
+3027          el = etree.HTML('<hha:page-description>aa</hha:page-description>').find('.//page-description') 
+3028          self.assertEqual({'hha': None}, el.nsmap) 
+
3029   
+3030 -    def test_getiterator_filter_multiple(self): 
+
3031          Element = self.etree.Element 
+3032          SubElement = self.etree.SubElement 
+3033   
+3034          a = Element('a') 
+3035          b = SubElement(a, 'b') 
+3036          c = SubElement(a, 'c') 
+3037          d = SubElement(b, 'd') 
+3038          e = SubElement(c, 'e') 
+3039          f = SubElement(c, 'f') 
+3040   
+3041          self.assertEqual( 
+3042              [a, b], 
+3043                 list(a.getiterator('a', 'b'))) 
+3044          self.assertEqual( 
+3045              [], 
+3046                list(a.getiterator('x', 'y'))) 
+3047          self.assertEqual( 
+3048              [a, f], 
+3049                list(a.getiterator('f', 'a'))) 
+3050          self.assertEqual( 
+3051              [c, e, f], 
+3052                 list(c.getiterator('c', '*', 'a'))) 
+3053          self.assertEqual( 
+3054              [], 
+3055                    list(a.getiterator( (), () ))) 
+
3056   
+3057 -    def test_getiterator_filter_multiple_tuple(self): 
+
3058          Element = self.etree.Element 
+3059          SubElement = self.etree.SubElement 
+3060   
+3061          a = Element('a') 
+3062          b = SubElement(a, 'b') 
+3063          c = SubElement(a, 'c') 
+3064          d = SubElement(b, 'd') 
+3065          e = SubElement(c, 'e') 
+3066          f = SubElement(c, 'f') 
+3067   
+3068          self.assertEqual( 
+3069              [a, b], 
+3070                    list(a.getiterator( ('a', 'b') ))) 
+3071          self.assertEqual( 
+3072              [], 
+3073                list(a.getiterator( ('x', 'y') ))) 
+3074          self.assertEqual( 
+3075              [a, f], 
+3076                    list(a.getiterator( ('f', 'a') ))) 
+3077          self.assertEqual( 
+3078              [c, e, f], 
+3079                       list(c.getiterator( ('c', '*', 'a') ))) 
+3080          self.assertEqual( 
+3081              [], 
+3082                list(a.getiterator( () ))) 
+
3083   
+3084 -    def test_getiterator_filter_namespace(self): 
+
3085          Element = self.etree.Element 
+3086          SubElement = self.etree.SubElement 
+3087   
+3088          a = Element('{a}a') 
+3089          b = SubElement(a, '{a}b') 
+3090          c = SubElement(a, '{a}c') 
+3091          d = SubElement(b, '{b}d') 
+3092          e = SubElement(c, '{a}e') 
+3093          f = SubElement(c, '{b}f') 
+3094          g = SubElement(c, 'g') 
+3095   
+3096          self.assertEqual( 
+3097              [a], 
+3098              list(a.getiterator('{a}a'))) 
+3099          self.assertEqual( 
+3100              [], 
+3101              list(a.getiterator('{b}a'))) 
+3102          self.assertEqual( 
+3103              [], 
+3104              list(a.getiterator('a'))) 
+3105          self.assertEqual( 
+3106              [a,b,d,c,e,f,g], 
+3107              list(a.getiterator('*'))) 
+3108          self.assertEqual( 
+3109              [f], 
+3110              list(c.getiterator('{b}*'))) 
+3111          self.assertEqual( 
+3112              [d, f], 
+3113              list(a.getiterator('{b}*'))) 
+3114          self.assertEqual( 
+3115              [g], 
+3116              list(a.getiterator('g'))) 
+3117          self.assertEqual( 
+3118              [g], 
+3119              list(a.getiterator('{}g'))) 
+3120          self.assertEqual( 
+3121              [g], 
+3122              list(a.getiterator('{}*'))) 
+
3123   
+3124 -    def test_getiterator_filter_local_name(self): 
+
3125          Element = self.etree.Element 
+3126          Comment = self.etree.Comment 
+3127          SubElement = self.etree.SubElement 
+3128   
+3129          a = Element('{a}a') 
+3130          b = SubElement(a, '{nsA}b') 
+3131          c = SubElement(b, '{nsB}b') 
+3132          d = SubElement(a, 'b') 
+3133          e = SubElement(a, '{nsA}e') 
+3134          f = SubElement(e, '{nsB}e') 
+3135          g = SubElement(e, 'e') 
+3136          a.append(Comment('test')) 
+3137   
+3138          self.assertEqual( 
+3139              [b, c, d], 
+3140              list(a.getiterator('{*}b'))) 
+3141          self.assertEqual( 
+3142              [e, f, g], 
+3143              list(a.getiterator('{*}e'))) 
+3144          self.assertEqual( 
+3145              [a, b, c, d, e, f, g], 
+3146              list(a.getiterator('{*}*'))) 
+
3147   
+3148 -    def test_getiterator_filter_entities(self): 
+
3149          Element = self.etree.Element 
+3150          Entity = self.etree.Entity 
+3151          SubElement = self.etree.SubElement 
+3152   
+3153          a = Element('a') 
+3154          b = SubElement(a, 'b') 
+3155          entity_b = Entity("TEST-b") 
+3156          b.append(entity_b) 
+3157   
+3158          self.assertEqual( 
+3159              [entity_b], 
+3160              list(a.getiterator(Entity))) 
+3161   
+3162          entity_a = Entity("TEST-a") 
+3163          a.append(entity_a) 
+3164   
+3165          self.assertEqual( 
+3166              [entity_b, entity_a], 
+3167              list(a.getiterator(Entity))) 
+3168   
+3169          self.assertEqual( 
+3170              [entity_b], 
+3171              list(b.getiterator(Entity))) 
+
3172   
+3173 -    def test_getiterator_filter_element(self): 
+
3174          Element = self.etree.Element 
+3175          Comment = self.etree.Comment 
+3176          PI = self.etree.PI 
+3177          SubElement = self.etree.SubElement 
+3178   
+3179          a = Element('a') 
+3180          b = SubElement(a, 'b') 
+3181          a.append(Comment("test")) 
+3182          a.append(PI("pi", "content")) 
+3183          c = SubElement(a, 'c') 
+3184   
+3185          self.assertEqual( 
+3186              [a, b, c], 
+3187              list(a.getiterator(Element))) 
+
3188   
+3189 -    def test_getiterator_filter_all_comment_pi(self): 
+
3190          # ElementTree iterates over everything here 
+3191          Element = self.etree.Element 
+3192          Comment = self.etree.Comment 
+3193          PI = self.etree.PI 
+3194          SubElement = self.etree.SubElement 
+3195   
+3196          a = Element('a') 
+3197          b = SubElement(a, 'b') 
+3198          a.append(Comment("test")) 
+3199          a.append(PI("pi", "content")) 
+3200          c = SubElement(a, 'c') 
+3201   
+3202          self.assertEqual( 
+3203              [a, b, c], 
+3204              list(a.getiterator('*'))) 
+
3205   
+3206 -    def test_elementtree_getelementpath(self): 
+
3207          a  = etree.Element("a") 
+3208          b  = etree.SubElement(a, "b") 
+3209          c  = etree.SubElement(a, "c") 
+3210          d1 = etree.SubElement(c, "d") 
+3211          d2 = etree.SubElement(c, "d") 
+3212          c.text = d1.text = 'TEXT' 
+3213   
+3214          tree = etree.ElementTree(a) 
+3215          self.assertEqual('.', tree.getelementpath(a)) 
+3216          self.assertEqual('c/d[1]', tree.getelementpath(d1)) 
+3217          self.assertEqual('c/d[2]', tree.getelementpath(d2)) 
+3218   
+3219          self.assertEqual(d1, tree.find(tree.getelementpath(d1))) 
+3220          self.assertEqual(d2, tree.find(tree.getelementpath(d2))) 
+3221   
+3222          tree = etree.ElementTree(c) 
+3223          self.assertEqual('.', tree.getelementpath(c)) 
+3224          self.assertEqual('d[2]', tree.getelementpath(d2)) 
+3225          self.assertEqual(d2, tree.find(tree.getelementpath(d2))) 
+3226   
+3227          tree = etree.ElementTree(b)  # not a parent of a/c/d1/d2 
+3228          self.assertEqual('.', tree.getelementpath(b)) 
+3229          self.assertRaises(ValueError, tree.getelementpath, a) 
+3230          self.assertRaises(ValueError, tree.getelementpath, c) 
+3231          self.assertRaises(ValueError, tree.getelementpath, d2) 
+
3232   
+3233 -    def test_elementtree_getelementpath_ns(self): 
+
3234          a  = etree.Element("{http://ns1/}a") 
+3235          b  = etree.SubElement(a, "{http://ns1/}b") 
+3236          c  = etree.SubElement(a, "{http://ns1/}c") 
+3237          d1 = etree.SubElement(c, "{http://ns1/}d") 
+3238          d2 = etree.SubElement(c, "{http://ns2/}d") 
+3239          d3 = etree.SubElement(c, "{http://ns1/}d") 
+3240   
+3241          tree = etree.ElementTree(a) 
+3242          self.assertEqual('.', tree.getelementpath(a)) 
+3243          self.assertEqual('{http://ns1/}c/{http://ns1/}d[1]', 
+3244                           tree.getelementpath(d1)) 
+3245          self.assertEqual('{http://ns1/}c/{http://ns2/}d', 
+3246                           tree.getelementpath(d2)) 
+3247          self.assertEqual('{http://ns1/}c/{http://ns1/}d[2]', 
+3248                           tree.getelementpath(d3)) 
+3249   
+3250          self.assertEqual(a, tree.find(tree.getelementpath(a))) 
+3251          self.assertEqual(b, tree.find(tree.getelementpath(b))) 
+3252          self.assertEqual(c, tree.find(tree.getelementpath(c))) 
+3253          self.assertEqual(d1, tree.find(tree.getelementpath(d1))) 
+3254          self.assertEqual(d2, tree.find(tree.getelementpath(d2))) 
+3255          self.assertEqual(d3, tree.find(tree.getelementpath(d3))) 
+3256   
+3257          tree = etree.ElementTree(c) 
+3258          self.assertEqual('{http://ns1/}d[1]', tree.getelementpath(d1)) 
+3259          self.assertEqual('{http://ns2/}d', tree.getelementpath(d2)) 
+3260          self.assertEqual('{http://ns1/}d[2]', tree.getelementpath(d3)) 
+3261          self.assertEqual(d1, tree.find(tree.getelementpath(d1))) 
+3262          self.assertEqual(d2, tree.find(tree.getelementpath(d2))) 
+3263          self.assertEqual(d3, tree.find(tree.getelementpath(d3))) 
+3264   
+3265          tree = etree.ElementTree(b)  # not a parent of d1/d2 
+3266          self.assertRaises(ValueError, tree.getelementpath, d1) 
+3267          self.assertRaises(ValueError, tree.getelementpath, d2) 
+
3268   
+3269 -    def test_elementtree_find_qname(self): 
+
3270          XML = self.etree.XML 
+3271          ElementTree = self.etree.ElementTree 
+3272          QName = self.etree.QName 
+3273          tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>'))) 
+3274          self.assertEqual(tree.find(QName("c")), tree.getroot()[2]) 
+
3275   
+3276 -    def test_elementtree_findall_qname(self): 
+
3277          XML = self.etree.XML 
+3278          ElementTree = self.etree.ElementTree 
+3279          QName = self.etree.QName 
+3280          tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>'))) 
+3281          self.assertEqual(len(list(tree.findall(QName("c")))), 1) 
+
3282   
+3283 -    def test_elementtree_findall_ns_qname(self): 
+
3284          XML = self.etree.XML 
+3285          ElementTree = self.etree.ElementTree 
+3286          QName = self.etree.QName 
+3287          tree = ElementTree(XML( 
+3288                  _bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))) 
+3289          self.assertEqual(len(list(tree.findall(QName("b")))), 2) 
+3290          self.assertEqual(len(list(tree.findall(QName("X", "b")))), 1) 
+
3291   
+3292 -    def test_findall_ns(self): 
+
3293          XML = self.etree.XML 
+3294          root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')) 
+3295          self.assertEqual(len(root.findall(".//{X}b")), 2) 
+3296          self.assertEqual(len(root.findall(".//{X}*")), 2) 
+3297          self.assertEqual(len(root.findall(".//b")), 3) 
+
3298   
+3299 -    def test_findall_different_nsmaps(self): 
+
3300          XML = self.etree.XML 
+3301          root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><y:b/></a>')) 
+3302          nsmap = {'xx': 'X'} 
+3303          self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2) 
+3304          self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 2) 
+3305          self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) 
+3306          nsmap = {'xx': 'Y'} 
+3307          self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 1) 
+3308          self.assertEqual(len(root.findall(".//xx:*", namespaces=nsmap)), 1) 
+3309          self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 2) 
+
3310   
+3311 -    def test_findall_empty_prefix(self): 
+
3312          XML = self.etree.XML 
+3313          root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><y:b/></a>')) 
+3314          nsmap = {'xx': 'X'} 
+3315          self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2) 
+3316          nsmap = {'xx': 'X', None: 'Y'} 
+3317          self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 1) 
+3318          nsmap = {'xx': 'X', '': 'Y'} 
+3319          self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 1) 
+
3320   
+3321 -    def test_findall_syntax_error(self): 
+
3322          XML = self.etree.XML 
+3323          root = XML(_bytes('<a><b><c/></b><b/><c><b/><b/></c><b/></a>')) 
+3324          self.assertRaises(SyntaxError, root.findall, '') 
+3325          self.assertRaises(SyntaxError, root.findall, '//')  # absolute path on Element 
+3326          self.assertRaises(SyntaxError, root.findall, './//') 
+
3327   
+3328 -    def test_index(self): 
+
3329          etree = self.etree 
+3330          e = etree.Element('foo') 
+3331          for i in range(10): 
+3332              etree.SubElement(e, 'a%s' % i) 
+3333          for i in range(10): 
+3334              self.assertEqual( 
+3335                  i, 
+3336                  e.index(e[i])) 
+3337          self.assertEqual( 
+3338              3, e.index(e[3], 3)) 
+3339          self.assertRaises( 
+3340              ValueError, e.index, e[3], 4) 
+3341          self.assertRaises( 
+3342              ValueError, e.index, e[3], 0, 2) 
+3343          self.assertRaises( 
+3344              ValueError, e.index, e[8], 0, -3) 
+3345          self.assertRaises( 
+3346              ValueError, e.index, e[8], -5, -3) 
+3347          self.assertEqual( 
+3348              8, e.index(e[8], 0, -1)) 
+3349          self.assertEqual( 
+3350              8, e.index(e[8], -12, -1)) 
+3351          self.assertEqual( 
+3352              0, e.index(e[0], -12, -1)) 
+
3353   
+3354 -    def test_replace(self): 
+
3355          etree = self.etree 
+3356          e = etree.Element('foo') 
+3357          for i in range(10): 
+3358              el = etree.SubElement(e, 'a%s' % i) 
+3359              el.text = "text%d" % i 
+3360              el.tail = "tail%d" % i 
+3361   
+3362          child0 = e[0] 
+3363          child1 = e[1] 
+3364          child2 = e[2] 
+3365   
+3366          e.replace(e[0], e[1]) 
+3367          self.assertEqual( 
+3368              9, len(e)) 
+3369          self.assertEqual( 
+3370              child1, e[0]) 
+3371          self.assertEqual( 
+3372              child1.text, "text1") 
+3373          self.assertEqual( 
+3374              child1.tail, "tail1") 
+3375          self.assertEqual( 
+3376              child0.tail, "tail0") 
+3377          self.assertEqual( 
+3378              child2, e[1]) 
+3379   
+3380          e.replace(e[-1], e[0]) 
+3381          self.assertEqual( 
+3382              child1, e[-1]) 
+3383          self.assertEqual( 
+3384              child1.text, "text1") 
+3385          self.assertEqual( 
+3386              child1.tail, "tail1") 
+3387          self.assertEqual( 
+3388              child2, e[0]) 
+
3389   
+3390 -    def test_replace_new(self): 
+
3391          etree = self.etree 
+3392          e = etree.Element('foo') 
+3393          for i in range(10): 
+3394              etree.SubElement(e, 'a%s' % i) 
+3395   
+3396          new_element = etree.Element("test") 
+3397          new_element.text = "TESTTEXT" 
+3398          new_element.tail = "TESTTAIL" 
+3399          child1 = e[1] 
+3400          e.replace(e[0], new_element) 
+3401          self.assertEqual( 
+3402              new_element, e[0]) 
+3403          self.assertEqual( 
+3404              "TESTTEXT", 
+3405              e[0].text) 
+3406          self.assertEqual( 
+3407              "TESTTAIL", 
+3408              e[0].tail) 
+3409          self.assertEqual( 
+3410              child1, e[1]) 
+
3411   
+3412 -    def test_setslice_all_reversed(self): 
+
3413          Element = self.etree.Element 
+3414          SubElement = self.etree.SubElement 
+3415   
+3416          a = Element('a') 
+3417   
+3418          e = Element('e') 
+3419          f = Element('f') 
+3420          g = Element('g') 
+3421   
+3422          a[:] = [e, f, g] 
+3423          self.assertEqual( 
+3424              [e, f, g], 
+3425              list(a)) 
+3426   
+3427          a[::-1] = [e, f, g] 
+3428          self.assertEqual( 
+3429              [g, f, e], 
+3430              list(a)) 
+
3431   
+3432 -    def test_setslice_step(self): 
+
3433          Element = self.etree.Element 
+3434          SubElement = self.etree.SubElement 
+3435   
+3436          a = Element('a') 
+3437          b = SubElement(a, 'b') 
+3438          c = SubElement(a, 'c') 
+3439          d = SubElement(a, 'd') 
+3440          e = SubElement(a, 'e') 
+3441   
+3442          x = Element('x') 
+3443          y = Element('y') 
+3444   
+3445          a[1::2] = [x, y] 
+3446          self.assertEqual( 
+3447              [b, x, d, y], 
+3448              list(a)) 
+
3449   
+3450 -    def test_setslice_step_negative(self): 
+
3451          Element = self.etree.Element 
+3452          SubElement = self.etree.SubElement 
+3453   
+3454          a = Element('a') 
+3455          b = SubElement(a, 'b') 
+3456          c = SubElement(a, 'c') 
+3457          d = SubElement(a, 'd') 
+3458          e = SubElement(a, 'e') 
+3459   
+3460          x = Element('x') 
+3461          y = Element('y') 
+3462   
+3463          a[1::-1] = [x, y] 
+3464          self.assertEqual( 
+3465              [y, x, d, e], 
+3466              list(a)) 
+
3467   
+3468 -    def test_setslice_step_negative2(self): 
+
3469          Element = self.etree.Element 
+3470          SubElement = self.etree.SubElement 
+3471   
+3472          a = Element('a') 
+3473          b = SubElement(a, 'b') 
+3474          c = SubElement(a, 'c') 
+3475          d = SubElement(a, 'd') 
+3476          e = SubElement(a, 'e') 
+3477   
+3478          x = Element('x') 
+3479          y = Element('y') 
+3480   
+3481          a[::-2] = [x, y] 
+3482          self.assertEqual( 
+3483              [b, y, d, x], 
+3484              list(a)) 
+
3485   
+3486 -    def test_setslice_step_overrun(self): 
+
3487          Element = self.etree.Element 
+3488          SubElement = self.etree.SubElement 
+3489          try: 
+3490              slice 
+3491          except NameError: 
+3492              print("slice() not found") 
+3493              return 
+3494   
+3495          a = Element('a') 
+3496          b = SubElement(a, 'b') 
+3497          c = SubElement(a, 'c') 
+3498          d = SubElement(a, 'd') 
+3499          e = SubElement(a, 'e') 
+3500   
+3501          x = Element('x') 
+3502          y = Element('y') 
+3503          z = Element('z') 
+3504   
+3505          self.assertRaises( 
+3506              ValueError, 
+3507              operator.setitem, a, slice(1,None,2), [x, y, z]) 
+3508   
+3509          self.assertEqual( 
+3510              [b, c, d, e], 
+3511              list(a)) 
+
3512   
+3513 -    def test_sourceline_XML(self): 
+
3514          XML = self.etree.XML 
+3515          root = XML(_bytes('''<?xml version="1.0"?> 
+3516          <root><test> 
+3517   
+3518          <bla/></test> 
+3519          </root> 
+3520          ''')) 
+3521   
+3522          self.assertEqual( 
+3523              [2, 2, 4], 
+3524              [ el.sourceline for el in root.getiterator() ]) 
+
3525   
+3526 -    def test_large_sourceline_XML(self): 
+
3527          XML = self.etree.XML 
+3528          root = XML(_bytes( 
+3529              '<?xml version="1.0"?>\n' 
+3530              '<root>' + '\n' * 65536 + 
+3531              '<p>' + '\n' * 65536 + '</p>\n' + 
+3532              '<br/>\n' 
+3533              '</root>')) 
+3534   
+3535          if self.etree.LIBXML_VERSION >= (2, 9): 
+3536              expected = [2, 131074, 131076] 
+3537          else: 
+3538              expected = [2, 65535, 65535] 
+3539   
+3540          self.assertEqual(expected, [el.sourceline for el in root.iter()]) 
+
3541   
+3542 -    def test_sourceline_parse(self): 
+
3543          parse = self.etree.parse 
+3544          tree = parse(fileInTestDir('include/test_xinclude.xml')) 
+3545   
+3546          self.assertEqual( 
+3547              [1, 2, 3], 
+3548              [ el.sourceline for el in tree.getiterator() ]) 
+
3549   
+3550 -    def test_sourceline_iterparse_end(self): 
+
3551          iterparse = self.etree.iterparse 
+3552          lines = [ el.sourceline for (event, el) in  
+3553                    iterparse(fileInTestDir('include/test_xinclude.xml')) ] 
+3554   
+3555          self.assertEqual( 
+3556              [2, 3, 1], 
+3557              lines) 
+
3558   
+3559 -    def test_sourceline_iterparse_start(self): 
+
3560          iterparse = self.etree.iterparse 
+3561          lines = [ el.sourceline for (event, el) in  
+3562                    iterparse(fileInTestDir('include/test_xinclude.xml'), 
+3563                              events=("start",)) ] 
+3564   
+3565          self.assertEqual( 
+3566              [1, 2, 3], 
+3567              lines) 
+
3568   
+3569 -    def test_sourceline_element(self): 
+
3570          Element = self.etree.Element 
+3571          SubElement = self.etree.SubElement 
+3572          el = Element("test") 
+3573          self.assertEqual(None, el.sourceline) 
+3574   
+3575          child = SubElement(el, "test") 
+3576          self.assertEqual(None, el.sourceline) 
+3577          self.assertEqual(None, child.sourceline) 
+
3578   
+3579 -    def test_XML_base_url_docinfo(self): 
+
3580          etree = self.etree 
+3581          root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 
+3582          docinfo = root.getroottree().docinfo 
+3583          self.assertEqual(docinfo.URL, "http://no/such/url") 
+
3584   
+3585 -    def test_XML_set_base_url_docinfo(self): 
+
3586          etree = self.etree 
+3587          root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 
+3588          docinfo = root.getroottree().docinfo 
+3589          self.assertEqual(docinfo.URL, "http://no/such/url") 
+3590          docinfo.URL = "https://secret/url" 
+3591          self.assertEqual(docinfo.URL, "https://secret/url") 
+
3592   
+3593 -    def test_parse_stringio_base_url(self): 
+
3594          etree = self.etree 
+3595          tree = etree.parse(BytesIO("<root/>"), base_url="http://no/such/url") 
+3596          docinfo = tree.docinfo 
+3597          self.assertEqual(docinfo.URL, "http://no/such/url") 
+
3598   
+3599 -    def test_parse_base_url_docinfo(self): 
+
3600          etree = self.etree 
+3601          tree = etree.parse(fileInTestDir('include/test_xinclude.xml'), 
+3602                             base_url="http://no/such/url") 
+3603          docinfo = tree.docinfo 
+3604          self.assertEqual(docinfo.URL, "http://no/such/url") 
+
3605   
+3606 -    def test_HTML_base_url_docinfo(self): 
+
3607          etree = self.etree 
+3608          root = etree.HTML(_bytes("<html/>"), base_url="http://no/such/url") 
+3609          docinfo = root.getroottree().docinfo 
+3610          self.assertEqual(docinfo.URL, "http://no/such/url") 
+
3611   
+3612 -    def test_docinfo_public(self): 
+
3613          etree = self.etree 
+3614          xml_header = '<?xml version="1.0" encoding="ascii"?>' 
+3615          pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" 
+3616          sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" 
+3617          doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id) 
+3618   
+3619          xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') 
+3620   
+3621          tree = etree.parse(BytesIO(xml)) 
+3622          docinfo = tree.docinfo 
+3623          self.assertEqual(docinfo.encoding,    "ascii") 
+3624          self.assertEqual(docinfo.xml_version, "1.0") 
+3625          self.assertEqual(docinfo.public_id,   pub_id) 
+3626          self.assertEqual(docinfo.system_url,  sys_id) 
+3627          self.assertEqual(docinfo.root_name,   'html') 
+3628          self.assertEqual(docinfo.doctype, doctype_string) 
+
3629   
+3630 -    def test_docinfo_system(self): 
+
3631          etree = self.etree 
+3632          xml_header = '<?xml version="1.0" encoding="UTF-8"?>' 
+3633          sys_id = "some.dtd" 
+3634          doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id 
+3635          xml = _bytes(xml_header + doctype_string + '<html><body></body></html>') 
+3636   
+3637          tree = etree.parse(BytesIO(xml)) 
+3638          docinfo = tree.docinfo 
+3639          self.assertEqual(docinfo.encoding,    "UTF-8") 
+3640          self.assertEqual(docinfo.xml_version, "1.0") 
+3641          self.assertEqual(docinfo.public_id,   None) 
+3642          self.assertEqual(docinfo.system_url,  sys_id) 
+3643          self.assertEqual(docinfo.root_name,   'html') 
+3644          self.assertEqual(docinfo.doctype, doctype_string) 
+
3645   
+3646 -    def test_docinfo_empty(self): 
+
3647          etree = self.etree 
+3648          xml = _bytes('<html><body></body></html>') 
+3649          tree = etree.parse(BytesIO(xml)) 
+3650          docinfo = tree.docinfo 
+3651          self.assertEqual(docinfo.encoding,    "UTF-8") 
+3652          self.assertEqual(docinfo.xml_version, "1.0") 
+3653          self.assertEqual(docinfo.public_id,   None) 
+3654          self.assertEqual(docinfo.system_url,  None) 
+3655          self.assertEqual(docinfo.root_name,   'html') 
+3656          self.assertEqual(docinfo.doctype, '') 
+
3657   
+3658 -    def test_docinfo_name_only(self): 
+
3659          etree = self.etree 
+3660          xml = _bytes('<!DOCTYPE root><root></root>') 
+3661          tree = etree.parse(BytesIO(xml)) 
+3662          docinfo = tree.docinfo 
+3663          self.assertEqual(docinfo.encoding,    "UTF-8") 
+3664          self.assertEqual(docinfo.xml_version, "1.0") 
+3665          self.assertEqual(docinfo.public_id,   None) 
+3666          self.assertEqual(docinfo.system_url,  None) 
+3667          self.assertEqual(docinfo.root_name,   'root') 
+3668          self.assertEqual(docinfo.doctype, '<!DOCTYPE root>') 
+
3669   
+3670 -    def test_doctype_name_only_roundtrip(self): 
+
3671          etree = self.etree 
+3672          xml = _bytes('<!DOCTYPE root>\n<root/>') 
+3673          tree = etree.parse(BytesIO(xml)) 
+3674          self.assertEqual(xml, etree.tostring(tree)) 
+
3675   
+3676 -    def test_doctype_output_override(self): 
+
3677          etree = self.etree 
+3678          pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN" 
+3679          sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" 
+3680          doctype_string = _bytes('<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id)) 
+3681   
+3682          xml = _bytes('<!DOCTYPE root>\n<root/>') 
+3683          tree = etree.parse(BytesIO(xml)) 
+3684          self.assertEqual(xml.replace(_bytes('<!DOCTYPE root>'), doctype_string), 
+3685                            etree.tostring(tree, doctype=doctype_string)) 
+
3686   
+3687 -    def test_xml_base(self): 
+
3688          etree = self.etree 
+3689          root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 
+3690          self.assertEqual(root.base, "http://no/such/url") 
+3691          self.assertEqual( 
+3692              root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 
+3693          root.base = "https://secret/url" 
+3694          self.assertEqual(root.base, "https://secret/url") 
+3695          self.assertEqual( 
+3696              root.get('{http://www.w3.org/XML/1998/namespace}base'), 
+3697              "https://secret/url") 
+
3698   
+3699 -    def test_xml_base_attribute(self): 
+
3700          etree = self.etree 
+3701          root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url") 
+3702          self.assertEqual(root.base, "http://no/such/url") 
+3703          self.assertEqual( 
+3704              root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 
+3705          root.set('{http://www.w3.org/XML/1998/namespace}base', 
+3706                   "https://secret/url") 
+3707          self.assertEqual(root.base, "https://secret/url") 
+3708          self.assertEqual( 
+3709              root.get('{http://www.w3.org/XML/1998/namespace}base'), 
+3710              "https://secret/url") 
+
3711   
+3712 -    def test_html_base(self): 
+
3713          etree = self.etree 
+3714          root = etree.HTML(_bytes("<html><body></body></html>"), 
+3715                            base_url="http://no/such/url") 
+3716          self.assertEqual(root.base, "http://no/such/url") 
+
3717   
+3718 -    def test_html_base_tag(self): 
+
3719          etree = self.etree 
+3720          root = etree.HTML(_bytes('<html><head><base href="http://no/such/url"></head></html>')) 
+3721          self.assertEqual(root.base, "http://no/such/url") 
+
3722   
+3723 -    def test_parse_fileobject_unicode(self): 
+
3724          # parse from a file object that returns unicode strings 
+3725          f = LargeFileLikeUnicode() 
+3726          tree = self.etree.parse(f) 
+3727          root = tree.getroot() 
+3728          self.assertTrue(root.tag.endswith('root')) 
+
3729   
+3730 -    def test_dtd_io(self): 
+
3731          # check that DTDs that go in also go back out 
+3732          xml = _bytes('''\ 
+3733          <!DOCTYPE test SYSTEM "test.dtd" [ 
+3734            <!ENTITY entity "tasty"> 
+3735            <!ELEMENT test (a)> 
+3736            <!ELEMENT a (#PCDATA)> 
+3737          ]> 
+3738          <test><a>test-test</a></test>\ 
+3739          ''') 
+3740          tree = self.etree.parse(BytesIO(xml)) 
+3741          self.assertEqual(self.etree.tostring(tree).replace(_bytes(" "), _bytes("")), 
+3742                           xml.replace(_bytes(" "), _bytes(""))) 
+
3743   
+3744 -    def test_byte_zero(self): 
+
3745          Element = self.etree.Element 
+3746   
+3747          a = Element('a') 
+3748          self.assertRaises(ValueError, setattr, a, "text", 'ha\0ho') 
+3749          self.assertRaises(ValueError, setattr, a, "tail", 'ha\0ho') 
+3750   
+3751          self.assertRaises(ValueError, Element, 'ha\0ho') 
+
3752   
+3753 -    def test_unicode_byte_zero(self): 
+
3754          Element = self.etree.Element 
+3755   
+3756          a = Element('a') 
+3757          self.assertRaises(ValueError, setattr, a, "text", 
+3758                            _str('ha\0ho')) 
+3759          self.assertRaises(ValueError, setattr, a, "tail", 
+3760                            _str('ha\0ho')) 
+3761   
+3762          self.assertRaises(ValueError, Element, 
+3763                            _str('ha\0ho')) 
+
3764   
+3765 -    def test_byte_invalid(self): 
+
3766          Element = self.etree.Element 
+3767   
+3768          a = Element('a') 
+3769          self.assertRaises(ValueError, setattr, a, "text", 'ha\x07ho') 
+3770          self.assertRaises(ValueError, setattr, a, "text", 'ha\x02ho') 
+3771   
+3772          self.assertRaises(ValueError, setattr, a, "tail", 'ha\x07ho') 
+3773          self.assertRaises(ValueError, setattr, a, "tail", 'ha\x02ho') 
+3774   
+3775          self.assertRaises(ValueError, Element, 'ha\x07ho') 
+3776          self.assertRaises(ValueError, Element, 'ha\x02ho') 
+
3777   
+3778 -    def test_unicode_byte_invalid(self): 
+
3779          Element = self.etree.Element 
+3780   
+3781          a = Element('a') 
+3782          self.assertRaises(ValueError, setattr, a, "text", 
+3783                            _str('ha\x07ho')) 
+3784          self.assertRaises(ValueError, setattr, a, "text", 
+3785                            _str('ha\x02ho')) 
+3786   
+3787          self.assertRaises(ValueError, setattr, a, "tail", 
+3788                            _str('ha\x07ho')) 
+3789          self.assertRaises(ValueError, setattr, a, "tail", 
+3790                            _str('ha\x02ho')) 
+3791   
+3792          self.assertRaises(ValueError, Element, 
+3793                            _str('ha\x07ho')) 
+3794          self.assertRaises(ValueError, Element, 
+3795                            _str('ha\x02ho')) 
+
3796   
+3797 -    def test_unicode_byte_invalid_sequence(self): 
+
3798          Element = self.etree.Element 
+3799   
+3800          a = Element('a') 
+3801          self.assertRaises(ValueError, setattr, a, "text", 
+3802                            _str('ha\u1234\x07ho')) 
+3803          self.assertRaises(ValueError, setattr, a, "text", 
+3804                            _str('ha\u1234\x02ho')) 
+3805   
+3806          self.assertRaises(ValueError, setattr, a, "tail", 
+3807                            _str('ha\u1234\x07ho')) 
+3808          self.assertRaises(ValueError, setattr, a, "tail", 
+3809                            _str('ha\u1234\x02ho')) 
+3810   
+3811          self.assertRaises(ValueError, Element, 
+3812                            _str('ha\u1234\x07ho')) 
+3813          self.assertRaises(ValueError, Element, 
+3814                            _str('ha\u1234\x02ho')) 
+
3815   
+3816 -    def test_encoding_tostring_utf16(self): 
+
3817          # ElementTree fails to serialize this 
+3818          tostring = self.etree.tostring 
+3819          Element = self.etree.Element 
+3820          SubElement = self.etree.SubElement 
+3821           
+3822          a = Element('a') 
+3823          b = SubElement(a, 'b') 
+3824          c = SubElement(a, 'c') 
+3825   
+3826          result = tostring(a, encoding='UTF-16') 
+3827          self.assertEqual(_bytes('<a><b></b><c></c></a>'), 
+3828                            canonicalize(result)) 
+
3829   
+3830 -    def test_tostring_none(self): 
+
3831          # ElementTree raises an AssertionError here 
+3832          tostring = self.etree.tostring 
+3833          self.assertRaises(TypeError, self.etree.tostring, None) 
+
3834   
+3835 -    def test_tostring_pretty(self): 
+
3836          tostring = self.etree.tostring 
+3837          Element = self.etree.Element 
+3838          SubElement = self.etree.SubElement 
+3839   
+3840          a = Element('a') 
+3841          b = SubElement(a, 'b') 
+3842          c = SubElement(a, 'c') 
+3843   
+3844          result = tostring(a) 
+3845          self.assertEqual(result, _bytes("<a><b/><c/></a>")) 
+3846   
+3847          result = tostring(a, pretty_print=False) 
+3848          self.assertEqual(result, _bytes("<a><b/><c/></a>")) 
+3849   
+3850          result = tostring(a, pretty_print=True) 
+3851          self.assertEqual(result, _bytes("<a>\n  <b/>\n  <c/>\n</a>\n")) 
+
3852   
+3853 -    def test_tostring_with_tail(self): 
+
3854          tostring = self.etree.tostring 
+3855          Element = self.etree.Element 
+3856          SubElement = self.etree.SubElement 
+3857   
+3858          a = Element('a') 
+3859          a.tail = "aTAIL" 
+3860          b = SubElement(a, 'b') 
+3861          b.tail = "bTAIL" 
+3862          c = SubElement(a, 'c') 
+3863   
+3864          result = tostring(a) 
+3865          self.assertEqual(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL")) 
+3866   
+3867          result = tostring(a, with_tail=False) 
+3868          self.assertEqual(result, _bytes("<a><b/>bTAIL<c/></a>")) 
+3869   
+3870          result = tostring(a, with_tail=True) 
+3871          self.assertEqual(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL")) 
+
3872   
+3873 -    def test_tostring_method_html_with_tail(self): 
+
3874          tostring = self.etree.tostring 
+3875          html = self.etree.fromstring( 
+3876              '<html><body>' 
+3877              '<div><p>Some text<i>\r\n</i></p></div>\r\n' 
+3878              '</body></html>', 
+3879              parser=self.etree.HTMLParser()) 
+3880          self.assertEqual(html.tag, 'html') 
+3881          div = html.find('.//div') 
+3882          self.assertEqual(div.tail, '\r\n') 
+3883          result = tostring(div, method='html') 
+3884          self.assertEqual( 
+3885              result, 
+3886              _bytes("<div><p>Some text<i>\r\n</i></p></div>\r\n")) 
+3887          result = tostring(div, method='html', with_tail=True) 
+3888          self.assertEqual( 
+3889              result, 
+3890              _bytes("<div><p>Some text<i>\r\n</i></p></div>\r\n")) 
+3891          result = tostring(div, method='html', with_tail=False) 
+3892          self.assertEqual( 
+3893              result, 
+3894              _bytes("<div><p>Some text<i>\r\n</i></p></div>")) 
+
3895   
+3896 -    def test_standalone(self): 
+
3897          tostring = self.etree.tostring 
+3898          XML = self.etree.XML 
+3899          ElementTree = self.etree.ElementTree 
+3900          Element = self.etree.Element 
+3901   
+3902          tree = Element("root").getroottree() 
+3903          self.assertEqual(None, tree.docinfo.standalone) 
+3904   
+3905          tree = XML(_bytes("<root/>")).getroottree() 
+3906          self.assertEqual(None, tree.docinfo.standalone) 
+3907   
+3908          tree = XML(_bytes( 
+3909              "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>" 
+3910              )).getroottree() 
+3911          self.assertEqual(True, tree.docinfo.standalone) 
+3912   
+3913          tree = XML(_bytes( 
+3914              "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>" 
+3915              )).getroottree() 
+3916          self.assertEqual(False, tree.docinfo.standalone) 
+
3917   
+3918 -    def test_tostring_standalone(self): 
+
3919          tostring = self.etree.tostring 
+3920          XML = self.etree.XML 
+3921          ElementTree = self.etree.ElementTree 
+3922   
+3923          root = XML(_bytes("<root/>")) 
+3924   
+3925          tree = ElementTree(root) 
+3926          self.assertEqual(None, tree.docinfo.standalone) 
+3927   
+3928          result = tostring(root, xml_declaration=True, encoding="ASCII") 
+3929          self.assertEqual(result, _bytes( 
+3930              "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) 
+3931   
+3932          result = tostring(root, xml_declaration=True, encoding="ASCII", 
+3933                            standalone=True) 
+3934          self.assertEqual(result, _bytes( 
+3935              "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>")) 
+3936   
+3937          tree = ElementTree(XML(result)) 
+3938          self.assertEqual(True, tree.docinfo.standalone) 
+3939   
+3940          result = tostring(root, xml_declaration=True, encoding="ASCII", 
+3941                            standalone=False) 
+3942          self.assertEqual(result, _bytes( 
+3943              "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>")) 
+3944   
+3945          tree = ElementTree(XML(result)) 
+3946          self.assertEqual(False, tree.docinfo.standalone) 
+
3947   
+3948 -    def test_tostring_standalone_in_out(self): 
+
3949          tostring = self.etree.tostring 
+3950          XML = self.etree.XML 
+3951          ElementTree = self.etree.ElementTree 
+3952   
+3953          root = XML(_bytes( 
+3954              "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n<root/>")) 
+3955   
+3956          tree = ElementTree(root) 
+3957          self.assertEqual(True, tree.docinfo.standalone) 
+3958   
+3959          result = tostring(root, xml_declaration=True, encoding="ASCII") 
+3960          self.assertEqual(result, _bytes( 
+3961              "<?xml version='1.0' encoding='ASCII'?>\n<root/>")) 
+3962   
+3963          result = tostring(root, xml_declaration=True, encoding="ASCII", 
+3964                            standalone=True) 
+3965          self.assertEqual(result, _bytes( 
+3966              "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>")) 
+
3967   
+3968 -    def test_tostring_method_text_encoding(self): 
+
3969          tostring = self.etree.tostring 
+3970          Element = self.etree.Element 
+3971          SubElement = self.etree.SubElement 
+3972           
+3973          a = Element('a') 
+3974          a.text = "A" 
+3975          a.tail = "tail" 
+3976          b = SubElement(a, 'b') 
+3977          b.text = "B" 
+3978          b.tail = _str("Søk på nettet") 
+3979          c = SubElement(a, 'c') 
+3980          c.text = "C" 
+3981   
+3982          result = tostring(a, method="text", encoding="UTF-16") 
+3983   
+3984          self.assertEqual(_str('ABSøk på nettetCtail').encode("UTF-16"), 
+3985                            result) 
+
3986   
+3987 -    def test_tostring_method_text_unicode(self): 
+
3988          tostring = self.etree.tostring 
+3989          Element = self.etree.Element 
+3990          SubElement = self.etree.SubElement 
+3991           
+3992          a = Element('a') 
+3993          a.text = _str('Søk på nettetA') 
+3994          a.tail = "tail" 
+3995          b = SubElement(a, 'b') 
+3996          b.text = "B" 
+3997          b.tail = _str('Søk på nettetB') 
+3998          c = SubElement(a, 'c') 
+3999          c.text = "C" 
+4000           
+4001          self.assertRaises(UnicodeEncodeError, 
+4002                            tostring, a, method="text") 
+4003           
+4004          self.assertEqual( 
+4005              _str('Søk på nettetABSøk på nettetBCtail').encode('utf-8'), 
+4006              tostring(a, encoding="UTF-8", method="text")) 
+
4007   
+4008 -    def test_tounicode(self): 
+
4009          tounicode = self.etree.tounicode 
+4010          Element = self.etree.Element 
+4011          SubElement = self.etree.SubElement 
+4012           
+4013          a = Element('a') 
+4014          b = SubElement(a, 'b') 
+4015          c = SubElement(a, 'c') 
+4016           
+4017          self.assertTrue(isinstance(tounicode(a), _unicode)) 
+4018          self.assertEqual(_bytes('<a><b></b><c></c></a>'), 
+4019                            canonicalize(tounicode(a))) 
+
4020   
+4021 -    def test_tounicode_element(self): 
+
4022          tounicode = self.etree.tounicode 
+4023          Element = self.etree.Element 
+4024          SubElement = self.etree.SubElement 
+4025           
+4026          a = Element('a') 
+4027          b = SubElement(a, 'b') 
+4028          c = SubElement(a, 'c') 
+4029          d = SubElement(c, 'd') 
+4030          self.assertTrue(isinstance(tounicode(b), _unicode)) 
+4031          self.assertTrue(isinstance(tounicode(c), _unicode)) 
+4032          self.assertEqual(_bytes('<b></b>'), 
+4033                            canonicalize(tounicode(b))) 
+4034          self.assertEqual(_bytes('<c><d></d></c>'), 
+4035                            canonicalize(tounicode(c))) 
+
4036   
+4037 -    def test_tounicode_none(self): 
+
4038          tounicode = self.etree.tounicode 
+4039          self.assertRaises(TypeError, self.etree.tounicode, None) 
+
4040   
+4041 -    def test_tounicode_element_tail(self): 
+
4042          tounicode = self.etree.tounicode 
+4043          Element = self.etree.Element 
+4044          SubElement = self.etree.SubElement 
+4045           
+4046          a = Element('a') 
+4047          b = SubElement(a, 'b') 
+4048          c = SubElement(a, 'c') 
+4049          d = SubElement(c, 'd') 
+4050          b.tail = 'Foo' 
+4051   
+4052          self.assertTrue(isinstance(tounicode(b), _unicode)) 
+4053          self.assertTrue(tounicode(b) == '<b/>Foo' or 
+4054                       tounicode(b) == '<b />Foo') 
+
4055   
+4056 -    def test_tounicode_pretty(self): 
+
4057          tounicode = self.etree.tounicode 
+4058          Element = self.etree.Element 
+4059          SubElement = self.etree.SubElement 
+4060   
+4061          a = Element('a') 
+4062          b = SubElement(a, 'b') 
+4063          c = SubElement(a, 'c') 
+4064   
+4065          result = tounicode(a) 
+4066          self.assertEqual(result, "<a><b/><c/></a>") 
+4067   
+4068          result = tounicode(a, pretty_print=False) 
+4069          self.assertEqual(result, "<a><b/><c/></a>") 
+4070   
+4071          result = tounicode(a, pretty_print=True) 
+4072          self.assertEqual(result, "<a>\n  <b/>\n  <c/>\n</a>\n") 
+
4073   
+4074 -    def test_tostring_unicode(self): 
+
4075          tostring = self.etree.tostring 
+4076          Element = self.etree.Element 
+4077          SubElement = self.etree.SubElement 
+4078           
+4079          a = Element('a') 
+4080          b = SubElement(a, 'b') 
+4081          c = SubElement(a, 'c') 
+4082           
+4083          self.assertTrue(isinstance(tostring(a, encoding=_unicode), _unicode)) 
+4084          self.assertEqual(_bytes('<a><b></b><c></c></a>'), 
+4085                            canonicalize(tostring(a, encoding=_unicode))) 
+
4086   
+4087 -    def test_tostring_unicode_element(self): 
+
4088          tostring = self.etree.tostring 
+4089          Element = self.etree.Element 
+4090          SubElement = self.etree.SubElement 
+4091           
+4092          a = Element('a') 
+4093          b = SubElement(a, 'b') 
+4094          c = SubElement(a, 'c') 
+4095          d = SubElement(c, 'd') 
+4096          self.assertTrue(isinstance(tostring(b, encoding=_unicode), _unicode)) 
+4097          self.assertTrue(isinstance(tostring(c, encoding=_unicode), _unicode)) 
+4098          self.assertEqual(_bytes('<b></b>'), 
+4099                            canonicalize(tostring(b, encoding=_unicode))) 
+4100          self.assertEqual(_bytes('<c><d></d></c>'), 
+4101                            canonicalize(tostring(c, encoding=_unicode))) 
+
4102   
+4103 -    def test_tostring_unicode_none(self): 
+
4104          tostring = self.etree.tostring 
+4105          self.assertRaises(TypeError, self.etree.tostring, 
+4106                            None, encoding=_unicode) 
+
4107   
+4108 -    def test_tostring_unicode_element_tail(self): 
+
4109          tostring = self.etree.tostring 
+4110          Element = self.etree.Element 
+4111          SubElement = self.etree.SubElement 
+4112           
+4113          a = Element('a') 
+4114          b = SubElement(a, 'b') 
+4115          c = SubElement(a, 'c') 
+4116          d = SubElement(c, 'd') 
+4117          b.tail = 'Foo' 
+4118   
+4119          self.assertTrue(isinstance(tostring(b, encoding=_unicode), _unicode)) 
+4120          self.assertTrue(tostring(b, encoding=_unicode) == '<b/>Foo' or 
+4121                       tostring(b, encoding=_unicode) == '<b />Foo') 
+
4122   
+4123 -    def test_tostring_unicode_pretty(self): 
+
4124          tostring = self.etree.tostring 
+4125          Element = self.etree.Element 
+4126          SubElement = self.etree.SubElement 
+4127   
+4128          a = Element('a') 
+4129          b = SubElement(a, 'b') 
+4130          c = SubElement(a, 'c') 
+4131   
+4132          result = tostring(a, encoding=_unicode) 
+4133          self.assertEqual(result, "<a><b/><c/></a>") 
+4134   
+4135          result = tostring(a, encoding=_unicode, pretty_print=False) 
+4136          self.assertEqual(result, "<a><b/><c/></a>") 
+4137   
+4138          result = tostring(a, encoding=_unicode, pretty_print=True) 
+4139          self.assertEqual(result, "<a>\n  <b/>\n  <c/>\n</a>\n") 
+
4140   
+4141 -    def test_pypy_proxy_collect(self): 
+
4142          root = etree.Element('parent') 
+4143          etree.SubElement(root, 'child') 
+4144   
+4145          self.assertEqual(len(root), 1) 
+4146          self.assertEqual(root[0].tag, 'child') 
+4147   
+4148          # in PyPy, GC used to kill the Python proxy instance without cleanup 
+4149          gc.collect() 
+4150          self.assertEqual(len(root), 1) 
+4151          self.assertEqual(root[0].tag, 'child') 
+
4152   
+4153 -    def test_element_refcycle(self): 
+
4154          class SubEl(etree.ElementBase): 
+4155              pass 
+
4156   
+4157          el1 = SubEl() 
+4158          el2 = SubEl() 
+4159          self.assertEqual('SubEl', el1.tag) 
+4160          self.assertEqual('SubEl', el2.tag) 
+4161          el1.other = el2 
+4162          el2.other = el1 
+4163   
+4164          del el1, el2 
+4165          gc.collect() 
+4166          # not really testing anything here, but it shouldn't crash 
+4167   
+4168 -    def test_proxy_collect_siblings(self): 
+
4169          root = etree.Element('parent') 
+4170          c1 = etree.SubElement(root, 'child1') 
+4171          c2 = etree.SubElement(root, 'child2') 
+4172   
+4173          root.remove(c1) 
+4174          root.remove(c2) 
+4175          c1.addnext(c2) 
+4176          del c1 
+4177          # trigger deallocation attempt of c1 
+4178          c2.getprevious() 
+4179          # make sure it wasn't deallocated 
+4180          self.assertEqual('child1', c2.getprevious().tag) 
+
4181   
+4182 -    def test_proxy_collect_siblings_text(self): 
+
4183          root = etree.Element('parent') 
+4184          c1 = etree.SubElement(root, 'child1') 
+4185          c2 = etree.SubElement(root, 'child2') 
+4186   
+4187          root.remove(c1) 
+4188          root.remove(c2) 
+4189          c1.addnext(c2) 
+4190          c1.tail = 'abc' 
+4191          c2.tail = 'xyz' 
+4192          del c1 
+4193          # trigger deallocation attempt of c1 
+4194          c2.getprevious() 
+4195          # make sure it wasn't deallocated 
+4196          self.assertEqual('child1', c2.getprevious().tag) 
+4197          self.assertEqual('abc', c2.getprevious().tail) 
+
4198   
+4199      # helper methods 
+4200   
+4201 -    def _writeElement(self, element, encoding='us-ascii', compression=0): 
+
4202          """Write out element for comparison. 
+4203          """ 
+4204          ElementTree = self.etree.ElementTree 
+4205          f = BytesIO() 
+4206          tree = ElementTree(element=element) 
+4207          tree.write(f, encoding=encoding, compression=compression) 
+4208          data = f.getvalue() 
+4209          if compression: 
+4210              data = zlib.decompress(data) 
+4211          return canonicalize(data) 
+
4212   
+4213   
+4214 -class _XIncludeTestCase(HelperTestCase): 
+
4215 -    def test_xinclude_text(self): 
+
4216          filename = fileInTestDir('test_broken.xml') 
+4217          root = etree.XML(_bytes('''\ 
+4218          <doc xmlns:xi="http://www.w3.org/2001/XInclude"> 
+4219            <xi:include href="%s" parse="text"/> 
+4220          </doc> 
+4221          ''' % path2url(filename))) 
+4222          old_text = root.text 
+4223          content = read_file(filename) 
+4224          old_tail = root[0].tail 
+4225   
+4226          self.include( etree.ElementTree(root) ) 
+4227          self.assertEqual(old_text + content + old_tail, 
+4228                            root.text) 
+
4229   
+4230 -    def test_xinclude(self): 
+
4231          tree = etree.parse(fileInTestDir('include/test_xinclude.xml')) 
+4232          self.assertNotEqual( 
+4233              'a', 
+4234              tree.getroot()[1].tag) 
+4235          # process xincludes 
+4236          self.include( tree ) 
+4237          # check whether we find it replaced with included data 
+4238          self.assertEqual( 
+4239              'a', 
+4240              tree.getroot()[1].tag) 
+
4241   
+4242 -    def test_xinclude_resolver(self): 
+
4243          class res(etree.Resolver): 
+4244              include_text = read_file(fileInTestDir('test.xml')) 
+4245              called = {} 
+4246              def resolve(self, url, id, context): 
+4247                  if url.endswith(".dtd"): 
+4248                      self.called["dtd"] = True 
+4249                      return self.resolve_filename( 
+4250                          fileInTestDir('test.dtd'), context) 
+4251                  elif url.endswith("test_xinclude.xml"): 
+4252                      self.called["input"] = True 
+4253                      return None # delegate to default resolver 
+4254                  else: 
+4255                      self.called["include"] = True 
+4256                      return self.resolve_string(self.include_text, context) 
+
4257   
+4258          res_instance = res() 
+4259          parser = etree.XMLParser(load_dtd = True) 
+4260          parser.resolvers.add(res_instance) 
+4261   
+4262          tree = etree.parse(fileInTestDir('include/test_xinclude.xml'), 
+4263                             parser = parser) 
+4264   
+4265          self.include(tree) 
+4266   
+4267          called = list(res_instance.called.items()) 
+4268          called.sort() 
+4269          self.assertEqual( 
+4270              [("dtd", True), ("include", True), ("input", True)], 
+4271              called) 
+4272   
+4273 -    def test_xinclude_resolver_recursive(self): 
+
4274          data = textwrap.dedent(''' 
+4275          <doc xmlns:xi="http://www.w3.org/2001/XInclude"> 
+4276          <foo/> 
+4277          <xi:include href="./test.xml" /> 
+4278          </doc> 
+4279          ''') 
+4280   
+4281          class Resolver(etree.Resolver): 
+4282              called = {} 
+4283   
+4284              def resolve(self, url, id, context): 
+4285                  if url.endswith("test_xinclude.xml"): 
+4286                      assert not self.called.get("input") 
+4287                      self.called["input"] = True 
+4288                      return None  # delegate to default resolver 
+4289                  elif url.endswith('/test5.xml'): 
+4290                      assert not self.called.get("DONE") 
+4291                      self.called["DONE"] = True 
+4292                      return self.resolve_string('<DONE/>', context) 
+4293                  else: 
+4294                      _, filename = url.rsplit('/', 1) 
+4295                      assert not self.called.get(filename) 
+4296                      self.called[filename] = True 
+4297                      next_data = data.replace( 
+4298                          'test.xml', 'test%d.xml' % len(self.called)) 
+4299                      return self.resolve_string(next_data, context) 
+
4300   
+4301          res_instance = Resolver() 
+4302          parser = etree.XMLParser(load_dtd=True) 
+4303          parser.resolvers.add(res_instance) 
+4304   
+4305          tree = etree.parse(fileInTestDir('include/test_xinclude.xml'), 
+4306                             parser=parser) 
+4307   
+4308          self.include(tree) 
+4309   
+4310          called = list(res_instance.called.items()) 
+4311          called.sort() 
+4312          self.assertEqual( 
+4313              [("DONE", True), ("input", True), ("test.xml", True), 
+4314               ("test2.xml", True), ("test3.xml", True), ("test4.xml", True)], 
+4315              called) 
+4316   
+4317   
+4318 -class ETreeXIncludeTestCase(_XIncludeTestCase): 
+
4319 -    def include(self, tree): 
+
4320          tree.xinclude() 
+
4321   
+4322   
+4323 -class ElementIncludeTestCase(_XIncludeTestCase): 
+
4324      from lxml import ElementInclude 
+4325   
+4326 -    def include(self, tree, loader=None, max_depth=None): 
+
4327          self.ElementInclude.include(tree.getroot(), loader=loader, max_depth=max_depth) 
+
4328   
+4329      XINCLUDE = {} 
+4330   
+4331      XINCLUDE["Recursive1.xml"] = """\ 
+4332      <?xml version='1.0'?> 
+4333      <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+4334        <p>The following is the source code of Recursive2.xml:</p> 
+4335        <xi:include href="Recursive2.xml"/> 
+4336      </document> 
+4337      """ 
+4338   
+4339      XINCLUDE["Recursive2.xml"] = """\ 
+4340      <?xml version='1.0'?> 
+4341      <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+4342        <p>The following is the source code of Recursive3.xml:</p> 
+4343        <xi:include href="Recursive3.xml"/> 
+4344      </document> 
+4345      """ 
+4346   
+4347      XINCLUDE["Recursive3.xml"] = """\ 
+4348      <?xml version='1.0'?> 
+4349      <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+4350        <p>The following is the source code of Recursive1.xml:</p> 
+4351        <xi:include href="Recursive1.xml"/> 
+4352      </document> 
+4353      """ 
+4354   
+4355      XINCLUDE["NonRecursive1.xml"] = """\ 
+4356      <?xml version='1.0'?> 
+4357      <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+4358        <p>The following is multiple times the source code of NonRecursive3.xml:</p> 
+4359        <xi:include href="NonRecursive3.xml"/> 
+4360        <xi:include href="NonRecursive3.xml"/> 
+4361        <p>The following is multiple times the source code of Leaf.xml:</p> 
+4362        <xi:include href="Leaf.xml"/> 
+4363        <xi:include href="Leaf.xml"/> 
+4364        <xi:include href="Leaf.xml"/> 
+4365        <p>One more time the source code of NonRecursive3.xml:</p> 
+4366        <xi:include href="NonRecursive3.xml"/> 
+4367      </document> 
+4368      """ 
+4369   
+4370      XINCLUDE["NonRecursive2.xml"] = """\ 
+4371      <?xml version='1.0'?> 
+4372      <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+4373        <p>The following is multiple times the source code of NonRecursive3.xml:</p> 
+4374        <xi:include href="NonRecursive3.xml"/> 
+4375        <xi:include href="NonRecursive3.xml"/> 
+4376      </document> 
+4377      """ 
+4378   
+4379      XINCLUDE["NonRecursive3.xml"] = """\ 
+4380      <?xml version='1.0'?> 
+4381      <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+4382        <p>The following is multiple times the source code of Leaf.xml:</p> 
+4383        <xi:include href="Leaf.xml"/> 
+4384        <xi:include href="Leaf.xml"/> 
+4385      </document> 
+4386      """ 
+4387   
+4388      XINCLUDE["Leaf.xml"] = """\ 
+4389      <?xml version='1.0'?> 
+4390      <document xmlns:xi="http://www.w3.org/2001/XInclude"> 
+4391        <p>No further includes</p> 
+4392      </document> 
+4393      """ 
+4394   
+4395 -    def xinclude_loader(self, href, parse="xml", encoding=None): 
+
4396          try: 
+4397              data = textwrap.dedent(self.XINCLUDE[href]) 
+4398          except KeyError: 
+4399              raise OSError("resource not found") 
+4400          if parse == "xml": 
+4401              data = etree.fromstring(data) 
+4402          return data 
+
4403   
+4404 -    def test_xinclude_failures(self): 
+
4405          # Test infinitely recursive includes. 
+4406          document = self.xinclude_loader("Recursive1.xml").getroottree() 
+4407          with self.assertRaises(self.ElementInclude.FatalIncludeError) as cm: 
+4408              self.include(document, self.xinclude_loader) 
+4409          self.assertEqual(str(cm.exception), 
+4410                           "recursive include of 'Recursive2.xml' detected") 
+4411   
+4412          # Test 'max_depth' limitation. 
+4413          document = self.xinclude_loader("Recursive1.xml").getroottree() 
+4414          with self.assertRaises(self.ElementInclude.FatalIncludeError) as cm: 
+4415              self.include(document, self.xinclude_loader, max_depth=None) 
+4416          self.assertEqual(str(cm.exception), 
+4417                           "recursive include of 'Recursive2.xml' detected") 
+4418   
+4419          document = self.xinclude_loader("Recursive1.xml").getroottree() 
+4420          with self.assertRaises(self.ElementInclude.LimitedRecursiveIncludeError) as cm: 
+4421              self.include(document, self.xinclude_loader, max_depth=0) 
+4422          self.assertEqual(str(cm.exception), 
+4423                           "maximum xinclude depth reached when including file Recursive2.xml") 
+4424   
+4425          document = self.xinclude_loader("Recursive1.xml").getroottree() 
+4426          with self.assertRaises(self.ElementInclude.LimitedRecursiveIncludeError) as cm: 
+4427              self.include(document, self.xinclude_loader, max_depth=1) 
+4428          self.assertEqual(str(cm.exception), 
+4429                           "maximum xinclude depth reached when including file Recursive3.xml") 
+4430   
+4431          document = self.xinclude_loader("Recursive1.xml").getroottree() 
+4432          with self.assertRaises(self.ElementInclude.LimitedRecursiveIncludeError) as cm: 
+4433              self.include(document, self.xinclude_loader, max_depth=2) 
+4434          self.assertEqual(str(cm.exception), 
+4435                           "maximum xinclude depth reached when including file Recursive1.xml") 
+4436   
+4437          document = self.xinclude_loader("Recursive1.xml").getroottree() 
+4438          with self.assertRaises(self.ElementInclude.FatalIncludeError) as cm: 
+4439              self.include(document, self.xinclude_loader, max_depth=3) 
+4440          self.assertEqual(str(cm.exception), 
+4441                           "recursive include of 'Recursive2.xml' detected") 
+
4442   
+4443 -    def test_multiple_include_of_same_file(self): 
+
4444          # Test that including the same file multiple times, but on the same level 
+4445          # is not detected as recursive include 
+4446          document = self.xinclude_loader("NonRecursive3.xml").getroottree() 
+4447          self.include(document, self.xinclude_loader) 
+4448   
+4449          # same but for more than one level 
+4450          document = self.xinclude_loader("NonRecursive1.xml").getroottree() 
+4451          self.include(document, self.xinclude_loader) 
+4452   
+4453          # same but no Leaf.xml in top-level file 
+4454          document = self.xinclude_loader("NonRecursive2.xml").getroottree() 
+4455          self.include(document, self.xinclude_loader) 
+
4456   
+4457   
+4458 -class ETreeC14NTestCase(HelperTestCase): 
+
4459 -    def test_c14n(self): 
+
4460          tree = self.parse(_bytes('<a><b/></a>')) 
+4461          f = BytesIO() 
+4462          tree.write_c14n(f) 
+4463          s = f.getvalue() 
+4464          self.assertEqual(_bytes('<a><b></b></a>'), 
+4465                            s) 
+
4466   
+4467 -    def test_c14n_gzip(self): 
+
4468          tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 
+4469          f = BytesIO() 
+4470          tree.write_c14n(f, compression=9) 
+4471          with gzip.GzipFile(fileobj=BytesIO(f.getvalue())) as gzfile: 
+4472              s = gzfile.read() 
+4473          self.assertEqual(_bytes('<a>'+'<b></b>'*200+'</a>'), 
+4474                            s) 
+
4475   
+4476 -    def test_c14n_file(self): 
+
4477          tree = self.parse(_bytes('<a><b/></a>')) 
+4478          with tmpfile() as filename: 
+4479              tree.write_c14n(filename) 
+4480              data = read_file(filename, 'rb') 
+4481          self.assertEqual(_bytes('<a><b></b></a>'), 
+4482                            data) 
+
4483   
+4484 -    def test_c14n_file_gzip(self): 
+
4485          tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 
+4486          with tmpfile() as filename: 
+4487              tree.write_c14n(filename, compression=9) 
+4488              with gzip.open(filename, 'rb') as f: 
+4489                  data = f.read() 
+4490          self.assertEqual(_bytes('<a>'+'<b></b>'*200+'</a>'), 
+4491                            data) 
+
4492   
+4493 -    def test_c14n2_file_gzip(self): 
+
4494          tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 
+4495          with tmpfile() as filename: 
+4496              tree.write(filename, method='c14n2', compression=9) 
+4497              with gzip.open(filename, 'rb') as f: 
+4498                  data = f.read() 
+4499          self.assertEqual(_bytes('<a>'+'<b></b>'*200+'</a>'), 
+4500                            data) 
+
4501   
+4502 -    def test_c14n2_with_text(self): 
+
4503          tree = self.parse( 
+4504              b'<?xml version="1.0"?>    <a> abc \n <b>  btext </b> btail <c/>    ctail </a>     ') 
+4505          f = BytesIO() 
+4506          tree.write(f, method='c14n2') 
+4507          s = f.getvalue() 
+4508          self.assertEqual(b'<a> abc \n <b>  btext </b> btail <c></c>    ctail </a>', 
+4509                           s) 
+4510   
+4511          f = BytesIO() 
+4512          tree.write(f, method='c14n2', strip_text=True) 
+4513          s = f.getvalue() 
+4514          self.assertEqual(b'<a>abc<b>btext</b>btail<c></c>ctail</a>', 
+4515                           s) 
+
4516   
+4517 -    def test_c14n_with_comments(self): 
+
4518          tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->')) 
+4519          f = BytesIO() 
+4520          tree.write_c14n(f) 
+4521          s = f.getvalue() 
+4522          self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 
+4523                            s) 
+4524          f = BytesIO() 
+4525          tree.write_c14n(f, with_comments=True) 
+4526          s = f.getvalue() 
+4527          self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 
+4528                            s) 
+4529          f = BytesIO() 
+4530          tree.write_c14n(f, with_comments=False) 
+4531          s = f.getvalue() 
+4532          self.assertEqual(_bytes('<a><b></b></a>'), 
+4533                            s) 
+
4534   
+4535 -    def test_c14n2_with_comments(self): 
+
4536          tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->')) 
+4537          f = BytesIO() 
+4538          tree.write(f, method='c14n2') 
+4539          s = f.getvalue() 
+4540          self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 
+4541                            s) 
+4542          f = BytesIO() 
+4543          tree.write(f, method='c14n2', with_comments=True) 
+4544          s = f.getvalue() 
+4545          self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 
+4546                            s) 
+4547          f = BytesIO() 
+4548          tree.write(f, method='c14n2', with_comments=False) 
+4549          s = f.getvalue() 
+4550          self.assertEqual(_bytes('<a><b></b></a>'), 
+4551                            s) 
+
4552   
+4553 -    def test_c14n_tostring_with_comments(self): 
+
4554          tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->')) 
+4555          s = etree.tostring(tree, method='c14n') 
+4556          self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 
+4557                            s) 
+4558          s = etree.tostring(tree, method='c14n', with_comments=True) 
+4559          self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'), 
+4560                            s) 
+4561          s = etree.tostring(tree, method='c14n', with_comments=False) 
+4562          self.assertEqual(_bytes('<a><b></b></a>'), 
+4563                            s) 
+
4564   
+4565 -    def test_c14n2_tostring_with_comments(self): 
+
4566          tree = self.parse(b'<!--hi--><a><!--ho--><b/></a><!--hu-->') 
+4567          s = etree.tostring(tree, method='c14n2') 
+4568          self.assertEqual(b'<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->', 
+4569                            s) 
+4570          s = etree.tostring(tree, method='c14n2', with_comments=True) 
+4571          self.assertEqual(b'<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->', 
+4572                            s) 
+4573          s = etree.tostring(tree, method='c14n2', with_comments=False) 
+4574          self.assertEqual(b'<a><b></b></a>', 
+4575                            s) 
+
4576   
+4577 -    def test_c14n_element_tostring_with_comments(self): 
+
4578          tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->')) 
+4579          s = etree.tostring(tree.getroot(), method='c14n') 
+4580          self.assertEqual(_bytes('<a><!--ho--><b></b></a>'), 
+4581                            s) 
+4582          s = etree.tostring(tree.getroot(), method='c14n', with_comments=True) 
+4583          self.assertEqual(_bytes('<a><!--ho--><b></b></a>'), 
+4584                            s) 
+4585          s = etree.tostring(tree.getroot(), method='c14n', with_comments=False) 
+4586          self.assertEqual(_bytes('<a><b></b></a>'), 
+4587                            s) 
+
4588   
+4589 -    def test_c14n_exclusive(self): 
+
4590          tree = self.parse(_bytes( 
+4591                  '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 
+4592          f = BytesIO() 
+4593          tree.write_c14n(f) 
+4594          s = f.getvalue() 
+4595          self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 
+4596                            s) 
+4597          f = BytesIO() 
+4598          tree.write_c14n(f, exclusive=False) 
+4599          s = f.getvalue() 
+4600          self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 
+4601                            s) 
+4602          f = BytesIO() 
+4603          tree.write_c14n(f, exclusive=True) 
+4604          s = f.getvalue() 
+4605          self.assertEqual(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'), 
+4606                            s) 
+4607   
+4608          f = BytesIO() 
+4609          tree.write_c14n(f, exclusive=True, inclusive_ns_prefixes=['z']) 
+4610          s = f.getvalue() 
+4611          self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:z="http://cde"><z:b></z:b></a>'), 
+4612                            s) 
+
4613   
+4614 -    def test_c14n_tostring_exclusive(self): 
+
4615          tree = self.parse(_bytes( 
+4616                  '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 
+4617          s = etree.tostring(tree, method='c14n') 
+4618          self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 
+4619                            s) 
+4620          s = etree.tostring(tree, method='c14n', exclusive=False) 
+4621          self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 
+4622                            s) 
+4623          s = etree.tostring(tree, method='c14n', exclusive=True) 
+4624          self.assertEqual(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'), 
+4625                            s) 
+4626   
+4627          s = etree.tostring(tree, method='c14n', exclusive=True, inclusive_ns_prefixes=['y']) 
+4628          self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd"><z:b xmlns:z="http://cde"></z:b></a>'), 
+4629                            s) 
+
4630   
+4631 -    def test_c14n_element_tostring_exclusive(self): 
+
4632          tree = self.parse(_bytes( 
+4633                  '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 
+4634          s = etree.tostring(tree.getroot(), method='c14n') 
+4635          self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 
+4636                            s) 
+4637          s = etree.tostring(tree.getroot(), method='c14n', exclusive=False) 
+4638          self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 
+4639                            s) 
+4640          s = etree.tostring(tree.getroot(), method='c14n', exclusive=True) 
+4641          self.assertEqual(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'), 
+4642                            s) 
+4643   
+4644          s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=False) 
+4645          self.assertEqual(_bytes('<z:b xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"></z:b>'), 
+4646                            s) 
+4647          s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=True) 
+4648          self.assertEqual(_bytes('<z:b xmlns:z="http://cde"></z:b>'), 
+4649                            s) 
+4650   
+4651          s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=True, inclusive_ns_prefixes=['y']) 
+4652          self.assertEqual(_bytes('<z:b xmlns:y="http://bcd" xmlns:z="http://cde"></z:b>'), 
+4653                            s) 
+
4654   
+4655 -    def test_c14n_tostring_inclusive_ns_prefixes(self): 
+
4656          """ Regression test to fix memory allocation issues (use 3+ inclusive NS spaces)""" 
+4657          tree = self.parse(_bytes( 
+4658                  '<a xmlns:x="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>')) 
+4659   
+4660          s = etree.tostring(tree, method='c14n', exclusive=True, inclusive_ns_prefixes=['x', 'y', 'z']) 
+4661          self.assertEqual(_bytes('<a xmlns:x="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'), 
+4662                            s) 
+
4663   
+4664   
+4665 -class ETreeWriteTestCase(HelperTestCase): 
+
4666 -    def test_write(self): 
+
4667          tree = self.parse(_bytes('<a><b/></a>')) 
+4668          f = BytesIO() 
+4669          tree.write(f) 
+4670          s = f.getvalue() 
+4671          self.assertEqual(_bytes('<a><b/></a>'), 
+4672                            s) 
+
4673   
+4674 -    def test_write_doctype(self): 
+
4675          tree = self.parse(_bytes('<a><b/></a>')) 
+4676          f = BytesIO() 
+4677          tree.write(f, doctype='HUHU') 
+4678          s = f.getvalue() 
+4679          self.assertEqual(_bytes('HUHU\n<a><b/></a>'), 
+4680                            s) 
+
4681   
+4682 -    def test_write_gzip(self): 
+
4683          tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 
+4684          f = BytesIO() 
+4685          tree.write(f, compression=9) 
+4686          with gzip.GzipFile(fileobj=BytesIO(f.getvalue())) as gzfile: 
+4687              s = gzfile.read() 
+4688          self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'), 
+4689                            s) 
+
4690   
+4691 -    def test_write_gzip_doctype(self): 
+
4692          tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 
+4693          f = BytesIO() 
+4694          tree.write(f, compression=9, doctype='<!DOCTYPE a>') 
+4695          with gzip.GzipFile(fileobj=BytesIO(f.getvalue())) as gzfile: 
+4696              s = gzfile.read() 
+4697          self.assertEqual(_bytes('<!DOCTYPE a>\n<a>'+'<b/>'*200+'</a>'), 
+4698                            s) 
+
4699   
+4700 -    def test_write_gzip_level(self): 
+
4701          tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 
+4702          f = BytesIO() 
+4703          tree.write(f, compression=0) 
+4704          s0 = f.getvalue() 
+4705   
+4706          f = BytesIO() 
+4707          tree.write(f) 
+4708          self.assertEqual(f.getvalue(), s0) 
+4709   
+4710          f = BytesIO() 
+4711          tree.write(f, compression=1) 
+4712          s = f.getvalue() 
+4713          self.assertTrue(len(s) <= len(s0)) 
+4714          with gzip.GzipFile(fileobj=BytesIO(s)) as gzfile: 
+4715              s1 = gzfile.read() 
+4716   
+4717          f = BytesIO() 
+4718          tree.write(f, compression=9) 
+4719          s = f.getvalue() 
+4720          self.assertTrue(len(s) <= len(s0)) 
+4721          with gzip.GzipFile(fileobj=BytesIO(s)) as gzfile: 
+4722              s9 = gzfile.read() 
+4723   
+4724          self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'), 
+4725                            s0) 
+4726          self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'), 
+4727                            s1) 
+4728          self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'), 
+4729                            s9) 
+
4730   
+4731 -    def test_write_file(self): 
+
4732          tree = self.parse(_bytes('<a><b/></a>')) 
+4733          with tmpfile() as filename: 
+4734              tree.write(filename) 
+4735              data = read_file(filename, 'rb') 
+4736          self.assertEqual(_bytes('<a><b/></a>'), 
+4737                            data) 
+
4738   
+4739 -    def test_write_file_gzip(self): 
+
4740          tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 
+4741          with tmpfile() as filename: 
+4742              tree.write(filename, compression=9) 
+4743              with gzip.open(filename, 'rb') as f: 
+4744                  data = f.read() 
+4745          self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'), 
+4746                            data) 
+
4747   
+4748 -    def test_write_file_gzip_parse(self): 
+
4749          tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 
+4750          with tmpfile() as filename: 
+4751              tree.write(filename, compression=9) 
+4752              data = etree.tostring(etree.parse(filename)) 
+4753          self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'), 
+4754                            data) 
+
4755   
+4756 -    def test_write_file_gzipfile_parse(self): 
+
4757          tree = self.parse(_bytes('<a>'+'<b/>'*200+'</a>')) 
+4758          with tmpfile() as filename: 
+4759              tree.write(filename, compression=9) 
+4760              with gzip.GzipFile(filename) as f: 
+4761                  data = etree.tostring(etree.parse(f)) 
+4762          self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'), 
+4763                            data) 
+
4764   
+4765 -    def test_write_file_url(self): 
+
4766          xml = _bytes('<a>'+'<b/>'*200+'</a>') 
+4767          tree = self.parse(xml) 
+4768          with tmpfile(prefix="p+%20", suffix=".xml") as filename: 
+4769              url = 'file://' + (filename if sys.platform != 'win32' 
+4770                                 else '/' + filename.replace('\\', '/')) 
+4771              tree.write(url) 
+4772              data = read_file(filename, 'rb').replace(_bytes('\n'), _bytes('')) 
+4773          self.assertEqual(data, xml) 
+
4774   
+4775   
+4776 -class ETreeErrorLogTest(HelperTestCase): 
+
4777      etree = etree 
+4778   
+4779 -    def test_parse_error_logging(self): 
+
4780          parse = self.etree.parse 
+4781          f = BytesIO('<a><b></c></b></a>') 
+4782          self.etree.clear_error_log() 
+4783          try: 
+4784              parse(f) 
+4785              logs = None 
+4786          except SyntaxError: 
+4787              e = sys.exc_info()[1] 
+4788              logs = e.error_log 
+4789          f.close() 
+4790          self.assertTrue([ log for log in logs 
+4791                         if 'mismatch' in log.message ]) 
+4792          self.assertTrue([ log for log in logs 
+4793                         if 'PARSER'   in log.domain_name]) 
+4794          self.assertTrue([ log for log in logs 
+4795                         if 'ERR_TAG_NAME_MISMATCH' in log.type_name ]) 
+4796          self.assertTrue([ log for log in logs 
+4797                         if 1 == log.line ]) 
+4798          self.assertTrue([ log for log in logs 
+4799                         if 15 == log.column ]) 
+
4800   
+4801 -    def _test_python_error_logging(self): 
+
4802          """This can't really be tested as long as there isn't a way to 
+4803          reset the logging setup ... 
+4804          """ 
+4805          parse = self.etree.parse 
+4806   
+4807          messages = [] 
+4808          class Logger(self.etree.PyErrorLog): 
+4809              def log(self, entry, message, *args): 
+4810                  messages.append(message) 
+
4811   
+4812          self.etree.use_global_python_log(Logger()) 
+4813          f = BytesIO('<a><b></c></b></a>') 
+4814          try: 
+4815              parse(f) 
+4816          except SyntaxError: 
+4817              pass 
+4818          f.close() 
+4819   
+4820          self.assertTrue([ message for message in messages 
+4821                         if 'mismatch' in message ]) 
+4822          self.assertTrue([ message for message in messages 
+4823                         if ':PARSER:'   in message]) 
+4824          self.assertTrue([ message for message in messages 
+4825                         if ':ERR_TAG_NAME_MISMATCH:' in message ]) 
+4826          self.assertTrue([ message for message in messages 
+4827                         if ':1:15:' in message ]) 
+4828   
+4829   
+4830 -class XMLPullParserTest(unittest.TestCase): 
+
4831      etree = etree 
+4832   
+4833 -    def assert_event_tags(self, events, expected): 
+
4834          self.assertEqual([(action, elem.tag) for action, elem in events], 
+4835                           expected) 
+
4836   
+4837 -    def test_pull_from_simple_target(self): 
+
4838          class Target(object): 
+4839              def start(self, tag, attrib): 
+4840                  return 'start(%s)' % tag 
+
4841              def end(self, tag): 
+4842                  return 'end(%s)' % tag 
+
4843              def close(self): 
+4844                  return 'close()' 
+4845   
+4846          parser = self.etree.XMLPullParser(target=Target()) 
+4847          events = parser.read_events() 
+4848   
+4849          parser.feed('<root><element>') 
+4850          self.assertFalse(list(events)) 
+4851          self.assertFalse(list(events)) 
+4852          parser.feed('</element><child>') 
+4853          self.assertEqual([('end', 'end(element)')], list(events)) 
+4854          parser.feed('</child>') 
+4855          self.assertEqual([('end', 'end(child)')], list(events)) 
+4856          parser.feed('</root>') 
+4857          self.assertEqual([('end', 'end(root)')], list(events)) 
+4858          self.assertFalse(list(events)) 
+4859          self.assertEqual('close()', parser.close()) 
+4860   
+4861 -    def test_pull_from_simple_target_start_end(self): 
+
4862          class Target(object): 
+4863              def start(self, tag, attrib): 
+4864                  return 'start(%s)' % tag 
+
4865              def end(self, tag): 
+4866                  return 'end(%s)' % tag 
+4867              def close(self): 
+4868                  return 'close()' 
+4869   
+4870          parser = self.etree.XMLPullParser( 
+4871              ['start', 'end'], target=Target()) 
+4872          events = parser.read_events() 
+4873   
+4874          parser.feed('<root><element>') 
+4875          self.assertEqual( 
+4876              [('start', 'start(root)'), ('start', 'start(element)')], 
+4877              list(events)) 
+4878          self.assertFalse(list(events)) 
+4879          parser.feed('</element><child>') 
+4880          self.assertEqual( 
+4881              [('end', 'end(element)'), ('start', 'start(child)')], 
+4882              list(events)) 
+4883          parser.feed('</child>') 
+4884          self.assertEqual( 
+4885              [('end', 'end(child)')], 
+4886              list(events)) 
+4887          parser.feed('</root>') 
+4888          self.assertEqual( 
+4889              [('end', 'end(root)')], 
+4890              list(events)) 
+4891          self.assertFalse(list(events)) 
+4892          self.assertEqual('close()', parser.close()) 
+4893   
+4894 -    def test_pull_from_tree_builder(self): 
+
4895          parser = self.etree.XMLPullParser( 
+4896              ['start', 'end'], target=etree.TreeBuilder()) 
+4897          events = parser.read_events() 
+4898   
+4899          parser.feed('<root><element>') 
+4900          self.assert_event_tags( 
+4901              events, [('start', 'root'), ('start', 'element')]) 
+4902          self.assertFalse(list(events)) 
+4903          parser.feed('</element><child>') 
+4904          self.assert_event_tags( 
+4905              events, [('end', 'element'), ('start', 'child')]) 
+4906          parser.feed('</child>') 
+4907          self.assert_event_tags( 
+4908              events, [('end', 'child')]) 
+4909          parser.feed('</root>') 
+4910          self.assert_event_tags( 
+4911              events, [('end', 'root')]) 
+4912          self.assertFalse(list(events)) 
+4913          root = parser.close() 
+4914          self.assertEqual('root', root.tag) 
+
4915   
+4916 -    def test_pull_from_tree_builder_subclass(self): 
+
4917          class Target(etree.TreeBuilder): 
+4918              def end(self, tag): 
+4919                  el = super(Target, self).end(tag) 
+4920                  el.tag += '-huhu' 
+4921                  return el 
+
4922   
+4923          parser = self.etree.XMLPullParser( 
+4924              ['start', 'end'], target=Target()) 
+4925          events = parser.read_events() 
+4926   
+4927          parser.feed('<root><element>') 
+4928          self.assert_event_tags( 
+4929              events, [('start', 'root'), ('start', 'element')]) 
+4930          self.assertFalse(list(events)) 
+4931          parser.feed('</element><child>') 
+4932          self.assert_event_tags( 
+4933              events, [('end', 'element-huhu'), ('start', 'child')]) 
+4934          parser.feed('</child>') 
+4935          self.assert_event_tags( 
+4936              events, [('end', 'child-huhu')]) 
+4937          parser.feed('</root>') 
+4938          self.assert_event_tags( 
+4939              events, [('end', 'root-huhu')]) 
+4940          self.assertFalse(list(events)) 
+4941          root = parser.close() 
+4942          self.assertEqual('root-huhu', root.tag) 
+4943   
+4944   
+4945 -def test_suite(): 
+
4946      suite = unittest.TestSuite() 
+4947      suite.addTests([unittest.makeSuite(ETreeOnlyTestCase)]) 
+4948      suite.addTests([unittest.makeSuite(ETreeXIncludeTestCase)]) 
+4949      suite.addTests([unittest.makeSuite(ElementIncludeTestCase)]) 
+4950      suite.addTests([unittest.makeSuite(ETreeC14NTestCase)]) 
+4951      suite.addTests([unittest.makeSuite(ETreeWriteTestCase)]) 
+4952      suite.addTests([unittest.makeSuite(ETreeErrorLogTest)]) 
+4953      suite.addTests([unittest.makeSuite(XMLPullParserTest)]) 
+4954   
+4955      # add original doctests from ElementTree selftest modules 
+4956      from . import selftest, selftest2 
+4957      suite.addTests(doctest.DocTestSuite(selftest)) 
+4958      suite.addTests(doctest.DocTestSuite(selftest2)) 
+4959   
+4960      # add doctests 
+4961      suite.addTests(doctest.DocTestSuite(etree)) 
+4962      suite.addTests( 
+4963          [make_doctest('../../../doc/tutorial.txt')]) 
+4964      suite.addTests( 
+4965          [make_doctest('../../../doc/api.txt')]) 
+4966      suite.addTests( 
+4967          [make_doctest('../../../doc/FAQ.txt')]) 
+4968      suite.addTests( 
+4969          [make_doctest('../../../doc/parsing.txt')]) 
+4970      suite.addTests( 
+4971          [make_doctest('../../../doc/resolvers.txt')]) 
+4972      return suite 
+
4973   
+4974   
+4975  if __name__ == '__main__': 
+4976      print('to test use test.py %s' % __file__) 
+4977   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeC14NTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeErrorLogTest
+
lxml.etree
lxml.etree
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeOnlyTestCase
+
lxml.etree
lxml.etree
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeWriteTestCase
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+                _XIncludeTestCase --+
+                                    |
+                                   ETreeXIncludeTestCase
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+                _XIncludeTestCase --+
+                                    |
+                                   ElementIncludeTestCase
+
+{'Leaf.xml': '''    <?xml version=\'1.0\'?>
+    <document xmlns:xi="http://www.w3.org/2001/XInclude">
+      <p>No further includes</p>
+    </document>
+    ''',
+ 'NonRecursive1.xml': '''    <?xml version=\'1.0\'?>
+    <document xmlns:xi="http://www.w3.org/2001/XInclude">
+      <p>The following is multiple times the source code of NonRecursi
+...
+
+            object --+    
+                     |    
+unittest.case.TestCase --+
+                         |
+                        XMLPullParserTest
+
lxml.etree
lxml.etree
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               _XIncludeTestCase
+
+  1  # -*- coding: utf-8 -*- 
+  2  """ 
+  3  Test cases related to direct loading of external libxml2 documents 
+  4  """ 
+  5   
+  6  from __future__ import absolute_import 
+  7   
+  8  import sys 
+  9  import unittest 
+ 10   
+ 11  from .common_imports import HelperTestCase, etree 
+ 12   
+ 13  DOC_NAME = b'libxml2:xmlDoc' 
+ 14  DESTRUCTOR_NAME = b'destructor:xmlFreeDoc' 
+ 15   
+ 16   
+ 17 -class ExternalDocumentTestCase(HelperTestCase): 
+
 18 -    def setUp(self): 
+
 19          try: 
+ 20              import ctypes 
+ 21              from ctypes import pythonapi 
+ 22              from ctypes.util import find_library 
+ 23          except ImportError: 
+ 24              raise unittest.SkipTest("ctypes support missing") 
+ 25   
+ 26          def wrap(func, restype, *argtypes): 
+ 27              func.restype = restype 
+ 28              func.argtypes = list(argtypes) 
+ 29              return func 
+
 30   
+ 31          self.get_capsule_name = wrap(pythonapi.PyCapsule_GetName, 
+ 32                                       ctypes.c_char_p, ctypes.py_object) 
+ 33          self.capsule_is_valid = wrap(pythonapi.PyCapsule_IsValid, ctypes.c_int, 
+ 34                                       ctypes.py_object, ctypes.c_char_p) 
+ 35          self.new_capsule = wrap(pythonapi.PyCapsule_New, ctypes.py_object, 
+ 36                                  ctypes.c_void_p, ctypes.c_char_p, 
+ 37                                  ctypes.c_void_p) 
+ 38          self.set_capsule_name = wrap(pythonapi.PyCapsule_SetName, ctypes.c_int, 
+ 39                                       ctypes.py_object, ctypes.c_char_p) 
+ 40          self.set_capsule_context = wrap(pythonapi.PyCapsule_SetContext, 
+ 41                                          ctypes.c_int, ctypes.py_object, 
+ 42                                          ctypes.c_char_p) 
+ 43          self.get_capsule_context = wrap(pythonapi.PyCapsule_GetContext, 
+ 44                                          ctypes.c_char_p, ctypes.py_object) 
+ 45          self.get_capsule_pointer = wrap(pythonapi.PyCapsule_GetPointer, 
+ 46                                          ctypes.c_void_p, ctypes.py_object, 
+ 47                                          ctypes.c_char_p) 
+ 48          self.set_capsule_pointer = wrap(pythonapi.PyCapsule_SetPointer, 
+ 49                                          ctypes.c_int, ctypes.py_object, 
+ 50                                          ctypes.c_void_p) 
+ 51          self.set_capsule_destructor = wrap(pythonapi.PyCapsule_SetDestructor, 
+ 52                                             ctypes.c_int, ctypes.py_object, 
+ 53                                             ctypes.c_void_p) 
+ 54          self.PyCapsule_Destructor = ctypes.CFUNCTYPE(None, ctypes.py_object) 
+ 55          libxml2 = ctypes.CDLL(find_library('xml2')) 
+ 56          self.create_doc = wrap(libxml2.xmlReadMemory, ctypes.c_void_p, 
+ 57                                 ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, 
+ 58                                 ctypes.c_char_p, ctypes.c_int) 
+ 59          self.free_doc = wrap(libxml2.xmlFreeDoc, None, ctypes.c_void_p) 
+
 60   
+ 61 -    def as_capsule(self, text, capsule_name=DOC_NAME): 
+
 62          if not isinstance(text, bytes): 
+ 63              text = text.encode('utf-8') 
+ 64          doc = self.create_doc(text, len(text), b'base.xml', b'utf-8', 0) 
+ 65          ans = self.new_capsule(doc, capsule_name, None) 
+ 66          self.set_capsule_context(ans, DESTRUCTOR_NAME) 
+ 67          return ans 
+
 68   
+ 69 -    def test_external_document_adoption(self): 
+
 70          xml = '<r a="1">t</r>' 
+ 71          self.assertRaises(TypeError, etree.adopt_external_document, None) 
+ 72          capsule = self.as_capsule(xml) 
+ 73          self.assertTrue(self.capsule_is_valid(capsule, DOC_NAME)) 
+ 74          self.assertEqual(DOC_NAME, self.get_capsule_name(capsule)) 
+ 75          # Create an lxml tree from the capsule (this is a move not a copy) 
+ 76          root = etree.adopt_external_document(capsule).getroot() 
+ 77          self.assertIsNone(self.get_capsule_name(capsule)) 
+ 78          self.assertEqual(root.text, 't') 
+ 79          root.text = 'new text' 
+ 80          # Now reset the capsule so we can copy it 
+ 81          self.assertEqual(0, self.set_capsule_name(capsule, DOC_NAME)) 
+ 82          self.assertEqual(0, self.set_capsule_context(capsule, b'invalid')) 
+ 83          # Create an lxml tree from the capsule (this is a copy not a move) 
+ 84          root2 = etree.adopt_external_document(capsule).getroot() 
+ 85          self.assertEqual(self.get_capsule_context(capsule), b'invalid') 
+ 86          # Check that the modification to the tree using the transferred 
+ 87          # document was successful 
+ 88          self.assertEqual(root.text, root2.text) 
+ 89          # Check that further modifications do not show up in the copy (they are 
+ 90          # disjoint) 
+ 91          root.text = 'other text' 
+ 92          self.assertNotEqual(root.text, root2.text) 
+ 93          # delete root and ensure root2 survives 
+ 94          del root 
+ 95          self.assertEqual(root2.text, 'new text') 
+
 96   
+ 97   
+ 98 -def test_suite(): 
+
 99      suite = unittest.TestSuite() 
+100      if sys.platform != 'win32': 
+101          suite.addTests([unittest.makeSuite(ExternalDocumentTestCase)]) 
+102      return suite 
+
103   
+104   
+105  if __name__ == '__main__': 
+106      print('to test use test.py %s' % __file__) 
+107   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ExternalDocumentTestCase
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  HTML parser test cases for etree 
+  5  """ 
+  6   
+  7  import unittest 
+  8  import tempfile, os, os.path, sys 
+  9   
+ 10  this_dir = os.path.dirname(__file__) 
+ 11  if this_dir not in sys.path: 
+ 12      sys.path.insert(0, this_dir) # needed for Py3 
+ 13   
+ 14  from common_imports import etree, html, StringIO, BytesIO, fileInTestDir, _bytes, _str 
+ 15  from common_imports import SillyFileLike, HelperTestCase, write_to_file, next 
+ 16   
+ 17  try: 
+ 18      unicode 
+ 19  except NameError: 
+ 20      unicode = str 
+ 21   
+ 22   
+ 23 -class HtmlParserTestCase(HelperTestCase): 
+
 24      """HTML parser test cases 
+ 25      """ 
+ 26      etree = etree 
+ 27   
+ 28      html_str = _bytes("<html><head><title>test</title></head><body><h1>page title</h1></body></html>") 
+ 29      html_str_pretty = _bytes("""\ 
+ 30  <html> 
+ 31  <head><title>test</title></head> 
+ 32  <body><h1>page title</h1></body> 
+ 33  </html> 
+ 34  """) 
+ 35      broken_html_str = _bytes("<html><head><title>test" 
+ 36                               "<body><h1>page title</h3></p></html>") 
+ 37      uhtml_str = _bytes( 
+ 38          "<html><head><title>test Ã¡</title></head>" 
+ 39          "<body><h1>page Ã¡ title</h1></body></html>").decode('utf8') 
+ 40   
+ 41 -    def tearDown(self): 
+
 42          super(HtmlParserTestCase, self).tearDown() 
+ 43          self.etree.set_default_parser() 
+
 44   
+ 45 -    def test_module_HTML(self): 
+
 46          element = self.etree.HTML(self.html_str) 
+ 47          self.assertEqual(self.etree.tostring(element, method="html"), 
+ 48                           self.html_str) 
+
 49   
+ 50 -    def test_module_HTML_unicode(self): 
+
 51          element = self.etree.HTML(self.uhtml_str) 
+ 52          self.assertEqual( 
+ 53              self.etree.tostring(element, method="html", encoding='unicode'), 
+ 54              self.uhtml_str) 
+ 55          self.assertEqual(element.findtext('.//h1'), 
+ 56                           _bytes("page Ã¡ title").decode('utf8')) 
+
 57   
+ 58 -    def test_wide_unicode_xml(self): 
+
 59          if sys.maxunicode < 1114111: 
+ 60              return  # skip test 
+ 61          element = self.etree.HTML(_bytes( 
+ 62              '<html><body><p>\\U00026007</p></body></html>' 
+ 63          ).decode('unicode_escape')) 
+ 64          p_text = element.findtext('.//p') 
+ 65          self.assertEqual(1, len(p_text)) 
+ 66          self.assertEqual(_bytes('\\U00026007').decode('unicode_escape'), 
+ 67                           p_text) 
+
 68   
+ 69 -    def test_html_ids(self): 
+
 70          parser = self.etree.HTMLParser(recover=False) 
+ 71          fromstring = self.etree.fromstring 
+ 72          html = fromstring(''' 
+ 73              <html><body id="bodyID"><p id="pID"></p></body></html> 
+ 74          ''', parser=parser) 
+ 75          self.assertEqual(len(html.xpath('//p[@id="pID"]')), 1) 
+
 76   
+ 77 -    def test_html_ids_no_collect_ids(self): 
+
 78          parser = self.etree.HTMLParser(recover=False, collect_ids=False) 
+ 79          fromstring = self.etree.fromstring 
+ 80          html = fromstring(''' 
+ 81              <html><body id="bodyID"><p id="pID"></p></body></html> 
+ 82          ''', parser=parser) 
+ 83          self.assertEqual(len(html.xpath('//p[@id="pID"]')), 1) 
+
 84   
+ 85 -    def test_module_HTML_pretty_print(self): 
+
 86          element = self.etree.HTML(self.html_str) 
+ 87          self.assertEqual(self.etree.tostring(element, method="html", pretty_print=True), 
+ 88                           self.html_str_pretty) 
+
 89   
+ 90 -    def test_module_parse_html_error(self): 
+
 91          parser = self.etree.HTMLParser(recover=False) 
+ 92          parse = self.etree.parse 
+ 93          f = BytesIO("<html></body>") 
+ 94          self.assertRaises(self.etree.XMLSyntaxError, 
+ 95                            parse, f, parser) 
+
 96   
+ 97 -    def test_html_element_name_empty(self): 
+
 98          parser = self.etree.HTMLParser() 
+ 99          Element = parser.makeelement 
+100   
+101          el = Element('name') 
+102          self.assertRaises(ValueError, Element, '{}') 
+103          self.assertRaises(ValueError, setattr, el, 'tag', '{}') 
+104   
+105          self.assertRaises(ValueError, Element, '{test}') 
+106          self.assertRaises(ValueError, setattr, el, 'tag', '{test}') 
+
107   
+108 -    def test_html_element_name_colon(self): 
+
109          parser = self.etree.HTMLParser() 
+110          Element = parser.makeelement 
+111   
+112          pname = Element('p:name') 
+113          self.assertEqual(pname.tag, 'p:name') 
+114   
+115          pname = Element('{test}p:name') 
+116          self.assertEqual(pname.tag, '{test}p:name') 
+117   
+118          pname = Element('name') 
+119          pname.tag = 'p:name' 
+120          self.assertEqual(pname.tag, 'p:name') 
+
121   
+122 -    def test_html_element_name_quote(self): 
+
123          parser = self.etree.HTMLParser() 
+124          Element = parser.makeelement 
+125   
+126          self.assertRaises(ValueError, Element, 'p"name') 
+127          self.assertRaises(ValueError, Element, "na'me") 
+128          self.assertRaises(ValueError, Element, '{test}"name') 
+129          self.assertRaises(ValueError, Element, "{test}name'") 
+130   
+131          el = Element('name') 
+132          self.assertRaises(ValueError, setattr, el, 'tag', "pname'") 
+133          self.assertRaises(ValueError, setattr, el, 'tag', '"pname') 
+134          self.assertEqual(el.tag, "name") 
+
135   
+136 -    def test_html_element_name_space(self): 
+
137          parser = self.etree.HTMLParser() 
+138          Element = parser.makeelement 
+139   
+140          self.assertRaises(ValueError, Element, ' name ') 
+141          self.assertRaises(ValueError, Element, 'na me') 
+142          self.assertRaises(ValueError, Element, '{test} name') 
+143   
+144          el = Element('name') 
+145          self.assertRaises(ValueError, setattr, el, 'tag', ' name ') 
+146          self.assertEqual(el.tag, "name") 
+
147   
+148 -    def test_html_subelement_name_empty(self): 
+
149          parser = self.etree.HTMLParser() 
+150          Element = parser.makeelement 
+151   
+152          SubElement = self.etree.SubElement 
+153   
+154          el = Element('name') 
+155          self.assertRaises(ValueError, SubElement, el, '{}') 
+156          self.assertRaises(ValueError, SubElement, el, '{test}') 
+
157   
+158 -    def test_html_subelement_name_colon(self): 
+
159          parser = self.etree.HTMLParser() 
+160          Element = parser.makeelement 
+161          SubElement = self.etree.SubElement 
+162   
+163          el = Element('name') 
+164          pname = SubElement(el, 'p:name') 
+165          self.assertEqual(pname.tag, 'p:name') 
+166   
+167          pname = SubElement(el, '{test}p:name') 
+168          self.assertEqual(pname.tag, '{test}p:name') 
+
169   
+170 -    def test_html_subelement_name_quote(self): 
+
171          parser = self.etree.HTMLParser() 
+172          Element = parser.makeelement 
+173          SubElement = self.etree.SubElement 
+174   
+175          el = Element('name') 
+176          self.assertRaises(ValueError, SubElement, el, "name'") 
+177          self.assertRaises(ValueError, SubElement, el, 'na"me') 
+178          self.assertRaises(ValueError, SubElement, el, "{test}na'me") 
+179          self.assertRaises(ValueError, SubElement, el, '{test}"name') 
+
180   
+181 -    def test_html_subelement_name_space(self): 
+
182          parser = self.etree.HTMLParser() 
+183          Element = parser.makeelement 
+184          SubElement = self.etree.SubElement 
+185   
+186          el = Element('name') 
+187          self.assertRaises(ValueError, SubElement, el, ' name ') 
+188          self.assertRaises(ValueError, SubElement, el, 'na me') 
+189          self.assertRaises(ValueError, SubElement, el, '{test} name') 
+
190   
+191 -    def test_module_parse_html_norecover(self): 
+
192          parser = self.etree.HTMLParser(recover=False) 
+193          parse = self.etree.parse 
+194          f = BytesIO(self.broken_html_str) 
+195          self.assertRaises(self.etree.XMLSyntaxError, 
+196                            parse, f, parser) 
+
197   
+198 -    def test_module_parse_html_default_doctype(self): 
+
199          parser = self.etree.HTMLParser(default_doctype=False) 
+200          d = html.fromstring('<!DOCTYPE html><h1>S</h1></html>', parser=parser) 
+201          self.assertEqual(d.getroottree().docinfo.doctype, '<!DOCTYPE html>') 
+202   
+203          d = html.fromstring('<html><h1>S</h1></html>', parser=parser) 
+204          self.assertEqual(d.getroottree().docinfo.doctype, '') 
+
205   
+206 -    def test_parse_encoding_8bit_explicit(self): 
+
207          text = _str('Søk på nettet') 
+208          html_latin1 = (_str('<p>%s</p>') % text).encode('iso-8859-1') 
+209   
+210          tree = self.etree.parse( 
+211              BytesIO(html_latin1), 
+212              self.etree.HTMLParser(encoding="iso-8859-1")) 
+213          p = tree.find("//p") 
+214          self.assertEqual(p.text, text) 
+
215   
+216 -    def test_parse_encoding_8bit_override(self): 
+
217          text = _str('Søk på nettet') 
+218          wrong_head = _str(''' 
+219          <head> 
+220            <meta http-equiv="Content-Type" 
+221                  content="text/html; charset=UTF-8" /> 
+222          </head>''') 
+223          html_latin1 = (_str('<html>%s<body><p>%s</p></body></html>') % (wrong_head, 
+224                                                                          text) 
+225                        ).encode('iso-8859-1') 
+226   
+227          self.assertRaises(self.etree.ParseError, 
+228                            self.etree.parse, 
+229                            BytesIO(html_latin1)) 
+230   
+231          tree = self.etree.parse( 
+232              BytesIO(html_latin1), 
+233              self.etree.HTMLParser(encoding="iso-8859-1")) 
+234          p = tree.find("//p") 
+235          self.assertEqual(p.text, text) 
+
236   
+237 -    def test_module_HTML_broken(self): 
+
238          element = self.etree.HTML(self.broken_html_str) 
+239          self.assertEqual(self.etree.tostring(element, method="html"), 
+240                           self.html_str) 
+
241   
+242 -    def test_module_HTML_cdata(self): 
+
243          # by default, libxml2 generates CDATA nodes for <script> content 
+244          html = _bytes('<html><head><style>foo</style></head></html>') 
+245          element = self.etree.HTML(html) 
+246          self.assertEqual(element[0][0].text, "foo") 
+
247   
+248 -    def test_module_HTML_access(self): 
+
249          element = self.etree.HTML(self.html_str) 
+250          self.assertEqual(element[0][0].tag, 'title') 
+
251   
+252 -    def test_module_parse_html(self): 
+
253          parser = self.etree.HTMLParser() 
+254          filename = tempfile.mktemp(suffix=".html") 
+255          write_to_file(filename, self.html_str, 'wb') 
+256          try: 
+257              f = open(filename, 'rb') 
+258              tree = self.etree.parse(f, parser) 
+259              f.close() 
+260              self.assertEqual(self.etree.tostring(tree.getroot(), method="html"), 
+261                               self.html_str) 
+262          finally: 
+263              os.remove(filename) 
+
264   
+265 -    def test_module_parse_html_filelike(self): 
+
266          parser = self.etree.HTMLParser() 
+267          f = SillyFileLike(self.html_str) 
+268          tree = self.etree.parse(f, parser) 
+269          html = self.etree.tostring(tree.getroot(), 
+270                                     method="html", encoding='UTF-8') 
+271          self.assertEqual(html, self.html_str) 
+
272   
+273  ##     def test_module_parse_html_filelike_unicode(self): 
+274  ##         parser = self.etree.HTMLParser() 
+275  ##         f = SillyFileLike(self.uhtml_str) 
+276  ##         tree = self.etree.parse(f, parser) 
+277  ##         html = self.etree.tostring(tree.getroot(), encoding='UTF-8') 
+278  ##         self.assertEqual(unicode(html, 'UTF-8'), self.uhtml_str) 
+279   
+280 -    def test_html_file_error(self): 
+
281          parser = self.etree.HTMLParser() 
+282          parse = self.etree.parse 
+283          self.assertRaises(IOError, 
+284                            parse, "__some_hopefully_nonexisting_file__.html", 
+285                            parser) 
+
286   
+287 -    def test_default_parser_HTML_broken(self): 
+
288          self.assertRaises(self.etree.XMLSyntaxError, 
+289                            self.etree.parse, BytesIO(self.broken_html_str)) 
+290   
+291          self.etree.set_default_parser( self.etree.HTMLParser() ) 
+292   
+293          tree = self.etree.parse(BytesIO(self.broken_html_str)) 
+294          self.assertEqual(self.etree.tostring(tree.getroot(), method="html"), 
+295                           self.html_str) 
+296   
+297          self.etree.set_default_parser() 
+298   
+299          self.assertRaises(self.etree.XMLSyntaxError, 
+300                            self.etree.parse, BytesIO(self.broken_html_str)) 
+
301   
+302 -    def test_html_iterparse(self): 
+
303          iterparse = self.etree.iterparse 
+304          f = BytesIO( 
+305              '<html><head><title>TITLE</title><body><p>P</p></body></html>') 
+306   
+307          iterator = iterparse(f, html=True) 
+308          self.assertEqual(None, iterator.root) 
+309   
+310          events = list(iterator) 
+311          root = iterator.root 
+312          self.assertTrue(root is not None) 
+313          self.assertEqual( 
+314              [('end', root[0][0]), ('end', root[0]), ('end', root[1][0]), 
+315               ('end', root[1]), ('end', root)], 
+316              events) 
+
317   
+318 -    def test_html_iterparse_stop_short(self): 
+
319          iterparse = self.etree.iterparse 
+320          f = BytesIO( 
+321              '<html><head><title>TITLE</title><body><p>P</p></body></html>') 
+322   
+323          iterator = iterparse(f, html=True) 
+324          self.assertEqual(None, iterator.root) 
+325   
+326          event, element = next(iterator) 
+327          self.assertEqual('end', event) 
+328          self.assertEqual('title', element.tag) 
+329          self.assertEqual(None, iterator.root) 
+330          del element 
+331   
+332          event, element = next(iterator) 
+333          self.assertEqual('end', event) 
+334          self.assertEqual('head', element.tag) 
+335          self.assertEqual(None, iterator.root) 
+336          del element 
+337          del iterator 
+
338   
+339 -    def test_html_iterparse_broken(self): 
+
340          iterparse = self.etree.iterparse 
+341          f = BytesIO('<head><title>TEST></head><p>P<br></div>') 
+342   
+343          iterator = iterparse(f, html=True) 
+344          self.assertEqual(None, iterator.root) 
+345   
+346          events = list(iterator) 
+347          root = iterator.root 
+348          self.assertTrue(root is not None) 
+349          self.assertEqual('html', root.tag) 
+350          self.assertEqual('head', root[0].tag) 
+351          self.assertEqual('body', root[1].tag) 
+352          self.assertEqual('p', root[1][0].tag) 
+353          self.assertEqual('br', root[1][0][0].tag) 
+354          self.assertEqual( 
+355              [('end', root[0][0]), ('end', root[0]), ('end', root[1][0][0]), 
+356               ('end', root[1][0]), ('end', root[1]), ('end', root)], 
+357              events) 
+
358   
+359 -    def test_html_iterparse_broken_no_recover(self): 
+
360          iterparse = self.etree.iterparse 
+361          f = BytesIO('<p>P<br></div>') 
+362          iterator = iterparse(f, html=True, recover=False) 
+363          self.assertRaises(self.etree.XMLSyntaxError, list, iterator) 
+
364   
+365 -    def test_html_iterparse_file(self): 
+
366          iterparse = self.etree.iterparse 
+367          iterator = iterparse(fileInTestDir("shakespeare.html"), 
+368                               html=True) 
+369   
+370          self.assertEqual(None, iterator.root) 
+371          events = list(iterator) 
+372          root = iterator.root 
+373          self.assertTrue(root is not None) 
+374          self.assertEqual(249, len(events)) 
+375          self.assertFalse( 
+376              [event for (event, element) in events if event != 'end']) 
+
377   
+378 -    def test_html_iterparse_start(self): 
+
379          iterparse = self.etree.iterparse 
+380          f = BytesIO( 
+381              '<html><head><title>TITLE</title><body><p>P</p></body></html>') 
+382   
+383          iterator = iterparse(f, html=True, events=('start',)) 
+384          self.assertEqual(None, iterator.root) 
+385   
+386          events = list(iterator) 
+387          root = iterator.root 
+388          self.assertNotEqual(None, root) 
+389          self.assertEqual( 
+390              [('start', root), ('start', root[0]), ('start', root[0][0]), 
+391                  ('start', root[1]), ('start', root[1][0])], 
+392              events) 
+
393   
+394 -    def test_html_feed_parser(self): 
+
395          parser = self.etree.HTMLParser() 
+396          parser.feed("<html><body></") 
+397          parser.feed("body></html>") 
+398          root = parser.close() 
+399   
+400          self.assertEqual('html', root.tag) 
+401          # test that we find all names in the parser dict 
+402          self.assertEqual([root], list(root.iter('html'))) 
+403          self.assertEqual([root[0]], list(root.iter('body'))) 
+
404   
+405 -    def test_html_feed_parser_chunky(self): 
+
406          parser = self.etree.HTMLParser() 
+407          parser.feed("<htm") 
+408          parser.feed("l><body") 
+409          parser.feed("><") 
+410          parser.feed("p><") 
+411          parser.feed("strong") 
+412          parser.feed(">some ") 
+413          parser.feed("text</strong></p><") 
+414          parser.feed("/body></html>") 
+415          root = parser.close() 
+416   
+417          self.assertEqual('html', root.tag) 
+418          # test that we find all names in the parser dict 
+419          self.assertEqual([root], list(root.iter('html'))) 
+420          self.assertEqual([root[0]], list(root.iter('body'))) 
+421          self.assertEqual([root[0][0]], list(root.iter('p'))) 
+422          self.assertEqual([root[0][0][0]], list(root.iter('strong'))) 
+
423   
+424 -    def test_html_feed_parser_more_tags(self): 
+
425          parser = self.etree.HTMLParser() 
+426          parser.feed('<html><head>') 
+427          parser.feed('<title>TITLE</title><body><p>P</p></body><') 
+428          parser.feed("/html>") 
+429          root = parser.close() 
+430   
+431          self.assertEqual('html', root.tag) 
+432          # test that we find all names in the parser dict 
+433          self.assertEqual([root], list(root.iter('html'))) 
+434          self.assertEqual([root[0]], list(root.iter('head'))) 
+435          self.assertEqual([root[0][0]], list(root.iter('title'))) 
+436          self.assertEqual([root[1]], list(root.iter('body'))) 
+437          self.assertEqual([root[1][0]], list(root.iter('p'))) 
+
438   
+439 -    def test_html_parser_target_tag(self): 
+
440          assertFalse  = self.assertFalse 
+441          events = [] 
+442          class Target(object): 
+443              def start(self, tag, attrib): 
+444                  events.append(("start", tag)) 
+445                  assertFalse(attrib) 
+
446              def end(self, tag): 
+447                  events.append(("end", tag)) 
+
448              def close(self): 
+449                  return "DONE" 
+450   
+451          parser = self.etree.HTMLParser(target=Target()) 
+452   
+453          parser.feed("<html><body></body></html>") 
+454          done = parser.close() 
+455   
+456          self.assertEqual("DONE", done) 
+457          self.assertEqual([ 
+458              ("start", "html"), ("start", "body"), 
+459              ("end", "body"), ("end", "html")], events) 
+460   
+461 -    def test_html_parser_target_doctype_empty(self): 
+
462          assertFalse  = self.assertFalse 
+463          events = [] 
+464          class Target(object): 
+465              def start(self, tag, attrib): 
+466                  events.append(("start", tag)) 
+467                  assertFalse(attrib) 
+
468              def end(self, tag): 
+469                  events.append(("end", tag)) 
+470              def doctype(self, *args): 
+471                  events.append(("doctype", args)) 
+472              def close(self): 
+473                  return "DONE" 
+474   
+475          parser = self.etree.HTMLParser(target=Target()) 
+476          parser.feed("<!DOCTYPE><html><body></body></html>") 
+477          done = parser.close() 
+478   
+479          self.assertEqual("DONE", done) 
+480          self.assertEqual([ 
+481              ("doctype", (None, None, None)), 
+482              ("start", "html"), ("start", "body"), 
+483              ("end", "body"), ("end", "html")], events) 
+484   
+485 -    def test_html_parser_target_doctype_html(self): 
+
486          assertFalse  = self.assertFalse 
+487          events = [] 
+488          class Target(object): 
+489              def start(self, tag, attrib): 
+490                  events.append(("start", tag)) 
+491                  assertFalse(attrib) 
+
492              def end(self, tag): 
+493                  events.append(("end", tag)) 
+494              def doctype(self, *args): 
+495                  events.append(("doctype", args)) 
+496              def close(self): 
+497                  return "DONE" 
+498   
+499          parser = self.etree.HTMLParser(target=Target()) 
+500          parser.feed("<!DOCTYPE html><html><body></body></html>") 
+501          done = parser.close() 
+502   
+503          self.assertEqual("DONE", done) 
+504          self.assertEqual([ 
+505              ("doctype", ("html", None, None)), 
+506              ("start", "html"), ("start", "body"), 
+507              ("end", "body"), ("end", "html")], events) 
+508   
+509 -    def test_html_parser_target_doctype_html_full(self): 
+
510          assertFalse  = self.assertFalse 
+511          events = [] 
+512          class Target(object): 
+513              def start(self, tag, attrib): 
+514                  events.append(("start", tag)) 
+515                  assertFalse(attrib) 
+
516              def end(self, tag): 
+517                  events.append(("end", tag)) 
+518              def doctype(self, *args): 
+519                  events.append(("doctype", args)) 
+520              def close(self): 
+521                  return "DONE" 
+522   
+523          parser = self.etree.HTMLParser(target=Target()) 
+524          parser.feed('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "sys.dtd">' 
+525                      '<html><body></body></html>') 
+526          done = parser.close() 
+527   
+528          self.assertEqual("DONE", done) 
+529          self.assertEqual([ 
+530              ("doctype", ("html", "-//W3C//DTD HTML 4.01//EN", "sys.dtd")), 
+531              ("start", "html"), ("start", "body"), 
+532              ("end", "body"), ("end", "html")], events) 
+533   
+534 -    def test_html_parser_target_exceptions(self): 
+
535          events = [] 
+536          class Target(object): 
+537              def start(self, tag, attrib): 
+538                  events.append(("start", tag)) 
+539                  raise ValueError("START") 
+
540              def end(self, tag): 
+541                  events.append(("end", tag)) 
+542                  raise TypeError("END") 
+543              def close(self): 
+544                  return "DONE" 
+545   
+546          parser = self.etree.HTMLParser(target=Target()) 
+547          try: 
+548              parser.feed('<html><body>') 
+549              parser.feed('</body></html>') 
+550          except ValueError as exc: 
+551              assert "START" in str(exc) 
+552          except TypeError as exc: 
+553              assert "END" in str(exc) 
+554              self.assertTrue(False, "wrong exception raised") 
+555          else: 
+556              self.assertTrue(False, "no exception raised") 
+557   
+558          self.assertTrue(("start", "html") in events, events) 
+559          self.assertTrue(("end", "html") not in events, events) 
+560   
+561 -    def test_html_fromstring_target_exceptions(self): 
+
562          events = [] 
+563          class Target(object): 
+564              def start(self, tag, attrib): 
+565                  events.append(("start", tag)) 
+566                  raise ValueError("START") 
+
567              def end(self, tag): 
+568                  events.append(("end", tag)) 
+569                  raise TypeError("END") 
+570              def close(self): 
+571                  return "DONE" 
+572   
+573          parser = self.etree.HTMLParser(target=Target()) 
+574          try: 
+575              self.etree.fromstring('<html><body></body></html>', parser) 
+576          except ValueError as exc: 
+577              assert "START" in str(exc), str(exc) 
+578          except TypeError as exc: 
+579              assert "END" in str(exc), str(exc) 
+580              self.assertTrue(False, "wrong exception raised") 
+581          else: 
+582              self.assertTrue(False, "no exception raised") 
+583   
+584          self.assertTrue(("start", "html") in events, events) 
+585          self.assertTrue(("end", "html") not in events, events) 
+586   
+587 -    def test_set_decl_html(self): 
+
588          doc = html.Element('html').getroottree() 
+589          doc.docinfo.public_id = "-//W3C//DTD XHTML 1.0 Strict//EN" 
+590          doc.docinfo.system_url = \ 
+591              "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd" 
+592          self.assertEqual(doc.docinfo.doctype, 
+593                           '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">') 
+594          self.assertEqual(self.etree.tostring(doc), 
+595                           _bytes('''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> 
+596  <html xmlns="http://www.w3.org/1999/xhtml"></html>''')) 
+
597   
+598 -    def test_html5_doctype(self): 
+
599          # document type declaration with neither public if nor system url 
+600          doc = html.Element('html').getroottree() 
+601          doc.docinfo.public_id = None 
+602          doc.docinfo.system_url = None 
+603          self.assertEqual(doc.docinfo.doctype, 
+604                           '<!DOCTYPE html>') 
+605          self.assertTrue(doc.docinfo.public_id is None) 
+606          self.assertEqual(self.etree.tostring(doc), 
+607                           _bytes('<!DOCTYPE html>\n<html/>')) 
+
608   
+609 -    def test_ietf_decl(self): 
+
610          # legacy declaration with public id, no system url 
+611          doc = html.Element('html').getroottree() 
+612          doc.docinfo.public_id = '-//IETF//DTD HTML//EN' 
+613          doc.docinfo.system_url = None 
+614          self.assertEqual(doc.docinfo.doctype, 
+615                           '<!DOCTYPE html PUBLIC "-//IETF//DTD HTML//EN">') 
+616          self.assertEqual(self.etree.tostring(doc), 
+617                           _bytes('<!DOCTYPE html PUBLIC "-//IETF//DTD HTML//EN">\n<html/>')) 
+
618   
+619 -    def test_boolean_attribute(self): 
+
620          # ability to serialize boolean attribute by setting value to None 
+621          form = html.Element('form') 
+622          form.set('novalidate', None) 
+623          self.assertEqual(html.tostring(form), 
+624                           _bytes('<form novalidate></form>')) 
+625          form.set('custom') 
+626          self.assertEqual(html.tostring(form), 
+627                           _bytes('<form novalidate custom></form>')) 
+
628   
+629 -    def test_boolean_attribute_round_trip(self): 
+
630          # ability to pass boolean attributes unmodified 
+631          fragment = '<tag attribute></tag>' 
+632          self.assertEqual(html.tostring(html.fragment_fromstring(fragment)), 
+633                           _bytes(fragment)) 
+
634   
+635 -    def test_boolean_attribute_xml_adds_empty_string(self): 
+
636          # html serialized as xml converts boolean attributes to empty strings 
+637          fragment = '<tag attribute></tag>' 
+638          self.assertEqual(self.etree.tostring(html.fragment_fromstring(fragment)), 
+639                           _bytes('<tag attribute=""/>')) 
+
640   
+641   
+642 -def test_suite(): 
+
643      suite = unittest.TestSuite() 
+644      suite.addTests([unittest.makeSuite(HtmlParserTestCase)]) 
+645      return suite 
+
646   
+647   
+648  if __name__ == '__main__': 
+649      print('to test use test.py %s' % __file__) 
+650   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               HtmlParserTestCase
+
lxml.etree
lxml.etree
+'<html><head><title>test</title></head><body><h1>page title</h1></body
+></html>'
+
+'''<html>
+<head><title>test</title></head>
+<body><h1>page title</h1></body>
+</html>
+'''
+
+'<html><head><title>test<body><h1>page title</h3></p></html>'
+
+u'<html><head><title>test Ã¡</title></head><body><h1>page Ã¡ title</
+h1></body></html>'
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Web IO test cases (wsgiref) 
+  5  """ 
+  6   
+  7  from __future__ import with_statement 
+  8   
+  9  import unittest 
+ 10  import textwrap 
+ 11  import os 
+ 12  import sys 
+ 13  import gzip 
+ 14   
+ 15  this_dir = os.path.dirname(__file__) 
+ 16  if this_dir not in sys.path: 
+ 17      sys.path.insert(0, this_dir)  # needed for Py3 
+ 18   
+ 19  from .common_imports import ( 
+ 20      etree, HelperTestCase, BytesIO, _bytes) 
+ 21  from .dummy_http_server import webserver, HTTPRequestCollector 
+ 22   
+ 23   
+ 24 -class HttpIOTestCase(HelperTestCase): 
+
 25      etree = etree 
+ 26   
+ 27 -    def _parse_from_http(self, data, code=200, headers=None, parser=None): 
+
 28          handler = HTTPRequestCollector(data, code, headers) 
+ 29          with webserver(handler) as host_url: 
+ 30              tree = self.etree.parse(host_url + 'TEST', parser=parser) 
+ 31          self.assertEqual([('/TEST', [])], handler.requests) 
+ 32          return tree 
+
 33   
+ 34 -    def test_http_client(self): 
+
 35          tree = self._parse_from_http(_bytes('<root><a/></root>')) 
+ 36          self.assertEqual('root', tree.getroot().tag) 
+ 37          self.assertEqual('a', tree.getroot()[0].tag) 
+
 38   
+ 39 -    def test_http_client_404(self): 
+
 40          try: 
+ 41              self._parse_from_http(_bytes('<root/>'), code=404) 
+ 42          except IOError: 
+ 43              self.assertTrue(True) 
+ 44          else: 
+ 45              self.assertTrue(False, "expected IOError") 
+
 46   
+ 47 -    def test_http_client_gzip(self): 
+
 48          f = BytesIO() 
+ 49          gz = gzip.GzipFile(fileobj=f, mode='w', filename='test.xml') 
+ 50          gz.write(_bytes('<root><a/></root>')) 
+ 51          gz.close() 
+ 52          data = f.getvalue() 
+ 53          del f, gz 
+ 54   
+ 55          headers = [('Content-Encoding', 'gzip')] 
+ 56          tree = self._parse_from_http(data, headers=headers) 
+ 57          self.assertEqual('root', tree.getroot().tag) 
+ 58          self.assertEqual('a', tree.getroot()[0].tag) 
+
 59   
+ 60 -    def test_parser_input_mix(self): 
+
 61          data = _bytes('<root><a/></root>') 
+ 62          handler = HTTPRequestCollector(data) 
+ 63   
+ 64          with webserver(handler) as host_url: 
+ 65              tree = self.etree.parse(host_url) 
+ 66              root = tree.getroot() 
+ 67              self.assertEqual('a', root[0].tag) 
+ 68   
+ 69              root = self.etree.fromstring(data) 
+ 70              self.assertEqual('a', root[0].tag) 
+ 71   
+ 72              tree = self.etree.parse(host_url) 
+ 73              root = tree.getroot() 
+ 74              self.assertEqual('a', root[0].tag) 
+ 75   
+ 76              root = self.etree.fromstring(data) 
+ 77              self.assertEqual('a', root[0].tag) 
+ 78   
+ 79          root = self.etree.fromstring(data) 
+ 80          self.assertEqual('a', root[0].tag) 
+
 81   
+ 82 -    def test_network_dtd(self): 
+
 83          data = [_bytes(textwrap.dedent(s)) for s in [ 
+ 84              # XML file 
+ 85              '''\ 
+ 86              <?xml version="1.0"?> 
+ 87              <!DOCTYPE root SYSTEM "./file.dtd"> 
+ 88              <root>&myentity;</root> 
+ 89              ''', 
+ 90              # DTD 
+ 91              '<!ENTITY myentity "DEFINED">', 
+ 92          ]] 
+ 93   
+ 94          responses = [] 
+ 95          def handler(environ, start_response): 
+ 96              start_response('200 OK', []) 
+ 97              return [responses.pop()] 
+
 98   
+ 99          with webserver(handler) as host_url: 
+100              # DTD network loading enabled 
+101              responses = data[::-1] 
+102              tree = self.etree.parse( 
+103                  host_url + 'dir/test.xml', 
+104                  parser=self.etree.XMLParser( 
+105                      load_dtd=True, no_network=False)) 
+106              self.assertFalse(responses)  # all read 
+107              root = tree.getroot() 
+108              self.assertEqual('DEFINED', root.text) 
+109   
+110              # DTD network loading disabled 
+111              responses = data[::-1] 
+112              try: 
+113                  self.etree.parse( 
+114                      host_url + 'dir/test.xml', 
+115                      parser=self.etree.XMLParser( 
+116                          load_dtd=True, no_network=True)) 
+117              except self.etree.XMLSyntaxError: 
+118                  self.assertTrue("myentity" in str(sys.exc_info()[1])) 
+119              else: 
+120                  self.assertTrue(False) 
+121              self.assertEqual(1, len(responses))  # DTD not read 
+
122   
+123   
+124 -def test_suite(): 
+
125      suite = unittest.TestSuite() 
+126      suite.addTests([unittest.makeSuite(HttpIOTestCase)]) 
+127      return suite 
+
128   
+129   
+130  if __name__ == '__main__': 
+131      print('to test use test.py %s' % __file__) 
+132   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               HttpIOTestCase
+
lxml.etree
lxml.etree
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Tests for the incremental XML serialisation API. 
+  5  """ 
+  6   
+  7  from __future__ import absolute_import 
+  8   
+  9  import io 
+ 10  import os 
+ 11  import sys 
+ 12  import unittest 
+ 13  import textwrap 
+ 14  import tempfile 
+ 15   
+ 16  from lxml.etree import LxmlSyntaxError 
+ 17   
+ 18  this_dir = os.path.dirname(__file__) 
+ 19  if this_dir not in sys.path: 
+ 20      sys.path.insert(0, this_dir) # needed for Py3 
+ 21   
+ 22  from .common_imports import etree, BytesIO, HelperTestCase, skipIf, _str 
+ 23   
+ 24   
+ 25 -class _XmlFileTestCaseBase(HelperTestCase): 
+
 26      _file = None  # to be set by specific subtypes below 
+ 27   
+ 28 -    def test_element(self): 
+
 29          with etree.xmlfile(self._file) as xf: 
+ 30              with xf.element('test'): 
+ 31                  pass 
+ 32          self.assertXml('<test></test>') 
+
 33   
+ 34 -    def test_element_write_text(self): 
+
 35          with etree.xmlfile(self._file) as xf: 
+ 36              with xf.element('test'): 
+ 37                  xf.write('toast') 
+ 38          self.assertXml('<test>toast</test>') 
+
 39   
+ 40 -    def test_element_write_empty(self): 
+
 41          with etree.xmlfile(self._file) as xf: 
+ 42              with xf.element('test'): 
+ 43                  xf.write(None) 
+ 44                  xf.write('') 
+ 45                  xf.write('') 
+ 46                  xf.write(None) 
+ 47          self.assertXml('<test></test>') 
+
 48   
+ 49 -    def test_element_nested(self): 
+
 50          with etree.xmlfile(self._file) as xf: 
+ 51              with xf.element('test'): 
+ 52                  with xf.element('toast'): 
+ 53                      with xf.element('taste'): 
+ 54                          xf.write('conTent') 
+ 55          self.assertXml('<test><toast><taste>conTent</taste></toast></test>') 
+
 56   
+ 57 -    def test_element_nested_with_text(self): 
+
 58          with etree.xmlfile(self._file) as xf: 
+ 59              with xf.element('test'): 
+ 60                  xf.write('con') 
+ 61                  with xf.element('toast'): 
+ 62                      xf.write('tent') 
+ 63                      with xf.element('taste'): 
+ 64                          xf.write('inside') 
+ 65                      xf.write('tnet') 
+ 66                  xf.write('noc') 
+ 67          self.assertXml('<test>con<toast>tent<taste>inside</taste>' 
+ 68                         'tnet</toast>noc</test>') 
+
 69   
+ 70 -    def test_write_Element(self): 
+
 71          with etree.xmlfile(self._file) as xf: 
+ 72              xf.write(etree.Element('test')) 
+ 73          self.assertXml('<test/>') 
+
 74   
+ 75 -    def test_write_Element_repeatedly(self): 
+
 76          element = etree.Element('test') 
+ 77          with etree.xmlfile(self._file) as xf: 
+ 78              with xf.element('test'): 
+ 79                  for i in range(100): 
+ 80                      xf.write(element) 
+ 81   
+ 82          tree = self._parse_file() 
+ 83          self.assertTrue(tree is not None) 
+ 84          self.assertEqual(100, len(tree.getroot())) 
+ 85          self.assertEqual({'test'}, {el.tag for el in tree.getroot()}) 
+
 86   
+ 87 -    def test_namespace_nsmap(self): 
+
 88          with etree.xmlfile(self._file) as xf: 
+ 89              with xf.element('{nsURI}test', nsmap={'x': 'nsURI'}): 
+ 90                  pass 
+ 91          self.assertXml('<x:test xmlns:x="nsURI"></x:test>') 
+
 92   
+ 93 -    def test_namespace_nested_nsmap(self): 
+
 94          with etree.xmlfile(self._file) as xf: 
+ 95              with xf.element('test', nsmap={'x': 'nsURI'}): 
+ 96                  with xf.element('{nsURI}toast'): 
+ 97                      pass 
+ 98          self.assertXml('<test xmlns:x="nsURI"><x:toast></x:toast></test>') 
+
 99   
+100 -    def test_anonymous_namespace(self): 
+
101          with etree.xmlfile(self._file) as xf: 
+102              with xf.element('{nsURI}test'): 
+103                  pass 
+104          self.assertXml('<ns0:test xmlns:ns0="nsURI"></ns0:test>') 
+
105   
+106 -    def test_namespace_nested_anonymous(self): 
+
107          with etree.xmlfile(self._file) as xf: 
+108              with xf.element('test'): 
+109                  with xf.element('{nsURI}toast'): 
+110                      pass 
+111          self.assertXml('<test><ns0:toast xmlns:ns0="nsURI"></ns0:toast></test>') 
+
112   
+113 -    def test_default_namespace(self): 
+
114          with etree.xmlfile(self._file) as xf: 
+115              with xf.element('{nsURI}test', nsmap={None: 'nsURI'}): 
+116                  pass 
+117          self.assertXml('<test xmlns="nsURI"></test>') 
+
118   
+119 -    def test_nested_default_namespace(self): 
+
120          with etree.xmlfile(self._file) as xf: 
+121              with xf.element('{nsURI}test', nsmap={None: 'nsURI'}): 
+122                  with xf.element('{nsURI}toast'): 
+123                      pass 
+124          self.assertXml('<test xmlns="nsURI"><toast></toast></test>') 
+
125   
+126 -    def test_nested_default_namespace_and_other(self): 
+
127          with etree.xmlfile(self._file) as xf: 
+128              with xf.element('{nsURI}test', nsmap={None: 'nsURI', 'p': 'ns2'}): 
+129                  with xf.element('{nsURI}toast'): 
+130                      pass 
+131                  with xf.element('{ns2}toast'): 
+132                      pass 
+133          self.assertXml( 
+134              '<test xmlns="nsURI" xmlns:p="ns2"><toast></toast><p:toast></p:toast></test>') 
+
135   
+136 -    def test_pi(self): 
+
137          with etree.xmlfile(self._file) as xf: 
+138              xf.write(etree.ProcessingInstruction('pypi')) 
+139              with xf.element('test'): 
+140                  pass 
+141          self.assertXml('<?pypi ?><test></test>') 
+
142   
+143 -    def test_comment(self): 
+
144          with etree.xmlfile(self._file) as xf: 
+145              xf.write(etree.Comment('a comment')) 
+146              with xf.element('test'): 
+147                  pass 
+148          self.assertXml('<!--a comment--><test></test>') 
+
149   
+150 -    def test_attribute(self): 
+
151          with etree.xmlfile(self._file) as xf: 
+152              with xf.element('test', attrib={'k': 'v'}): 
+153                  pass 
+154          self.assertXml('<test k="v"></test>') 
+
155   
+156 -    def test_attribute_extra(self): 
+
157          with etree.xmlfile(self._file) as xf: 
+158              with xf.element('test', attrib={'k': 'v'}, n='N'): 
+159                  pass 
+160          self.assertXml('<test k="v" n="N"></test>') 
+
161   
+162 -    def test_attribute_extra_duplicate(self): 
+
163          with etree.xmlfile(self._file) as xf: 
+164              with xf.element('test', attrib={'k': 'v'}, k='V'): 
+165                  pass 
+166          self.assertXml('<test k="V"></test>') 
+
167   
+168 -    def test_escaping(self): 
+
169          with etree.xmlfile(self._file) as xf: 
+170              with xf.element('test'): 
+171                  xf.write('Comments: <!-- text -->\n') 
+172                  xf.write('Entities: &amp;') 
+173          self.assertXml( 
+174              '<test>Comments: &lt;!-- text --&gt;\nEntities: &amp;amp;</test>') 
+
175   
+176 -    def test_encoding(self): 
+
177          with etree.xmlfile(self._file, encoding='utf16') as xf: 
+178              with xf.element('test'): 
+179                  xf.write('toast') 
+180          self.assertXml('<test>toast</test>', encoding='utf16') 
+
181   
+182 -    def test_buffering(self): 
+
183          with etree.xmlfile(self._file, buffered=False) as xf: 
+184              with xf.element('test'): 
+185                  self.assertXml("<test>") 
+186                  xf.write('toast') 
+187                  self.assertXml("<test>toast") 
+188                  with xf.element('taste'): 
+189                      self.assertXml("<test>toast<taste>") 
+190                      xf.write('some', etree.Element("more"), "toast") 
+191                      self.assertXml("<test>toast<taste>some<more/>toast") 
+192                  self.assertXml("<test>toast<taste>some<more/>toast</taste>") 
+193                  xf.write('end') 
+194                  self.assertXml("<test>toast<taste>some<more/>toast</taste>end") 
+195              self.assertXml("<test>toast<taste>some<more/>toast</taste>end</test>") 
+196          self.assertXml("<test>toast<taste>some<more/>toast</taste>end</test>") 
+
197   
+198 -    def test_flush(self): 
+
199          with etree.xmlfile(self._file, buffered=True) as xf: 
+200              with xf.element('test'): 
+201                  self.assertXml("") 
+202                  xf.write('toast') 
+203                  self.assertXml("") 
+204                  with xf.element('taste'): 
+205                      self.assertXml("") 
+206                      xf.flush() 
+207                      self.assertXml("<test>toast<taste>") 
+208                  self.assertXml("<test>toast<taste>") 
+209              self.assertXml("<test>toast<taste>") 
+210          self.assertXml("<test>toast<taste></taste></test>") 
+
211   
+212 -    def test_non_io_exception_continues_closing(self): 
+
213          try: 
+214              with etree.xmlfile(self._file) as xf: 
+215                  with xf.element('root'): 
+216                      with xf.element('test'): 
+217                          xf.write("BEFORE") 
+218                          raise TypeError("FAIL!") 
+219                      xf.write("AFTER") 
+220          except TypeError as exc: 
+221              self.assertTrue("FAIL" in str(exc), exc) 
+222          else: 
+223              self.assertTrue(False, "exception not propagated") 
+224          self.assertXml("<root><test>BEFORE</test></root>") 
+
225   
+226 -    def test_generator_close_continues_closing(self): 
+
227          def gen(): 
+228              with etree.xmlfile(self._file) as xf: 
+229                  with xf.element('root'): 
+230                      while True: 
+231                          content = (yield) 
+232                          with xf.element('entry'): 
+233                              xf.write(content) 
+
234   
+235          g = gen() 
+236          next(g) 
+237          g.send('A') 
+238          g.send('B') 
+239          g.send('C') 
+240          g.close() 
+241          self.assertXml("<root><entry>A</entry><entry>B</entry><entry>C</entry></root>") 
+
242   
+243 -    def test_failure_preceding_text(self): 
+
244          try: 
+245              with etree.xmlfile(self._file) as xf: 
+246                  xf.write('toast') 
+247          except etree.LxmlSyntaxError: 
+248              self.assertTrue(True) 
+249          else: 
+250              self.assertTrue(False) 
+
251   
+252 -    def test_failure_trailing_text(self): 
+
253          with etree.xmlfile(self._file) as xf: 
+254              with xf.element('test'): 
+255                  pass 
+256              try: 
+257                  xf.write('toast') 
+258              except etree.LxmlSyntaxError: 
+259                  self.assertTrue(True) 
+260              else: 
+261                  self.assertTrue(False) 
+
262   
+263 -    def test_failure_trailing_Element(self): 
+
264          with etree.xmlfile(self._file) as xf: 
+265              with xf.element('test'): 
+266                  pass 
+267              try: 
+268                  xf.write(etree.Element('test')) 
+269              except etree.LxmlSyntaxError: 
+270                  self.assertTrue(True) 
+271              else: 
+272                  self.assertTrue(False) 
+
273   
+274 -    def test_closing_out_of_order_in_error_case(self): 
+
275          cm_exit = None 
+276          try: 
+277              with etree.xmlfile(self._file) as xf: 
+278                  x = xf.element('test') 
+279                  cm_exit = x.__exit__ 
+280                  x.__enter__() 
+281                  raise ValueError('123') 
+282          except ValueError: 
+283              self.assertTrue(cm_exit) 
+284              try: 
+285                  cm_exit(ValueError, ValueError("huhu"), None) 
+286              except etree.LxmlSyntaxError: 
+287                  self.assertTrue(True) 
+288              else: 
+289                  self.assertTrue(False) 
+290          else: 
+291              self.assertTrue(False) 
+
292   
+293 -    def _read_file(self): 
+
294          pos = self._file.tell() 
+295          self._file.seek(0) 
+296          try: 
+297              return self._file.read() 
+298          finally: 
+299              self._file.seek(pos) 
+
300   
+301 -    def _parse_file(self): 
+
302          pos = self._file.tell() 
+303          self._file.seek(0) 
+304          try: 
+305              return etree.parse(self._file) 
+306          finally: 
+307              self._file.seek(pos) 
+
308   
+309 -    def tearDown(self): 
+
310          if self._file is not None: 
+311              self._file.close() 
+
312   
+313 -    def assertXml(self, expected, encoding='utf8'): 
+
314          self.assertEqual(self._read_file().decode(encoding), expected) 
+
315   
+316   
+317 -class BytesIOXmlFileTestCase(_XmlFileTestCaseBase): 
+
318 -    def setUp(self): 
+
319          self._file = BytesIO() 
+
320   
+321 -    def test_filelike_close(self): 
+
322          with etree.xmlfile(self._file, close=True) as xf: 
+323              with xf.element('test'): 
+324                  pass 
+325          self.assertRaises(ValueError, self._file.getvalue) 
+
326   
+327   
+328 -class TempXmlFileTestCase(_XmlFileTestCaseBase): 
+
329 -    def setUp(self): 
+
330          self._file = tempfile.TemporaryFile() 
+
331   
+332   
+333  @skipIf(sys.platform.startswith("win"), "Can't reopen temporary files on Windows") 
+334 -class TempPathXmlFileTestCase(_XmlFileTestCaseBase): 
+
335 -    def setUp(self): 
+
336          self._tmpfile = tempfile.NamedTemporaryFile() 
+337          self._file = self._tmpfile.name 
+
338   
+339 -    def tearDown(self): 
+
340          try: 
+341              self._tmpfile.close() 
+342          finally: 
+343              if os.path.exists(self._tmpfile.name): 
+344                  os.unlink(self._tmpfile.name) 
+
345   
+346 -    def _read_file(self): 
+
347          self._tmpfile.seek(0) 
+348          return self._tmpfile.read() 
+
349   
+350 -    def _parse_file(self): 
+
351          self._tmpfile.seek(0) 
+352          return etree.parse(self._tmpfile) 
+
353   
+354      @skipIf(True, "temp file behaviour is too platform specific here") 
+355 -    def test_buffering(self): 
+
356          pass 
+
357   
+358      @skipIf(True, "temp file behaviour is too platform specific here") 
+359 -    def test_flush(self): 
+
360          pass 
+
361   
+362   
+363 -class SimpleFileLikeXmlFileTestCase(_XmlFileTestCaseBase): 
+
364 -    class SimpleFileLike(object): 
+
365 -        def __init__(self, target): 
+
366              self._target = target 
+367              self.write = target.write 
+368              self.tell = target.tell 
+369              self.seek = target.seek 
+370              self.closed = False 
+
371   
+372 -        def close(self): 
+
373              assert not self.closed 
+374              self.closed = True 
+375              self._target.close() 
+
376   
+377 -    def setUp(self): 
+
378          self._target = BytesIO() 
+379          self._file = self.SimpleFileLike(self._target) 
+
380   
+381 -    def _read_file(self): 
+
382          return self._target.getvalue() 
+
383   
+384 -    def _parse_file(self): 
+
385          pos = self._file.tell() 
+386          self._target.seek(0) 
+387          try: 
+388              return etree.parse(self._target) 
+389          finally: 
+390              self._target.seek(pos) 
+
391   
+392 -    def test_filelike_not_closing(self): 
+
393          with etree.xmlfile(self._file) as xf: 
+394              with xf.element('test'): 
+395                  pass 
+396          self.assertFalse(self._file.closed) 
+
397   
+398 -    def test_filelike_close(self): 
+
399          with etree.xmlfile(self._file, close=True) as xf: 
+400              with xf.element('test'): 
+401                  pass 
+402          self.assertTrue(self._file.closed) 
+403          self._file = None  # prevent closing in tearDown() 
+
404   
+405 -    def test_write_fails(self): 
+
406          class WriteError(Exception): 
+407              pass 
+
408   
+409          class Writer(object): 
+410              def __init__(self, trigger): 
+411                  self._trigger = trigger 
+412                  self._failed = False 
+
413   
+414              def write(self, data): 
+415                  assert not self._failed, "write() called again after failure" 
+416                  if self._trigger in data: 
+417                      self._failed = True 
+418                      raise WriteError("FAILED: " + self._trigger.decode('utf8')) 
+419   
+420          for trigger in ['text', 'root', 'tag', 'noflush']: 
+421              try: 
+422                  with etree.xmlfile(Writer(trigger.encode('utf8')), encoding='utf8') as xf: 
+423                      with xf.element('root'): 
+424                          xf.flush() 
+425                          with xf.element('tag'): 
+426                              xf.write('text') 
+427                              xf.flush() 
+428                              xf.write('noflush') 
+429                          xf.flush() 
+430                      xf.flush() 
+431              except WriteError as exc: 
+432                  self.assertTrue('FAILED: ' + trigger in str(exc)) 
+433              else: 
+434                  self.assertTrue(False, "exception not raised for '%s'" % trigger) 
+435   
+436   
+437 -class HtmlFileTestCase(_XmlFileTestCaseBase): 
+
438 -    def setUp(self): 
+
439          self._file = BytesIO() 
+
440   
+441 -    def test_void_elements(self): 
+
442          # http://www.w3.org/TR/html5/syntax.html#elements-0 
+443          void_elements = { 
+444              "area", "base", "br", "col", "embed", "hr", "img", "input", 
+445              "keygen", "link", "meta", "param", "source", "track", "wbr"} 
+446   
+447          # FIXME: These don't get serialized as void elements. 
+448          void_elements.difference_update([ 
+449              'area', 'embed', 'keygen', 'source', 'track', 'wbr' 
+450          ]) 
+451   
+452          for tag in sorted(void_elements): 
+453              with etree.htmlfile(self._file) as xf: 
+454                  xf.write(etree.Element(tag)) 
+455              self.assertXml('<%s>' % tag) 
+456              self._file = BytesIO() 
+
457   
+458 -    def test_method_context_manager_misuse(self): 
+
459          with etree.htmlfile(self._file) as xf: 
+460              with xf.element('foo'): 
+461                  cm = xf.method('xml') 
+462                  cm.__enter__() 
+463   
+464                  self.assertRaises(LxmlSyntaxError, cm.__enter__) 
+465   
+466                  cm2 = xf.method('xml') 
+467                  cm2.__enter__() 
+468                  cm2.__exit__(None, None, None) 
+469   
+470                  self.assertRaises(LxmlSyntaxError, cm2.__exit__, None, None, None) 
+471   
+472                  cm3 = xf.method('xml') 
+473                  cm3.__enter__() 
+474                  with xf.method('html'): 
+475                      self.assertRaises(LxmlSyntaxError, cm3.__exit__, None, None, None) 
+
476   
+477 -    def test_xml_mode_write_inside_html(self): 
+
478          tag = 'foo' 
+479          attrib = {'selected': 'bar'} 
+480          elt = etree.Element(tag, attrib=attrib) 
+481   
+482          with etree.htmlfile(self._file) as xf: 
+483              with xf.element("root"): 
+484                  xf.write(elt)  # 1 
+485   
+486                  assert elt.text is None 
+487                  xf.write(elt, method='xml')  # 2 
+488   
+489                  elt.text = "" 
+490                  xf.write(elt, method='xml')  # 3 
+491   
+492                  with xf.element(tag, attrib=attrib, method='xml'): 
+493                      pass # 4 
+494   
+495                  xf.write(elt)  # 5 
+496   
+497                  with xf.method('xml'): 
+498                      xf.write(elt)  # 6 
+499   
+500          self.assertXml( 
+501              '<root>' 
+502                  '<foo selected></foo>'  # 1 
+503                  '<foo selected="bar"/>'  # 2 
+504                  '<foo selected="bar"></foo>'  # 3 
+505                  '<foo selected="bar"></foo>'  # 4 
+506                  '<foo selected></foo>'  # 5 
+507                  '<foo selected="bar"></foo>'  # 6 
+508              '</root>') 
+509          self._file = BytesIO() 
+
510   
+511 -    def test_xml_mode_element_inside_html(self): 
+
512          # The htmlfile already outputs in xml mode for .element calls. This 
+513          # test actually illustrates a bug 
+514   
+515          with etree.htmlfile(self._file) as xf: 
+516              with xf.element("root"): 
+517                  with xf.element('foo', attrib={'selected': 'bar'}): 
+518                      pass 
+519   
+520          self.assertXml( 
+521              '<root>' 
+522                # '<foo selected></foo>'  # FIXME: this is the correct output 
+523                                          # in html mode 
+524                '<foo selected="bar"></foo>' 
+525              '</root>') 
+526          self._file = BytesIO() 
+
527   
+528 -    def test_attribute_quoting(self): 
+
529          with etree.htmlfile(self._file) as xf: 
+530              with xf.element("tagname", attrib={"attr": '"misquoted"'}): 
+531                  xf.write("foo") 
+532   
+533          self.assertXml('<tagname attr="&quot;misquoted&quot;">foo</tagname>') 
+
534   
+535 -    def test_attribute_quoting_unicode(self): 
+
536          with etree.htmlfile(self._file) as xf: 
+537              with xf.element("tagname", attrib={"attr": _str('"misquöted\\u3344\\U00013344"')}): 
+538                  xf.write("foo") 
+539   
+540          self.assertXml('<tagname attr="&quot;misqu&#xF6;ted&#x3344;&#x13344;&quot;">foo</tagname>') 
+
541   
+542 -    def test_unescaped_script(self): 
+
543          with etree.htmlfile(self._file) as xf: 
+544              elt = etree.Element('script') 
+545              elt.text = "if (a < b);" 
+546              xf.write(elt) 
+547          self.assertXml('<script>if (a < b);</script>') 
+
548   
+549 -    def test_unescaped_script_incremental(self): 
+
550          with etree.htmlfile(self._file) as xf: 
+551              with xf.element('script'): 
+552                  xf.write("if (a < b);") 
+553   
+554          self.assertXml('<script>if (a < b);</script>') 
+
555   
+556 -    def test_write_declaration(self): 
+
557          with etree.htmlfile(self._file) as xf: 
+558              try: 
+559                  xf.write_declaration() 
+560              except etree.LxmlSyntaxError: 
+561                  self.assertTrue(True) 
+562              else: 
+563                  self.assertTrue(False) 
+564              xf.write(etree.Element('html')) 
+
565   
+566 -    def test_write_namespaced_element(self): 
+
567          with etree.htmlfile(self._file) as xf: 
+568              xf.write(etree.Element('{some_ns}some_tag')) 
+569          self.assertXml('<ns0:some_tag xmlns:ns0="some_ns"></ns0:some_tag>') 
+
570   
+571 -    def test_open_namespaced_element(self): 
+
572          with etree.htmlfile(self._file) as xf: 
+573              with xf.element("{some_ns}some_tag"): 
+574                  pass 
+575          self.assertXml('<ns0:some_tag xmlns:ns0="some_ns"></ns0:some_tag>') 
+
576   
+577   
+578 -class AsyncXmlFileTestCase(HelperTestCase): 
+
579 -    def test_async_api(self): 
+
580          out = io.BytesIO() 
+581          xf = etree.xmlfile(out) 
+582          scm = xf.__enter__() 
+583          acm = xf.__aenter__() 
+584          list(acm.__await__())  # fake await to avoid destructor warning 
+585   
+586          def api_of(obj): 
+587              return sorted(name for name in dir(scm) if not name.startswith('__')) 
+
588   
+589          a_api = api_of(acm) 
+590   
+591          self.assertEqual(api_of(scm), api_of(acm)) 
+592          self.assertTrue('write' in a_api) 
+593          self.assertTrue('element' in a_api) 
+594          self.assertTrue('method' in a_api) 
+595          self.assertTrue(len(a_api) > 5) 
+
596   
+597 -    def _run_async(self, coro): 
+
598          while True: 
+599              try: 
+600                  coro.send(None) 
+601              except StopIteration as ex: 
+602                  return ex.value 
+
603   
+604      @skipIf(sys.version_info < (3, 5), "requires support for async-def (Py3.5+)") 
+605 -    def test_async(self): 
+
606          code = textwrap.dedent("""\ 
+607          async def test_async_xmlfile(close=True, buffered=True): 
+608              class Writer(object): 
+609                  def __init__(self): 
+610                      self._data = [] 
+611                      self._all_data = None 
+612                      self._calls = 0 
+613   
+614                  async def write(self, data): 
+615                      self._calls += 1 
+616                      self._data.append(data) 
+617   
+618                  async def close(self): 
+619                      assert self._all_data is None 
+620                      assert self._data is not None 
+621                      self._all_data = b''.join(self._data) 
+622                      self._data = None  # make writing fail afterwards 
+623   
+624              async def generate(out, close=True, buffered=True): 
+625                  async with etree.xmlfile(out, close=close, buffered=buffered) as xf: 
+626                      async with xf.element('root'): 
+627                          await xf.write('root-text') 
+628                          async with xf.method('html'): 
+629                              await xf.write(etree.Element('img', src='http://huhu.org/')) 
+630                          await xf.flush() 
+631                          for i in range(3): 
+632                              async with xf.element('el'): 
+633                                  await xf.write('text-%d' % i) 
+634   
+635              out = Writer() 
+636              await generate(out, close=close, buffered=buffered) 
+637              if not close: 
+638                  await out.close() 
+639              assert out._data is None, out._data 
+640              return out._all_data, out._calls 
+641          """) 
+642          lns = {} 
+643          exec(code, globals(), lns) 
+644          test_async_xmlfile = lns['test_async_xmlfile'] 
+645   
+646          expected = ( 
+647              b'<root>root-text<img src="http://huhu.org/">' 
+648              b'<el>text-0</el><el>text-1</el><el>text-2</el></root>' 
+649          ) 
+650   
+651          data, calls = self._run_async(test_async_xmlfile(close=True)) 
+652          self.assertEqual(expected, data) 
+653          self.assertEqual(2, calls)  # only flush() and close() 
+654   
+655          data, calls = self._run_async(test_async_xmlfile(close=False)) 
+656          self.assertEqual(expected, data) 
+657          self.assertEqual(2, calls)  # only flush() and close() 
+658   
+659          data, unbuffered_calls = self._run_async(test_async_xmlfile(buffered=False)) 
+660          self.assertEqual(expected, data) 
+661          self.assertTrue(unbuffered_calls > calls, unbuffered_calls) 
+
662   
+663   
+664 -def test_suite(): 
+
665      suite = unittest.TestSuite() 
+666      suite.addTests([ 
+667          unittest.makeSuite(BytesIOXmlFileTestCase), 
+668          unittest.makeSuite(TempXmlFileTestCase), 
+669          unittest.makeSuite(TempPathXmlFileTestCase), 
+670          unittest.makeSuite(SimpleFileLikeXmlFileTestCase), 
+671          unittest.makeSuite(HtmlFileTestCase), 
+672          unittest.makeSuite(AsyncXmlFileTestCase), 
+673      ]) 
+674      return suite 
+
675   
+676   
+677  if __name__ == '__main__': 
+678      print('to test use test.py %s' % __file__) 
+679   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               AsyncXmlFileTestCase
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+             _XmlFileTestCaseBase --+
+                                    |
+                                   BytesIOXmlFileTestCase
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+             _XmlFileTestCaseBase --+
+                                    |
+                                   HtmlFileTestCase
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+             _XmlFileTestCaseBase --+
+                                    |
+                                   SimpleFileLikeXmlFileTestCase
+
+object --+
+         |
+        SimpleFileLikeXmlFileTestCase.SimpleFileLike
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+             _XmlFileTestCaseBase --+
+                                    |
+                                   TempPathXmlFileTestCase
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+             _XmlFileTestCaseBase --+
+                                    |
+                                   TempXmlFileTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               _XmlFileTestCaseBase
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  IO test cases that apply to both etree and ElementTree 
+  5  """ 
+  6   
+  7  import unittest 
+  8  import tempfile, gzip, os, os.path, gc, shutil 
+  9   
+ 10  from lxml.tests.common_imports import ( 
+ 11      etree, ElementTree, _str, _bytes, 
+ 12      SillyFileLike, LargeFileLike, HelperTestCase, 
+ 13      read_file, write_to_file, BytesIO, tmpfile 
+ 14  ) 
+ 15   
+ 16   
+ 17 -class _IOTestCaseBase(HelperTestCase): 
+
 18      """(c)ElementTree compatibility for IO functions/methods 
+ 19      """ 
+ 20      etree = None 
+ 21       
+ 22 -    def setUp(self): 
+
 23          """Setting up a minimal tree 
+ 24          """ 
+ 25          self.root = self.etree.Element('a') 
+ 26          self.root_str = self.etree.tostring(self.root) 
+ 27          self.tree = self.etree.ElementTree(self.root) 
+ 28          self._temp_dir = tempfile.mkdtemp() 
+
 29   
+ 30 -    def tearDown(self): 
+
 31          gc.collect() 
+ 32          shutil.rmtree(self._temp_dir) 
+
 33   
+ 34 -    def getTestFilePath(self, name): 
+
 35          return os.path.join(self._temp_dir, name) 
+
 36   
+ 37 -    def buildNodes(self, element, children, depth): 
+
 38          Element = self.etree.Element 
+ 39   
+ 40          if depth == 0: 
+ 41              return 
+ 42          for i in range(children): 
+ 43              new_element = Element('element_%s_%s' % (depth, i)) 
+ 44              self.buildNodes(new_element, children, depth - 1) 
+ 45              element.append(new_element) 
+
 46   
+ 47 -    def test_tree_io(self): 
+
 48          Element = self.etree.Element 
+ 49          ElementTree = self.etree.ElementTree 
+ 50   
+ 51          element = Element('top') 
+ 52          element.text = _str("qwrtioüöä\uAABB") 
+ 53          tree = ElementTree(element) 
+ 54          self.buildNodes(element, 10, 3) 
+ 55          with open(self.getTestFilePath('testdump.xml'), 'wb') as f: 
+ 56              tree.write(f, encoding='UTF-8') 
+ 57          with open(self.getTestFilePath('testdump.xml'), 'rb') as f: 
+ 58              tree = ElementTree(file=f) 
+ 59          with open(self.getTestFilePath('testdump2.xml'), 'wb') as f: 
+ 60              tree.write(f, encoding='UTF-8') 
+ 61          with open(self.getTestFilePath('testdump.xml'), 'rb') as f: 
+ 62              data1 = f.read() 
+ 63          with open(self.getTestFilePath('testdump2.xml'), 'rb') as f: 
+ 64              data2 = f.read() 
+ 65          self.assertEqual(data1, data2) 
+
 66   
+ 67 -    def test_tree_io_latin1(self): 
+
 68          Element = self.etree.Element 
+ 69          ElementTree = self.etree.ElementTree 
+ 70   
+ 71          element = Element('top') 
+ 72          element.text = _str("qwrtioüöäßÃ¡") 
+ 73          tree = ElementTree(element) 
+ 74          self.buildNodes(element, 10, 3) 
+ 75          with open(self.getTestFilePath('testdump.xml'), 'wb') as f: 
+ 76              tree.write(f, encoding='iso-8859-1') 
+ 77          with open(self.getTestFilePath('testdump.xml'), 'rb') as f: 
+ 78              tree = ElementTree(file=f) 
+ 79          with open(self.getTestFilePath('testdump2.xml'), 'wb') as f: 
+ 80              tree.write(f, encoding='iso-8859-1') 
+ 81          with open(self.getTestFilePath('testdump.xml'), 'rb') as f: 
+ 82              data1 = f.read() 
+ 83          with open(self.getTestFilePath('testdump2.xml'), 'rb') as f: 
+ 84              data2 = f.read() 
+ 85          self.assertEqual(data1, data2) 
+
 86   
+ 87 -    def test_write_filename(self): 
+
 88          # (c)ElementTree  supports filename strings as write argument 
+ 89          with tmpfile(prefix="p", suffix=".xml") as filename: 
+ 90              self.tree.write(filename) 
+ 91              self.assertEqual(read_file(filename, 'rb').replace(b'\n', b''), 
+ 92                               self.root_str) 
+
 93   
+ 94 -    def test_write_filename_special_percent(self): 
+
 95          # '%20' is a URL escaped space character. 
+ 96          before_test = os.listdir(tempfile.gettempdir()) 
+ 97   
+ 98          def difference(filenames): 
+ 99              return sorted( 
+100                  fn for fn in set(filenames).difference(before_test) 
+101                  if fn.startswith('lxmltmp-') 
+102              ) 
+
103   
+104          with tmpfile(prefix="lxmltmp-p%20p", suffix=".xml") as filename: 
+105              try: 
+106                  before_write = os.listdir(tempfile.gettempdir()) 
+107                  self.tree.write(filename) 
+108                  after_write = os.listdir(tempfile.gettempdir()) 
+109                  self.assertEqual(read_file(filename, 'rb').replace(b'\n', b''), 
+110                                   self.root_str) 
+111              except (AssertionError, IOError, OSError): 
+112                  print("Before write: %s, after write: %s" % ( 
+113                      difference(before_write), difference(after_write)) 
+114                  ) 
+115                  raise 
+
116   
+117 -    def test_write_filename_special_plus(self): 
+
118          # '+' is used as an escaped space character in URLs. 
+119          with tmpfile(prefix="p+", suffix=".xml") as filename: 
+120              self.tree.write(filename) 
+121              self.assertEqual(read_file(filename, 'rb').replace(b'\n', b''), 
+122                               self.root_str) 
+
123   
+124 -    def test_write_invalid_filename(self): 
+
125          filename = os.path.join( 
+126              os.path.join('hopefullynonexistingpathname'), 
+127              'invalid_file.xml') 
+128          try: 
+129              self.tree.write(filename) 
+130          except IOError: 
+131              pass 
+132          else: 
+133              self.assertTrue( 
+134                  False, "writing to an invalid file path should fail") 
+
135   
+136 -    def test_module_parse_gzipobject(self): 
+
137          # (c)ElementTree supports gzip instance as parse argument 
+138          with tmpfile(suffix=".xml.gz") as filename: 
+139              with gzip.open(filename, 'wb') as f: 
+140                  f.write(self.root_str) 
+141              with gzip.open(filename, 'rb') as f_gz: 
+142                  tree = self.etree.parse(f_gz) 
+143              self.assertEqual(self.etree.tostring(tree.getroot()), self.root_str) 
+
144   
+145 -    def test_class_parse_filename(self): 
+
146          # (c)ElementTree class ElementTree has a 'parse' method that returns 
+147          # the root of the tree 
+148   
+149          # parse from filename 
+150          with tmpfile(suffix=".xml") as filename: 
+151              write_to_file(filename, self.root_str, 'wb') 
+152              tree = self.etree.ElementTree() 
+153              root = tree.parse(filename) 
+154              self.assertEqual(self.etree.tostring(root), self.root_str) 
+
155   
+156 -    def test_class_parse_filename_remove_previous(self): 
+
157          with tmpfile(suffix=".xml") as filename: 
+158              write_to_file(filename, self.root_str, 'wb') 
+159              tree = self.etree.ElementTree() 
+160              root = tree.parse(filename) 
+161              # and now do it again; previous content should still be there 
+162              root2 = tree.parse(filename) 
+163              self.assertEqual('a', root.tag) 
+164              self.assertEqual('a', root2.tag) 
+165              # now remove all references to root2, and parse again 
+166              del root2 
+167              root3 = tree.parse(filename) 
+168              self.assertEqual('a', root.tag) 
+169              self.assertEqual('a', root3.tag) 
+
170              # root2's memory should've been freed here 
+171              # XXX how to check? 
+172   
+173 -    def test_class_parse_fileobject(self): 
+
174          # (c)ElementTree class ElementTree has a 'parse' method that returns 
+175          # the root of the tree 
+176   
+177          # parse from file object 
+178          handle, filename = tempfile.mkstemp(suffix=".xml") 
+179          try: 
+180              os.write(handle, self.root_str) 
+181              with open(filename, 'rb') as f: 
+182                  tree = self.etree.ElementTree() 
+183                  root = tree.parse(f) 
+184              self.assertEqual(self.etree.tostring(root), self.root_str) 
+185          finally: 
+186              os.close(handle) 
+187              os.remove(filename) 
+
188   
+189 -    def test_class_parse_unamed_fileobject(self): 
+
190          # (c)ElementTree class ElementTree has a 'parse' method that returns 
+191          # the root of the tree 
+192   
+193          # parse from unamed file object     
+194          f = SillyFileLike() 
+195          root = self.etree.ElementTree().parse(f) 
+196          self.assertTrue(root.tag.endswith('foo')) 
+
197   
+198 -    def test_module_parse_large_fileobject(self): 
+
199          # parse from unamed file object 
+200          f = LargeFileLike() 
+201          tree = self.etree.parse(f) 
+202          root = tree.getroot() 
+203          self.assertTrue(root.tag.endswith('root')) 
+
204   
+205 -    def test_module_parse_fileobject_error(self): 
+
206          class LocalError(Exception): 
+207              pass 
+
208          class TestFile: 
+209              def read(*args): 
+210                  raise LocalError 
+211          f = TestFile() 
+212          self.assertRaises(LocalError, self.etree.parse, f) 
+213   
+214 -    def test_module_parse_fileobject_late_error(self): 
+
215          class LocalError(Exception): 
+216              pass 
+
217          class TestFile: 
+218              data = '<root>test</' 
+219              try: 
+220                  next_char = iter(data).next 
+221              except AttributeError: 
+222                  # Python 3 
+223                  next_char = iter(data).__next__ 
+224              counter = 0 
+225              def read(self, amount=None): 
+226                  if amount is None: 
+227                      while True: 
+228                          self.read(1) 
+229                  else: 
+230                      try: 
+231                          self.counter += 1 
+232                          return _bytes(self.next_char()) 
+233                      except StopIteration: 
+234                          raise LocalError 
+235          f = TestFile() 
+236          self.assertRaises(LocalError, self.etree.parse, f) 
+237          self.assertEqual(f.counter, len(f.data)+1) 
+238   
+239 -    def test_module_parse_fileobject_type_error(self): 
+
240          class TestFile: 
+241              def read(*args): 
+242                  return 1 
+
243          f = TestFile() 
+244   
+245          try: 
+246              expect_exc = (TypeError, self.etree.ParseError) 
+247          except AttributeError: 
+248              expect_exc = TypeError 
+249          self.assertRaises(expect_exc, self.etree.parse, f) 
+250   
+251 -    def test_etree_parse_io_error(self): 
+
252          # this is a directory name that contains characters beyond latin-1 
+253          dirnameEN = _str('Directory') 
+254          dirnameRU = _str('ÐšÐ°Ñ‚Ð°Ð»Ð¾Ð³') 
+255          filename = _str('nosuchfile.xml') 
+256          dn = tempfile.mkdtemp(prefix=dirnameEN) 
+257          try: 
+258              self.assertRaises(IOError, self.etree.parse, os.path.join(dn, filename)) 
+259          finally: 
+260              os.rmdir(dn) 
+261          dn = tempfile.mkdtemp(prefix=dirnameRU) 
+262          try: 
+263              self.assertRaises(IOError, self.etree.parse, os.path.join(dn, filename)) 
+264          finally: 
+265              os.rmdir(dn) 
+
266   
+267 -    def test_parse_utf8_bom(self): 
+
268          utext = _str('Søk på nettet') 
+269          uxml = '<?xml version="1.0" encoding="UTF-8"?><p>%s</p>' % utext 
+270          bom = _bytes('\\xEF\\xBB\\xBF').decode( 
+271              "unicode_escape").encode("latin1") 
+272          self.assertEqual(3, len(bom)) 
+273          f = tempfile.NamedTemporaryFile(delete=False) 
+274          try: 
+275              try: 
+276                  f.write(bom) 
+277                  f.write(uxml.encode("utf-8")) 
+278              finally: 
+279                  f.close() 
+280              tree = self.etree.parse(f.name) 
+281          finally: 
+282              os.unlink(f.name) 
+283          self.assertEqual(utext, tree.getroot().text) 
+
284   
+285 -    def test_iterparse_utf8_bom(self): 
+
286          utext = _str('Søk på nettet') 
+287          uxml = '<?xml version="1.0" encoding="UTF-8"?><p>%s</p>' % utext 
+288          bom = _bytes('\\xEF\\xBB\\xBF').decode( 
+289              "unicode_escape").encode("latin1") 
+290          self.assertEqual(3, len(bom)) 
+291          f = tempfile.NamedTemporaryFile(delete=False) 
+292          try: 
+293              try: 
+294                  f.write(bom) 
+295                  f.write(uxml.encode("utf-8")) 
+296              finally: 
+297                  f.close() 
+298              elements = [el for _, el in self.etree.iterparse(f.name)] 
+299              self.assertEqual(1, len(elements)) 
+300              root = elements[0] 
+301          finally: 
+302              os.unlink(f.name) 
+303          self.assertEqual(utext, root.text) 
+
304   
+305 -    def test_iterparse_utf16_bom(self): 
+
306          utext = _str('Søk på nettet') 
+307          uxml = '<?xml version="1.0" encoding="UTF-16"?><p>%s</p>' % utext 
+308          boms = _bytes('\\xFE\\xFF \\xFF\\xFE').decode( 
+309              "unicode_escape").encode("latin1") 
+310          self.assertEqual(5, len(boms)) 
+311          xml = uxml.encode("utf-16") 
+312          self.assertTrue(xml[:2] in boms, repr(xml[:2])) 
+313   
+314          f = tempfile.NamedTemporaryFile(delete=False) 
+315          try: 
+316              try: 
+317                  f.write(xml) 
+318              finally: 
+319                  f.close() 
+320              elements = [el for _, el in self.etree.iterparse(f.name)] 
+321              self.assertEqual(1, len(elements)) 
+322              root = elements[0] 
+323          finally: 
+324              os.unlink(f.name) 
+325          self.assertEqual(utext, root.text) 
+
326   
+327   
+328 -class ETreeIOTestCase(_IOTestCaseBase): 
+
329      etree = etree 
+330   
+331 -    def test_write_compressed_text(self): 
+
332          Element = self.etree.Element 
+333          SubElement = self.etree.SubElement 
+334          ElementTree = self.etree.ElementTree 
+335          text = _str("qwrtioüöä") 
+336   
+337          root = Element('root') 
+338          root.text = text 
+339          child = SubElement(root, 'sub') 
+340          child.text = 'TEXT' 
+341          child.tail = 'TAIL' 
+342          SubElement(root, 'sub').text = text 
+343   
+344          tree = ElementTree(root) 
+345          out = BytesIO() 
+346          tree.write(out, method='text', encoding='utf8', compression=9) 
+347          out.seek(0) 
+348   
+349          f = gzip.GzipFile(fileobj=out) 
+350          try: 
+351              result = f.read().decode('utf8') 
+352          finally: 
+353              f.close() 
+354          self.assertEqual(text+'TEXTTAIL'+text, result) 
+
355   
+356   
+357  if ElementTree: 
+358 -    class ElementTreeIOTestCase(_IOTestCaseBase): 
+
359          etree = ElementTree 
+
360   
+361   
+362 -def test_suite(): 
+
363      suite = unittest.TestSuite() 
+364      suite.addTests([unittest.makeSuite(ETreeIOTestCase)]) 
+365      if ElementTree: 
+366          suite.addTests([unittest.makeSuite(ElementTreeIOTestCase)]) 
+367      return suite 
+
368   
+369   
+370  if __name__ == '__main__': 
+371      print('to test use test.py %s' % __file__) 
+372   
+
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+                  _IOTestCaseBase --+
+                                    |
+                                   ETreeIOTestCase
+
lxml.etree
lxml.etree
+               object --+            
+                        |            
+   unittest.case.TestCase --+        
+                            |        
+common_imports.HelperTestCase --+    
+                                |    
+                  _IOTestCaseBase --+
+                                    |
+                                   ElementTreeIOTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               _IOTestCaseBase
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Test cases related to ISO-Schematron parsing and validation 
+  5  """ 
+  6   
+  7  import unittest, sys, os.path 
+  8  from lxml import isoschematron 
+  9   
+ 10  this_dir = os.path.dirname(__file__) 
+ 11  if this_dir not in sys.path: 
+ 12      sys.path.insert(0, this_dir) # needed for Py3 
+ 13   
+ 14  from common_imports import etree, HelperTestCase, fileInTestDir 
+ 15  from common_imports import doctest, make_doctest 
+ 16   
+ 17   
+ 18 -class ETreeISOSchematronTestCase(HelperTestCase): 
+
 19 -    def test_schematron(self): 
+
 20          tree_valid = self.parse('<AAA><BBB/><CCC/></AAA>') 
+ 21          tree_invalid = self.parse('<AAA><BBB/><CCC/><DDD/></AAA>') 
+ 22          schema = self.parse('''\ 
+ 23  <schema xmlns="http://purl.oclc.org/dsdl/schematron" > 
+ 24      <pattern id="OpenModel"> 
+ 25          <title>Open Model</title> 
+ 26          <rule context="AAA"> 
+ 27              <assert test="BBB"> BBB element is not present</assert> 
+ 28              <assert test="CCC"> CCC element is not present</assert> 
+ 29          </rule> 
+ 30      </pattern> 
+ 31      <pattern id="ClosedModel"> 
+ 32          <title>Closed model"</title> 
+ 33          <rule context="AAA"> 
+ 34              <assert test="BBB"> BBB element is not present</assert> 
+ 35              <assert test="CCC"> CCC element is not present</assert> 
+ 36              <assert test="count(BBB|CCC) = count (*)">There is an extra element</assert> 
+ 37          </rule> 
+ 38      </pattern> 
+ 39  </schema> 
+ 40  ''') 
+ 41   
+ 42          schema = isoschematron.Schematron(schema) 
+ 43          self.assertTrue(schema.validate(tree_valid)) 
+ 44          self.assertTrue(not schema.validate(tree_invalid)) 
+
 45   
+ 46 -    def test_schematron_elementtree_error(self): 
+
 47          self.assertRaises(ValueError, isoschematron.Schematron, etree.ElementTree()) 
+
 48   
+ 49      # an empty pattern is valid in iso schematron 
+ 50 -    def test_schematron_empty_pattern(self): 
+
 51          schema = self.parse('''\ 
+ 52  <schema xmlns="http://purl.oclc.org/dsdl/schematron" > 
+ 53      <pattern id="OpenModel"> 
+ 54          <title>Open model</title> 
+ 55      </pattern> 
+ 56  </schema> 
+ 57  ''') 
+ 58          schema = isoschematron.Schematron(schema) 
+ 59          self.assertTrue(schema) 
+
 60   
+ 61 -    def test_schematron_invalid_schema_empty(self): 
+
 62          schema = self.parse('''\ 
+ 63  <schema xmlns="http://purl.oclc.org/dsdl/schematron" /> 
+ 64  ''') 
+ 65          self.assertRaises(etree.SchematronParseError, 
+ 66                            isoschematron.Schematron, schema) 
+
 67   
+ 68 -    def test_schematron_invalid_schema_namespace(self): 
+
 69          schema = self.parse('''\ 
+ 70  <schema xmlns="mynamespace" /> 
+ 71  ''') 
+ 72          self.assertRaises(etree.SchematronParseError, 
+ 73                            isoschematron.Schematron, schema) 
+
 74   
+ 75 -    def test_schematron_from_tree(self): 
+
 76          schema = self.parse('''\ 
+ 77  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+ 78    <sch:pattern id="number_of_entries"> 
+ 79      <sch:title>mandatory number_of_entries tests</sch:title> 
+ 80      <sch:rule context="number_of_entries"> 
+ 81        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+ 82      </sch:rule> 
+ 83    </sch:pattern> 
+ 84  </sch:schema> 
+ 85  ''') 
+ 86          schematron = isoschematron.Schematron(schema) 
+ 87          self.assertTrue(isinstance(schematron, isoschematron.Schematron)) 
+
 88   
+ 89 -    def test_schematron_from_element(self): 
+
 90          schema = self.parse('''\ 
+ 91  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+ 92    <sch:pattern id="number_of_entries"> 
+ 93      <sch:title>mandatory number_of_entries tests</sch:title> 
+ 94      <sch:rule context="number_of_entries"> 
+ 95        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+ 96      </sch:rule> 
+ 97    </sch:pattern> 
+ 98  </sch:schema> 
+ 99  ''') 
+100          schematron = isoschematron.Schematron(schema.getroot()) 
+101          self.assertTrue(isinstance(schematron, isoschematron.Schematron)) 
+
102   
+103 -    def test_schematron_from_file(self): 
+
104          schematron = isoschematron.Schematron(file=fileInTestDir('test.sch')) 
+105          self.assertTrue(isinstance(schematron, isoschematron.Schematron)) 
+
106   
+107 -    def test_schematron_call(self): 
+
108          schema = self.parse('''\ 
+109  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+110    <sch:pattern id="number_of_entries"> 
+111      <sch:title>mandatory number_of_entries tests</sch:title> 
+112      <sch:rule context="number_of_entries"> 
+113        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+114      </sch:rule> 
+115    </sch:pattern> 
+116  </sch:schema> 
+117  ''') 
+118          tree_valid = self.parse('''\ 
+119  <message> 
+120    <number_of_entries>0</number_of_entries> 
+121    <entries> 
+122    </entries> 
+123  </message> 
+124  ''') 
+125          tree_invalid = self.parse('''\ 
+126  <message> 
+127    <number_of_entries>3</number_of_entries> 
+128    <entries> 
+129      <entry>Entry 1</entry> 
+130      <entry>Entry 2</entry> 
+131    </entries> 
+132  </message> 
+133  ''') 
+134          schematron = isoschematron.Schematron(schema) 
+135          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+136          valid = schematron(tree_invalid) 
+137          self.assertTrue(not valid) 
+
138   
+139 -    def test_schematron_validate(self): 
+
140          schema = self.parse('''\ 
+141  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+142    <sch:pattern id="number_of_entries"> 
+143      <sch:title>mandatory number_of_entries tests</sch:title> 
+144      <sch:rule context="number_of_entries"> 
+145        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+146      </sch:rule> 
+147    </sch:pattern> 
+148  </sch:schema> 
+149  ''') 
+150          tree_valid = self.parse('''\ 
+151  <message> 
+152    <number_of_entries>0</number_of_entries> 
+153    <entries> 
+154    </entries> 
+155  </message> 
+156  ''') 
+157          tree_invalid = self.parse('''\ 
+158  <message> 
+159    <number_of_entries>3</number_of_entries> 
+160    <entries> 
+161      <entry>Entry 1</entry> 
+162      <entry>Entry 2</entry> 
+163    </entries> 
+164  </message> 
+165  ''') 
+166          schematron = isoschematron.Schematron(schema) 
+167          self.assertTrue(schematron.validate(tree_valid), schematron.error_log) 
+168          valid = schematron.validate(tree_invalid) 
+169          self.assertTrue(not valid) 
+
170   
+171 -    def test_schematron_assertValid(self): 
+
172          schema = self.parse('''\ 
+173  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+174    <sch:pattern id="number_of_entries"> 
+175      <sch:title>mandatory number_of_entries tests</sch:title> 
+176      <sch:rule context="number_of_entries"> 
+177        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+178      </sch:rule> 
+179    </sch:pattern> 
+180  </sch:schema> 
+181  ''') 
+182          tree_valid = self.parse('''\ 
+183  <message> 
+184    <number_of_entries>0</number_of_entries> 
+185    <entries> 
+186    </entries> 
+187  </message> 
+188  ''') 
+189          tree_invalid = self.parse('''\ 
+190  <message> 
+191    <number_of_entries>3</number_of_entries> 
+192    <entries> 
+193      <entry>Entry 1</entry> 
+194      <entry>Entry 2</entry> 
+195    </entries> 
+196  </message> 
+197  ''') 
+198          schematron = isoschematron.Schematron(schema) 
+199          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+200          self.assertRaises(etree.DocumentInvalid, schematron.assertValid, 
+201                            tree_invalid) 
+
202   
+203 -    def test_schematron_error_log(self): 
+
204          schema = self.parse('''\ 
+205  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+206    <sch:pattern id="number_of_entries"> 
+207      <sch:title>mandatory number_of_entries tests</sch:title> 
+208      <sch:rule context="number_of_entries"> 
+209        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+210      </sch:rule> 
+211    </sch:pattern> 
+212  </sch:schema> 
+213  ''') 
+214          tree_valid = self.parse('''\ 
+215  <message> 
+216    <number_of_entries>0</number_of_entries> 
+217    <entries> 
+218    </entries> 
+219  </message> 
+220  ''') 
+221          tree_invalid = self.parse('''\ 
+222  <message> 
+223    <number_of_entries>3</number_of_entries> 
+224    <entries> 
+225      <entry>Entry 1</entry> 
+226      <entry>Entry 2</entry> 
+227    </entries> 
+228  </message> 
+229  ''') 
+230          schematron = isoschematron.Schematron(schema) 
+231          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+232          valid = schematron(tree_invalid) 
+233          self.assertTrue(not valid) 
+234          self.assertEqual(len(schematron.error_log), 1, 
+235                            'expected single error: %s (%s errors)' % 
+236                            (schematron.error_log, len(schematron.error_log))) 
+
237   
+238 -    def test_schematron_result_report(self): 
+
239          schema = self.parse('''\ 
+240  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+241    <sch:pattern id="number_of_entries"> 
+242      <sch:title>mandatory number_of_entries tests</sch:title> 
+243      <sch:rule context="number_of_entries"> 
+244        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+245      </sch:rule> 
+246    </sch:pattern> 
+247  </sch:schema> 
+248  ''') 
+249          tree_valid = self.parse('''\ 
+250  <message> 
+251    <number_of_entries>0</number_of_entries> 
+252    <entries> 
+253    </entries> 
+254  </message> 
+255  ''') 
+256          tree_invalid = self.parse('''\ 
+257  <message> 
+258    <number_of_entries>3</number_of_entries> 
+259    <entries> 
+260      <entry>Entry 1</entry> 
+261      <entry>Entry 2</entry> 
+262    </entries> 
+263  </message> 
+264  ''') 
+265          schematron = isoschematron.Schematron(schema, store_report=True) 
+266          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+267          valid = schematron(tree_invalid) 
+268          self.assertTrue(not valid) 
+269          self.assertTrue( 
+270              isinstance(schematron.validation_report, etree._ElementTree), 
+271              'expected a validation report result tree, got: %s' % schematron.validation_report) 
+272   
+273          schematron = isoschematron.Schematron(schema, store_report=False) 
+274          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+275          valid = schematron(tree_invalid) 
+276          self.assertTrue(not valid) 
+277          self.assertTrue(schematron.validation_report is None, 
+278              'validation reporting switched off, still: %s' % schematron.validation_report) 
+
279   
+280 -    def test_schematron_store_schematron(self): 
+
281          schema = self.parse('''\ 
+282  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+283    <sch:pattern id="number_of_entries"> 
+284      <sch:title>mandatory number_of_entries tests</sch:title> 
+285      <sch:rule context="number_of_entries"> 
+286        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+287      </sch:rule> 
+288    </sch:pattern> 
+289  </sch:schema> 
+290  ''') 
+291          schematron = isoschematron.Schematron(schema) 
+292          self.assertTrue(schematron.validator_xslt is None) 
+293   
+294          schematron = isoschematron.Schematron(schema, store_schematron=True) 
+295          self.assertTrue(isinstance(schematron.schematron, etree._ElementTree), 
+296                       'expected schematron schema to be stored') 
+
297   
+298 -    def test_schematron_store_xslt(self): 
+
299          schema = self.parse('''\ 
+300  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+301    <sch:pattern id="number_of_entries"> 
+302      <sch:title>mandatory number_of_entries tests</sch:title> 
+303      <sch:rule context="number_of_entries"> 
+304        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+305      </sch:rule> 
+306    </sch:pattern> 
+307  </sch:schema> 
+308  ''') 
+309          schematron = isoschematron.Schematron(schema) 
+310          self.assertTrue(schematron.validator_xslt is None) 
+311   
+312          schematron = isoschematron.Schematron(schema, store_xslt=True) 
+313          self.assertTrue(isinstance(schematron.validator_xslt, etree._ElementTree), 
+314                       'expected validator xslt to be stored') 
+
315   
+316 -    def test_schematron_abstract(self): 
+
317          schema = self.parse('''\ 
+318  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+319    <sch:title>iso schematron validation</sch:title> 
+320    <sch:ns uri="http://www.w3.org/2001/XMLSchema-instance" prefix="xsi"/> 
+321    <sch:ns uri="http://codespeak.net/lxml/objectify/pytype" prefix="py"/> 
+322   
+323    <!-- of course, these only really make sense when combined with a schema that 
+324         ensures datatype xs:dateTime --> 
+325   
+326    <sch:pattern abstract="true" id="abstract.dateTime.tz_utc"> 
+327      <sch:rule context="$datetime"> 
+328        <sch:let name="tz" value="concat(substring-after(substring-after(./text(), 'T'), '+'), substring-after(substring-after(./text(), 'T'), '-'))"/> 
+329        <sch:let name="lastchar" value="substring(./text(), string-length(./text()))"/> 
+330        <sch:assert test="$lastchar='Z' or $tz='00:00'">[ERROR] element (<sch:value-of select="name(.)"/>) dateTime value (<sch:value-of select="."/>) is not qualified as UTC (tz: <sch:value-of select="$tz"/>)</sch:assert> 
+331      </sch:rule> 
+332    </sch:pattern> 
+333   
+334    <sch:pattern abstract="true" id="abstract.dateTime.tz_utc_nillable"> 
+335      <sch:rule context="$datetime"> 
+336        <sch:let name="tz" value="concat(substring-after(substring-after(./text(), 'T'), '+'), substring-after(substring-after(./text(), 'T'), '-'))"/> 
+337        <sch:let name="lastchar" value="substring(./text(), string-length(./text()))"/> 
+338        <sch:assert test="@xsi:nil='true'  or ($lastchar='Z' or $tz='00:00')">[ERROR] element (<sch:value-of select="name(.)"/>) dateTime value (<sch:value-of select="."/>) is not qualified as UTC (tz: <sch:value-of select="$tz"/>)</sch:assert> 
+339      </sch:rule> 
+340    </sch:pattern> 
+341   
+342    <sch:pattern is-a="abstract.dateTime.tz_utc" id="datetime" > 
+343      <sch:param name="datetime" value="datetime"/> 
+344    </sch:pattern> 
+345   
+346    <sch:pattern is-a="abstract.dateTime.tz_utc_nillable" id="nillableDatetime"> 
+347      <sch:param name="datetime" value="nillableDatetime"/> 
+348    </sch:pattern> 
+349   
+350  </sch:schema> 
+351  ''') 
+352          valid_trees = [ 
+353              self.parse('''\ 
+354  <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+355    <datetime>2009-12-10T15:21:00Z</datetime> 
+356    <nillableDatetime xsi:nil="true"/> 
+357  </root> 
+358  '''), 
+359              self.parse('''\ 
+360  <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+361    <datetime>2009-12-10T15:21:00Z</datetime> 
+362    <nillableDatetime>2009-12-10T15:21:00Z</nillableDatetime> 
+363  </root> 
+364  '''), 
+365              self.parse('''\ 
+366  <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+367    <datetime>2009-12-10T15:21:00+00:00</datetime> 
+368    <nillableDatetime>2009-12-10T15:21:00-00:00</nillableDatetime> 
+369  </root> 
+370  '''), 
+371              ] 
+372   
+373          schematron = isoschematron.Schematron(schema) 
+374          for tree_valid in valid_trees: 
+375              self.assertTrue(schematron(tree_valid), schematron.error_log) 
+376   
+377          tree_invalid = self.parse('''\ 
+378  <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+379    <datetime>2009-12-10T16:21:00+01:00</datetime> 
+380    <nillableDatetime>2009-12-10T16:21:00+01:00</nillableDatetime> 
+381  </root> 
+382  ''') 
+383          expected = 2 
+384          valid = schematron(tree_invalid) 
+385          self.assertTrue(not valid) 
+386          self.assertEqual( 
+387              len(schematron.error_log), expected, 
+388              'expected %s errors: %s (%s errors)' % 
+389              (expected, schematron.error_log, len(schematron.error_log))) 
+390   
+391          tree_invalid = self.parse('''\ 
+392  <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+393    <datetime xsi:nil="true"/> 
+394    <nillableDatetime>2009-12-10T16:21:00Z</nillableDatetime> 
+395  </root> 
+396  ''') 
+397          expected = 1 
+398          valid = schematron(tree_invalid) 
+399          self.assertTrue(not valid) 
+400          self.assertEqual( 
+401              len(schematron.error_log), expected, 
+402              'expected %s errors: %s (%s errors)' % 
+403              (expected, schematron.error_log, len(schematron.error_log))) 
+
404   
+405 -    def test_schematron_phases(self): 
+
406          schema = self.parse('''\ 
+407  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+408    <sch:title>iso schematron validation</sch:title> 
+409    <sch:ns uri="http://www.w3.org/2001/XMLSchema-instance" prefix="xsi"/> 
+410    <sch:ns uri="http://codespeak.net/lxml/objectify/pytype" prefix="py"/> 
+411   
+412    <sch:phase id="mandatory"> 
+413      <sch:active pattern="number_of_entries"/> 
+414    </sch:phase> 
+415   
+416    <sch:phase id="datetime_checks"> 
+417      <sch:active pattern="datetime"/> 
+418      <sch:active pattern="nillableDatetime"/> 
+419    </sch:phase> 
+420   
+421    <sch:phase id="full"> 
+422      <sch:active pattern="number_of_entries"/> 
+423      <sch:active pattern="datetime"/> 
+424      <sch:active pattern="nillableDatetime"/> 
+425    </sch:phase> 
+426   
+427    <!-- of course, these only really make sense when combined with a schema that 
+428         ensures datatype xs:dateTime --> 
+429   
+430    <sch:pattern abstract="true" id="abstract.dateTime.tz_utc"> 
+431      <sch:rule context="$datetime"> 
+432        <sch:let name="tz" value="concat(substring-after(substring-after(./text(), 'T'), '+'), substring-after(substring-after(./text(), 'T'), '-'))"/> 
+433        <sch:let name="lastchar" value="substring(./text(), string-length(./text()))"/> 
+434        <sch:assert test="$lastchar='Z' or $tz='00:00'">[ERROR] element (<sch:value-of select="name(.)"/>) dateTime value (<sch:value-of select="."/>) is not qualified as UTC (tz: <sch:value-of select="$tz"/>)</sch:assert> 
+435      </sch:rule> 
+436    </sch:pattern> 
+437   
+438    <sch:pattern abstract="true" id="abstract.dateTime.tz_utc_nillable"> 
+439      <sch:rule context="$datetime"> 
+440        <sch:let name="tz" value="concat(substring-after(substring-after(./text(), 'T'), '+'), substring-after(substring-after(./text(), 'T'), '-'))"/> 
+441        <sch:let name="lastchar" value="substring(./text(), string-length(./text()))"/> 
+442        <sch:assert test="@xsi:nil='true'  or ($lastchar='Z' or $tz='00:00')">[ERROR] element (<sch:value-of select="name(.)"/>) dateTime value (<sch:value-of select="."/>) is not qualified as UTC (tz: <sch:value-of select="$tz"/>)</sch:assert> 
+443      </sch:rule> 
+444    </sch:pattern> 
+445   
+446    <sch:pattern id="number_of_entries"> 
+447      <sch:title>mandatory number_of_entries test</sch:title> 
+448      <sch:rule context="number_of_entries"> 
+449        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+450      </sch:rule> 
+451    </sch:pattern> 
+452   
+453    <sch:pattern  id="datetime" is-a="abstract.dateTime.tz_utc"> 
+454      <sch:param name="datetime" value="datetime"/> 
+455    </sch:pattern> 
+456   
+457    <sch:pattern  id="nillableDatetime" is-a="abstract.dateTime.tz_utc_nillable"> 
+458      <sch:param name="datetime" value="nillableDatetime"/> 
+459    </sch:pattern> 
+460   
+461  </sch:schema> 
+462  ''') 
+463          tree_valid = self.parse('''\ 
+464  <message xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+465    <datetime>2009-12-10T15:21:00Z</datetime> 
+466    <nillableDatetime xsi:nil="true"/> 
+467    <number_of_entries>0</number_of_entries> 
+468    <entries> 
+469    </entries> 
+470  </message> 
+471  ''') 
+472          tree_invalid = self.parse('''\ 
+473  <message> 
+474    <datetime>2009-12-10T16:21:00+01:00</datetime> 
+475    <nillableDatetime>2009-12-10T16:21:00+01:00</nillableDatetime> 
+476    <number_of_entries>3</number_of_entries> 
+477    <entries> 
+478      <entry>Entry 1</entry> 
+479      <entry>Entry 2</entry> 
+480    </entries> 
+481  </message> 
+482  ''') 
+483          # check everything (default phase #ALL) 
+484          schematron = isoschematron.Schematron(schema) 
+485          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+486          expected = 3 
+487          valid = schematron(tree_invalid) 
+488          self.assertTrue(not valid) 
+489          self.assertEqual( 
+490              len(schematron.error_log), expected, 
+491              'expected %s errors: %s (%s errors)' % 
+492              (expected, schematron.error_log, len(schematron.error_log))) 
+493   
+494          # check phase mandatory 
+495          schematron = isoschematron.Schematron( 
+496              schema, compile_params={'phase': 'mandatory'}) 
+497          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+498          expected = 1 
+499          valid = schematron(tree_invalid) 
+500          self.assertTrue(not valid) 
+501          self.assertEqual( 
+502              len(schematron.error_log), expected, 
+503              'expected %s errors: %s (%s errors)' % 
+504              (expected, schematron.error_log, len(schematron.error_log))) 
+505   
+506          # check phase datetime_checks 
+507          schematron = isoschematron.Schematron( 
+508              schema, compile_params={'phase': 'datetime_checks'}) 
+509          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+510          expected = 2 
+511          valid = schematron(tree_invalid) 
+512          self.assertTrue(not valid) 
+513          self.assertEqual( 
+514              len(schematron.error_log), expected, 
+515              'expected %s errors: %s (%s errors)' % 
+516              (expected, schematron.error_log, len(schematron.error_log))) 
+517   
+518          # check phase full 
+519          schematron = isoschematron.Schematron( 
+520              schema, compile_params={'phase': 'full'}) 
+521          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+522          expected = 3 
+523          valid = schematron(tree_invalid) 
+524          self.assertTrue(not valid) 
+525          self.assertEqual( 
+526              len(schematron.error_log), expected, 
+527              'expected %s errors: %s (%s errors)' % 
+528              (expected, schematron.error_log, len(schematron.error_log))) 
+
529   
+530 -    def test_schematron_phases_kwarg(self): 
+
531          schema = self.parse('''\ 
+532  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+533    <sch:title>iso schematron validation</sch:title> 
+534    <sch:ns uri="http://www.w3.org/2001/XMLSchema-instance" prefix="xsi"/> 
+535    <sch:ns uri="http://codespeak.net/lxml/objectify/pytype" prefix="py"/> 
+536   
+537    <sch:phase id="mandatory"> 
+538      <sch:active pattern="number_of_entries"/> 
+539    </sch:phase> 
+540   
+541    <sch:phase id="datetime_checks"> 
+542      <sch:active pattern="datetime"/> 
+543      <sch:active pattern="nillableDatetime"/> 
+544    </sch:phase> 
+545   
+546    <sch:phase id="full"> 
+547      <sch:active pattern="number_of_entries"/> 
+548      <sch:active pattern="datetime"/> 
+549      <sch:active pattern="nillableDatetime"/> 
+550    </sch:phase> 
+551   
+552    <!-- of course, these only really make sense when combined with a schema that 
+553         ensures datatype xs:dateTime --> 
+554   
+555    <sch:pattern abstract="true" id="abstract.dateTime.tz_utc"> 
+556      <sch:rule context="$datetime"> 
+557        <sch:let name="tz" value="concat(substring-after(substring-after(./text(), 'T'), '+'), substring-after(substring-after(./text(), 'T'), '-'))"/> 
+558        <sch:let name="lastchar" value="substring(./text(), string-length(./text()))"/> 
+559        <sch:assert test="$lastchar='Z' or $tz='00:00'">[ERROR] element (<sch:value-of select="name(.)"/>) dateTime value (<sch:value-of select="."/>) is not qualified as UTC (tz: <sch:value-of select="$tz"/>)</sch:assert> 
+560      </sch:rule> 
+561    </sch:pattern> 
+562   
+563    <sch:pattern abstract="true" id="abstract.dateTime.tz_utc_nillable"> 
+564      <sch:rule context="$datetime"> 
+565        <sch:let name="tz" value="concat(substring-after(substring-after(./text(), 'T'), '+'), substring-after(substring-after(./text(), 'T'), '-'))"/> 
+566        <sch:let name="lastchar" value="substring(./text(), string-length(./text()))"/> 
+567        <sch:assert test="@xsi:nil='true'  or ($lastchar='Z' or $tz='00:00')">[ERROR] element (<sch:value-of select="name(.)"/>) dateTime value (<sch:value-of select="."/>) is not qualified as UTC (tz: <sch:value-of select="$tz"/>)</sch:assert> 
+568      </sch:rule> 
+569    </sch:pattern> 
+570   
+571    <sch:pattern id="number_of_entries"> 
+572      <sch:title>mandatory number_of_entries test</sch:title> 
+573      <sch:rule context="number_of_entries"> 
+574        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+575      </sch:rule> 
+576    </sch:pattern> 
+577   
+578    <sch:pattern  id="datetime" is-a="abstract.dateTime.tz_utc"> 
+579      <sch:param name="datetime" value="datetime"/> 
+580    </sch:pattern> 
+581   
+582    <sch:pattern  id="nillableDatetime" is-a="abstract.dateTime.tz_utc_nillable"> 
+583      <sch:param name="datetime" value="nillableDatetime"/> 
+584    </sch:pattern> 
+585   
+586  </sch:schema> 
+587  ''') 
+588          tree_valid = self.parse('''\ 
+589  <message xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+590    <datetime>2009-12-10T15:21:00Z</datetime> 
+591    <nillableDatetime xsi:nil="true"/> 
+592    <number_of_entries>0</number_of_entries> 
+593    <entries> 
+594    </entries> 
+595  </message> 
+596  ''') 
+597          tree_invalid = self.parse('''\ 
+598  <message> 
+599    <datetime>2009-12-10T16:21:00+01:00</datetime> 
+600    <nillableDatetime>2009-12-10T16:21:00+01:00</nillableDatetime> 
+601    <number_of_entries>3</number_of_entries> 
+602    <entries> 
+603      <entry>Entry 1</entry> 
+604      <entry>Entry 2</entry> 
+605    </entries> 
+606  </message> 
+607  ''') 
+608          # check everything (default phase #ALL) 
+609          schematron = isoschematron.Schematron(schema) 
+610          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+611          expected = 3 
+612          valid = schematron(tree_invalid) 
+613          self.assertTrue(not valid) 
+614          self.assertEqual( 
+615              len(schematron.error_log), expected, 
+616              'expected %s errors: %s (%s errors)' % 
+617              (expected, schematron.error_log, len(schematron.error_log))) 
+618   
+619          # check phase mandatory 
+620          schematron = isoschematron.Schematron(schema, phase='mandatory') 
+621          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+622          expected = 1 
+623          valid = schematron(tree_invalid) 
+624          self.assertTrue(not valid) 
+625          self.assertEqual( 
+626              len(schematron.error_log), expected, 
+627              'expected %s errors: %s (%s errors)' % 
+628              (expected, schematron.error_log, len(schematron.error_log))) 
+629   
+630          # check phase datetime_checks 
+631          schematron = isoschematron.Schematron(schema, phase='datetime_checks') 
+632          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+633          expected = 2 
+634          valid = schematron(tree_invalid) 
+635          self.assertTrue(not valid) 
+636          self.assertEqual( 
+637              len(schematron.error_log), expected, 
+638              'expected %s errors: %s (%s errors)' % 
+639              (expected, schematron.error_log, len(schematron.error_log))) 
+640   
+641          # check phase full 
+642          schematron = isoschematron.Schematron(schema, phase='full') 
+643          self.assertTrue(schematron(tree_valid), schematron.error_log) 
+644          expected = 3 
+645          valid = schematron(tree_invalid) 
+646          self.assertTrue(not valid) 
+647          self.assertEqual( 
+648              len(schematron.error_log), expected, 'expected %s errors: %s (%s errors)' % 
+649              (expected, schematron.error_log, len(schematron.error_log))) 
+
650   
+651 -    def test_schematron_xmlschema_embedded(self): 
+
652          schema = self.parse('''\ 
+653  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+654      xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+655      <xs:element name="message"> 
+656          <xs:complexType> 
+657              <xs:sequence> 
+658                  <xs:element name="number_of_entries" type="xs:positiveInteger"> 
+659                      <xs:annotation> 
+660                          <xs:appinfo> 
+661                              <sch:pattern id="number_of_entries"> 
+662                                  <sch:title>mandatory number_of_entries tests</sch:title> 
+663                                  <sch:rule context="number_of_entries"> 
+664                                      <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+665                                  </sch:rule> 
+666                              </sch:pattern> 
+667                          </xs:appinfo> 
+668                      </xs:annotation> 
+669                  </xs:element> 
+670                  <xs:element name="entries"> 
+671                      <xs:complexType> 
+672                          <xs:sequence> 
+673                              <xs:element name="entry" type="xs:string" minOccurs="0" maxOccurs="unbounded"/> 
+674                          </xs:sequence> 
+675                      </xs:complexType> 
+676                  </xs:element> 
+677              </xs:sequence> 
+678          </xs:complexType> 
+679      </xs:element> 
+680  </xs:schema> 
+681  ''') 
+682          tree_valid = self.parse('''\ 
+683  <message> 
+684    <number_of_entries>2</number_of_entries> 
+685    <entries> 
+686      <entry>Entry 1</entry> 
+687      <entry>Entry 2</entry> 
+688    </entries> 
+689  </message> 
+690  ''') 
+691          tree_invalid = self.parse('''\ 
+692  <message> 
+693    <number_of_entries>1</number_of_entries> 
+694    <entries> 
+695      <entry>Entry 1</entry> 
+696      <entry>Entry 2</entry> 
+697    </entries> 
+698  </message> 
+699  ''') 
+700          xmlschema = etree.XMLSchema(schema) 
+701          schematron = isoschematron.Schematron(schema) 
+702          # fwiw, this must also be XMLSchema-valid 
+703          self.assertTrue(xmlschema(tree_valid), xmlschema.error_log) 
+704          self.assertTrue(schematron(tree_valid)) 
+705          # still schema-valid 
+706          self.assertTrue(xmlschema(tree_invalid), xmlschema.error_log) 
+707          self.assertTrue(not schematron(tree_invalid)) 
+
708   
+709 -    def test_schematron_relaxng_embedded(self): 
+
710          schema = self.parse('''\ 
+711  <grammar xmlns="http://relaxng.org/ns/structure/1.0" 
+712    xmlns:sch="http://purl.oclc.org/dsdl/schematron" 
+713    datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"> 
+714    <start> 
+715      <ref name="message"/> 
+716    </start> 
+717    <define name="message"> 
+718      <element name="message"> 
+719        <element name="number_of_entries"> 
+720          <!-- RelaxNG can be mixed freely with stuff from other namespaces --> 
+721          <sch:pattern id="number_of_entries"> 
+722            <sch:title>mandatory number_of_entries tests</sch:title> 
+723            <sch:rule context="number_of_entries"> 
+724              <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+725            </sch:rule> 
+726          </sch:pattern> 
+727          <data type="positiveInteger"/> 
+728        </element> 
+729        <element name="entries"> 
+730          <zeroOrMore> 
+731            <element name="entry"><data type="string"/></element> 
+732          </zeroOrMore> 
+733        </element> 
+734      </element> 
+735    </define> 
+736  </grammar> 
+737  ''') 
+738          tree_valid = self.parse('''\ 
+739  <message> 
+740    <number_of_entries>2</number_of_entries> 
+741    <entries> 
+742      <entry>Entry 1</entry> 
+743      <entry>Entry 2</entry> 
+744    </entries> 
+745  </message> 
+746  ''') 
+747          tree_invalid = self.parse('''\ 
+748  <message> 
+749    <number_of_entries>1</number_of_entries> 
+750    <entries> 
+751      <entry>Entry 1</entry> 
+752      <entry>Entry 2</entry> 
+753    </entries> 
+754  </message> 
+755  ''') 
+756          relaxng = etree.RelaxNG(schema) 
+757          schematron = isoschematron.Schematron(schema) 
+758          # fwiw, this must also be RelaxNG-valid 
+759          self.assertTrue(relaxng(tree_valid), relaxng.error_log) 
+760          self.assertTrue(schematron(tree_valid)) 
+761          # still schema-valid 
+762          self.assertTrue(relaxng(tree_invalid), relaxng.error_log) 
+763          self.assertTrue(not schematron(tree_invalid)) 
+
764   
+765 -    def test_schematron_invalid_args(self): 
+
766          schema = self.parse('''\ 
+767  <sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron"> 
+768    <sch:pattern id="number_of_entries"> 
+769      <sch:title>mandatory number_of_entries tests</sch:title> 
+770      <sch:rule context="number_of_entries"> 
+771        <sch:assert test="text()=count(../entries/entry)">[ERROR] number_of_entries (<sch:value-of select="."/>) must equal the number of entries/entry elements (<sch:value-of select="count(../entries/entry)"/>)</sch:assert> 
+772      </sch:rule> 
+773    </sch:pattern> 
+774  </sch:schema> 
+775  ''') 
+776          # handing phase as keyword arg will *not* raise the type error 
+777          self.assertRaises(TypeError, isoschematron.Schematron, schema, 
+778                            compile_params={'phase': None}) 
+
779   
+780 -    def test_schematron_customization(self): 
+
781          class MySchematron(isoschematron.Schematron): 
+782              def _extract(self, root): 
+783                  schematron = (root.xpath( 
+784                      '//sch:schema', 
+785                      namespaces={'sch': "http://purl.oclc.org/dsdl/schematron"}) 
+786                      or [None])[0] 
+787                  return schematron 
+
788   
+789              def _include(self, schematron, **kwargs): 
+790                  raise RuntimeError('inclusion unsupported') 
+
791   
+792              def _expand(self, schematron, **kwargs): 
+793                  raise RuntimeError('expansion unsupported') 
+794   
+795              def _validation_errors(self, validationReport): 
+796                  valid = etree.XPath( 
+797                      'count(//svrl:successful-report[@flag="critical"])=1', 
+798                      namespaces={'svrl': isoschematron.SVRL_NS})( 
+799                      validationReport) 
+800                  if valid: 
+801                      return [] 
+802                  error = etree.Element('Error') 
+803                  error.text = 'missing critical condition report' 
+804                  return [error] 
+805   
+806          tree_valid = self.parse('<AAA><BBB/><CCC/></AAA>') 
+807          tree_invalid = self.parse('<AAA><BBB/><CCC/><DDD/></AAA>') 
+808          schema = self.parse('''\ 
+809  <schema xmlns="http://www.example.org/yet/another/schema/dialect"> 
+810    <schema xmlns="http://purl.oclc.org/dsdl/schematron" > 
+811      <pattern id="OpenModel"> 
+812        <title>Open Model</title> 
+813        <rule context="AAA"> 
+814          <report test="BBB" flag="info">BBB element must be present</report> 
+815          <report test="CCC" flag="info">CCC element must be present</report> 
+816        </rule> 
+817      </pattern> 
+818      <pattern id="ClosedModel"> 
+819        <title>Closed model"</title> 
+820        <rule context="AAA"> 
+821          <report test="BBB" flag="info">BBB element must be present</report> 
+822          <report test="CCC" flag="info">CCC element must be present</report> 
+823          <report test="count(BBB|CCC) = count(*)" flag="critical">Only BBB and CCC children must be present</report> 
+824        </rule> 
+825      </pattern> 
+826    </schema> 
+827  </schema> 
+828  ''') 
+829          # check if overridden _include is run 
+830          self.assertRaises(RuntimeError, MySchematron, schema, store_report=True) 
+831          # check if overridden _expand is run 
+832          self.assertRaises(RuntimeError, MySchematron, schema, store_report=True, 
+833                            include=False) 
+834   
+835          schema = MySchematron(schema, store_report=True, include=False, 
+836                                expand=False) 
+837          self.assertTrue(schema.validate(tree_valid)) 
+838          self.assertTrue(not schema.validate(tree_invalid)) 
+839   
+840      #TODO: test xslt parameters for inclusion, expand & compile steps (?) 
+841   
+842 -    def test_schematron_fail_on_report(self): 
+
843          tree_valid = self.parse('<AAA><BBB/><CCC/></AAA>') 
+844          tree_invalid = self.parse('<AAA><BBB/><CCC/><DDD/></AAA>') 
+845          schema = self.parse('''\ 
+846  <schema xmlns="http://purl.oclc.org/dsdl/schematron" > 
+847      <pattern id="OpenModel"> 
+848          <title>Simple Report</title> 
+849          <rule context="AAA"> 
+850              <report test="DDD"> DDD element must not be present</report> 
+851          </rule> 
+852      </pattern> 
+853  </schema> 
+854  ''') 
+855          schema_report = isoschematron.Schematron( 
+856              schema, error_finder=isoschematron.Schematron.ASSERTS_AND_REPORTS) 
+857          schema_no_report = isoschematron.Schematron(schema) 
+858          self.assertTrue(schema_report.validate(tree_valid)) 
+859          self.assertTrue(not schema_report.validate(tree_invalid)) 
+860          self.assertTrue(schema_no_report.validate(tree_valid)) 
+861          self.assertTrue(schema_no_report.validate(tree_invalid)) 
+
862   
+863   
+864 -def test_suite(): 
+
865      suite = unittest.TestSuite() 
+866      suite.addTests([unittest.makeSuite(ETreeISOSchematronTestCase)]) 
+867      suite.addTests(doctest.DocTestSuite(isoschematron)) 
+868      suite.addTests( 
+869          [make_doctest('../../../doc/validation.txt')]) 
+870      return suite 
+
871   
+872  if __name__ == '__main__': 
+873      print('to test use test.py %s' % __file__) 
+874   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeISOSchematronTestCase
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Test cases related to namespace implementation classes and the 
+  5  namespace registry mechanism 
+  6  """ 
+  7   
+  8  import unittest, sys, os.path 
+  9   
+ 10  this_dir = os.path.dirname(__file__) 
+ 11  if this_dir not in sys.path: 
+ 12      sys.path.insert(0, this_dir) # needed for Py3 
+ 13   
+ 14  from common_imports import etree, HelperTestCase, _bytes 
+ 15  from common_imports import doctest, make_doctest 
+ 16   
+ 17 -class ETreeNamespaceClassesTestCase(HelperTestCase): 
+
 18       
+ 19 -    class default_class(etree.ElementBase): 
+
 20          pass 
+
 21 -    class maeh_class(etree.ElementBase): 
+
 22 -        def maeh(self): 
+
 23              return 'maeh' 
+
 24 -    class bluff_class(etree.ElementBase): 
+
 25 -        def bluff(self): 
+
 26              return 'bluff' 
+
 27   
+ 28 -    def setUp(self): 
+
 29          super(ETreeNamespaceClassesTestCase, self).setUp() 
+ 30          lookup = etree.ElementNamespaceClassLookup() 
+ 31          self.Namespace = lookup.get_namespace 
+ 32          parser = etree.XMLParser() 
+ 33          parser.set_element_class_lookup(lookup) 
+ 34          etree.set_default_parser(parser) 
+
 35   
+ 36 -    def tearDown(self): 
+
 37          etree.set_default_parser() 
+ 38          del self.Namespace 
+ 39          super(ETreeNamespaceClassesTestCase, self).tearDown() 
+
 40   
+ 41 -    def test_registry(self): 
+
 42          ns = self.Namespace('ns01') 
+ 43          ns['maeh'] = self.maeh_class 
+ 44   
+ 45          self.Namespace('ns01').clear() 
+ 46   
+ 47          self.Namespace('ns02').update({'maeh'  : self.maeh_class}) 
+ 48          self.Namespace('ns03').update({'bluff' : self.bluff_class}.items()) 
+ 49          self.Namespace('ns02').clear() 
+ 50          self.Namespace('ns03').clear() 
+
 51   
+ 52 -    def test_ns_classes(self): 
+
 53          bluff_dict = {'bluff' : self.bluff_class} 
+ 54          maeh_dict  = {'maeh'  : self.maeh_class} 
+ 55   
+ 56          self.Namespace('ns10').update(bluff_dict) 
+ 57   
+ 58          tree = self.parse(_bytes('<bluff xmlns="ns10"><ns11:maeh xmlns:ns11="ns11"/></bluff>')) 
+ 59   
+ 60          el = tree.getroot() 
+ 61          self.assertTrue(isinstance(el, etree.ElementBase)) 
+ 62          self.assertTrue(hasattr(el, 'bluff')) 
+ 63          self.assertFalse(hasattr(el[0], 'maeh')) 
+ 64          self.assertFalse(hasattr(el[0], 'bluff')) 
+ 65          self.assertEqual(el.bluff(), 'bluff') 
+ 66          del el 
+ 67   
+ 68          self.Namespace('ns11').update(maeh_dict) 
+ 69          el = tree.getroot() 
+ 70          self.assertTrue(hasattr(el, 'bluff')) 
+ 71          self.assertTrue(hasattr(el[0], 'maeh')) 
+ 72          self.assertEqual(el.bluff(), 'bluff') 
+ 73          self.assertEqual(el[0].maeh(), 'maeh') 
+ 74          del el 
+ 75   
+ 76          self.Namespace('ns10').clear() 
+ 77   
+ 78          tree = self.parse(_bytes('<bluff xmlns="ns10"><ns11:maeh xmlns:ns11="ns11"/></bluff>')) 
+ 79          el = tree.getroot() 
+ 80          self.assertFalse(hasattr(el, 'bluff')) 
+ 81          self.assertFalse(hasattr(el, 'maeh')) 
+ 82          self.assertFalse(hasattr(el[0], 'bluff')) 
+ 83          self.assertTrue(hasattr(el[0], 'maeh')) 
+ 84   
+ 85          self.Namespace('ns11').clear() 
+
 86   
+ 87 -    def test_default_tagname(self): 
+
 88          bluff_dict = { 
+ 89              None   : self.bluff_class, 
+ 90              'maeh' : self.maeh_class 
+ 91              } 
+ 92   
+ 93          ns = self.Namespace("uri:nsDefClass") 
+ 94          ns.update(bluff_dict) 
+ 95   
+ 96          tree = self.parse(_bytes(''' 
+ 97              <test xmlns="bla" xmlns:ns1="uri:nsDefClass" xmlns:ns2="uri:nsDefClass"> 
+ 98                <ns2:el1/><ns1:el2/><ns1:maeh/><ns2:maeh/><maeh/> 
+ 99              </test> 
+100              ''')) 
+101   
+102          el = tree.getroot() 
+103          self.assertFalse(isinstance(el, etree.ElementBase)) 
+104          for child in el[:-1]: 
+105              self.assertTrue(isinstance(child, etree.ElementBase), child.tag) 
+106          self.assertFalse(isinstance(el[-1], etree.ElementBase)) 
+107   
+108          self.assertTrue(hasattr(el[0], 'bluff')) 
+109          self.assertTrue(hasattr(el[1], 'bluff')) 
+110          self.assertTrue(hasattr(el[2], 'maeh')) 
+111          self.assertTrue(hasattr(el[3], 'maeh')) 
+112          self.assertFalse(hasattr(el[4], 'maeh')) 
+113          del el 
+114   
+115          ns.clear() 
+
116   
+117 -    def test_create_element(self): 
+
118          bluff_dict = {'bluff' : self.bluff_class} 
+119          self.Namespace('ns20').update(bluff_dict) 
+120   
+121          maeh_dict  = {'maeh'  : self.maeh_class} 
+122          self.Namespace('ns21').update(maeh_dict) 
+123   
+124          el = etree.Element("{ns20}bluff") 
+125          self.assertTrue(hasattr(el, 'bluff')) 
+126   
+127          child = etree.SubElement(el, "{ns21}maeh") 
+128          self.assertTrue(hasattr(child, 'maeh')) 
+129          child = etree.SubElement(el, "{ns20}bluff") 
+130          self.assertTrue(hasattr(child, 'bluff')) 
+131          child = etree.SubElement(el, "{ns21}bluff") 
+132          self.assertFalse(hasattr(child, 'bluff')) 
+133          self.assertFalse(hasattr(child, 'maeh')) 
+134   
+135          self.assertTrue(hasattr(el[0], 'maeh')) 
+136          self.assertTrue(hasattr(el[1], 'bluff')) 
+137          self.assertFalse(hasattr(el[2], 'bluff')) 
+138          self.assertFalse(hasattr(el[2], 'maeh')) 
+139   
+140          self.assertEqual(el.bluff(), 'bluff') 
+141          self.assertEqual(el[0].maeh(), 'maeh') 
+142          self.assertEqual(el[1].bluff(), 'bluff') 
+143   
+144          self.Namespace('ns20').clear() 
+145          self.Namespace('ns21').clear() 
+
146   
+147 -    def test_create_element_default(self): 
+
148          bluff_dict = {None : self.bluff_class} 
+149          self.Namespace('ns30').update(bluff_dict) 
+150   
+151          maeh_dict  = {'maeh'  : self.maeh_class} 
+152          self.Namespace(None).update(maeh_dict) 
+153   
+154          el = etree.Element("{ns30}bluff") 
+155          etree.SubElement(el, "maeh") 
+156          self.assertTrue(hasattr(el, 'bluff')) 
+157          self.assertTrue(hasattr(el[0], 'maeh')) 
+158          self.assertEqual(el.bluff(), 'bluff') 
+159          self.assertEqual(el[0].maeh(), 'maeh') 
+160   
+161          self.Namespace(None).clear() 
+162          self.Namespace('ns30').clear() 
+
163   
+164 -    def test_element_creation(self): 
+
165          default, bluff, maeh = ( 
+166              self.default_class, self.bluff_class, self.maeh_class) 
+167   
+168          class honk(etree.ElementBase): 
+169              TAG = 'HONK' 
+170              NAMESPACE = 'http://a.b/c' 
+
171   
+172          el = default( 
+173              "test", 
+174              "text", 
+175              bluff(honk, "TaIL", maeh), 
+176              maeh("TeXT", bluff, honk(), "TAiL"), 
+177              "Tail") 
+178   
+179          self.assertEqual('default_class', el.tag) 
+180          self.assertEqual('testtext', el.text) 
+181          self.assertEqual(None, el.tail) 
+182          self.assertEqual(2, len(el)) 
+183          self.assertEqual(7, len(list(el.iter()))) 
+184   
+185          self.assertEqual('bluff_class', el[0].tag) 
+186          self.assertEqual('TaIL', el[0][0].tail) 
+187          self.assertEqual('TaIL', ''.join(el[0].itertext())) 
+188          self.assertEqual('{http://a.b/c}HONK', 
+189                            el[0][0].tag) 
+190          self.assertEqual('maeh_class', 
+191                            el[0][1].tag) 
+192   
+193          self.assertEqual('maeh_class', el[1].tag) 
+194          self.assertEqual('TeXT', el[1].text) 
+195          self.assertEqual('bluff_class', el[1][0].tag) 
+196          self.assertEqual('{http://a.b/c}HONK', el[1][1].tag) 
+197          self.assertEqual('TAiL', el[1][1].tail) 
+198   
+199          self.assertEqual('TeXTTAiL', 
+200                            ''.join(el[1].itertext())) 
+201          self.assertEqual('Tail', el[1].tail) 
+202          self.assertEqual('TAiL', el[1][1].tail) 
+203          self.assertEqual('bluff_class', el[1][0].tag) 
+204          self.assertEqual('{http://a.b/c}HONK', el[1][1].tag) 
+
205           
+206   
+207 -def test_suite(): 
+
208      suite = unittest.TestSuite() 
+209      suite.addTests([unittest.makeSuite(ETreeNamespaceClassesTestCase)]) 
+210      suite.addTests( 
+211          [make_doctest('../../../doc/element_classes.txt')]) 
+212      return suite 
+
213   
+214  if __name__ == '__main__': 
+215      print('to test use test.py %s' % __file__) 
+216   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeNamespaceClassesTestCase
+
+    object --+        
+             |        
+etree._Element --+    
+                 |    
+ etree.ElementBase --+
+                     |
+                    ETreeNamespaceClassesTestCase.bluff_class
+
+    object --+        
+             |        
+etree._Element --+    
+                 |    
+ etree.ElementBase --+
+                     |
+                    ETreeNamespaceClassesTestCase.default_class
+
+    object --+        
+             |        
+etree._Element --+    
+                 |    
+ etree.ElementBase --+
+                     |
+                    ETreeNamespaceClassesTestCase.maeh_class
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+'http://www.w3.org/2001/XMLSchema-instance'
+
+'{http://www.w3.org/2001/XMLSchema-instance}type'
+
+'{http://www.w3.org/2001/XMLSchema-instance}nil'
+
+{'py': 'http://codespeak.net/lxml/objectify/pytype',
+ 'xsd': 'http://www.w3.org/2001/XMLSchema',
+ 'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
+
+{<type 'lxml.objectify.IntElement'>: ('int',
+                                      'short',
+                                      'byte',
+                                      'unsignedShort',
+                                      'unsignedByte',
+                                      'integer',
+                                      'nonPositiveInteger',
+                                      'negativeInteger',
+...
+
+{'ENTITY': <type 'lxml.objectify.StringElement'>,
+ 'ID': <type 'lxml.objectify.StringElement'>,
+ 'IDREF': <type 'lxml.objectify.StringElement'>,
+ 'NCName': <type 'lxml.objectify.StringElement'>,
+ 'NMTOKEN': <type 'lxml.objectify.StringElement'>,
+ 'Name': <type 'lxml.objectify.StringElement'>,
+ 'boolean': <type 'lxml.objectify.BoolElement'>,
+ 'byte': <type 'lxml.objectify.IntElement'>,
+...
+
+{<type 'lxml.objectify.IntElement'>: 'int',
+ <type 'lxml.objectify.FloatElement'>: 'float',
+ <type 'lxml.objectify.StringElement'>: 'str',
+ <type 'lxml.objectify.BoolElement'>: 'bool'}
+
+{'bool': <type 'lxml.objectify.BoolElement'>,
+ 'float': <type 'lxml.objectify.FloatElement'>,
+ 'int': <type 'lxml.objectify.IntElement'>,
+ 'str': <type 'lxml.objectify.StringElement'>}
+
+'''<obj:root xmlns:obj="objectified" xmlns:other="otherNS">
+  <obj:c1 a1="A1" a2="A2" other:a3="A3">
+    <obj:c2>0</obj:c2>
+    <obj:c2>1</obj:c2>
+    <obj:c2>2</obj:c2>
+    <other:c2>3</other:c2>
+    <c2>4</c2>
+  </obj:c1>
+...
+
+   1  # -*- coding: utf-8 -*- 
+   2   
+   3  """ 
+   4  Tests specific to the lxml.objectify API 
+   5  """ 
+   6   
+   7   
+   8  import unittest, operator, sys, os.path 
+   9   
+  10  this_dir = os.path.dirname(__file__) 
+  11  if this_dir not in sys.path: 
+  12      sys.path.insert(0, this_dir) # needed for Py3 
+  13   
+  14  from common_imports import etree, HelperTestCase, fileInTestDir 
+  15  from common_imports import SillyFileLike, canonicalize, doctest, make_doctest 
+  16  from common_imports import _bytes, _str, StringIO, BytesIO 
+  17   
+  18  from lxml import objectify 
+  19   
+  20  PYTYPE_NAMESPACE = "http://codespeak.net/lxml/objectify/pytype" 
+  21  XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema" 
+  22  XML_SCHEMA_INSTANCE_NS = "http://www.w3.org/2001/XMLSchema-instance" 
+  23  XML_SCHEMA_INSTANCE_TYPE_ATTR = "{%s}type" % XML_SCHEMA_INSTANCE_NS 
+  24  XML_SCHEMA_NIL_ATTR = "{%s}nil" % XML_SCHEMA_INSTANCE_NS 
+  25  TREE_PYTYPE = "TREE" 
+  26  DEFAULT_NSMAP = { "py"  : PYTYPE_NAMESPACE, 
+  27                    "xsi" : XML_SCHEMA_INSTANCE_NS, 
+  28                    "xsd" : XML_SCHEMA_NS} 
+  29   
+  30  objectclass2xsitype = { 
+  31      # objectify built-in 
+  32      objectify.IntElement: ("int", "short", "byte", "unsignedShort", 
+  33                             "unsignedByte", "integer", "nonPositiveInteger", 
+  34                             "negativeInteger", "long", "nonNegativeInteger", 
+  35                             "unsignedLong", "unsignedInt", "positiveInteger",), 
+  36      objectify.FloatElement: ("float", "double"), 
+  37      objectify.BoolElement: ("boolean",), 
+  38      objectify.StringElement: ("string", "normalizedString", "token", "language", 
+  39                                "Name", "NCName", "ID", "IDREF", "ENTITY", 
+  40                                "NMTOKEN", ), 
+  41      # None: xsi:nil="true" 
+  42      } 
+  43   
+  44  xsitype2objclass = dict([ (v, k) for k in objectclass2xsitype 
+  45                            for v in objectclass2xsitype[k] ]) 
+  46   
+  47  objectclass2pytype = { 
+  48      # objectify built-in 
+  49      objectify.IntElement: "int", 
+  50      objectify.FloatElement: "float", 
+  51      objectify.BoolElement: "bool", 
+  52      objectify.StringElement: "str", 
+  53      # None: xsi:nil="true" 
+  54      } 
+  55   
+  56  pytype2objclass = dict([ (objectclass2pytype[k], k) 
+  57                           for k in objectclass2pytype]) 
+  58   
+  59  xml_str = '''\ 
+  60  <obj:root xmlns:obj="objectified" xmlns:other="otherNS"> 
+  61    <obj:c1 a1="A1" a2="A2" other:a3="A3"> 
+  62      <obj:c2>0</obj:c2> 
+  63      <obj:c2>1</obj:c2> 
+  64      <obj:c2>2</obj:c2> 
+  65      <other:c2>3</other:c2> 
+  66      <c2>4</c2> 
+  67    </obj:c1> 
+  68  </obj:root>''' 
+  69   
+  70 -class ObjectifyTestCase(HelperTestCase): 
+
  71      """Test cases for lxml.objectify 
+  72      """ 
+  73      etree = etree 
+  74       
+  75 -    def XML(self, xml): 
+
  76          return self.etree.XML(xml, self.parser) 
+
  77   
+  78 -    def setUp(self): 
+
  79          super(ObjectifyTestCase, self).setUp() 
+  80          self.parser = self.etree.XMLParser(remove_blank_text=True) 
+  81          self.lookup = etree.ElementNamespaceClassLookup( 
+  82              objectify.ObjectifyElementClassLookup() ) 
+  83          self.parser.set_element_class_lookup(self.lookup) 
+  84   
+  85          self.Element = self.parser.makeelement 
+  86   
+  87          ns = self.lookup.get_namespace("otherNS") 
+  88          ns[None] = self.etree.ElementBase 
+  89   
+  90          self._orig_types = objectify.getRegisteredTypes() 
+
  91   
+  92 -    def tearDown(self): 
+
  93          self.lookup.get_namespace("otherNS").clear() 
+  94          objectify.set_pytype_attribute_tag() 
+  95          del self.lookup 
+  96          del self.parser 
+  97   
+  98          for pytype in objectify.getRegisteredTypes(): 
+  99              pytype.unregister() 
+ 100          for pytype in self._orig_types: 
+ 101              pytype.register() 
+ 102          del self._orig_types 
+ 103   
+ 104          super(ObjectifyTestCase, self).tearDown() 
+
 105   
+ 106   
+ 107 -    def test_element_nsmap_default(self): 
+
 108          elt = objectify.Element("test") 
+ 109          self.assertEqual(elt.nsmap, DEFAULT_NSMAP) 
+
 110   
+ 111 -    def test_element_nsmap_empty(self): 
+
 112          nsmap = {} 
+ 113          elt = objectify.Element("test", nsmap=nsmap) 
+ 114          self.assertEqual(list(elt.nsmap.values()), [PYTYPE_NAMESPACE]) 
+
 115   
+ 116 -    def test_element_nsmap_custom_prefixes(self): 
+
 117          nsmap = {"mypy": PYTYPE_NAMESPACE, 
+ 118                   "myxsi": XML_SCHEMA_INSTANCE_NS, 
+ 119                   "myxsd": XML_SCHEMA_NS} 
+ 120          elt = objectify.Element("test", nsmap=nsmap) 
+ 121          self.assertEqual(elt.nsmap, nsmap) 
+
 122           
+ 123 -    def test_element_nsmap_custom(self): 
+
 124          nsmap = {"my": "someNS", 
+ 125                   "myother": "someOtherNS", 
+ 126                   "myxsd": XML_SCHEMA_NS} 
+ 127          elt = objectify.Element("test", nsmap=nsmap) 
+ 128          self.assertTrue(PYTYPE_NAMESPACE in elt.nsmap.values()) 
+ 129          for prefix, ns in nsmap.items(): 
+ 130              self.assertTrue(prefix in elt.nsmap) 
+ 131              self.assertEqual(nsmap[prefix], elt.nsmap[prefix])  
+
 132           
+ 133 -    def test_sub_element_nsmap_default(self): 
+
 134          root = objectify.Element("root") 
+ 135          root.sub = objectify.Element("test") 
+ 136          self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP) 
+
 137   
+ 138 -    def test_sub_element_nsmap_empty(self): 
+
 139          root = objectify.Element("root") 
+ 140          nsmap = {} 
+ 141          root.sub = objectify.Element("test", nsmap=nsmap) 
+ 142          self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP) 
+
 143   
+ 144 -    def test_sub_element_nsmap_custom_prefixes(self): 
+
 145          root = objectify.Element("root") 
+ 146          nsmap = {"mypy": PYTYPE_NAMESPACE, 
+ 147                   "myxsi": XML_SCHEMA_INSTANCE_NS, 
+ 148                   "myxsd": XML_SCHEMA_NS} 
+ 149          root.sub = objectify.Element("test", nsmap=nsmap) 
+ 150          self.assertEqual(root.sub.nsmap, DEFAULT_NSMAP) 
+
 151           
+ 152 -    def test_sub_element_nsmap_custom(self): 
+
 153          root = objectify.Element("root") 
+ 154          nsmap = {"my": "someNS", 
+ 155                   "myother": "someOtherNS", 
+ 156                   "myxsd": XML_SCHEMA_NS,} 
+ 157          root.sub = objectify.Element("test", nsmap=nsmap) 
+ 158          expected = nsmap.copy() 
+ 159          del expected["myxsd"] 
+ 160          expected.update(DEFAULT_NSMAP) 
+ 161          self.assertEqual(root.sub.nsmap, expected)  
+
 162           
+ 163 -    def test_data_element_nsmap_default(self): 
+
 164          value = objectify.DataElement("test this") 
+ 165          self.assertEqual(value.nsmap, DEFAULT_NSMAP) 
+
 166   
+ 167 -    def test_data_element_nsmap_empty(self): 
+
 168          nsmap = {} 
+ 169          value = objectify.DataElement("test this", nsmap=nsmap) 
+ 170          self.assertEqual(list(value.nsmap.values()), [PYTYPE_NAMESPACE]) 
+
 171   
+ 172 -    def test_data_element_nsmap_custom_prefixes(self): 
+
 173          nsmap = {"mypy": PYTYPE_NAMESPACE, 
+ 174                   "myxsi": XML_SCHEMA_INSTANCE_NS, 
+ 175                   "myxsd": XML_SCHEMA_NS} 
+ 176          value = objectify.DataElement("test this", nsmap=nsmap) 
+ 177          self.assertEqual(value.nsmap, nsmap) 
+
 178           
+ 179 -    def test_data_element_nsmap_custom(self): 
+
 180          nsmap = {"my": "someNS", 
+ 181                   "myother": "someOtherNS", 
+ 182                   "myxsd": XML_SCHEMA_NS,} 
+ 183          value = objectify.DataElement("test", nsmap=nsmap) 
+ 184          self.assertTrue(PYTYPE_NAMESPACE in value.nsmap.values()) 
+ 185          for prefix, ns in nsmap.items(): 
+ 186              self.assertTrue(prefix in value.nsmap) 
+ 187              self.assertEqual(nsmap[prefix], value.nsmap[prefix])  
+
 188           
+ 189 -    def test_sub_data_element_nsmap_default(self): 
+
 190          root = objectify.Element("root") 
+ 191          root.value = objectify.DataElement("test this") 
+ 192          self.assertEqual(root.value.nsmap, DEFAULT_NSMAP) 
+
 193   
+ 194 -    def test_sub_data_element_nsmap_empty(self): 
+
 195          root = objectify.Element("root") 
+ 196          nsmap = {} 
+ 197          root.value = objectify.DataElement("test this", nsmap=nsmap) 
+ 198          self.assertEqual(root.value.nsmap, DEFAULT_NSMAP) 
+
 199   
+ 200 -    def test_sub_data_element_nsmap_custom_prefixes(self): 
+
 201          root = objectify.Element("root") 
+ 202          nsmap = {"mypy": PYTYPE_NAMESPACE, 
+ 203                   "myxsi": XML_SCHEMA_INSTANCE_NS, 
+ 204                   "myxsd": XML_SCHEMA_NS} 
+ 205          root.value = objectify.DataElement("test this", nsmap=nsmap) 
+ 206          self.assertEqual(root.value.nsmap, DEFAULT_NSMAP) 
+
 207           
+ 208 -    def test_sub_data_element_nsmap_custom(self): 
+
 209          root = objectify.Element("root") 
+ 210          nsmap = {"my": "someNS", 
+ 211                   "myother": "someOtherNS", 
+ 212                   "myxsd": XML_SCHEMA_NS} 
+ 213          root.value = objectify.DataElement("test", nsmap=nsmap) 
+ 214          expected = nsmap.copy() 
+ 215          del expected["myxsd"] 
+ 216          expected.update(DEFAULT_NSMAP) 
+ 217          self.assertEqual(root.value.nsmap, expected) 
+
 218   
+ 219 -    def test_date_element_efactory_text(self): 
+
 220          # ObjectifiedDataElement can also be used as E-Factory 
+ 221          value = objectify.ObjectifiedDataElement('test', 'toast') 
+ 222          self.assertEqual(value.text, 'testtoast') 
+
 223   
+ 224 -    def test_date_element_efactory_tail(self): 
+
 225          # ObjectifiedDataElement can also be used as E-Factory 
+ 226          value = objectify.ObjectifiedElement(objectify.ObjectifiedDataElement(), 'test', 'toast') 
+ 227          self.assertEqual(value.ObjectifiedDataElement.tail, 'testtoast') 
+
 228   
+ 229 -    def test_data_element_attrib_attributes_precedence(self): 
+
 230          # keyword arguments override attrib entries 
+ 231          value = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
+ 232                                        attrib={"gnu": "muh", "cat": "meeow", 
+ 233                                                "dog": "wuff"}, 
+ 234                                        bird="tchilp", dog="grrr") 
+ 235          self.assertEqual(value.get("gnu"), "muh") 
+ 236          self.assertEqual(value.get("cat"), "meeow") 
+ 237          self.assertEqual(value.get("dog"), "grrr") 
+ 238          self.assertEqual(value.get("bird"), "tchilp") 
+
 239           
+ 240 -    def test_data_element_data_element_arg(self): 
+
 241          # Check that DataElement preserves all attributes ObjectifiedDataElement 
+ 242          # arguments 
+ 243          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
+ 244                                      attrib={"gnu": "muh", "cat": "meeow", 
+ 245                                              "dog": "wuff"}, 
+ 246                                      bird="tchilp", dog="grrr") 
+ 247          value = objectify.DataElement(arg) 
+ 248          self.assertTrue(isinstance(value, objectify.StringElement)) 
+ 249          for attr in arg.attrib: 
+ 250              self.assertEqual(value.get(attr), arg.get(attr)) 
+
 251   
+ 252 -    def test_data_element_data_element_arg_pytype_none(self): 
+
 253          # Check that _pytype arg overrides original py:pytype of 
+ 254          # ObjectifiedDataElement 
+ 255          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
+ 256                                      attrib={"gnu": "muh", "cat": "meeow", 
+ 257                                              "dog": "wuff"}, 
+ 258                                      bird="tchilp", dog="grrr") 
+ 259          value = objectify.DataElement(arg, _pytype="NoneType") 
+ 260          self.assertTrue(isinstance(value, objectify.NoneElement)) 
+ 261          self.assertEqual(value.get(XML_SCHEMA_NIL_ATTR), "true") 
+ 262          self.assertEqual(value.text, None) 
+ 263          self.assertEqual(value.pyval, None) 
+ 264          for attr in arg.attrib: 
+ 265              #if not attr == objectify.PYTYPE_ATTRIBUTE: 
+ 266              self.assertEqual(value.get(attr), arg.get(attr)) 
+
 267   
+ 268 -    def test_data_element_data_element_arg_pytype(self): 
+
 269          # Check that _pytype arg overrides original py:pytype of 
+ 270          # ObjectifiedDataElement 
+ 271          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
+ 272                                      attrib={"gnu": "muh", "cat": "meeow", 
+ 273                                              "dog": "wuff"}, 
+ 274                                      bird="tchilp", dog="grrr") 
+ 275          value = objectify.DataElement(arg, _pytype="int") 
+ 276          self.assertTrue(isinstance(value, objectify.IntElement)) 
+ 277          self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 
+ 278          for attr in arg.attrib: 
+ 279              if not attr == objectify.PYTYPE_ATTRIBUTE: 
+ 280                  self.assertEqual(value.get(attr), arg.get(attr)) 
+
 281   
+ 282 -    def test_data_element_data_element_arg_xsitype(self): 
+
 283          # Check that _xsi arg overrides original xsi:type of given 
+ 284          # ObjectifiedDataElement 
+ 285          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
+ 286                                      attrib={"gnu": "muh", "cat": "meeow", 
+ 287                                              "dog": "wuff"}, 
+ 288                                      bird="tchilp", dog="grrr") 
+ 289          value = objectify.DataElement(arg, _xsi="xsd:int") 
+ 290          self.assertTrue(isinstance(value, objectify.IntElement)) 
+ 291          self.assertEqual(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 
+ 292          self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 
+ 293          for attr in arg.attrib: 
+ 294              if not attr in [objectify.PYTYPE_ATTRIBUTE, 
+ 295                              XML_SCHEMA_INSTANCE_TYPE_ATTR]: 
+ 296                  self.assertEqual(value.get(attr), arg.get(attr)) 
+
 297   
+ 298 -    def test_data_element_data_element_arg_pytype_xsitype(self): 
+
 299          # Check that _pytype and _xsi args override original py:pytype and 
+ 300          # xsi:type attributes of given ObjectifiedDataElement 
+ 301          arg = objectify.DataElement(23, _pytype="str", _xsi="foobar", 
+ 302                                      attrib={"gnu": "muh", "cat": "meeow", 
+ 303                                              "dog": "wuff"}, 
+ 304                                      bird="tchilp", dog="grrr") 
+ 305          value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int") 
+ 306          self.assertTrue(isinstance(value, objectify.IntElement)) 
+ 307          self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), "int") 
+ 308          self.assertEqual(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int") 
+ 309          for attr in arg.attrib: 
+ 310              if not attr in [objectify.PYTYPE_ATTRIBUTE, 
+ 311                              XML_SCHEMA_INSTANCE_TYPE_ATTR]: 
+ 312                  self.assertEqual(value.get(attr), arg.get(attr)) 
+
 313   
+ 314 -    def test_data_element_invalid_pytype(self): 
+
 315          self.assertRaises(ValueError, objectify.DataElement, 3.1415, 
+ 316                            _pytype="int") 
+
 317   
+ 318 -    def test_data_element_invalid_xsi(self): 
+
 319          self.assertRaises(ValueError, objectify.DataElement, 3.1415, 
+ 320                            _xsi="xsd:int") 
+
 321           
+ 322 -    def test_data_element_data_element_arg_invalid_pytype(self): 
+
 323          arg = objectify.DataElement(3.1415) 
+ 324          self.assertRaises(ValueError, objectify.DataElement, arg, 
+ 325                            _pytype="int") 
+
 326   
+ 327 -    def test_data_element_data_element_arg_invalid_xsi(self): 
+
 328          arg = objectify.DataElement(3.1415) 
+ 329          self.assertRaises(ValueError, objectify.DataElement, arg, 
+ 330                            _xsi="xsd:int") 
+
 331   
+ 332 -    def test_data_element_element_arg(self): 
+
 333          arg = objectify.Element('arg') 
+ 334          value = objectify.DataElement(arg) 
+ 335          self.assertTrue(isinstance(value, objectify.ObjectifiedElement)) 
+ 336          for attr in arg.attrib: 
+ 337              self.assertEqual(value.get(attr), arg.get(attr)) 
+
 338           
+ 339 -    def test_root(self): 
+
 340          root = self.Element("test") 
+ 341          self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 
+
 342   
+ 343 -    def test_str(self): 
+
 344          root = self.Element("test") 
+ 345          self.assertEqual('', str(root)) 
+
 346   
+ 347 -    def test_child(self): 
+
 348          root = self.XML(xml_str) 
+ 349          self.assertEqual("0", root.c1.c2.text) 
+
 350   
+ 351 -    def test_child_ns_nons(self): 
+
 352          root = self.XML(""" 
+ 353              <root> 
+ 354                  <foo:x xmlns:foo="/foo/bar">1</foo:x> 
+ 355                  <x>2</x> 
+ 356              </root> 
+ 357          """) 
+ 358          self.assertEqual(2, root.x) 
+
 359   
+ 360 -    def test_countchildren(self): 
+
 361          root = self.XML(xml_str) 
+ 362          self.assertEqual(1, root.countchildren()) 
+ 363          self.assertEqual(5, root.c1.countchildren()) 
+
 364   
+ 365 -    def test_child_getattr(self): 
+
 366          root = self.XML(xml_str) 
+ 367          self.assertEqual("0", getattr(root.c1, "{objectified}c2").text) 
+ 368          self.assertEqual("3", getattr(root.c1, "{otherNS}c2").text) 
+
 369   
+ 370 -    def test_child_nonexistant(self): 
+
 371          root = self.XML(xml_str) 
+ 372          self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE") 
+ 373          self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2") 
+
 374   
+ 375 -    def test_child_getattr_empty_ns(self): 
+
 376          root = self.XML(xml_str) 
+ 377          self.assertEqual("4", getattr(root.c1, "{}c2").text) 
+ 378          self.assertEqual("0", getattr(root.c1, "c2").text) 
+
 379   
+ 380 -    def test_setattr(self): 
+
 381          for val in [ 
+ 382              2, 2**32, 1.2, "Won't get fooled again",  
+ 383              _str("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1'), True, 
+ 384              False, None]:  
+ 385              root = self.Element('root') 
+ 386              attrname = 'val' 
+ 387              setattr(root, attrname, val) 
+ 388              result = getattr(root, attrname) 
+ 389              self.assertEqual(val, result) 
+ 390              self.assertEqual(type(val), type(result.pyval)) 
+
 391    
+ 392 -    def test_setattr_nonunicode(self): 
+
 393          root = self.Element('root') 
+ 394          attrname = 'val' 
+ 395          val = _bytes("W\xf6n't get f\xf6\xf6led \xe4g\xe4in", 'ISO-8859-1') 
+ 396          self.assertRaises(ValueError, setattr, root, attrname, val) 
+ 397          self.assertRaises(AttributeError, getattr, root, attrname)  
+
 398    
+ 399 -    def test_addattr(self): 
+
 400          root = self.XML(xml_str) 
+ 401          self.assertEqual(1, len(root.c1)) 
+ 402          root.addattr("c1", "test") 
+ 403          self.assertEqual(2, len(root.c1)) 
+ 404          self.assertEqual("test", root.c1[1].text) 
+
 405   
+ 406 -    def test_addattr_element(self): 
+
 407          root = self.XML(xml_str) 
+ 408          self.assertEqual(1, len(root.c1)) 
+ 409   
+ 410          new_el = self.Element("test", myattr="5") 
+ 411          root.addattr("c1", new_el) 
+ 412          self.assertEqual(2, len(root.c1)) 
+ 413          self.assertEqual(None, root.c1[0].get("myattr")) 
+ 414          self.assertEqual("5",  root.c1[1].get("myattr")) 
+
 415   
+ 416 -    def test_addattr_list(self): 
+
 417          root = self.XML(xml_str) 
+ 418          self.assertEqual(1, len(root.c1)) 
+ 419   
+ 420          new_el = self.Element("test") 
+ 421          self.etree.SubElement(new_el, "a", myattr="A") 
+ 422          self.etree.SubElement(new_el, "a", myattr="B") 
+ 423   
+ 424          root.addattr("c1", list(new_el.a)) 
+ 425          self.assertEqual(3, len(root.c1)) 
+ 426          self.assertEqual(None, root.c1[0].get("myattr")) 
+ 427          self.assertEqual("A",  root.c1[1].get("myattr")) 
+ 428          self.assertEqual("B",  root.c1[2].get("myattr")) 
+
 429   
+ 430 -    def test_child_addattr(self): 
+
 431          root = self.XML(xml_str) 
+ 432          self.assertEqual(3, len(root.c1.c2)) 
+ 433          root.c1.addattr("c2", 3) 
+ 434          self.assertEqual(4, len(root.c1.c2)) 
+ 435          self.assertEqual("3", root.c1.c2[3].text) 
+
 436   
+ 437 -    def test_child_index(self): 
+
 438          root = self.XML(xml_str) 
+ 439          self.assertEqual("0", root.c1.c2[0].text) 
+ 440          self.assertEqual("1", root.c1.c2[1].text) 
+ 441          self.assertEqual("2", root.c1.c2[2].text) 
+ 442          self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3) 
+ 443          self.assertEqual(root, root[0]) 
+ 444          self.assertRaises(IndexError, operator.getitem, root, 1) 
+ 445   
+ 446          c1 = root.c1 
+ 447          del root.c1  # unlink from parent 
+ 448          self.assertEqual(c1, c1[0]) 
+ 449          self.assertRaises(IndexError, operator.getitem, c1, 1) 
+
 450   
+ 451 -    def test_child_index_neg(self): 
+
 452          root = self.XML(xml_str) 
+ 453          self.assertEqual("0", root.c1.c2[0].text) 
+ 454          self.assertEqual("0", root.c1.c2[-3].text) 
+ 455          self.assertEqual("1", root.c1.c2[-2].text) 
+ 456          self.assertEqual("2", root.c1.c2[-1].text) 
+ 457          self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4) 
+ 458          self.assertEqual(root, root[-1]) 
+ 459          self.assertRaises(IndexError, operator.getitem, root, -2) 
+ 460   
+ 461          c1 = root.c1 
+ 462          del root.c1  # unlink from parent 
+ 463          self.assertEqual(c1, c1[-1]) 
+ 464          self.assertRaises(IndexError, operator.getitem, c1, -2) 
+
 465   
+ 466 -    def test_child_len(self): 
+
 467          root = self.XML(xml_str) 
+ 468          self.assertEqual(1, len(root)) 
+ 469          self.assertEqual(1, len(root.c1)) 
+ 470          self.assertEqual(3, len(root.c1.c2)) 
+
 471   
+ 472 -    def test_child_iter(self): 
+
 473          root = self.XML(xml_str) 
+ 474          self.assertEqual([root], 
+ 475                            list(iter(root))) 
+ 476          self.assertEqual([root.c1], 
+ 477                            list(iter(root.c1))) 
+ 478          self.assertEqual([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]], 
+ 479                           list(iter(root.c1.c2))) 
+
 480   
+ 481 -    def test_class_lookup(self): 
+
 482          root = self.XML(xml_str) 
+ 483          self.assertTrue(isinstance(root.c1.c2, objectify.ObjectifiedElement)) 
+ 484          self.assertFalse(isinstance(getattr(root.c1, "{otherNS}c2"), 
+ 485                                      objectify.ObjectifiedElement)) 
+
 486   
+ 487 -    def test_dir(self): 
+
 488          root = self.XML(xml_str) 
+ 489          dir_c1 = dir(objectify.ObjectifiedElement) + ['c1'] 
+ 490          dir_c1.sort() 
+ 491          dir_c2 = dir(objectify.ObjectifiedElement) + ['c2'] 
+ 492          dir_c2.sort() 
+ 493   
+ 494          self.assertEqual(dir_c1, dir(root)) 
+ 495          self.assertEqual(dir_c2, dir(root.c1)) 
+
 496   
+ 497 -    def test_vars(self): 
+
 498          root = self.XML(xml_str) 
+ 499          self.assertEqual({'c1' : root.c1},    vars(root)) 
+ 500          self.assertEqual({'c2' : root.c1.c2}, vars(root.c1)) 
+
 501   
+ 502 -    def test_child_set_ro(self): 
+
 503          root = self.XML(xml_str) 
+ 504          self.assertRaises(TypeError, setattr, root.c1.c2, 'text',  "test") 
+ 505          self.assertRaises(TypeError, setattr, root.c1.c2, 'pyval', "test") 
+
 506   
+ 507      # slicing 
+ 508   
+ 509 -    def test_getslice_complete(self): 
+
 510          root = self.XML("<root><c>c1</c><c>c2</c></root>") 
+ 511          self.assertEqual(["c1", "c2"], 
+ 512                            [ c.text for c in root.c[:] ]) 
+
 513   
+ 514 -    def test_getslice_partial(self): 
+
 515          root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 
+ 516          test_list = ["c1", "c2", "c3", "c4"] 
+ 517   
+ 518          self.assertEqual(test_list, 
+ 519                            [ c.text for c in root.c[:] ]) 
+ 520          self.assertEqual(test_list[1:2], 
+ 521                            [ c.text for c in root.c[1:2] ]) 
+ 522          self.assertEqual(test_list[-3:-1], 
+ 523                            [ c.text for c in root.c[-3:-1] ]) 
+ 524          self.assertEqual(test_list[-3:3], 
+ 525                            [ c.text for c in root.c[-3:3] ]) 
+ 526          self.assertEqual(test_list[-3000:3], 
+ 527                            [ c.text for c in root.c[-3000:3] ]) 
+ 528          self.assertEqual(test_list[-3:3000], 
+ 529                            [ c.text for c in root.c[-3:3000] ]) 
+
 530   
+ 531 -    def test_getslice_partial_neg(self): 
+
 532          root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>") 
+ 533          test_list = ["c1", "c2", "c3", "c4"] 
+ 534   
+ 535          self.assertEqual(test_list, 
+ 536                            [ c.text for c in root.c[:] ]) 
+ 537          self.assertEqual(test_list[2:1:-1], 
+ 538                            [ c.text for c in root.c[2:1:-1] ]) 
+ 539          self.assertEqual(test_list[-1:-3:-1], 
+ 540                            [ c.text for c in root.c[-1:-3:-1] ]) 
+ 541          self.assertEqual(test_list[2:-3:-1], 
+ 542                            [ c.text for c in root.c[2:-3:-1] ]) 
+ 543          self.assertEqual(test_list[2:-3000:-1], 
+ 544                            [ c.text for c in root.c[2:-3000:-1] ]) 
+
 545   
+ 546      # slice assignment 
+ 547   
+ 548 -    def test_setslice_complete(self): 
+
 549          Element = self.Element 
+ 550          root = Element("root") 
+ 551          root.c = ["c1", "c2"] 
+ 552   
+ 553          c1 = root.c[0] 
+ 554          c2 = root.c[1] 
+ 555   
+ 556          self.assertEqual([c1,c2], list(root.c)) 
+ 557          self.assertEqual(["c1", "c2"], 
+ 558                            [ c.text for c in root.c ]) 
+
 559   
+ 560 -    def test_setslice_elements(self): 
+
 561          Element = self.Element 
+ 562          root = Element("root") 
+ 563          root.c = ["c1", "c2"] 
+ 564   
+ 565          c1 = root.c[0] 
+ 566          c2 = root.c[1] 
+ 567   
+ 568          self.assertEqual([c1,c2], list(root.c)) 
+ 569          self.assertEqual(["c1", "c2"], 
+ 570                            [ c.text for c in root.c ]) 
+ 571   
+ 572          root2 = Element("root2") 
+ 573          root2.el = [ "test", "test" ] 
+ 574          self.assertEqual(["test", "test"], 
+ 575                            [ el.text for el in root2.el ]) 
+ 576   
+ 577          root.c = [ root2.el, root2.el ] 
+ 578          self.assertEqual(["test", "test"], 
+ 579                            [ c.text for c in root.c ]) 
+ 580          self.assertEqual(["test", "test"], 
+ 581                            [ el.text for el in root2.el ]) 
+ 582   
+ 583          root.c[:] = [ c1, c2, c2, c1 ] 
+ 584          self.assertEqual(["c1", "c2", "c2", "c1"], 
+ 585                            [ c.text for c in root.c ]) 
+
 586   
+ 587 -    def test_setslice_partial(self): 
+
 588          Element = self.Element 
+ 589          root = Element("root") 
+ 590          l = ["c1", "c2", "c3", "c4"] 
+ 591          root.c = l 
+ 592   
+ 593          self.assertEqual(["c1", "c2", "c3", "c4"], 
+ 594                            [ c.text for c in root.c ]) 
+ 595          self.assertEqual(l, 
+ 596                            [ c.text for c in root.c ]) 
+ 597   
+ 598          new_slice = ["cA", "cB"] 
+ 599          l[1:2] = new_slice 
+ 600          root.c[1:2] = new_slice 
+ 601   
+ 602          self.assertEqual(["c1", "cA", "cB", "c3", "c4"], l) 
+ 603          self.assertEqual(["c1", "cA", "cB", "c3", "c4"], 
+ 604                            [ c.text for c in root.c ]) 
+ 605          self.assertEqual(l, 
+ 606                            [ c.text for c in root.c ]) 
+
 607   
+ 608 -    def test_setslice_insert(self): 
+
 609          Element = self.Element 
+ 610          root = Element("root") 
+ 611          l = ["c1", "c2", "c3", "c4"] 
+ 612          root.c = l 
+ 613   
+ 614          self.assertEqual(["c1", "c2", "c3", "c4"], 
+ 615                            [ c.text for c in root.c ]) 
+ 616          self.assertEqual(l, 
+ 617                            [ c.text for c in root.c ]) 
+ 618   
+ 619          new_slice = ["cA", "cB"] 
+ 620          l[1:1] = new_slice 
+ 621          root.c[1:1] = new_slice 
+ 622   
+ 623          self.assertEqual(["c1", "cA", "cB", "c2", "c3", "c4"], l) 
+ 624          self.assertEqual(["c1", "cA", "cB", "c2", "c3", "c4"], 
+ 625                            [ c.text for c in root.c ]) 
+ 626          self.assertEqual(l, 
+ 627                            [ c.text for c in root.c ]) 
+
 628   
+ 629 -    def test_setslice_insert_neg(self): 
+
 630          Element = self.Element 
+ 631          root = Element("root") 
+ 632          l = ["c1", "c2", "c3", "c4"] 
+ 633          root.c = l 
+ 634   
+ 635          self.assertEqual(["c1", "c2", "c3", "c4"], 
+ 636                            [ c.text for c in root.c ]) 
+ 637          self.assertEqual(l, 
+ 638                            [ c.text for c in root.c ]) 
+ 639   
+ 640          new_slice = ["cA", "cB"] 
+ 641          l[-2:-2] = new_slice 
+ 642          root.c[-2:-2] = new_slice 
+ 643   
+ 644          self.assertEqual(["c1", "c2", "cA", "cB", "c3", "c4"], l) 
+ 645          self.assertEqual(["c1", "c2", "cA", "cB", "c3", "c4"], 
+ 646                            [ c.text for c in root.c ]) 
+ 647          self.assertEqual(l, 
+ 648                            [ c.text for c in root.c ]) 
+
 649   
+ 650 -    def test_setslice_empty(self): 
+
 651          Element = self.Element 
+ 652          root = Element("root") 
+ 653   
+ 654          root.c = [] 
+ 655          self.assertRaises( 
+ 656              AttributeError, getattr, root, 'c') 
+
 657   
+ 658 -    def test_setslice_partial_wrong_length(self): 
+
 659          Element = self.Element 
+ 660          root = Element("root") 
+ 661          l = ["c1", "c2", "c3", "c4"] 
+ 662          root.c = l 
+ 663   
+ 664          self.assertEqual(["c1", "c2", "c3", "c4"], 
+ 665                            [ c.text for c in root.c ]) 
+ 666          self.assertEqual(l, 
+ 667                            [ c.text for c in root.c ]) 
+ 668   
+ 669          new_slice = ["cA", "cB", "cC"] 
+ 670          self.assertRaises( 
+ 671              ValueError, operator.setitem, 
+ 672              l, slice(1,2,-1), new_slice) 
+ 673          self.assertRaises( 
+ 674              ValueError, operator.setitem, 
+ 675              root.c, slice(1,2,-1), new_slice) 
+
 676   
+ 677 -    def test_setslice_partial_neg(self): 
+
 678          Element = self.Element 
+ 679          root = Element("root") 
+ 680          l = ["c1", "c2", "c3", "c4"] 
+ 681          root.c = l 
+ 682   
+ 683          self.assertEqual(["c1", "c2", "c3", "c4"], 
+ 684                            [ c.text for c in root.c ]) 
+ 685          self.assertEqual(l, 
+ 686                            [ c.text for c in root.c ]) 
+ 687   
+ 688          new_slice = ["cA", "cB"] 
+ 689          l[-1:1:-1] = new_slice 
+ 690          root.c[-1:1:-1] = new_slice 
+ 691   
+ 692          self.assertEqual(["c1", "c2", "cB", "cA"], l) 
+ 693          self.assertEqual(["c1", "c2", "cB", "cA"], 
+ 694                            [ c.text for c in root.c ]) 
+ 695          self.assertEqual(l, 
+ 696                            [ c.text for c in root.c ]) 
+
 697   
+ 698 -    def test_setslice_partial_allneg(self): 
+
 699          Element = self.Element 
+ 700          root = Element("root") 
+ 701          l = ["c1", "c2", "c3", "c4"] 
+ 702          root.c = l 
+ 703   
+ 704          self.assertEqual(["c1", "c2", "c3", "c4"], 
+ 705                            [ c.text for c in root.c ]) 
+ 706          self.assertEqual(l, 
+ 707                            [ c.text for c in root.c ]) 
+ 708   
+ 709          new_slice = ["cA", "cB"] 
+ 710          l[-1:-4:-2] = new_slice 
+ 711          root.c[-1:-4:-2] = new_slice 
+ 712   
+ 713          self.assertEqual(["c1", "cB", "c3", "cA"], l) 
+ 714          self.assertEqual(["c1", "cB", "c3", "cA"], 
+ 715                            [ c.text for c in root.c ]) 
+ 716          self.assertEqual(l, 
+ 717                            [ c.text for c in root.c ]) 
+
 718   
+ 719      # other stuff 
+ 720   
+ 721 -    def test_setitem_index(self): 
+
 722          Element = self.Element 
+ 723          root = Element("root") 
+ 724          root['child'] = ['CHILD1', 'CHILD2'] 
+ 725          self.assertEqual(["CHILD1", "CHILD2"], 
+ 726                            [ c.text for c in root.child ]) 
+ 727   
+ 728          self.assertRaises(IndexError, operator.setitem, root.child, -3, 'oob') 
+ 729          self.assertRaises(IndexError, operator.setitem, root.child, -300, 'oob') 
+ 730          self.assertRaises(IndexError, operator.setitem, root.child, 2, 'oob') 
+ 731          self.assertRaises(IndexError, operator.setitem, root.child, 200, 'oob') 
+ 732   
+ 733          root.child[0] = "child0" 
+ 734          root.child[-1] = "child-1" 
+ 735          self.assertEqual(["child0", "child-1"], 
+ 736                            [ c.text for c in root.child ]) 
+ 737   
+ 738          root.child[1] = "child1" 
+ 739          root.child[-2] = "child-2" 
+ 740          self.assertEqual(["child-2", "child1"], 
+ 741                            [ c.text for c in root.child ]) 
+
 742   
+ 743 -    def test_delitem_index(self): 
+
 744          # make sure strings are set as children 
+ 745          Element = self.Element 
+ 746          root = Element("root") 
+ 747          root['child'] = ['CHILD1', 'CHILD2', 'CHILD3', 'CHILD4'] 
+ 748          self.assertEqual(["CHILD1", "CHILD2", "CHILD3", "CHILD4"], 
+ 749                            [ c.text for c in root.child ]) 
+ 750   
+ 751          del root.child[-1] 
+ 752          self.assertEqual(["CHILD1", "CHILD2", "CHILD3"], 
+ 753                            [ c.text for c in root.child ]) 
+ 754          del root.child[-2] 
+ 755          self.assertEqual(["CHILD1", "CHILD3"], 
+ 756                            [ c.text for c in root.child ]) 
+ 757          del root.child[0] 
+ 758          self.assertEqual(["CHILD3"], 
+ 759                            [ c.text for c in root.child ]) 
+ 760          del root.child[-1] 
+ 761          self.assertRaises(AttributeError, getattr, root, 'child') 
+
 762   
+ 763 -    def test_set_string(self): 
+
 764          # make sure strings are not handled as sequences 
+ 765          Element = self.Element 
+ 766          root = Element("root") 
+ 767          root.c = "TEST" 
+ 768          self.assertEqual(["TEST"], 
+ 769                            [ c.text for c in root.c ]) 
+
 770   
+ 771 -    def test_setitem_string(self): 
+
 772          # make sure strings are set as children 
+ 773          Element = self.Element 
+ 774          root = Element("root") 
+ 775          root["c"] = "TEST" 
+ 776          self.assertEqual(["TEST"], 
+ 777                            [ c.text for c in root.c ]) 
+
 778   
+ 779 -    def test_setitem_string_special(self): 
+
 780          # make sure 'text' etc. are set as children 
+ 781          Element = self.Element 
+ 782          root = Element("root") 
+ 783   
+ 784          root["text"] = "TEST" 
+ 785          self.assertEqual(["TEST"], 
+ 786                            [ c.text for c in root["text"] ]) 
+ 787   
+ 788          root["tail"] = "TEST" 
+ 789          self.assertEqual(["TEST"], 
+ 790                            [ c.text for c in root["tail"] ]) 
+ 791   
+ 792          root["pyval"] = "TEST" 
+ 793          self.assertEqual(["TEST"], 
+ 794                            [ c.text for c in root["pyval"] ]) 
+ 795   
+ 796          root["tag"] = "TEST" 
+ 797          self.assertEqual(["TEST"], 
+ 798                            [ c.text for c in root["tag"] ]) 
+
 799   
+ 800 -    def test_findall(self): 
+
 801          XML = self.XML 
+ 802          root = XML('<a><b><c/></b><b/><c><b/></c></a>') 
+ 803          self.assertEqual(1, len(root.findall("c"))) 
+ 804          self.assertEqual(2, len(root.findall(".//c"))) 
+ 805          self.assertEqual(3, len(root.findall(".//b"))) 
+ 806          self.assertTrue(root.findall(".//b")[1] is root.getchildren()[1]) 
+
 807   
+ 808 -    def test_findall_ns(self): 
+
 809          XML = self.XML 
+ 810          root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>') 
+ 811          self.assertEqual(2, len(root.findall(".//{X}b"))) 
+ 812          self.assertEqual(3, len(root.findall(".//b"))) 
+ 813          self.assertEqual(2, len(root.findall("b"))) 
+
 814   
+ 815 -    def test_build_tree(self): 
+
 816          root = self.Element('root') 
+ 817          root.a = 5 
+ 818          root.b = 6 
+ 819          self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 
+ 820          self.assertTrue(isinstance(root.a, objectify.IntElement)) 
+ 821          self.assertTrue(isinstance(root.b, objectify.IntElement)) 
+
 822   
+ 823 -    def test_type_NoneType(self): 
+
 824          Element = self.Element 
+ 825          SubElement = self.etree.SubElement 
+ 826   
+ 827          nil_attr = XML_SCHEMA_NIL_ATTR 
+ 828          root = Element("{objectified}root") 
+ 829          SubElement(root, "{objectified}none") 
+ 830          SubElement(root, "{objectified}none", {nil_attr : "true"}) 
+ 831          self.assertFalse(isinstance(root.none, objectify.NoneElement)) 
+ 832          self.assertFalse(isinstance(root.none[0], objectify.NoneElement)) 
+ 833          self.assertTrue(isinstance(root.none[1], objectify.NoneElement)) 
+ 834          self.assertEqual(hash(root.none[1]), hash(None)) 
+ 835          self.assertEqual(root.none[1], None) 
+ 836          self.assertFalse(root.none[1]) 
+
 837   
+ 838 -    def test_data_element_NoneType(self): 
+
 839          value = objectify.DataElement(None) 
+ 840          self.assertTrue(isinstance(value, objectify.NoneElement)) 
+ 841          self.assertEqual(value, None) 
+ 842          self.assertEqual(value.get(XML_SCHEMA_NIL_ATTR), "true") 
+
 843   
+ 844 -    def test_type_bool(self): 
+
 845          Element = self.Element 
+ 846          SubElement = self.etree.SubElement 
+ 847          root = Element("{objectified}root") 
+ 848          root.bool = True 
+ 849          self.assertEqual(root.bool, True) 
+ 850          self.assertEqual(root.bool + root.bool, True + True) 
+ 851          self.assertEqual(True + root.bool, True + root.bool) 
+ 852          self.assertEqual(root.bool * root.bool, True * True) 
+ 853          self.assertEqual(int(root.bool), int(True)) 
+ 854          self.assertEqual(hash(root.bool), hash(True)) 
+ 855          self.assertEqual(complex(root.bool), complex(True)) 
+ 856          self.assertTrue(isinstance(root.bool, objectify.BoolElement)) 
+ 857   
+ 858          root.bool = False 
+ 859          self.assertEqual(root.bool, False) 
+ 860          self.assertEqual(root.bool + root.bool, False + False) 
+ 861          self.assertEqual(False + root.bool, False + root.bool) 
+ 862          self.assertEqual(root.bool * root.bool, False * False) 
+ 863          self.assertEqual(int(root.bool), int(False)) 
+ 864          self.assertEqual(hash(root.bool), hash(False)) 
+ 865          self.assertEqual(complex(root.bool), complex(False)) 
+ 866          self.assertTrue(isinstance(root.bool, objectify.BoolElement)) 
+
 867   
+ 868 -    def test_data_element_bool(self): 
+
 869          value = objectify.DataElement(True) 
+ 870          self.assertTrue(isinstance(value, objectify.BoolElement)) 
+ 871          self.assertEqual(value, True) 
+ 872   
+ 873          value = objectify.DataElement(False) 
+ 874          self.assertTrue(isinstance(value, objectify.BoolElement)) 
+ 875          self.assertEqual(value, False) 
+
 876   
+ 877 -    def test_type_str(self): 
+
 878          Element = self.Element 
+ 879          SubElement = self.etree.SubElement 
+ 880          root = Element("{objectified}root") 
+ 881          root.s = "test" 
+ 882          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
+
 883   
+ 884 -    def test_type_str_intliteral(self): 
+
 885          Element = self.Element 
+ 886          SubElement = self.etree.SubElement 
+ 887          root = Element("{objectified}root") 
+ 888          root.s = "3" 
+ 889          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
+
 890   
+ 891 -    def test_type_str_floatliteral(self): 
+
 892          Element = self.Element 
+ 893          SubElement = self.etree.SubElement 
+ 894          root = Element("{objectified}root") 
+ 895          root.s = "3.72" 
+ 896          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
+
 897   
+ 898 -    def test_type_str_mul(self): 
+
 899          Element = self.Element 
+ 900          SubElement = self.etree.SubElement 
+ 901          root = Element("{objectified}root") 
+ 902          root.s = "test" 
+ 903   
+ 904          self.assertEqual("test" * 5, root.s * 5) 
+ 905          self.assertEqual(5 * "test", 5 * root.s) 
+ 906   
+ 907          self.assertRaises(TypeError, operator.mul, root.s, "honk") 
+ 908          self.assertRaises(TypeError, operator.mul, "honk", root.s) 
+
 909   
+ 910 -    def test_type_str_add(self): 
+
 911          Element = self.Element 
+ 912          SubElement = self.etree.SubElement 
+ 913          root = Element("{objectified}root") 
+ 914          root.s = "test" 
+ 915   
+ 916          s = "toast" 
+ 917          self.assertEqual("test" + s, root.s + s) 
+ 918          self.assertEqual(s + "test", s + root.s) 
+
 919               
+ 920 -    def test_type_str_mod(self): 
+
 921          s = "%d %f %s %r" 
+ 922          el = objectify.DataElement(s) 
+ 923          values = (1, 7.0, "abcd", None) 
+ 924          self.assertEqual(s % values, el % values) 
+ 925   
+ 926          s = "%d" 
+ 927          el = objectify.DataElement(s) 
+ 928          val = 5 
+ 929          self.assertEqual(s % val, el % val) 
+ 930   
+ 931          s = "%d %s" 
+ 932          el = objectify.DataElement(s) 
+ 933          val = 5 
+ 934          self.assertRaises(TypeError, el.__mod__, val) 
+ 935   
+ 936          s = "" 
+ 937          el = objectify.DataElement(s) 
+ 938          val = 5 
+ 939          self.assertRaises(TypeError, el.__mod__, val) 
+
 940   
+ 941 -    def test_type_str_hash(self): 
+
 942          v = "1" 
+ 943          el = objectify.DataElement(v) 
+ 944          self.assertEqual(hash(el), hash("1")) 
+
 945   
+ 946 -    def test_type_str_as_int(self): 
+
 947          v = "1" 
+ 948          el = objectify.DataElement(v) 
+ 949          self.assertEqual(int(el), 1) 
+
 950               
+ 951 -    def test_type_str_as_float(self): 
+
 952          v = "1" 
+ 953          el = objectify.DataElement(v) 
+ 954          self.assertEqual(float(el), 1) 
+
 955   
+ 956 -    def test_type_str_as_complex(self): 
+
 957          v = "1" 
+ 958          el = objectify.DataElement(v) 
+ 959          self.assertEqual(complex(el), 1) 
+
 960               
+ 961 -    def test_type_str_mod_data_elements(self): 
+
 962          s = "%d %f %s %r" 
+ 963          el = objectify.DataElement(s) 
+ 964          values = (objectify.DataElement(1), 
+ 965                    objectify.DataElement(7.0), 
+ 966                    objectify.DataElement("abcd"), 
+ 967                    objectify.DataElement(None)) 
+ 968          self.assertEqual(s % values, el % values) 
+
 969   
+ 970 -    def test_data_element_str(self): 
+
 971          value = objectify.DataElement("test") 
+ 972          self.assertTrue(isinstance(value, objectify.StringElement)) 
+ 973          self.assertEqual(value, "test") 
+
 974   
+ 975 -    def test_data_element_str_intliteral(self): 
+
 976          value = objectify.DataElement("3") 
+ 977          self.assertTrue(isinstance(value, objectify.StringElement)) 
+ 978          self.assertEqual(value, "3") 
+
 979   
+ 980 -    def test_data_element_str_floatliteral(self): 
+
 981          value = objectify.DataElement("3.20") 
+ 982          self.assertTrue(isinstance(value, objectify.StringElement)) 
+ 983          self.assertEqual(value, "3.20") 
+
 984   
+ 985 -    def test_type_ustr(self): 
+
 986          Element = self.Element 
+ 987          SubElement = self.etree.SubElement 
+ 988          root = Element("{objectified}root") 
+ 989          root.s = _str("test") 
+ 990          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
+
 991   
+ 992 -    def test_type_ustr_intliteral(self): 
+
 993          Element = self.Element 
+ 994          SubElement = self.etree.SubElement 
+ 995          root = Element("{objectified}root") 
+ 996          root.s = _str("3") 
+ 997          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
+
 998   
+ 999 -    def test_type_ustr_floatliteral(self): 
+
1000          Element = self.Element 
+1001          SubElement = self.etree.SubElement 
+1002          root = Element("{objectified}root") 
+1003          root.s = _str("3.72") 
+1004          self.assertTrue(isinstance(root.s, objectify.StringElement)) 
+
1005   
+1006 -    def test_type_ustr_mul(self): 
+
1007          Element = self.Element 
+1008          SubElement = self.etree.SubElement 
+1009          root = Element("{objectified}root") 
+1010          root.s = _str("test") 
+1011   
+1012          self.assertEqual(_str("test") * 5, root.s * 5) 
+1013          self.assertEqual(5 * _str("test"), 5 * root.s) 
+1014   
+1015          self.assertRaises(TypeError, operator.mul, root.s, _str("honk")) 
+1016          self.assertRaises(TypeError, operator.mul, _str("honk"), root.s) 
+
1017   
+1018 -    def test_type_ustr_add(self): 
+
1019          Element = self.Element 
+1020          SubElement = self.etree.SubElement 
+1021          root = Element("{objectified}root") 
+1022          root.s = _str("test") 
+1023   
+1024          s = _str("toast") 
+1025          self.assertEqual(_str("test") + s, root.s + s) 
+1026          self.assertEqual(s + _str("test"), s + root.s) 
+
1027   
+1028 -    def test_data_element_ustr(self): 
+
1029          value = objectify.DataElement(_str("test")) 
+1030          self.assertTrue(isinstance(value, objectify.StringElement)) 
+1031          self.assertEqual(value, _str("test")) 
+
1032   
+1033 -    def test_data_element_ustr_intliteral(self): 
+
1034          value = objectify.DataElement("3") 
+1035          self.assertTrue(isinstance(value, objectify.StringElement)) 
+1036          self.assertEqual(value, _str("3")) 
+
1037   
+1038 -    def test_data_element_ustr_floatliteral(self): 
+
1039          value = objectify.DataElement(_str("3.20")) 
+1040          self.assertTrue(isinstance(value, objectify.StringElement)) 
+1041          self.assertEqual(value, _str("3.20")) 
+
1042   
+1043 -    def test_type_int(self): 
+
1044          Element = self.Element 
+1045          root = Element("{objectified}root") 
+1046          root.none = 5 
+1047          self.assertTrue(isinstance(root.none, objectify.IntElement)) 
+1048          self.assertEqual(5, root.none.__index__()) 
+
1049   
+1050 -    def test_data_element_int(self): 
+
1051          value = objectify.DataElement(5) 
+1052          self.assertTrue(isinstance(value, objectify.IntElement)) 
+1053          self.assertEqual(value, 5) 
+
1054   
+1055 -    def test_data_element_int_hash(self): 
+
1056          value = objectify.DataElement(123) 
+1057          self.assertEqual(hash(value), hash(123)) 
+
1058   
+1059 -    def test_type_float(self): 
+
1060          Element = self.Element 
+1061          SubElement = self.etree.SubElement 
+1062          root = Element("{objectified}root") 
+1063          root.none = 5.5 
+1064          self.assertTrue(isinstance(root.none, objectify.FloatElement)) 
+
1065   
+1066 -    def test_data_element_float(self): 
+
1067          value = objectify.DataElement(5.5) 
+1068          self.assertTrue(isinstance(value, objectify.FloatElement)) 
+1069          self.assertEqual(value, 5.5) 
+
1070   
+1071 -    def test_data_element_float_hash(self): 
+
1072          value = objectify.DataElement(5.5) 
+1073          self.assertEqual(hash(value), hash(5.5)) 
+
1074   
+1075 -    def test_type_float_precision(self): 
+
1076          # test not losing precision by shortened float str() value 
+1077          # repr(2.305064300557): '2.305064300557' 
+1078          # str(2.305064300557): '2.30506430056' 
+1079          # "%57.54f" % 2.305064300557: 
+1080          #     ' 2.305064300556999956626214043353684246540069580078125000' 
+1081          Element = self.Element 
+1082          root = Element("{objectified}root") 
+1083          s = "2.305064300557" 
+1084          root.f = float(s) 
+1085          self.assertTrue(isinstance(root.f, objectify.FloatElement)) 
+1086          self.assertEqual(root.f.text, s) 
+1087          self.assertEqual(root.f.pyval, float(s)) 
+
1088   
+1089 -    def test_type_float_instantiation_precision(self): 
+
1090          # test precision preservation for FloatElement instantiation 
+1091          s = "2.305064300557" 
+1092          self.assertEqual(objectify.FloatElement(s), float(s)) 
+
1093     
+1094 -    def test_type_float_precision_consistency(self): 
+
1095          # test consistent FloatElement values for the different instantiation 
+1096          # possibilities 
+1097          Element = self.Element 
+1098          root = Element("{objectified}root") 
+1099          s = "2.305064300557" 
+1100          f = float(s) 
+1101          float_elem = objectify.FloatElement(s) 
+1102          float_data_elem = objectify.DataElement(f) 
+1103          root.float_child = float(f) 
+1104          self.assertTrue(f == float_elem == float_data_elem == root.float_child) 
+
1105   
+1106 -    def test_data_element_float_precision(self): 
+
1107          # test not losing precision by shortened float str() value 
+1108          f = 2305064300557.0 
+1109          value = objectify.DataElement(f) 
+1110          self.assertTrue(isinstance(value, objectify.FloatElement)) 
+1111          self.assertEqual(value, f) 
+
1112   
+1113 -    def test_data_element_float_hash_repr(self): 
+
1114          # test not losing precision by shortened float str() value 
+1115          f = 2305064300557.0 
+1116          value = objectify.DataElement(f) 
+1117          self.assertEqual(hash(value), hash(f)) 
+
1118   
+1119 -    def test_data_element_xsitypes(self): 
+
1120          for xsi, objclass in xsitype2objclass.items(): 
+1121              # 1 is a valid value for all ObjectifiedDataElement classes 
+1122              pyval = 1 
+1123              value = objectify.DataElement(pyval, _xsi=xsi) 
+1124              self.assertTrue(isinstance(value, objclass), 
+1125                           "DataElement(%s, _xsi='%s') returns %s, expected %s" 
+1126                           % (pyval, xsi, type(value), objclass)) 
+
1127           
+1128 -    def test_data_element_xsitypes_xsdprefixed(self): 
+
1129          for xsi, objclass in xsitype2objclass.items(): 
+1130              # 1 is a valid value for all ObjectifiedDataElement classes 
+1131              pyval = 1 
+1132              value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi) 
+1133              self.assertTrue(isinstance(value, objclass), 
+1134                           "DataElement(%s, _xsi='%s') returns %s, expected %s" 
+1135                           % (pyval, xsi, type(value), objclass)) 
+
1136           
+1137 -    def test_data_element_xsitypes_prefixed(self): 
+
1138          for xsi, objclass in xsitype2objclass.items(): 
+1139              # 1 is a valid value for all ObjectifiedDataElement classes 
+1140              self.assertRaises(ValueError, objectify.DataElement, 1, 
+1141                                _xsi="foo:%s" % xsi) 
+
1142   
+1143 -    def test_data_element_pytypes(self): 
+
1144          for pytype, objclass in pytype2objclass.items(): 
+1145              # 1 is a valid value for all ObjectifiedDataElement classes 
+1146              pyval = 1 
+1147              value = objectify.DataElement(pyval, _pytype=pytype) 
+1148              self.assertTrue(isinstance(value, objclass), 
+1149                           "DataElement(%s, _pytype='%s') returns %s, expected %s" 
+1150                           % (pyval, pytype, type(value), objclass)) 
+
1151   
+1152 -    def test_data_element_pytype_none(self): 
+
1153          pyval = 1 
+1154          pytype = "NoneType" 
+1155          objclass = objectify.NoneElement 
+1156          value = objectify.DataElement(pyval, _pytype=pytype) 
+1157          self.assertTrue(isinstance(value, objclass), 
+1158                       "DataElement(%s, _pytype='%s') returns %s, expected %s" 
+1159                       % (pyval, pytype, type(value), objclass)) 
+1160          self.assertEqual(value.text, None) 
+1161          self.assertEqual(value.pyval, None) 
+
1162               
+1163 -    def test_data_element_pytype_none_compat(self): 
+
1164          # pre-2.0 lxml called NoneElement "none" 
+1165          pyval = 1 
+1166          pytype = "none" 
+1167          objclass = objectify.NoneElement 
+1168          value = objectify.DataElement(pyval, _pytype=pytype) 
+1169          self.assertTrue(isinstance(value, objclass), 
+1170                       "DataElement(%s, _pytype='%s') returns %s, expected %s" 
+1171                       % (pyval, pytype, type(value), objclass)) 
+1172          self.assertEqual(value.text, None) 
+1173          self.assertEqual(value.pyval, None) 
+
1174   
+1175 -    def test_type_unregistered(self): 
+
1176          Element = self.Element 
+1177          SubElement = self.etree.SubElement 
+1178          class MyFloat(float): 
+1179              pass 
+
1180          root = Element("{objectified}root") 
+1181          root.myfloat = MyFloat(5.5) 
+1182          self.assertTrue(isinstance(root.myfloat, objectify.FloatElement)) 
+1183          self.assertEqual(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None) 
+
1184   
+1185 -    def test_data_element_unregistered(self): 
+
1186          class MyFloat(float): 
+1187              pass 
+
1188          value = objectify.DataElement(MyFloat(5.5)) 
+1189          self.assertTrue(isinstance(value, objectify.FloatElement)) 
+1190          self.assertEqual(value, 5.5) 
+1191          self.assertEqual(value.get(objectify.PYTYPE_ATTRIBUTE), None) 
+1192   
+1193 -    def test_schema_types(self): 
+
1194          XML = self.XML 
+1195          root = XML('''\ 
+1196          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+1197            <b xsi:type="boolean">true</b> 
+1198            <b xsi:type="boolean">false</b> 
+1199            <b xsi:type="boolean">1</b> 
+1200            <b xsi:type="boolean">0</b> 
+1201   
+1202            <f xsi:type="float">5</f> 
+1203            <f xsi:type="double">5</f> 
+1204           
+1205            <s xsi:type="string">5</s> 
+1206            <s xsi:type="normalizedString">5</s> 
+1207            <s xsi:type="token">5</s> 
+1208            <s xsi:type="language">5</s> 
+1209            <s xsi:type="Name">5</s> 
+1210            <s xsi:type="NCName">5</s> 
+1211            <s xsi:type="ID">5</s> 
+1212            <s xsi:type="IDREF">5</s> 
+1213            <s xsi:type="ENTITY">5</s> 
+1214            <s xsi:type="NMTOKEN">5</s> 
+1215   
+1216            <l xsi:type="integer">5</l> 
+1217            <l xsi:type="nonPositiveInteger">5</l> 
+1218            <l xsi:type="negativeInteger">5</l> 
+1219            <l xsi:type="long">5</l> 
+1220            <l xsi:type="nonNegativeInteger">5</l> 
+1221            <l xsi:type="unsignedLong">5</l> 
+1222            <l xsi:type="unsignedInt">5</l> 
+1223            <l xsi:type="positiveInteger">5</l> 
+1224             
+1225            <i xsi:type="int">5</i> 
+1226            <i xsi:type="short">5</i> 
+1227            <i xsi:type="byte">5</i> 
+1228            <i xsi:type="unsignedShort">5</i> 
+1229            <i xsi:type="unsignedByte">5</i> 
+1230   
+1231            <n xsi:nil="true"/> 
+1232          </root> 
+1233          ''') 
+1234   
+1235          for b in root.b: 
+1236              self.assertTrue(isinstance(b, objectify.BoolElement)) 
+1237          self.assertEqual(True,  root.b[0]) 
+1238          self.assertEqual(False, root.b[1]) 
+1239          self.assertEqual(True,  root.b[2]) 
+1240          self.assertEqual(False, root.b[3]) 
+1241   
+1242          for f in root.f: 
+1243              self.assertTrue(isinstance(f, objectify.FloatElement)) 
+1244              self.assertEqual(5, f) 
+1245               
+1246          for s in root.s: 
+1247              self.assertTrue(isinstance(s, objectify.StringElement)) 
+1248              self.assertEqual("5", s) 
+1249   
+1250          for i in root.i: 
+1251              self.assertTrue(isinstance(i, objectify.IntElement)) 
+1252              self.assertEqual(5, i) 
+1253   
+1254          for l in root.l: 
+1255              self.assertTrue(isinstance(l, objectify.IntElement)) 
+1256              self.assertEqual(5, i) 
+1257               
+1258          self.assertTrue(isinstance(root.n, objectify.NoneElement)) 
+1259          self.assertEqual(None, root.n) 
+
1260   
+1261 -    def test_schema_types_prefixed(self): 
+
1262          XML = self.XML 
+1263          root = XML('''\ 
+1264          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1265          xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+1266            <b xsi:type="xsd:boolean">true</b> 
+1267            <b xsi:type="xsd:boolean">false</b> 
+1268            <b xsi:type="xsd:boolean">1</b> 
+1269            <b xsi:type="xsd:boolean">0</b> 
+1270   
+1271            <f xsi:type="xsd:float">5</f> 
+1272            <f xsi:type="xsd:double">5</f> 
+1273           
+1274            <s xsi:type="xsd:string">5</s> 
+1275            <s xsi:type="xsd:normalizedString">5</s> 
+1276            <s xsi:type="xsd:token">5</s> 
+1277            <s xsi:type="xsd:language">5</s> 
+1278            <s xsi:type="xsd:Name">5</s> 
+1279            <s xsi:type="xsd:NCName">5</s> 
+1280            <s xsi:type="xsd:ID">5</s> 
+1281            <s xsi:type="xsd:IDREF">5</s> 
+1282            <s xsi:type="xsd:ENTITY">5</s> 
+1283            <s xsi:type="xsd:NMTOKEN">5</s> 
+1284   
+1285            <l xsi:type="xsd:integer">5</l> 
+1286            <l xsi:type="xsd:nonPositiveInteger">5</l> 
+1287            <l xsi:type="xsd:negativeInteger">5</l> 
+1288            <l xsi:type="xsd:long">5</l> 
+1289            <l xsi:type="xsd:nonNegativeInteger">5</l> 
+1290            <l xsi:type="xsd:unsignedLong">5</l> 
+1291            <l xsi:type="xsd:unsignedInt">5</l> 
+1292            <l xsi:type="xsd:positiveInteger">5</l> 
+1293             
+1294            <i xsi:type="xsd:int">5</i> 
+1295            <i xsi:type="xsd:short">5</i> 
+1296            <i xsi:type="xsd:byte">5</i> 
+1297            <i xsi:type="xsd:unsignedShort">5</i> 
+1298            <i xsi:type="xsd:unsignedByte">5</i> 
+1299   
+1300            <n xsi:nil="true"/> 
+1301          </root> 
+1302          ''') 
+1303   
+1304          for b in root.b: 
+1305              self.assertTrue(isinstance(b, objectify.BoolElement)) 
+1306          self.assertEqual(True,  root.b[0]) 
+1307          self.assertEqual(False, root.b[1]) 
+1308          self.assertEqual(True,  root.b[2]) 
+1309          self.assertEqual(False, root.b[3]) 
+1310   
+1311          for f in root.f: 
+1312              self.assertTrue(isinstance(f, objectify.FloatElement)) 
+1313              self.assertEqual(5, f) 
+1314               
+1315          for s in root.s: 
+1316              self.assertTrue(isinstance(s, objectify.StringElement)) 
+1317              self.assertEqual("5", s) 
+1318   
+1319          for i in root.i: 
+1320              self.assertTrue(isinstance(i, objectify.IntElement)) 
+1321              self.assertEqual(5, i) 
+1322   
+1323          for l in root.l: 
+1324              self.assertTrue(isinstance(l, objectify.IntElement)) 
+1325              self.assertEqual(5, l) 
+1326               
+1327          self.assertTrue(isinstance(root.n, objectify.NoneElement)) 
+1328          self.assertEqual(None, root.n) 
+
1329           
+1330 -    def test_type_str_sequence(self): 
+
1331          XML = self.XML 
+1332          root = XML(_bytes('<root><b>why</b><b>try</b></root>')) 
+1333          strs = [ str(s) for s in root.b ] 
+1334          self.assertEqual(["why", "try"], 
+1335                            strs) 
+
1336   
+1337 -    def test_type_str_cmp(self): 
+
1338          XML = self.XML 
+1339          root = XML(_bytes('<root><b>test</b><b>taste</b><b></b><b/></root>')) 
+1340          self.assertFalse(root.b[0] <  root.b[1]) 
+1341          self.assertFalse(root.b[0] <= root.b[1]) 
+1342          self.assertFalse(root.b[0] == root.b[1]) 
+1343   
+1344          self.assertTrue(root.b[0] != root.b[1]) 
+1345          self.assertTrue(root.b[0] >= root.b[1]) 
+1346          self.assertTrue(root.b[0] >  root.b[1]) 
+1347   
+1348          self.assertEqual(root.b[0], "test") 
+1349          self.assertEqual("test", root.b[0]) 
+1350   
+1351          self.assertEqual("", root.b[2]) 
+1352          self.assertEqual(root.b[2], "") 
+1353          self.assertEqual("", root.b[3]) 
+1354          self.assertEqual(root.b[3], "") 
+1355          self.assertEqual(root.b[2], root.b[3]) 
+1356           
+1357          root.b = "test" 
+1358          self.assertTrue(root.b) 
+1359          root.b = "" 
+1360          self.assertFalse(root.b) 
+1361          self.assertEqual(root.b, "") 
+1362          self.assertEqual("", root.b) 
+
1363   
+1364 -    def test_type_int_cmp(self): 
+
1365          XML = self.XML 
+1366          root = XML(_bytes('<root><b>5</b><b>6</b></root>')) 
+1367          self.assertTrue(root.b[0] <  root.b[1]) 
+1368          self.assertTrue(root.b[0] <= root.b[1]) 
+1369          self.assertTrue(root.b[0] != root.b[1]) 
+1370   
+1371          self.assertFalse(root.b[0] == root.b[1]) 
+1372          self.assertFalse(root.b[0] >= root.b[1]) 
+1373          self.assertFalse(root.b[0] >  root.b[1]) 
+1374   
+1375          self.assertEqual(root.b[0], 5) 
+1376          self.assertEqual(5, root.b[0]) 
+1377          self.assertNotEqual(root.b[0], "5") 
+1378   
+1379          root.b = 5 
+1380          self.assertTrue(root.b) 
+1381          root.b = 0 
+1382          self.assertFalse(root.b) 
+
1383           
+1384      # float + long share the NumberElement implementation with int 
+1385   
+1386 -    def test_type_bool_cmp(self): 
+
1387          XML = self.XML 
+1388          root = XML(_bytes('<root><b>false</b><b>true</b></root>')) 
+1389          self.assertTrue(root.b[0] <  root.b[1]) 
+1390          self.assertTrue(root.b[0] <= root.b[1]) 
+1391          self.assertTrue(root.b[0] != root.b[1]) 
+1392   
+1393          self.assertFalse(root.b[0] == root.b[1]) 
+1394          self.assertFalse(root.b[0] >= root.b[1]) 
+1395          self.assertFalse(root.b[0] >  root.b[1]) 
+1396   
+1397          self.assertFalse(root.b[0]) 
+1398          self.assertTrue(root.b[1]) 
+1399   
+1400          self.assertEqual(root.b[0], False) 
+1401          self.assertEqual(False, root.b[0]) 
+1402          self.assertTrue(root.b[0] <  5) 
+1403          self.assertTrue(5 > root.b[0]) 
+1404   
+1405          root.b = True 
+1406          self.assertTrue(root.b) 
+1407          root.b = False 
+1408          self.assertFalse(root.b) 
+
1409   
+1410 -    def test_type_none_cmp(self): 
+
1411          XML = self.XML 
+1412          root = XML(_bytes(""" 
+1413          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+1414            <b xsi:nil="true"></b><b xsi:nil="true"/> 
+1415          </root>""")) 
+1416          self.assertTrue(root.b[0] == root.b[1]) 
+1417          self.assertFalse(root.b[0]) 
+1418          self.assertEqual(root.b[0], None) 
+1419          self.assertEqual(None, root.b[0]) 
+
1420   
+1421          # doesn't work in Py3: 
+1422   
+1423          #for comparison in ["abc", 5, 7.3, True, [], ()]: 
+1424          #    none = root.b[1] 
+1425          #    self.assertTrue(none < comparison, "%s (%s) should be < %s" % 
+1426          #                 (none, type(none), comparison) ) 
+1427          #    self.assertTrue(comparison > none, "%s should be > %s (%s)" % 
+1428          #                 (comparison, none, type(none)) ) 
+1429   
+1430 -    def test_dataelement_xsi(self): 
+
1431          el = objectify.DataElement(1, _xsi="string") 
+1432          self.assertEqual( 
+1433              el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 
+1434              'xsd:string') 
+
1435   
+1436 -    def test_dataelement_xsi_nsmap(self): 
+
1437          el = objectify.DataElement(1, _xsi="string",  
+1438                                     nsmap={'schema': XML_SCHEMA_NS}) 
+1439          self.assertEqual( 
+1440              el.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), 
+1441              'schema:string') 
+
1442   
+1443 -    def test_dataelement_xsi_prefix_error(self): 
+
1444          self.assertRaises(ValueError, objectify.DataElement, 1, 
+1445                            _xsi="foo:string") 
+
1446   
+1447 -    def test_pytype_annotation(self): 
+
1448          XML = self.XML 
+1449          root = XML(_bytes('''\ 
+1450          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1451          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1452            <b>5</b> 
+1453            <b>test</b> 
+1454            <c>1.1</c> 
+1455            <c>\uF8D2</c> 
+1456            <x>true</x> 
+1457            <n xsi:nil="true" /> 
+1458            <n></n> 
+1459            <b xsi:type="double">5</b> 
+1460            <b xsi:type="float">5</b> 
+1461            <s xsi:type="string">23</s> 
+1462            <s py:pytype="str">42</s> 
+1463            <f py:pytype="float">300</f> 
+1464            <l py:pytype="long">2</l> 
+1465            <t py:pytype="TREE"></t> 
+1466          </a> 
+1467          ''')) 
+1468          objectify.annotate(root) 
+1469   
+1470          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1471                          for c in root.iterchildren() ] 
+1472          self.assertEqual("int",   child_types[ 0]) 
+1473          self.assertEqual("str",   child_types[ 1]) 
+1474          self.assertEqual("float", child_types[ 2]) 
+1475          self.assertEqual("str",   child_types[ 3]) 
+1476          self.assertEqual("bool",  child_types[ 4]) 
+1477          self.assertEqual("NoneType",  child_types[ 5]) 
+1478          self.assertEqual(None,    child_types[ 6]) 
+1479          self.assertEqual("float", child_types[ 7]) 
+1480          self.assertEqual("float", child_types[ 8]) 
+1481          self.assertEqual("str",   child_types[ 9]) 
+1482          self.assertEqual("int",   child_types[10]) 
+1483          self.assertEqual("int",   child_types[11]) 
+1484          self.assertEqual("int",   child_types[12]) 
+1485          self.assertEqual(None,    child_types[13]) 
+1486           
+1487          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+
1488   
+1489 -    def test_pytype_annotation_empty(self): 
+
1490          XML = self.XML 
+1491          root = XML(_bytes('''\ 
+1492          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1493          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1494            <n></n> 
+1495          </a> 
+1496          ''')) 
+1497          objectify.annotate(root) 
+1498   
+1499          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1500                          for c in root.iterchildren() ] 
+1501          self.assertEqual(None,    child_types[0]) 
+1502   
+1503          objectify.annotate(root, empty_pytype="str") 
+1504   
+1505          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1506                          for c in root.iterchildren() ] 
+1507          self.assertEqual("str",    child_types[0]) 
+
1508   
+1509 -    def test_pytype_annotation_use_old(self): 
+
1510          XML = self.XML 
+1511          root = XML(_bytes('''\ 
+1512          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1513          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1514            <b>5</b> 
+1515            <b>test</b> 
+1516            <c>1.1</c> 
+1517            <c>\uF8D2</c> 
+1518            <x>true</x> 
+1519            <n xsi:nil="true" /> 
+1520            <n></n> 
+1521            <b xsi:type="double">5</b> 
+1522            <b xsi:type="float">5</b> 
+1523            <s xsi:type="string">23</s> 
+1524            <s py:pytype="str">42</s> 
+1525            <f py:pytype="float">300</f> 
+1526            <l py:pytype="long">2</l> 
+1527            <t py:pytype="TREE"></t> 
+1528          </a> 
+1529          ''')) 
+1530          objectify.annotate(root, ignore_old=False) 
+1531   
+1532          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1533                          for c in root.iterchildren() ] 
+1534          self.assertEqual("int",   child_types[ 0]) 
+1535          self.assertEqual("str",   child_types[ 1]) 
+1536          self.assertEqual("float", child_types[ 2]) 
+1537          self.assertEqual("str",   child_types[ 3]) 
+1538          self.assertEqual("bool",  child_types[ 4]) 
+1539          self.assertEqual("NoneType",  child_types[ 5]) 
+1540          self.assertEqual(None,    child_types[ 6]) 
+1541          self.assertEqual("float", child_types[ 7]) 
+1542          self.assertEqual("float", child_types[ 8]) 
+1543          self.assertEqual("str",   child_types[ 9]) 
+1544          self.assertEqual("str",   child_types[10]) 
+1545          self.assertEqual("float", child_types[11]) 
+1546          self.assertEqual("int",   child_types[12]) 
+1547          self.assertEqual(TREE_PYTYPE,  child_types[13]) 
+1548           
+1549          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+
1550   
+1551 -    def test_pytype_xsitype_annotation(self): 
+
1552          XML = self.XML 
+1553          root = XML(_bytes('''\ 
+1554          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1555          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1556            <b>5</b> 
+1557            <b>test</b> 
+1558            <c>1.1</c> 
+1559            <c>\uF8D2</c> 
+1560            <x>true</x> 
+1561            <n xsi:nil="true" /> 
+1562            <n></n> 
+1563            <b xsi:type="double">5</b> 
+1564            <b xsi:type="float">5</b> 
+1565            <s xsi:type="string">23</s> 
+1566            <s py:pytype="str">42</s> 
+1567            <f py:pytype="float">300</f> 
+1568            <l py:pytype="long">2</l> 
+1569            <t py:pytype="TREE"></t> 
+1570          </a> 
+1571          ''')) 
+1572          objectify.annotate(root, ignore_old=False, ignore_xsi=False, 
+1573                             annotate_xsi=1, annotate_pytype=1) 
+1574           
+1575          # check py annotations 
+1576          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1577                          for c in root.iterchildren() ] 
+1578          self.assertEqual("int",   child_types[ 0]) 
+1579          self.assertEqual("str",   child_types[ 1]) 
+1580          self.assertEqual("float", child_types[ 2]) 
+1581          self.assertEqual("str",   child_types[ 3]) 
+1582          self.assertEqual("bool",  child_types[ 4]) 
+1583          self.assertEqual("NoneType",  child_types[ 5]) 
+1584          self.assertEqual(None,    child_types[ 6]) 
+1585          self.assertEqual("float", child_types[ 7]) 
+1586          self.assertEqual("float", child_types[ 8]) 
+1587          self.assertEqual("str",   child_types[ 9]) 
+1588          self.assertEqual("str",   child_types[10]) 
+1589          self.assertEqual("float",   child_types[11]) 
+1590          self.assertEqual("int",     child_types[12]) 
+1591          self.assertEqual(TREE_PYTYPE,  child_types[13]) 
+1592           
+1593          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+1594   
+1595          child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
+1596                          for c in root.iterchildren() ] 
+1597   
+1598          # check xsi annotations 
+1599          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
+1600                          for c in root.iterchildren() ] 
+1601          self.assertEqual("xsd:integer", child_types[ 0]) 
+1602          self.assertEqual("xsd:string",  child_types[ 1]) 
+1603          self.assertEqual("xsd:double",  child_types[ 2]) 
+1604          self.assertEqual("xsd:string",  child_types[ 3]) 
+1605          self.assertEqual("xsd:boolean", child_types[ 4]) 
+1606          self.assertEqual(None,          child_types[ 5]) 
+1607          self.assertEqual(None,          child_types[ 6]) 
+1608          self.assertEqual("xsd:double",  child_types[ 7]) 
+1609          self.assertEqual("xsd:float",   child_types[ 8]) 
+1610          self.assertEqual("xsd:string",  child_types[ 9]) 
+1611          self.assertEqual("xsd:string",  child_types[10]) 
+1612          self.assertEqual("xsd:double",  child_types[11]) 
+1613          self.assertEqual("xsd:integer", child_types[12]) 
+1614          self.assertEqual(None,  child_types[13]) 
+1615   
+1616          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+
1617   
+1618 -    def test_xsiannotate_use_old(self): 
+
1619          XML = self.XML 
+1620          root = XML(_bytes('''\ 
+1621          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1622          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1623            <b>5</b> 
+1624            <b>test</b> 
+1625            <c>1.1</c> 
+1626            <c>\uF8D2</c> 
+1627            <x>true</x> 
+1628            <n xsi:nil="true" /> 
+1629            <n></n> 
+1630            <b xsi:type="double">5</b> 
+1631            <b xsi:type="float">5</b> 
+1632            <s xsi:type="string">23</s> 
+1633            <s py:pytype="str">42</s> 
+1634            <f py:pytype="float">300</f> 
+1635            <l py:pytype="long">2</l> 
+1636            <t py:pytype="TREE"></t> 
+1637          </a> 
+1638          ''')) 
+1639          objectify.xsiannotate(root, ignore_old=False) 
+1640   
+1641          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
+1642                          for c in root.iterchildren() ] 
+1643          self.assertEqual("xsd:integer", child_types[ 0]) 
+1644          self.assertEqual("xsd:string",  child_types[ 1]) 
+1645          self.assertEqual("xsd:double",  child_types[ 2]) 
+1646          self.assertEqual("xsd:string",  child_types[ 3]) 
+1647          self.assertEqual("xsd:boolean", child_types[ 4]) 
+1648          self.assertEqual(None,          child_types[ 5]) 
+1649          self.assertEqual(None,          child_types[ 6]) 
+1650          self.assertEqual("xsd:double",  child_types[ 7]) 
+1651          self.assertEqual("xsd:float",   child_types[ 8]) 
+1652          self.assertEqual("xsd:string",  child_types[ 9]) 
+1653          self.assertEqual("xsd:string",  child_types[10]) 
+1654          self.assertEqual("xsd:double",  child_types[11]) 
+1655          self.assertEqual("xsd:integer", child_types[12]) 
+1656          self.assertEqual(None,          child_types[13]) 
+
1657   
+1658 -    def test_pyannotate_ignore_old(self): 
+
1659          XML = self.XML 
+1660          root = XML(_bytes('''\ 
+1661          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1662          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1663            <b>5</b> 
+1664            <b>test</b> 
+1665            <c>1.1</c> 
+1666            <c>\uF8D2</c> 
+1667            <x>true</x> 
+1668            <n xsi:nil="true" /> 
+1669            <n></n> 
+1670            <b xsi:type="double">5</b> 
+1671            <b xsi:type="float">5</b> 
+1672            <s xsi:type="string">23</s> 
+1673            <s py:pytype="str">42</s> 
+1674            <f py:pytype="float">300</f> 
+1675            <l py:pytype="long">2</l> 
+1676            <t py:pytype="TREE"></t> 
+1677          </a> 
+1678          ''')) 
+1679          objectify.pyannotate(root, ignore_old=True) 
+1680   
+1681          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1682                          for c in root.iterchildren() ] 
+1683          self.assertEqual("int",   child_types[ 0]) 
+1684          self.assertEqual("str",   child_types[ 1]) 
+1685          self.assertEqual("float", child_types[ 2]) 
+1686          self.assertEqual("str",   child_types[ 3]) 
+1687          self.assertEqual("bool",  child_types[ 4]) 
+1688          self.assertEqual("NoneType",  child_types[ 5]) 
+1689          self.assertEqual(None,    child_types[ 6]) 
+1690          self.assertEqual("float", child_types[ 7]) 
+1691          self.assertEqual("float", child_types[ 8]) 
+1692          self.assertEqual("str",   child_types[ 9]) 
+1693          self.assertEqual("int",   child_types[10]) 
+1694          self.assertEqual("int",   child_types[11]) 
+1695          self.assertEqual("int",   child_types[12]) 
+1696          self.assertEqual(None,    child_types[13]) 
+1697           
+1698          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+
1699   
+1700 -    def test_pyannotate_empty(self): 
+
1701          XML = self.XML 
+1702          root = XML('''\ 
+1703          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1704          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1705            <n></n> 
+1706          </a> 
+1707          ''') 
+1708          objectify.pyannotate(root) 
+1709   
+1710          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1711                          for c in root.iterchildren() ] 
+1712          self.assertEqual(None,    child_types[0]) 
+1713   
+1714          objectify.annotate(root, empty_pytype="str") 
+1715   
+1716          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1717                          for c in root.iterchildren() ] 
+1718          self.assertEqual("str",    child_types[0]) 
+
1719   
+1720 -    def test_pyannotate_use_old(self): 
+
1721          XML = self.XML 
+1722          root = XML('''\ 
+1723          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1724          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1725            <b>5</b> 
+1726            <b>test</b> 
+1727            <c>1.1</c> 
+1728            <c>\uF8D2</c> 
+1729            <x>true</x> 
+1730            <n xsi:nil="true" /> 
+1731            <n></n> 
+1732            <b xsi:type="double">5</b> 
+1733            <b xsi:type="float">5</b> 
+1734            <s xsi:type="string">23</s> 
+1735            <s py:pytype="str">42</s> 
+1736            <f py:pytype="float">300</f> 
+1737            <l py:pytype="long">2</l> 
+1738            <t py:pytype="TREE"></t> 
+1739          </a> 
+1740          ''') 
+1741          objectify.pyannotate(root) 
+1742   
+1743          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1744                          for c in root.iterchildren() ] 
+1745          self.assertEqual("int",   child_types[ 0]) 
+1746          self.assertEqual("str",   child_types[ 1]) 
+1747          self.assertEqual("float", child_types[ 2]) 
+1748          self.assertEqual("str",   child_types[ 3]) 
+1749          self.assertEqual("bool",  child_types[ 4]) 
+1750          self.assertEqual("NoneType",  child_types[ 5]) 
+1751          self.assertEqual(None,    child_types[ 6]) 
+1752          self.assertEqual("float", child_types[ 7]) 
+1753          self.assertEqual("float", child_types[ 8]) 
+1754          self.assertEqual("str",   child_types[ 9]) 
+1755          self.assertEqual("str",   child_types[10]) 
+1756          self.assertEqual("float", child_types[11]) 
+1757          self.assertEqual("int",   child_types[12]) 
+1758          self.assertEqual(TREE_PYTYPE, child_types[13]) 
+1759           
+1760          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+
1761           
+1762 -    def test_xsiannotate_ignore_old(self): 
+
1763          XML = self.XML 
+1764          root = XML(_bytes('''\ 
+1765          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1766          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1767            <b>5</b> 
+1768            <b>test</b> 
+1769            <c>1.1</c> 
+1770            <c>\uF8D2</c> 
+1771            <x>true</x> 
+1772            <n xsi:nil="true" /> 
+1773            <n></n> 
+1774            <b xsi:type="double">5</b> 
+1775            <b xsi:type="float">5</b> 
+1776            <s xsi:type="string">23</s> 
+1777            <s py:pytype="str">42</s> 
+1778            <f py:pytype="float">300</f> 
+1779            <l py:pytype="long">2</l> 
+1780            <t py:pytype="TREE"></t> 
+1781          </a> 
+1782          ''')) 
+1783          objectify.xsiannotate(root, ignore_old=True) 
+1784   
+1785          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
+1786                          for c in root.iterchildren() ] 
+1787          self.assertEqual("xsd:integer", child_types[ 0]) 
+1788          self.assertEqual("xsd:string",  child_types[ 1]) 
+1789          self.assertEqual("xsd:double",  child_types[ 2]) 
+1790          self.assertEqual("xsd:string",  child_types[ 3]) 
+1791          self.assertEqual("xsd:boolean", child_types[ 4]) 
+1792          self.assertEqual(None,          child_types[ 5]) 
+1793          self.assertEqual(None,          child_types[ 6]) 
+1794          self.assertEqual("xsd:integer", child_types[ 7]) 
+1795          self.assertEqual("xsd:integer", child_types[ 8]) 
+1796          self.assertEqual("xsd:integer", child_types[ 9]) 
+1797          self.assertEqual("xsd:string",  child_types[10]) 
+1798          self.assertEqual("xsd:double",  child_types[11]) 
+1799          self.assertEqual("xsd:integer", child_types[12]) 
+1800          self.assertEqual(None,          child_types[13]) 
+1801   
+1802          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+
1803   
+1804 -    def test_deannotate(self): 
+
1805          XML = self.XML 
+1806          root = XML(_bytes('''\ 
+1807          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1808          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1809            <b>5</b> 
+1810            <b>test</b> 
+1811            <c>1.1</c> 
+1812            <c>\uF8D2</c> 
+1813            <x>true</x> 
+1814            <n xsi:nil="true" /> 
+1815            <n></n> 
+1816            <b xsi:type="double">5</b> 
+1817            <b xsi:type="float">5</b> 
+1818            <s xsi:type="string">23</s> 
+1819            <s py:pytype="str">42</s> 
+1820            <f py:pytype="float">300</f> 
+1821            <l py:pytype="long">2</l> 
+1822            <t py:pytype="TREE"></t> 
+1823          </a> 
+1824          ''')) 
+1825          objectify.deannotate(root) 
+1826   
+1827          for c in root.getiterator(): 
+1828              self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 
+1829              self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 
+1830   
+1831          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+
1832   
+1833 -    def test_xsinil_deannotate(self): 
+
1834          XML = self.XML 
+1835          root = XML(_bytes('''\ 
+1836          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1837          xmlns:py="http://codespeak.net/lxml/objectify/pytype"> 
+1838            <b>5</b> 
+1839            <b>test</b> 
+1840            <c>1.1</c> 
+1841            <c>\uF8D2</c> 
+1842            <x>true</x> 
+1843            <n xsi:nil="true" /> 
+1844            <n></n> 
+1845            <b xsi:type="double">5</b> 
+1846            <b xsi:type="float">5</b> 
+1847            <s xsi:type="string">23</s> 
+1848            <s py:pytype="str">42</s> 
+1849            <f py:pytype="float">300</f> 
+1850            <l py:pytype="long">2</l> 
+1851            <t py:pytype="TREE"></t> 
+1852          </a> 
+1853          ''')) 
+1854          objectify.annotate( 
+1855              root, ignore_old=False, ignore_xsi=False, annotate_xsi=True, 
+1856              empty_pytype='str', empty_type='string') 
+1857          objectify.deannotate(root, pytype=False, xsi=False, xsi_nil=True) 
+1858   
+1859          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
+1860                          for c in root.iterchildren() ] 
+1861          self.assertEqual("xsd:integer",  child_types[ 0]) 
+1862          self.assertEqual("xsd:string",   child_types[ 1]) 
+1863          self.assertEqual("xsd:double",   child_types[ 2]) 
+1864          self.assertEqual("xsd:string",   child_types[ 3]) 
+1865          self.assertEqual("xsd:boolean",  child_types[ 4]) 
+1866          self.assertEqual(None,           child_types[ 5]) 
+1867          self.assertEqual("xsd:string",   child_types[ 6]) 
+1868          self.assertEqual("xsd:double",   child_types[ 7]) 
+1869          self.assertEqual("xsd:float",    child_types[ 8]) 
+1870          self.assertEqual("xsd:string",   child_types[ 9]) 
+1871          self.assertEqual("xsd:string",   child_types[10]) 
+1872          self.assertEqual("xsd:double",    child_types[11]) 
+1873          self.assertEqual("xsd:integer",  child_types[12]) 
+1874          self.assertEqual(None,           child_types[13]) 
+1875   
+1876          self.assertEqual(None, root.n.get(XML_SCHEMA_NIL_ATTR)) 
+1877   
+1878          for c in root.iterchildren(): 
+1879              self.assertNotEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 
+1880              # these have no equivalent in xsi:type 
+1881              if (c.get(objectify.PYTYPE_ATTRIBUTE) not in [TREE_PYTYPE,  
+1882                  "NoneType"]): 
+1883                  self.assertNotEqual( 
+1884                      None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 
+
1885   
+1886 -    def test_xsitype_deannotate(self): 
+
1887          XML = self.XML 
+1888          root = XML(_bytes('''\ 
+1889          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1890          xmlns:py="http://codespeak.net/lxml/objectify/pytype" 
+1891          xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+1892            <b>5</b> 
+1893            <b>test</b> 
+1894            <c>1.1</c> 
+1895            <c>\uF8D2</c> 
+1896            <x>true</x> 
+1897            <n xsi:nil="true" /> 
+1898            <n></n> 
+1899            <b xsi:type="xsd:double">5</b> 
+1900            <b xsi:type="xsd:float">5</b> 
+1901            <s xsi:type="xsd:string">23</s> 
+1902            <s py:pytype="str">42</s> 
+1903            <f py:pytype="float">300</f> 
+1904            <l py:pytype="long">2</l> 
+1905            <t py:pytype="TREE"></t> 
+1906          </a> 
+1907          ''')) 
+1908          objectify.annotate(root) 
+1909          objectify.deannotate(root, pytype=False) 
+1910   
+1911          child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE) 
+1912                          for c in root.iterchildren() ] 
+1913          self.assertEqual("int",   child_types[ 0]) 
+1914          self.assertEqual("str",   child_types[ 1]) 
+1915          self.assertEqual("float", child_types[ 2]) 
+1916          self.assertEqual("str",   child_types[ 3]) 
+1917          self.assertEqual("bool",  child_types[ 4]) 
+1918          self.assertEqual("NoneType",  child_types[ 5]) 
+1919          self.assertEqual(None,    child_types[ 6]) 
+1920          self.assertEqual("float", child_types[ 7]) 
+1921          self.assertEqual("float", child_types[ 8]) 
+1922          self.assertEqual("str",   child_types[ 9]) 
+1923          self.assertEqual("int",   child_types[10]) 
+1924          self.assertEqual("int",   child_types[11]) 
+1925          self.assertEqual("int",   child_types[12]) 
+1926          self.assertEqual(None,    child_types[13]) 
+1927           
+1928          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+1929   
+1930          for c in root.getiterator(): 
+1931              self.assertEqual(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)) 
+
1932   
+1933 -    def test_pytype_deannotate(self): 
+
1934          XML = self.XML 
+1935          root = XML(_bytes('''\ 
+1936          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+1937          xmlns:py="http://codespeak.net/lxml/objectify/pytype" 
+1938          xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+1939            <b xsi:type="xsd:int">5</b> 
+1940            <b xsi:type="xsd:string">test</b> 
+1941            <c xsi:type="xsd:float">1.1</c> 
+1942            <c xsi:type="xsd:string">\uF8D2</c> 
+1943            <x xsi:type="xsd:boolean">true</x> 
+1944            <n xsi:nil="true" /> 
+1945            <n></n> 
+1946            <b xsi:type="xsd:double">5</b> 
+1947            <b xsi:type="xsd:float">5</b> 
+1948            <s xsi:type="xsd:string">23</s> 
+1949            <s xsi:type="xsd:string">42</s> 
+1950            <f xsi:type="xsd:float">300</f> 
+1951            <l xsi:type="xsd:long">2</l> 
+1952            <t py:pytype="TREE"></t> 
+1953          </a> 
+1954          ''')) 
+1955          objectify.annotate(root) 
+1956          objectify.deannotate(root, xsi=False) 
+1957   
+1958          child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR) 
+1959                          for c in root.iterchildren() ] 
+1960          self.assertEqual("xsd:int",      child_types[ 0]) 
+1961          self.assertEqual("xsd:string",   child_types[ 1]) 
+1962          self.assertEqual("xsd:float",    child_types[ 2]) 
+1963          self.assertEqual("xsd:string",   child_types[ 3]) 
+1964          self.assertEqual("xsd:boolean",  child_types[ 4]) 
+1965          self.assertEqual(None,           child_types[ 5]) 
+1966          self.assertEqual(None,           child_types[ 6]) 
+1967          self.assertEqual("xsd:double",   child_types[ 7]) 
+1968          self.assertEqual("xsd:float",    child_types[ 8]) 
+1969          self.assertEqual("xsd:string",   child_types[ 9]) 
+1970          self.assertEqual("xsd:string",   child_types[10]) 
+1971          self.assertEqual("xsd:float",    child_types[11]) 
+1972          self.assertEqual("xsd:long",     child_types[12]) 
+1973          self.assertEqual(None,           child_types[13]) 
+1974   
+1975          self.assertEqual("true", root.n.get(XML_SCHEMA_NIL_ATTR)) 
+1976   
+1977          for c in root.getiterator(): 
+1978              self.assertEqual(None, c.get(objectify.PYTYPE_ATTRIBUTE)) 
+
1979   
+1980 -    def test_change_pytype_attribute(self): 
+
1981          XML = self.XML 
+1982   
+1983          xml = _bytes('''\ 
+1984          <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+1985            <b>5</b> 
+1986            <b>test</b> 
+1987            <c>1.1</c> 
+1988            <c>\uF8D2</c> 
+1989            <x>true</x> 
+1990            <n xsi:nil="true" /> 
+1991            <n></n> 
+1992            <b xsi:type="double">5</b> 
+1993          </a> 
+1994          ''') 
+1995   
+1996          pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 
+1997          objectify.set_pytype_attribute_tag("{TEST}test") 
+1998   
+1999          root = XML(xml) 
+2000          objectify.annotate(root) 
+2001   
+2002          attribs = root.xpath("//@py:%s" % pytype_name, 
+2003                               namespaces={"py" : pytype_ns}) 
+2004          self.assertEqual(0, len(attribs)) 
+2005          attribs = root.xpath("//@py:test", 
+2006                               namespaces={"py" : "TEST"}) 
+2007          self.assertEqual(7, len(attribs)) 
+2008   
+2009          objectify.set_pytype_attribute_tag() 
+2010          pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}') 
+2011   
+2012          self.assertNotEqual("test", pytype_ns.lower()) 
+2013          self.assertNotEqual("test", pytype_name.lower()) 
+2014   
+2015          root = XML(xml) 
+2016          attribs = root.xpath("//@py:%s" % pytype_name, 
+2017                               namespaces={"py" : pytype_ns}) 
+2018          self.assertEqual(0, len(attribs)) 
+2019   
+2020          objectify.annotate(root) 
+2021          attribs = root.xpath("//@py:%s" % pytype_name, 
+2022                               namespaces={"py" : pytype_ns}) 
+2023          self.assertEqual(7, len(attribs)) 
+
2024   
+2025 -    def test_registered_types(self): 
+
2026          orig_types = objectify.getRegisteredTypes() 
+2027          orig_types[0].unregister() 
+2028          self.assertEqual(orig_types[1:], objectify.getRegisteredTypes()) 
+2029   
+2030          class NewType(objectify.ObjectifiedDataElement): 
+2031              pass 
+
2032   
+2033          def checkMyType(s): 
+2034              return True 
+2035   
+2036          pytype = objectify.PyType("mytype", checkMyType, NewType) 
+2037          self.assertTrue(pytype not in objectify.getRegisteredTypes()) 
+2038          pytype.register() 
+2039          self.assertTrue(pytype in objectify.getRegisteredTypes()) 
+2040          pytype.unregister() 
+2041          self.assertTrue(pytype not in objectify.getRegisteredTypes()) 
+2042   
+2043          pytype.register(before = [objectify.getRegisteredTypes()[0].name]) 
+2044          self.assertEqual(pytype, objectify.getRegisteredTypes()[0]) 
+2045          pytype.unregister() 
+2046   
+2047          pytype.register(after = [objectify.getRegisteredTypes()[0].name]) 
+2048          self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0]) 
+2049          pytype.unregister() 
+2050   
+2051          self.assertRaises(ValueError, pytype.register, 
+2052                            before = [objectify.getRegisteredTypes()[0].name], 
+2053                            after  = [objectify.getRegisteredTypes()[1].name]) 
+2054   
+2055 -    def test_registered_type_stringify(self): 
+
2056          from datetime import datetime 
+2057          def parse_date(value): 
+2058              if len(value) != 14: 
+2059                  raise ValueError(value) 
+2060              Y = int(value[0:4]) 
+2061              M = int(value[4:6]) 
+2062              D = int(value[6:8]) 
+2063              h = int(value[8:10]) 
+2064              m = int(value[10:12]) 
+2065              s = int(value[12:14]) 
+2066              return datetime(Y, M, D, h, m, s) 
+
2067   
+2068          def stringify_date(date): 
+2069              return date.strftime("%Y%m%d%H%M%S") 
+2070   
+2071          class DatetimeElement(objectify.ObjectifiedDataElement): 
+2072              def pyval(self): 
+2073                  return parse_date(self.text) 
+2074              pyval = property(pyval) 
+2075   
+2076          datetime_type = objectify.PyType( 
+2077              "datetime", parse_date, DatetimeElement, stringify_date) 
+2078          datetime_type.xmlSchemaTypes = "dateTime" 
+2079          datetime_type.register() 
+2080   
+2081          NAMESPACE = "http://foo.net/xmlns" 
+2082          NAMESPACE_MAP = {'ns': NAMESPACE} 
+2083   
+2084          r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP) 
+2085          time = datetime.now() 
+2086          r.date = time 
+2087   
+2088          self.assertTrue(isinstance(r.date, DatetimeElement)) 
+2089          self.assertTrue(isinstance(r.date.pyval, datetime)) 
+2090   
+2091          self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 
+2092          self.assertEqual(r.date.text, stringify_date(time)) 
+2093   
+2094          r.date = objectify.E.date(time) 
+2095   
+2096          self.assertTrue(isinstance(r.date, DatetimeElement)) 
+2097          self.assertTrue(isinstance(r.date.pyval, datetime)) 
+2098   
+2099          self.assertEqual(r.date.pyval, parse_date(stringify_date(time))) 
+2100          self.assertEqual(r.date.text, stringify_date(time)) 
+2101   
+2102          date = objectify.DataElement(time) 
+2103   
+2104          self.assertTrue(isinstance(date, DatetimeElement)) 
+2105          self.assertTrue(isinstance(date.pyval, datetime)) 
+2106   
+2107          self.assertEqual(date.pyval, parse_date(stringify_date(time))) 
+2108          self.assertEqual(date.text, stringify_date(time)) 
+2109   
+2110 -    def test_object_path(self): 
+
2111          root = self.XML(xml_str) 
+2112          path = objectify.ObjectPath( "root.c1.c2" ) 
+2113          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2114          self.assertEqual(root.c1.c2.text, path(root).text) 
+
2115   
+2116 -    def test_object_path_list(self): 
+
2117          root = self.XML(xml_str) 
+2118          path = objectify.ObjectPath( ['root', 'c1', 'c2'] ) 
+2119          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2120          self.assertEqual(root.c1.c2.text, path(root).text) 
+
2121   
+2122 -    def test_object_path_fail(self): 
+
2123          root = self.XML(xml_str) 
+2124          path = objectify.ObjectPath( "root.c1.c99" ) 
+2125          self.assertRaises(AttributeError, path, root) 
+
2126   
+2127 -    def test_object_path_default_absolute(self): 
+
2128          root = self.XML(xml_str) 
+2129          path = objectify.ObjectPath( "root.c1.c99" ) 
+2130          self.assertEqual(None, path(root, None)) 
+2131          path = objectify.ObjectPath( "root.c99.c2" ) 
+2132          self.assertEqual(None, path(root, None)) 
+2133          path = objectify.ObjectPath( "notroot.c99.c2" ) 
+2134          self.assertEqual(None, path(root, None)) 
+
2135   
+2136 -    def test_object_path_default_relative(self): 
+
2137          root = self.XML(xml_str) 
+2138          path = objectify.ObjectPath( ".c1.c99" ) 
+2139          self.assertEqual(None, path(root, None)) 
+2140          path = objectify.ObjectPath( ".c99.c2" ) 
+2141          self.assertEqual(None, path(root, None)) 
+
2142   
+2143 -    def test_object_path_syntax(self): 
+
2144          root = self.XML(xml_str) 
+2145          path = objectify.ObjectPath("root .    {objectified}c1.   c2") 
+2146          self.assertEqual(root.c1.c2.text, path(root).text) 
+2147   
+2148          path = objectify.ObjectPath("   root.{objectified}  c1.c2  [ 0 ]   ") 
+2149          self.assertEqual(root.c1.c2.text, path(root).text) 
+
2150   
+2151 -    def test_object_path_fail_parse_empty(self): 
+
2152          self.assertRaises(ValueError, objectify.ObjectPath, "") 
+
2153   
+2154 -    def test_object_path_fail_parse_empty_list(self): 
+
2155          self.assertRaises(ValueError, objectify.ObjectPath, []) 
+
2156   
+2157 -    def test_object_path_hasattr(self): 
+
2158          root = self.XML(xml_str) 
+2159          path = objectify.ObjectPath( "root" ) 
+2160          self.assertTrue(path.hasattr(root)) 
+2161          path = objectify.ObjectPath( "root.c1" ) 
+2162          self.assertTrue(path.hasattr(root)) 
+2163          path = objectify.ObjectPath( "root.c1.c2" ) 
+2164          self.assertTrue(path.hasattr(root)) 
+2165          path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 
+2166          self.assertTrue(path.hasattr(root)) 
+2167          path = objectify.ObjectPath( "root.c1.c2[1]" ) 
+2168          self.assertTrue(path.hasattr(root)) 
+2169          path = objectify.ObjectPath( "root.c1.c2[2]" ) 
+2170          self.assertTrue(path.hasattr(root)) 
+2171          path = objectify.ObjectPath( "root.c1.c2[3]" ) 
+2172          self.assertFalse(path.hasattr(root)) 
+2173          path = objectify.ObjectPath( "root.c1[1].c2" ) 
+2174          self.assertFalse(path.hasattr(root)) 
+
2175   
+2176 -    def test_object_path_dot(self): 
+
2177          root = self.XML(xml_str) 
+2178          path = objectify.ObjectPath( "." ) 
+2179          self.assertEqual(root.c1.c2.text, path(root).c1.c2.text) 
+
2180   
+2181 -    def test_object_path_dot_list(self): 
+
2182          root = self.XML(xml_str) 
+2183          path = objectify.ObjectPath( [''] ) 
+2184          self.assertEqual(root.c1.c2.text, path(root).c1.c2.text) 
+
2185   
+2186 -    def test_object_path_dot_root(self): 
+
2187          root = self.XML(xml_str) 
+2188          path = objectify.ObjectPath( ".c1.c2" ) 
+2189          self.assertEqual(root.c1.c2.text, path(root).text) 
+
2190   
+2191 -    def test_object_path_dot_root_list(self): 
+
2192          root = self.XML(xml_str) 
+2193          path = objectify.ObjectPath( ['', 'c1', 'c2'] ) 
+2194          self.assertEqual(root.c1.c2.text, path(root).text) 
+
2195   
+2196 -    def test_object_path_index(self): 
+
2197          root = self.XML(xml_str) 
+2198          path = objectify.ObjectPath( "root.c1[0].c2[0]" ) 
+2199          self.assertEqual(root.c1.c2.text, path(root).text) 
+2200   
+2201          path = objectify.ObjectPath( "root.c1[0].c2" ) 
+2202          self.assertEqual(root.c1.c2.text, path(root).text) 
+2203   
+2204          path = objectify.ObjectPath( "root.c1[0].c2[1]" ) 
+2205          self.assertEqual(root.c1.c2[1].text, path(root).text) 
+2206   
+2207          path = objectify.ObjectPath( "root.c1.c2[2]" ) 
+2208          self.assertEqual(root.c1.c2[2].text, path(root).text) 
+2209   
+2210          path = objectify.ObjectPath( "root.c1.c2[-1]" ) 
+2211          self.assertEqual(root.c1.c2[-1].text, path(root).text) 
+2212   
+2213          path = objectify.ObjectPath( "root.c1.c2[-3]" ) 
+2214          self.assertEqual(root.c1.c2[-3].text, path(root).text) 
+
2215   
+2216 -    def test_object_path_index_list(self): 
+
2217          root = self.XML(xml_str) 
+2218          path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] ) 
+2219          self.assertEqual(root.c1.c2.text, path(root).text) 
+2220   
+2221          path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] ) 
+2222          self.assertEqual(root.c1.c2[2].text, path(root).text) 
+2223   
+2224          path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] ) 
+2225          self.assertEqual(root.c1.c2[2].text, path(root).text) 
+2226   
+2227          path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] ) 
+2228          self.assertEqual(root.c1.c2[-1].text, path(root).text) 
+2229   
+2230          path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] ) 
+2231          self.assertEqual(root.c1.c2[-3].text, path(root).text) 
+
2232   
+2233 -    def test_object_path_index_fail_parse(self): 
+
2234          self.assertRaises(ValueError, objectify.ObjectPath, 
+2235                            "root.c1[0].c2[-1-2]") 
+2236          self.assertRaises(ValueError, objectify.ObjectPath, 
+2237                            ['root', 'c1[0]', 'c2[-1-2]']) 
+2238   
+2239          self.assertRaises(ValueError, objectify.ObjectPath, 
+2240                            "root[2].c1.c2") 
+2241          self.assertRaises(ValueError, objectify.ObjectPath, 
+2242                            ['root[2]', 'c1', 'c2']) 
+2243   
+2244          self.assertRaises(ValueError, objectify.ObjectPath, 
+2245                            []) 
+2246          self.assertRaises(ValueError, objectify.ObjectPath, 
+2247                            ['', '', '']) 
+
2248   
+2249 -    def test_object_path_index_fail_lookup(self): 
+
2250          root = self.XML(xml_str) 
+2251          path = objectify.ObjectPath("root.c1[9999].c2") 
+2252          self.assertRaises(AttributeError, path, root) 
+2253   
+2254          path = objectify.ObjectPath("root.c1[0].c2[9999]") 
+2255          self.assertRaises(AttributeError, path, root) 
+2256   
+2257          path = objectify.ObjectPath(".c1[9999].c2[0]") 
+2258          self.assertRaises(AttributeError, path, root) 
+2259   
+2260          path = objectify.ObjectPath("root.c1[-2].c2") 
+2261          self.assertRaises(AttributeError, path, root) 
+2262   
+2263          path = objectify.ObjectPath("root.c1[0].c2[-4]") 
+2264          self.assertRaises(AttributeError, path, root) 
+
2265   
+2266 -    def test_object_path_ns(self): 
+
2267          root = self.XML(xml_str) 
+2268          path = objectify.ObjectPath( "{objectified}root.c1.c2" ) 
+2269          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2270          path = objectify.ObjectPath( "{objectified}root.{objectified}c1.c2" ) 
+2271          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2272          path = objectify.ObjectPath( "root.{objectified}c1.{objectified}c2" ) 
+2273          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2274          path = objectify.ObjectPath( "root.c1.{objectified}c2" ) 
+2275          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2276          path = objectify.ObjectPath( "root.c1.{otherNS}c2" ) 
+2277          self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 
+2278                            path.find(root).text) 
+
2279   
+2280 -    def test_object_path_ns_list(self): 
+
2281          root = self.XML(xml_str) 
+2282          path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] ) 
+2283          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2284          path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] ) 
+2285          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2286          path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] ) 
+2287          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2288          path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] ) 
+2289          self.assertEqual(root.c1.c2[2].text, path.find(root).text) 
+2290          path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] ) 
+2291          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2292          path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] ) 
+2293          self.assertEqual(root.c1.c2[2].text, path.find(root).text) 
+2294          path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] ) 
+2295          self.assertEqual(getattr(root.c1, '{otherNS}c2').text, 
+2296                            path.find(root).text) 
+
2297   
+2298 -    def test_object_path_set(self): 
+
2299          root = self.XML(xml_str) 
+2300          path = objectify.ObjectPath( "root.c1.c2" ) 
+2301          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2302          self.assertEqual("1", root.c1.c2[1].text) 
+2303   
+2304          new_value = "my new value" 
+2305          path.setattr(root, new_value) 
+2306   
+2307          self.assertEqual(new_value, root.c1.c2.text) 
+2308          self.assertEqual(new_value, path(root).text) 
+2309          self.assertEqual("1", root.c1.c2[1].text) 
+
2310   
+2311 -    def test_object_path_set_element(self): 
+
2312          root = self.XML(xml_str) 
+2313          path = objectify.ObjectPath( "root.c1.c2" ) 
+2314          self.assertEqual(root.c1.c2.text, path.find(root).text) 
+2315          self.assertEqual("1", root.c1.c2[1].text) 
+2316   
+2317          new_el = self.Element("{objectified}test") 
+2318          etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 
+2319          path.setattr(root, new_el.sub) 
+2320   
+2321          self.assertEqual("ATTR", root.c1.c2.get("myattr")) 
+2322          self.assertEqual("TEST", root.c1.c2.a.text) 
+2323          self.assertEqual("TEST", path(root).a.text) 
+2324          self.assertEqual("1", root.c1.c2[1].text) 
+
2325   
+2326 -    def test_object_path_set_create(self): 
+
2327          root = self.XML(xml_str) 
+2328          path = objectify.ObjectPath( "root.c1.c99" ) 
+2329          self.assertRaises(AttributeError, path.find, root) 
+2330   
+2331          new_value = "my new value" 
+2332          path.setattr(root, new_value) 
+2333   
+2334          self.assertEqual(1, len(root.c1.c99)) 
+2335          self.assertEqual(new_value, root.c1.c99.text) 
+2336          self.assertEqual(new_value, path(root).text) 
+
2337   
+2338 -    def test_object_path_set_create_element(self): 
+
2339          root = self.XML(xml_str) 
+2340          path = objectify.ObjectPath( "root.c1.c99" ) 
+2341          self.assertRaises(AttributeError, path.find, root) 
+2342   
+2343          new_el = self.Element("{objectified}test") 
+2344          etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 
+2345          path.setattr(root, new_el.sub) 
+2346   
+2347          self.assertEqual(1, len(root.c1.c99)) 
+2348          self.assertEqual("ATTR", root.c1.c99.get("myattr")) 
+2349          self.assertEqual("TEST", root.c1.c99.a.text) 
+2350          self.assertEqual("TEST", path(root).a.text) 
+
2351   
+2352 -    def test_object_path_set_create_list(self): 
+
2353          root = self.XML(xml_str) 
+2354          path = objectify.ObjectPath( "root.c1.c99" ) 
+2355          self.assertRaises(AttributeError, path.find, root) 
+2356   
+2357          new_el = self.Element("{objectified}test") 
+2358          new_el.a = ["TEST1", "TEST2"] 
+2359          new_el.a[0].set("myattr", "ATTR1") 
+2360          new_el.a[1].set("myattr", "ATTR2") 
+2361   
+2362          path.setattr(root, list(new_el.a)) 
+2363   
+2364          self.assertEqual(2, len(root.c1.c99)) 
+2365          self.assertEqual("ATTR1", root.c1.c99[0].get("myattr")) 
+2366          self.assertEqual("TEST1", root.c1.c99[0].text) 
+2367          self.assertEqual("ATTR2", root.c1.c99[1].get("myattr")) 
+2368          self.assertEqual("TEST2", root.c1.c99[1].text) 
+2369          self.assertEqual("TEST1", path(root).text) 
+
2370   
+2371 -    def test_object_path_addattr(self): 
+
2372          root = self.XML(xml_str) 
+2373          path = objectify.ObjectPath( "root.c1.c2" ) 
+2374          self.assertEqual(3, len(root.c1.c2)) 
+2375          path.addattr(root, "test") 
+2376          self.assertEqual(4, len(root.c1.c2)) 
+2377          self.assertEqual(["0", "1", "2", "test"], 
+2378                            [el.text for el in root.c1.c2]) 
+
2379   
+2380 -    def test_object_path_addattr_element(self): 
+
2381          root = self.XML(xml_str) 
+2382          path = objectify.ObjectPath( "root.c1.c2" ) 
+2383          self.assertEqual(3, len(root.c1.c2)) 
+2384   
+2385          new_el = self.Element("{objectified}test") 
+2386          etree.SubElement(new_el, "{objectified}sub").a = "TEST" 
+2387   
+2388          path.addattr(root, new_el.sub) 
+2389          self.assertEqual(4, len(root.c1.c2)) 
+2390          self.assertEqual("TEST", root.c1.c2[3].a.text) 
+2391          self.assertEqual(["0", "1", "2"], 
+2392                            [el.text for el in root.c1.c2[:3]]) 
+
2393   
+2394 -    def test_object_path_addattr_create(self): 
+
2395          root = self.XML(xml_str) 
+2396          path = objectify.ObjectPath( "root.c1.c99" ) 
+2397          self.assertRaises(AttributeError, path.find, root) 
+2398   
+2399          new_value = "my new value" 
+2400          path.addattr(root, new_value) 
+2401   
+2402          self.assertEqual(1, len(root.c1.c99)) 
+2403          self.assertEqual(new_value, root.c1.c99.text) 
+2404          self.assertEqual(new_value, path(root).text) 
+
2405   
+2406 -    def test_object_path_addattr_create_element(self): 
+
2407          root = self.XML(xml_str) 
+2408          path = objectify.ObjectPath( "root.c1.c99" ) 
+2409          self.assertRaises(AttributeError, path.find, root) 
+2410   
+2411          new_el = self.Element("{objectified}test") 
+2412          etree.SubElement(new_el, "{objectified}sub", myattr="ATTR").a = "TEST" 
+2413   
+2414          path.addattr(root, new_el.sub) 
+2415          self.assertEqual(1, len(root.c1.c99)) 
+2416          self.assertEqual("TEST", root.c1.c99.a.text) 
+2417          self.assertEqual("TEST", path(root).a.text) 
+2418          self.assertEqual("ATTR", root.c1.c99.get("myattr")) 
+
2419   
+2420 -    def test_object_path_addattr_create_list(self): 
+
2421          root = self.XML(xml_str) 
+2422          path = objectify.ObjectPath( "root.c1.c99" ) 
+2423          self.assertRaises(AttributeError, path.find, root) 
+2424   
+2425          new_el = self.Element("{objectified}test") 
+2426          new_el.a = ["TEST1", "TEST2"] 
+2427   
+2428          self.assertEqual(2, len(new_el.a)) 
+2429   
+2430          path.addattr(root, list(new_el.a)) 
+2431          self.assertEqual(2, len(root.c1.c99)) 
+2432          self.assertEqual("TEST1", root.c1.c99.text) 
+2433          self.assertEqual("TEST2", path(root)[1].text) 
+
2434   
+2435 -    def test_descendant_paths(self): 
+
2436          root = self.XML(xml_str) 
+2437          self.assertEqual( 
+2438              ['{objectified}root', '{objectified}root.c1', 
+2439               '{objectified}root.c1.c2', 
+2440               '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]', 
+2441               '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'], 
+2442              root.descendantpaths()) 
+
2443   
+2444 -    def test_descendant_paths_child(self): 
+
2445          root = self.XML(xml_str) 
+2446          self.assertEqual( 
+2447              ['{objectified}c1', '{objectified}c1.c2', 
+2448               '{objectified}c1.c2[1]', '{objectified}c1.c2[2]', 
+2449               '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'], 
+2450              root.c1.descendantpaths()) 
+
2451   
+2452 -    def test_descendant_paths_prefix(self): 
+
2453          root = self.XML(xml_str) 
+2454          self.assertEqual( 
+2455              ['root.{objectified}c1', 'root.{objectified}c1.c2', 
+2456               'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]', 
+2457               'root.{objectified}c1.{otherNS}c2', 
+2458               'root.{objectified}c1.{}c2'], 
+2459              root.c1.descendantpaths('root')) 
+
2460   
+2461 -    def test_pickle(self): 
+
2462          import pickle 
+2463   
+2464          root = self.XML(xml_str) 
+2465          out = BytesIO() 
+2466          pickle.dump(root, out) 
+2467   
+2468          new_root = pickle.loads(out.getvalue()) 
+2469          self.assertEqual( 
+2470              etree.tostring(new_root), 
+2471              etree.tostring(root)) 
+
2472   
+2473 -    def test_pickle_elementtree(self): 
+
2474          import pickle 
+2475   
+2476          tree = etree.ElementTree(self.XML(xml_str + "<?my pi?>")) 
+2477          out = BytesIO() 
+2478          pickle.dump(tree, out) 
+2479   
+2480          new_tree = pickle.loads(out.getvalue()) 
+2481          self.assertTrue(isinstance(new_tree, etree._ElementTree)) 
+2482          self.assertEqual( 
+2483              etree.tostring(new_tree), 
+2484              etree.tostring(tree)) 
+
2485   
+2486 -    def test_pickle_intelement(self): 
+
2487          self._test_pickle('<x>42</x>') 
+2488          self._test_pickle(objectify.DataElement(42)) 
+
2489   
+2490 -    def test_pickle_floattelement(self): 
+
2491          self._test_pickle('<x>42.0</x>') 
+2492          self._test_pickle(objectify.DataElement(42.0)) 
+
2493   
+2494 -    def test_pickle_strelement(self): 
+
2495          self._test_pickle('<x>Pickle me!</x>') 
+2496          self._test_pickle(objectify.DataElement('Pickle me!')) 
+
2497   
+2498 -    def test_pickle_boolelement(self): 
+
2499          self._test_pickle('<x>true</x>') 
+2500          self._test_pickle('<x>false</x>') 
+2501          self._test_pickle(objectify.DataElement(True)) 
+2502          self._test_pickle(objectify.DataElement(False)) 
+
2503   
+2504 -    def test_pickle_noneelement(self): 
+
2505          self._test_pickle(''' 
+2506  <x xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>''') 
+2507          self._test_pickle(objectify.DataElement(None)) 
+
2508   
+2509 -    def _test_pickle(self, stringOrElt): 
+
2510          import pickle 
+2511          if isinstance(stringOrElt, (etree._Element, etree._ElementTree)): 
+2512              elt = stringOrElt 
+2513          else: 
+2514              elt = self.XML(stringOrElt) 
+2515          out = BytesIO() 
+2516          pickle.dump(elt, out) 
+2517   
+2518          new_elt = pickle.loads(out.getvalue()) 
+2519          self.assertEqual( 
+2520              etree.tostring(new_elt), 
+2521              etree.tostring(elt)) 
+
2522   
+2523      # E-Factory tests, need to use sub-elements as root element is always 
+2524      # type-looked-up as ObjectifiedElement (no annotations) 
+2525 -    def test_efactory_int(self): 
+
2526          E = objectify.E 
+2527          root = E.root(E.val(23)) 
+2528          self.assertTrue(isinstance(root.val, objectify.IntElement)) 
+
2529   
+2530 -    def test_efactory_float(self): 
+
2531          E = objectify.E 
+2532          root = E.root(E.val(233.23)) 
+2533          self.assertTrue(isinstance(root.val, objectify.FloatElement)) 
+
2534   
+2535 -    def test_efactory_str(self): 
+
2536          E = objectify.E 
+2537          root = E.root(E.val("what?")) 
+2538          self.assertTrue(isinstance(root.val, objectify.StringElement)) 
+
2539   
+2540 -    def test_efactory_unicode(self): 
+
2541          E = objectify.E 
+2542          root = E.root(E.val(_str("blöödy häll", encoding="ISO-8859-1"))) 
+2543          self.assertTrue(isinstance(root.val, objectify.StringElement)) 
+
2544   
+2545 -    def test_efactory_bool(self): 
+
2546          E = objectify.E 
+2547          root = E.root(E.val(True)) 
+2548          self.assertTrue(isinstance(root.val, objectify.BoolElement)) 
+
2549   
+2550 -    def test_efactory_none(self): 
+
2551          E = objectify.E 
+2552          root = E.root(E.val(None)) 
+2553          self.assertTrue(isinstance(root.val, objectify.NoneElement)) 
+
2554   
+2555 -    def test_efactory_value_concatenation(self): 
+
2556          E = objectify.E 
+2557          root = E.root(E.val(1, "foo", 2.0, "bar ", True, None)) 
+2558          self.assertTrue(isinstance(root.val, objectify.StringElement)) 
+
2559   
+2560 -    def test_efactory_attrib(self): 
+
2561          E = objectify.E 
+2562          root = E.root(foo="bar") 
+2563          self.assertEqual(root.get("foo"), "bar") 
+
2564   
+2565 -    def test_efactory_nested(self): 
+
2566          E = objectify.E 
+2567          DataElement = objectify.DataElement 
+2568          root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1), 
+2569                        DataElement(2.0)) 
+2570          self.assertTrue(isinstance(root, objectify.ObjectifiedElement)) 
+2571          self.assertEqual(root.text, "text") 
+2572          self.assertTrue(isinstance(root.sub, objectify.ObjectifiedElement)) 
+2573          self.assertEqual(root.sub.tail, "tail") 
+2574          self.assertTrue(isinstance(root.sub.subsub, objectify.StringElement)) 
+2575          self.assertEqual(len(root.value), 2) 
+2576          self.assertTrue(isinstance(root.value[0], objectify.IntElement)) 
+2577          self.assertTrue(isinstance(root.value[1], objectify.FloatElement)) 
+
2578   
+2579 -    def test_efactory_subtype(self): 
+
2580          class Attribute(objectify.ObjectifiedDataElement): 
+2581              def __init__(self): 
+2582                  objectify.ObjectifiedDataElement.__init__(self) 
+2583                  self.set("datatype", "TYPE") 
+2584                  self.set("range", "0.,1.") 
+
2585   
+2586          attr = Attribute() 
+2587          self.assertEqual(attr.text, None) 
+2588          self.assertEqual(attr.get("datatype"), "TYPE") 
+2589          self.assertEqual(attr.get("range"), "0.,1.") 
+2590   
+2591 -    def test_XML_base_url_docinfo(self): 
+
2592          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
+2593          docinfo = root.getroottree().docinfo 
+2594          self.assertEqual(docinfo.URL, "http://no/such/url") 
+
2595    
+2596 -    def test_XML_set_base_url_docinfo(self): 
+
2597          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
+2598          docinfo = root.getroottree().docinfo 
+2599          self.assertEqual(docinfo.URL, "http://no/such/url") 
+2600          docinfo.URL = "https://secret/url" 
+2601          self.assertEqual(docinfo.URL, "https://secret/url") 
+
2602    
+2603 -    def test_parse_stringio_base_url(self): 
+
2604          tree = objectify.parse(BytesIO("<root/>"), base_url="http://no/such/url") 
+2605          docinfo = tree.docinfo 
+2606          self.assertEqual(docinfo.URL, "http://no/such/url") 
+
2607    
+2608 -    def test_parse_base_url_docinfo(self): 
+
2609          tree = objectify.parse(fileInTestDir('include/test_xinclude.xml'), 
+2610                                 base_url="http://no/such/url") 
+2611          docinfo = tree.docinfo 
+2612          self.assertEqual(docinfo.URL, "http://no/such/url") 
+
2613   
+2614 -    def test_xml_base(self): 
+
2615          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
+2616          self.assertEqual(root.base, "http://no/such/url") 
+2617          self.assertEqual( 
+2618              root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 
+2619          root.base = "https://secret/url" 
+2620          self.assertEqual(root.base, "https://secret/url") 
+2621          self.assertEqual( 
+2622              root.get('{http://www.w3.org/XML/1998/namespace}base'), 
+2623              "https://secret/url") 
+
2624    
+2625 -    def test_xml_base_attribute(self): 
+
2626          root = objectify.XML(_bytes("<root/>"), base_url="http://no/such/url") 
+2627          self.assertEqual(root.base, "http://no/such/url") 
+2628          self.assertEqual( 
+2629              root.get('{http://www.w3.org/XML/1998/namespace}base'), None) 
+2630          root.set('{http://www.w3.org/XML/1998/namespace}base', 
+2631                   "https://secret/url") 
+2632          self.assertEqual(root.base, "https://secret/url") 
+2633          self.assertEqual( 
+2634              root.get('{http://www.w3.org/XML/1998/namespace}base'), 
+2635              "https://secret/url") 
+
2636   
+2637 -    def test_standard_lookup(self): 
+
2638          XML = self.XML 
+2639   
+2640          xml = _bytes('''\ 
+2641          <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
+2642            <i>5</i> 
+2643            <i>-5</i> 
+2644            <l>4294967296</l> 
+2645            <l>-4294967296</l> 
+2646            <f>1.1</f> 
+2647            <b>true</b> 
+2648            <b>false</b> 
+2649            <s>Strange things happen, where strings collide</s> 
+2650            <s>True</s> 
+2651            <s>False</s> 
+2652            <s>t</s> 
+2653            <s>f</s> 
+2654            <s></s> 
+2655            <s>None</s> 
+2656            <n xsi:nil="true" /> 
+2657          </root> 
+2658          ''') 
+2659          root = XML(xml) 
+2660   
+2661          for i in root.i: 
+2662              self.assertTrue(isinstance(i, objectify.IntElement)) 
+2663          for l in root.l: 
+2664              self.assertTrue(isinstance(l, objectify.IntElement)) 
+2665          for f in root.f: 
+2666              self.assertTrue(isinstance(f, objectify.FloatElement))   
+2667          for b in root.b: 
+2668              self.assertTrue(isinstance(b, objectify.BoolElement)) 
+2669          self.assertEqual(True,  root.b[0]) 
+2670          self.assertEqual(False, root.b[1]) 
+2671          for s in root.s: 
+2672              self.assertTrue(isinstance(s, objectify.StringElement)) 
+2673          self.assertTrue(isinstance(root.n, objectify.NoneElement)) 
+2674          self.assertEqual(None, root.n) 
+
2675   
+2676 -def test_suite(): 
+
2677      suite = unittest.TestSuite() 
+2678      suite.addTests([unittest.makeSuite(ObjectifyTestCase)]) 
+2679      suite.addTests(doctest.DocTestSuite(objectify)) 
+2680      suite.addTests([make_doctest('../../../doc/objectify.txt')]) 
+2681      return suite 
+
2682   
+2683  if __name__ == '__main__': 
+2684      print('to test use test.py %s' % __file__) 
+2685   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ObjectifyTestCase
+
lxml.etree
lxml.etree
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+'''<obj:root xmlns:obj="objectified" xmlns:other="otherNS">
+  <obj:c1 a1="A1" a2="A2" other:a3="A3">
+    <obj:c2>0</obj:c2>
+    <obj:c2>1</obj:c2>
+    <obj:c2>2</obj:c2>
+    <other:c2>3</other:c2>
+    <c2>3</c2>
+  </obj:c1>
+...
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Tests specific to the Python based class lookup. 
+  5  """ 
+  6   
+  7   
+  8  import unittest, os.path, sys 
+  9   
+ 10  this_dir = os.path.dirname(__file__) 
+ 11  if this_dir not in sys.path: 
+ 12      sys.path.insert(0, this_dir) # needed for Py3 
+ 13   
+ 14  from common_imports import etree, StringIO, HelperTestCase, fileInTestDir 
+ 15  from common_imports import SillyFileLike, canonicalize, doctest, _bytes 
+ 16   
+ 17  from lxml.etree import PythonElementClassLookup 
+ 18   
+ 19  xml_str = _bytes('''\ 
+ 20  <obj:root xmlns:obj="objectified" xmlns:other="otherNS"> 
+ 21    <obj:c1 a1="A1" a2="A2" other:a3="A3"> 
+ 22      <obj:c2>0</obj:c2> 
+ 23      <obj:c2>1</obj:c2> 
+ 24      <obj:c2>2</obj:c2> 
+ 25      <other:c2>3</other:c2> 
+ 26      <c2>3</c2> 
+ 27    </obj:c1> 
+ 28  </obj:root>''') 
+ 29   
+ 30   
+ 31 -class PyClassLookupTestCase(HelperTestCase): 
+
 32      """Test cases for the lxml.pyclasslookup class lookup mechanism. 
+ 33      """ 
+ 34      etree = etree 
+ 35      parser = etree.XMLParser() 
+ 36      Element = parser.makeelement 
+ 37   
+ 38 -    def tearDown(self): 
+
 39          self.parser.set_element_class_lookup(None) 
+ 40          super(PyClassLookupTestCase, self).tearDown() 
+
 41   
+ 42 -    def _setClassLookup(self, lookup_function): 
+
 43          class Lookup(PythonElementClassLookup): 
+ 44              def lookup(self, *args): 
+ 45                  return lookup_function(*args) 
+
 46          self.parser.set_element_class_lookup( Lookup() ) 
+ 47   
+ 48 -    def _buildElementClass(self): 
+
 49          class LocalElement(etree.ElementBase): 
+ 50              pass 
+
 51          return LocalElement 
+ 52   
+ 53 -    def XML(self, xml): 
+
 54          return self.etree.XML(xml, self.parser) 
+
 55   
+ 56      # --- Test cases 
+ 57   
+ 58 -    def test_lookup(self): 
+
 59          el_class = self._buildElementClass() 
+ 60          el_class.i = 1 
+ 61          def lookup(*args): 
+ 62              if el_class.i == 1: 
+ 63                  el_class.i = 2 
+ 64              return el_class 
+
 65          self._setClassLookup(lookup) 
+ 66          root = self.XML(xml_str) 
+ 67          self.assertEqual(2, el_class.i) 
+ 68   
+ 69 -    def test_lookup_keep_ref_assertion(self): 
+
 70          el_class = self._buildElementClass() 
+ 71          el_class.EL = None 
+ 72          def lookup(doc, el): 
+ 73              if el_class.EL is None: 
+ 74                  el_class.EL = el 
+ 75              return el_class 
+
 76          self._setClassLookup(lookup) 
+ 77          root = self.XML(xml_str) 
+ 78          self.assertNotEqual(None, el_class.EL) 
+ 79          self.assertRaises(ReferenceError, el_class.EL.getchildren) 
+ 80   
+ 81 -    def test_lookup_tag(self): 
+
 82          el_class = self._buildElementClass() 
+ 83          el_class.TAG = None 
+ 84          def lookup(doc, el): 
+ 85              if el_class.TAG is None: 
+ 86                  el_class.TAG = el.tag 
+ 87              return el_class 
+
 88          self._setClassLookup(lookup) 
+ 89          root = self.XML(xml_str) 
+ 90          self.assertNotEqual(None, root.TAG) 
+ 91          self.assertEqual(root.tag, root.TAG) 
+ 92   
+ 93 -    def test_lookup_text(self): 
+
 94          el_class = self._buildElementClass() 
+ 95          el_class.TEXT = None 
+ 96          def lookup(doc, el): 
+ 97              if el_class.TEXT is None: 
+ 98                  el_class.TEXT = el.text 
+ 99              return el_class 
+
100          self._setClassLookup(lookup) 
+101          root = self.XML(xml_str) 
+102          self.assertNotEqual(None, root.TEXT) 
+103          self.assertEqual(root.text, root.TEXT) 
+104   
+105 -    def test_lookup_tail(self): 
+
106          el_class = self._buildElementClass() 
+107          el_class.TAIL = None 
+108          def lookup(doc, el): 
+109              if el_class.TAIL is None: 
+110                  el_class.TAIL = el.tail 
+111              return el_class 
+
112          self._setClassLookup(lookup) 
+113          root = self.XML(xml_str) 
+114          self.assertEqual(root.tail, root.TAIL) 
+115   
+116 -    def test_lookup_attrib(self): 
+
117          el_class = self._buildElementClass() 
+118          el_class.ATTRIB = None 
+119          def lookup(doc, el): 
+120              if el_class.ATTRIB is None: 
+121                  el_class.ATTRIB = el[0].attrib 
+122              return el_class 
+
123          self._setClassLookup(lookup) 
+124          root = self.XML(xml_str) 
+125          items1 = list(root[0].attrib.items()) 
+126          items1.sort() 
+127          items2 = list(root.ATTRIB.items()) 
+128          items2.sort() 
+129          self.assertEqual(items1, items2) 
+130   
+131 -    def test_lookup_prefix(self): 
+
132          el_class = self._buildElementClass() 
+133          el_class.PREFIX = None 
+134          def lookup(doc, el): 
+135              if el_class.PREFIX is None: 
+136                  el_class.PREFIX = el.prefix 
+137              return el_class 
+
138          self._setClassLookup(lookup) 
+139          root = self.XML(xml_str) 
+140          self.assertEqual(root.prefix, root.PREFIX) 
+141   
+142 -    def test_lookup_sourceline(self): 
+
143          el_class = self._buildElementClass() 
+144          el_class.LINE = None 
+145          def lookup(doc, el): 
+146              if el_class.LINE is None: 
+147                  el_class.LINE = el.sourceline 
+148              return el_class 
+
149          self._setClassLookup(lookup) 
+150          root = self.XML(xml_str) 
+151          self.assertEqual(root.sourceline, root.LINE) 
+152   
+153 -    def test_lookup_getitem(self): 
+
154          el_class = self._buildElementClass() 
+155          el_class.CHILD_TAG = None 
+156          def lookup(doc, el): 
+157              el_class.CHILD_TAG = el[0].tag 
+158              return el_class 
+
159          self._setClassLookup(lookup) 
+160          root = self.XML(xml_str) 
+161          child_tag = root.CHILD_TAG 
+162          self.assertNotEqual(None, child_tag) 
+163          self.assertEqual(root[0].tag, child_tag) 
+164   
+165 -    def test_lookup_getitem_neg(self): 
+
166          el_class = self._buildElementClass() 
+167          el_class.CHILD_TAG = None 
+168          def lookup(doc, el): 
+169              if el_class.CHILD_TAG is None: 
+170                  el_class.CHILD_TAG = el[-1].tag 
+171              return el_class 
+
172          self._setClassLookup(lookup) 
+173          root = self.XML(xml_str) 
+174          child_tag = root.CHILD_TAG 
+175          self.assertNotEqual(None, child_tag) 
+176          self.assertEqual(root[-1].tag, child_tag) 
+177   
+178 -    def test_lookup_getslice(self): 
+
179          el_class = self._buildElementClass() 
+180          el_class.CHILD_TAGS = None 
+181          def lookup(doc, el): 
+182              if el_class.CHILD_TAGS is None: 
+183                  el_class.CHILD_TAGS = [ c.tag for c in el[1:-1] ] 
+184              return el_class 
+
185          self._setClassLookup(lookup) 
+186          root = self.XML(xml_str) 
+187          child_tags = root.CHILD_TAGS 
+188          self.assertNotEqual(None, child_tags) 
+189          self.assertEqual([ c.tag for c in root[1:-1] ], 
+190                            child_tags) 
+191   
+192 -    def test_lookup_len(self): 
+
193          el_class = self._buildElementClass() 
+194          el_class.LEN = None 
+195          def lookup(doc, el): 
+196              if el_class.LEN is None: 
+197                  el_class.LEN = len(el) 
+198              return el_class 
+
199          self._setClassLookup(lookup) 
+200          root = self.XML(xml_str) 
+201          self.assertEqual(1, el_class.LEN) 
+202   
+203 -    def test_lookup_bool(self): 
+
204          el_class = self._buildElementClass() 
+205          el_class.TRUE = None 
+206          def lookup(doc, el): 
+207              if el_class.TRUE is None: 
+208                  el_class.TRUE = bool(el) 
+209              return el_class 
+
210          self._setClassLookup(lookup) 
+211          root = self.XML(xml_str) 
+212          self.assertTrue(el_class.TRUE) 
+213   
+214 -    def test_lookup_get(self): 
+
215          el_class = self._buildElementClass() 
+216          el_class.VAL = None 
+217          def lookup(doc, el): 
+218              if el_class.VAL is None: 
+219                  el_class.VAL = el[0].get('a1') 
+220              return el_class 
+
221          self._setClassLookup(lookup) 
+222          root = self.XML(xml_str) 
+223          self.assertNotEqual(None, el_class.VAL) 
+224          self.assertEqual(root[0].get('a1'), el_class.VAL) 
+225   
+226 -    def test_lookup_get_default(self): 
+
227          el_class = self._buildElementClass() 
+228          default = str(id(el_class)) 
+229          el_class.VAL = None 
+230          def lookup(doc, el): 
+231              if el_class.VAL is None: 
+232                  el_class.VAL = el[0].get('unknownattribute', default) 
+233              return el_class 
+
234          self._setClassLookup(lookup) 
+235          root = self.XML(xml_str) 
+236          self.assertEqual(default, el_class.VAL) 
+237   
+238 -    def test_lookup_getchildren(self): 
+
239          el_class = self._buildElementClass() 
+240          el_class.CHILD_TAGS = None 
+241          def lookup(doc, el): 
+242              if el_class.CHILD_TAGS is None: 
+243                  el_class.CHILD_TAGS = [ c.tag for c in el.getchildren() ] 
+244              return el_class 
+
245          self._setClassLookup(lookup) 
+246          root = self.XML(xml_str) 
+247          child_tags = root.CHILD_TAGS 
+248          self.assertNotEqual(None, child_tags) 
+249          self.assertEqual([ c.tag for c in root.getchildren() ], 
+250                            child_tags) 
+251   
+252 -    def test_lookup_iter_children(self): 
+
253          el_class = self._buildElementClass() 
+254          el_class.CHILD_TAGS = None 
+255          def lookup(doc, el): 
+256              if el_class.CHILD_TAGS is None: 
+257                  el_class.CHILD_TAGS = [ c.tag for c in el ] 
+258              return el_class 
+
259          self._setClassLookup(lookup) 
+260          root = self.XML(xml_str) 
+261          child_tags = root.CHILD_TAGS 
+262          self.assertNotEqual(None, child_tags) 
+263          self.assertEqual([ c.tag for c in root.getchildren() ], 
+264                            child_tags) 
+265   
+266 -    def test_lookup_iterchildren(self): 
+
267          el_class = self._buildElementClass() 
+268          el_class.CHILD_TAGS = None 
+269          def lookup(doc, el): 
+270              if el_class.CHILD_TAGS is None: 
+271                  el_class.CHILD_TAGS = [ c.tag for c in el.iterchildren() ] 
+272              return el_class 
+
273          self._setClassLookup(lookup) 
+274          root = self.XML(xml_str) 
+275          child_tags = root.CHILD_TAGS 
+276          self.assertNotEqual(None, child_tags) 
+277          self.assertEqual([ c.tag for c in root.getchildren() ], 
+278                            child_tags) 
+279   
+280 -    def test_lookup_iterchildren_tag(self): 
+
281          el_class = self._buildElementClass() 
+282          el_class.CHILD_TAGS = None 
+283          def lookup(doc, el): 
+284              if not el_class.CHILD_TAGS: 
+285                  el_class.CHILD_TAGS = [ 
+286                      c.tag for c in el.iterchildren(tag='{objectified}c2') ] 
+287              return el_class 
+
288          self._setClassLookup(lookup) 
+289   
+290          root = self.XML(xml_str) 
+291          child_tags = root.CHILD_TAGS 
+292          self.assertNotEqual(None, child_tags) 
+293          self.assertEqual([], child_tags) 
+294   
+295          c1 = root[0] 
+296          child_tags = root.CHILD_TAGS 
+297          self.assertNotEqual(None, child_tags) 
+298          self.assertNotEqual([], child_tags) 
+299          self.assertEqual( 
+300              [ c.tag for c in root[0].iterchildren(tag='{objectified}c2') ], 
+301              child_tags) 
+302   
+303 -    def test_lookup_getparent(self): 
+
304          el_class = self._buildElementClass() 
+305          el_class.PARENT = None 
+306          def lookup(doc, el): 
+307              if el_class.PARENT is None: 
+308                  el_class.PARENT = el[0].getparent().tag 
+309              return el_class 
+
310          self._setClassLookup(lookup) 
+311          root = self.XML(xml_str) 
+312          self.assertEqual(root.tag, root.PARENT) 
+313   
+314 -    def test_lookup_getnext(self): 
+
315          el_class = self._buildElementClass() 
+316          el_class.NEXT = None 
+317          def lookup(doc, el): 
+318              if el_class.NEXT is None: 
+319                  el_class.NEXT = el[0][1].getnext().tag 
+320              return el_class 
+
321          self._setClassLookup(lookup) 
+322          root = self.XML(xml_str) 
+323          self.assertNotEqual(None, el_class.NEXT) 
+324          self.assertEqual(root[0][1].getnext().tag, el_class.NEXT) 
+325   
+326 -    def test_lookup_getprevious(self): 
+
327          el_class = self._buildElementClass() 
+328          el_class.PREV = None 
+329          def lookup(doc, el): 
+330              if el_class.PREV is None: 
+331                  el_class.PREV = el[0][1].getprevious().tag 
+332              return el_class 
+
333          self._setClassLookup(lookup) 
+334          root = self.XML(xml_str) 
+335          self.assertNotEqual(None, el_class.PREV) 
+336          self.assertEqual(root[0][1].getprevious().tag, el_class.PREV) 
+337   
+338 -    def test_comments_fallback(self): 
+
339          def return_none(*args): 
+340              return None 
+
341   
+342          self._setClassLookup(return_none) 
+343          el = self.XML('<a><!-- hello world --></a>') 
+344          self.assertEqual(el[0].tag, self.etree.Comment) 
+345          self.assertEqual(el[0].text, " hello world ") 
+346   
+347   
+348 -def test_suite(): 
+
349      suite = unittest.TestSuite() 
+350      suite.addTests([unittest.makeSuite(PyClassLookupTestCase)]) 
+351      return suite 
+
352   
+353  if __name__ == '__main__': 
+354      print('to test use test.py %s' % __file__) 
+355   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               PyClassLookupTestCase
+
lxml.etree
lxml.etree
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Test cases related to RelaxNG parsing and validation 
+  5  """ 
+  6   
+  7  import unittest, sys, os.path 
+  8   
+  9  this_dir = os.path.dirname(__file__) 
+ 10  if this_dir not in sys.path: 
+ 11      sys.path.insert(0, this_dir) # needed for Py3 
+ 12   
+ 13  from common_imports import etree, BytesIO, _bytes, HelperTestCase, fileInTestDir 
+ 14  from common_imports import doctest, make_doctest, skipif 
+ 15   
+ 16  try: 
+ 17      import rnc2rng 
+ 18  except ImportError: 
+ 19      rnc2rng = None 
+ 20   
+ 21   
+ 22 -class ETreeRelaxNGTestCase(HelperTestCase): 
+
 23 -    def test_relaxng(self): 
+
 24          tree_valid = self.parse('<a><b></b></a>') 
+ 25          tree_invalid = self.parse('<a><c></c></a>') 
+ 26          schema = self.parse('''\ 
+ 27  <element name="a" xmlns="http://relaxng.org/ns/structure/1.0"> 
+ 28    <zeroOrMore> 
+ 29       <element name="b"> 
+ 30         <text /> 
+ 31       </element> 
+ 32    </zeroOrMore> 
+ 33  </element> 
+ 34  ''') 
+ 35          schema = etree.RelaxNG(schema) 
+ 36          self.assertTrue(schema.validate(tree_valid)) 
+ 37          self.assertFalse(schema.error_log.filter_from_errors()) 
+ 38   
+ 39          self.assertFalse(schema.validate(tree_invalid)) 
+ 40          self.assertTrue(schema.error_log.filter_from_errors()) 
+ 41   
+ 42          self.assertTrue(schema.validate(tree_valid))             # repeat valid 
+ 43          self.assertFalse(schema.error_log.filter_from_errors())  # repeat valid 
+
 44   
+ 45 -    def test_relaxng_stringio(self): 
+
 46          tree_valid = self.parse('<a><b></b></a>') 
+ 47          tree_invalid = self.parse('<a><c></c></a>') 
+ 48          schema_file = BytesIO('''\ 
+ 49  <element name="a" xmlns="http://relaxng.org/ns/structure/1.0"> 
+ 50    <zeroOrMore> 
+ 51       <element name="b"> 
+ 52         <text /> 
+ 53       </element> 
+ 54    </zeroOrMore> 
+ 55  </element> 
+ 56  ''') 
+ 57          schema = etree.RelaxNG(file=schema_file) 
+ 58          self.assertTrue(schema.validate(tree_valid)) 
+ 59          self.assertFalse(schema.validate(tree_invalid)) 
+
 60   
+ 61 -    def test_relaxng_elementtree_error(self): 
+
 62          self.assertRaises(ValueError, etree.RelaxNG, etree.ElementTree()) 
+
 63   
+ 64 -    def test_relaxng_error(self): 
+
 65          tree_invalid = self.parse('<a><c></c></a>') 
+ 66          schema = self.parse('''\ 
+ 67  <element name="a" xmlns="http://relaxng.org/ns/structure/1.0"> 
+ 68    <zeroOrMore> 
+ 69       <element name="b"> 
+ 70         <text /> 
+ 71       </element> 
+ 72    </zeroOrMore> 
+ 73  </element> 
+ 74  ''') 
+ 75          schema = etree.RelaxNG(schema) 
+ 76          self.assertFalse(schema.validate(tree_invalid)) 
+ 77          errors = schema.error_log 
+ 78          self.assertTrue([log for log in errors 
+ 79                           if log.level_name == "ERROR"]) 
+ 80          self.assertTrue([log for log in errors 
+ 81                           if "not expect" in log.message]) 
+
 82   
+ 83 -    def test_relaxng_generic_error(self): 
+
 84          tree_invalid = self.parse('''\ 
+ 85          <test> 
+ 86            <reference id="my-ref">This is my unique ref.</reference> 
+ 87            <data ref="my-ref">Valid data</data> 
+ 88            <data ref="myref">Invalid data</data> 
+ 89          </test> 
+ 90          ''') 
+ 91          schema = self.parse('''\ 
+ 92          <grammar datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes" 
+ 93                   xmlns="http://relaxng.org/ns/structure/1.0"> 
+ 94            <define name="by-ref"> 
+ 95              <data type="IDREF"/> 
+ 96            </define> 
+ 97            <start> 
+ 98              <element name="test"> 
+ 99                <zeroOrMore> 
+100                  <element name="reference"> 
+101                    <attribute name="id"> 
+102                      <data type="ID"/> 
+103                    </attribute> 
+104                    <text/> 
+105                  </element> 
+106                </zeroOrMore> 
+107                <zeroOrMore> 
+108                  <element name="data"> 
+109                    <attribute name="ref"> 
+110                      <data type="IDREF"/> 
+111                    </attribute> 
+112                    <text/> 
+113                  </element> 
+114                </zeroOrMore> 
+115              </element> 
+116            </start> 
+117          </grammar> 
+118          ''') 
+119   
+120          schema = etree.RelaxNG(schema) 
+121          self.assertFalse(schema.validate(tree_invalid)) 
+122          errors = schema.error_log 
+123          self.assertTrue(errors) 
+124          self.assertTrue([log for log in errors if "IDREF" in log.message]) 
+125          self.assertTrue([log for log in errors if "myref" in log.message]) 
+
126   
+127 -    def test_relaxng_invalid_schema(self): 
+
128          schema = self.parse('''\ 
+129  <element name="a" xmlns="http://relaxng.org/ns/structure/1.0"> 
+130    <zeroOrMore> 
+131       <element name="b" /> 
+132    </zeroOrMore> 
+133  </element> 
+134  ''') 
+135          self.assertRaises(etree.RelaxNGParseError, 
+136                            etree.RelaxNG, schema) 
+
137   
+138 -    def test_relaxng_invalid_schema2(self): 
+
139          schema = self.parse('''\ 
+140  <grammar xmlns="http://relaxng.org/ns/structure/1.0" /> 
+141  ''') 
+142          self.assertRaises(etree.RelaxNGParseError, 
+143                            etree.RelaxNG, schema) 
+
144   
+145 -    def test_relaxng_invalid_schema3(self): 
+
146          schema = self.parse('''\ 
+147  <grammar xmlns="http://relaxng.org/ns/structure/1.0"> 
+148    <define name="test"> 
+149      <element name="test"/> 
+150    </define> 
+151  </grammar> 
+152  ''') 
+153          self.assertRaises(etree.RelaxNGParseError, 
+154                            etree.RelaxNG, schema) 
+
155   
+156 -    def test_relaxng_invalid_schema4(self): 
+
157          # segfault 
+158          schema = self.parse('''\ 
+159  <element name="a" xmlns="mynamespace" /> 
+160  ''') 
+161          self.assertRaises(etree.RelaxNGParseError, 
+162                            etree.RelaxNG, schema) 
+
163   
+164 -    def test_relaxng_include(self): 
+
165          # this will only work if we access the file through path or 
+166          # file object.. 
+167          f = open(fileInTestDir('test1.rng'), 'rb') 
+168          try: 
+169              schema = etree.RelaxNG(file=f) 
+170          finally: 
+171              f.close() 
+
172   
+173 -    def test_relaxng_shortcut(self): 
+
174          tree_valid = self.parse('<a><b></b></a>') 
+175          tree_invalid = self.parse('<a><c></c></a>') 
+176          schema = self.parse('''\ 
+177  <element name="a" xmlns="http://relaxng.org/ns/structure/1.0"> 
+178    <zeroOrMore> 
+179       <element name="b"> 
+180         <text /> 
+181       </element> 
+182    </zeroOrMore> 
+183  </element> 
+184  ''') 
+185          self.assertTrue(tree_valid.relaxng(schema)) 
+186          self.assertFalse(tree_invalid.relaxng(schema)) 
+
187   
+188 -    def test_multiple_elementrees(self): 
+
189          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+190          schema = etree.RelaxNG( self.parse('''\ 
+191  <element name="a" xmlns="http://relaxng.org/ns/structure/1.0"> 
+192    <element name="b"> 
+193      <text /> 
+194    </element> 
+195    <element name="c"> 
+196      <text /> 
+197    </element> 
+198  </element> 
+199  ''') ) 
+200          self.assertTrue(schema.validate(tree)) 
+201          self.assertFalse(schema.error_log.filter_from_errors()) 
+202   
+203          self.assertTrue(schema.validate(tree))                   # repeat valid 
+204          self.assertFalse(schema.error_log.filter_from_errors())  # repeat valid 
+205   
+206          schema = etree.RelaxNG( self.parse('''\ 
+207  <element name="b" xmlns="http://relaxng.org/ns/structure/1.0"> 
+208    <text /> 
+209  </element> 
+210  ''') ) 
+211          c_tree = etree.ElementTree(tree.getroot()[1]) 
+212          self.assertEqual(self._rootstring(c_tree), _bytes('<c>C</c>')) 
+213          self.assertFalse(schema.validate(c_tree)) 
+214          self.assertTrue(schema.error_log.filter_from_errors()) 
+215   
+216          b_tree = etree.ElementTree(tree.getroot()[0]) 
+217          self.assertEqual(self._rootstring(b_tree), _bytes('<b>B</b>')) 
+218          self.assertTrue(schema.validate(b_tree)) 
+219          self.assertFalse(schema.error_log.filter_from_errors()) 
+
220   
+221   
+222 -class RelaxNGCompactTestCase(HelperTestCase): 
+
223   
+224      pytestmark = skipif('rnc2rng is None') 
+225   
+226 -    def test_relaxng_compact(self): 
+
227          tree_valid = self.parse('<a><b>B</b><c>C</c></a>') 
+228          tree_invalid = self.parse('<a><b></b></a>') 
+229          schema = etree.RelaxNG(file=fileInTestDir('test.rnc')) 
+230          self.assertTrue(schema.validate(tree_valid)) 
+231          self.assertFalse(schema.validate(tree_invalid)) 
+
232   
+233 -    def test_relaxng_compact_file_obj(self): 
+
234          with open(fileInTestDir('test.rnc'), 'r') as f: 
+235              schema = etree.RelaxNG(file=f) 
+236   
+237          tree_valid = self.parse('<a><b>B</b><c>C</c></a>') 
+238          tree_invalid = self.parse('<a><b></b></a>') 
+239          self.assertTrue(schema.validate(tree_valid)) 
+240          self.assertFalse(schema.validate(tree_invalid)) 
+
241   
+242 -    def test_relaxng_compact_str(self): 
+
243          tree_valid = self.parse('<a><b>B</b></a>') 
+244          tree_invalid = self.parse('<a><b>X</b></a>') 
+245          rnc_str = 'element a { element b { "B" } }' 
+246          schema = etree.RelaxNG.from_rnc_string(rnc_str) 
+247          self.assertTrue(schema.validate(tree_valid)) 
+248          self.assertFalse(schema.validate(tree_invalid)) 
+
249   
+250   
+251 -def test_suite(): 
+
252      suite = unittest.TestSuite() 
+253      suite.addTests([unittest.makeSuite(ETreeRelaxNGTestCase)]) 
+254      suite.addTests( 
+255          [make_doctest('../../../doc/validation.txt')]) 
+256      if rnc2rng is not None: 
+257          suite.addTests([unittest.makeSuite(RelaxNGCompactTestCase)]) 
+258      return suite 
+
259   
+260  if __name__ == '__main__': 
+261      print('to test use test.py %s' % __file__) 
+262   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeRelaxNGTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               RelaxNGCompactTestCase
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Test cases related to SAX I/O 
+  5  """ 
+  6   
+  7  import unittest, sys, os.path 
+  8   
+  9  this_dir = os.path.dirname(__file__) 
+ 10  if this_dir not in sys.path: 
+ 11      sys.path.insert(0, this_dir) # needed for Py3 
+ 12   
+ 13  from common_imports import HelperTestCase, make_doctest, BytesIO, _bytes 
+ 14  from lxml import sax 
+ 15  from xml.dom import pulldom 
+ 16  from xml.sax.handler import ContentHandler 
+ 17   
+ 18   
+ 19 -class ETreeSaxTestCase(HelperTestCase): 
+
 20   
+ 21 -    def test_etree_sax_simple(self): 
+
 22          tree = self.parse('<a>ab<b/>ba</a>') 
+ 23          xml_out = self._saxify_serialize(tree) 
+ 24          self.assertEqual(_bytes('<a>ab<b/>ba</a>'), 
+ 25                            xml_out) 
+
 26   
+ 27 -    def test_etree_sax_double(self): 
+
 28          tree = self.parse('<a>ab<b>bb</b>ba</a>') 
+ 29          xml_out = self._saxify_serialize(tree) 
+ 30          self.assertEqual(_bytes('<a>ab<b>bb</b>ba</a>'), 
+ 31                            xml_out) 
+
 32   
+ 33 -    def test_etree_sax_comment(self): 
+
 34          tree = self.parse('<a>ab<!-- TEST -->ba</a>') 
+ 35          xml_out = self._saxify_serialize(tree) 
+ 36          self.assertEqual(_bytes('<a>abba</a>'), 
+ 37                            xml_out) 
+
 38   
+ 39 -    def test_etree_sax_pi(self): 
+
 40          tree = self.parse('<a>ab<?this and that?>ba</a>') 
+ 41          xml_out = self._saxify_serialize(tree) 
+ 42          self.assertEqual(_bytes('<a>ab<?this and that?>ba</a>'), 
+ 43                            xml_out) 
+
 44   
+ 45 -    def test_etree_sax_comment_root(self): 
+
 46          tree = self.parse('<!-- TEST --><a>ab</a>') 
+ 47          xml_out = self._saxify_serialize(tree) 
+ 48          self.assertEqual(_bytes('<a>ab</a>'), 
+ 49                            xml_out) 
+
 50   
+ 51 -    def test_etree_sax_pi_root(self): 
+
 52          tree = self.parse('<?this and that?><a>ab</a>') 
+ 53          xml_out = self._saxify_serialize(tree) 
+ 54          self.assertEqual(_bytes('<?this and that?><a>ab</a>'), 
+ 55                            xml_out) 
+
 56   
+ 57 -    def test_etree_sax_attributes(self): 
+
 58          tree = self.parse('<a aa="5">ab<b b="5"/>ba</a>') 
+ 59          xml_out = self._saxify_serialize(tree) 
+ 60          self.assertEqual(_bytes('<a aa="5">ab<b b="5"/>ba</a>'), 
+ 61                            xml_out) 
+
 62   
+ 63 -    def test_etree_sax_ns1(self): 
+
 64          tree = self.parse('<a xmlns="bla">ab<b>bb</b>ba</a>') 
+ 65          new_tree = self._saxify_unsaxify(tree) 
+ 66          root = new_tree.getroot() 
+ 67          self.assertEqual('{bla}a', 
+ 68                           root.tag) 
+ 69          self.assertEqual('{bla}b', 
+ 70                           root[0].tag) 
+
 71   
+ 72 -    def test_etree_sax_ns2(self): 
+
 73          tree = self.parse('<a xmlns="blaA">ab<b:b xmlns:b="blaB">bb</b:b>ba</a>') 
+ 74          new_tree = self._saxify_unsaxify(tree) 
+ 75          root = new_tree.getroot() 
+ 76          self.assertEqual('{blaA}a', 
+ 77                           root.tag) 
+ 78          self.assertEqual('{blaB}b', 
+ 79                           root[0].tag) 
+
 80   
+ 81 -    def test_sax_to_pulldom(self): 
+
 82          tree = self.parse('<a xmlns="blaA">ab<b:b xmlns:b="blaB">bb</b:b>ba</a>') 
+ 83          handler = pulldom.SAX2DOM() 
+ 84          sax.saxify(tree, handler) 
+ 85          dom = handler.document 
+ 86   
+ 87          self.assertEqual('a', 
+ 88                           dom.firstChild.localName) 
+ 89          self.assertEqual('blaA', 
+ 90                           dom.firstChild.namespaceURI) 
+ 91          self.assertEqual(None, 
+ 92                           dom.firstChild.prefix) 
+ 93   
+ 94          children = dom.firstChild.childNodes 
+ 95          self.assertEqual('ab', 
+ 96                           children[0].nodeValue) 
+ 97          self.assertEqual('blaB', 
+ 98                           children[1].namespaceURI) 
+ 99          self.assertEqual('ba', 
+100                           children[2].nodeValue) 
+
101   
+102 -    def test_sax_to_pulldom_multiple_namespaces(self): 
+
103          tree = self.parse('<a xmlns="blaA" xmlns:a="blaA"></a>') 
+104          handler = pulldom.SAX2DOM() 
+105          sax.saxify(tree, handler) 
+106          dom = handler.document 
+107   
+108          # With multiple prefix definitions, the node should keep the one 
+109          # that was actually used, even if the others also are valid. 
+110          self.assertEqual('a', 
+111                           dom.firstChild.localName) 
+112          self.assertEqual('blaA', 
+113                           dom.firstChild.namespaceURI) 
+114          self.assertEqual(None, 
+115                           dom.firstChild.prefix) 
+116   
+117          tree = self.parse('<a:a xmlns="blaA" xmlns:a="blaA"></a:a>') 
+118          handler = pulldom.SAX2DOM() 
+119          sax.saxify(tree, handler) 
+120          dom = handler.document 
+121   
+122          self.assertEqual('a', 
+123                           dom.firstChild.localName) 
+124          self.assertEqual('blaA', 
+125                           dom.firstChild.namespaceURI) 
+126          self.assertEqual('a', 
+127                           dom.firstChild.prefix) 
+
128   
+129 -    def test_element_sax(self): 
+
130          tree = self.parse('<a><b/></a>') 
+131          a = tree.getroot() 
+132          b = a[0] 
+133   
+134          xml_out = self._saxify_serialize(a) 
+135          self.assertEqual(_bytes('<a><b/></a>'), 
+136                            xml_out) 
+137   
+138          xml_out = self._saxify_serialize(b) 
+139          self.assertEqual(_bytes('<b/>'), 
+140                            xml_out) 
+
141   
+142 -    def test_element_sax_ns(self): 
+
143          tree = self.parse('<a:a xmlns:a="blaA"><b/></a:a>') 
+144          a = tree.getroot() 
+145          b = a[0] 
+146   
+147          new_tree = self._saxify_unsaxify(a) 
+148          root = new_tree.getroot() 
+149          self.assertEqual('{blaA}a', 
+150                           root.tag) 
+151          self.assertEqual('b', 
+152                           root[0].tag) 
+153   
+154          new_tree = self._saxify_unsaxify(b) 
+155          root = new_tree.getroot() 
+156          self.assertEqual('b', 
+157                           root.tag) 
+158          self.assertEqual(0, 
+159                           len(root)) 
+
160   
+161 -    def test_etree_sax_handler_default_ns(self): 
+
162          handler = sax.ElementTreeContentHandler() 
+163          handler.startDocument() 
+164          handler.startPrefixMapping(None, 'blaA') 
+165          handler.startElementNS(('blaA', 'a'), 'a', {}) 
+166          handler.startPrefixMapping(None, 'blaB') 
+167          handler.startElementNS(('blaB', 'b'), 'b', {}) 
+168          handler.endElementNS(  ('blaB', 'b'), 'b') 
+169          handler.endPrefixMapping(None) 
+170          handler.startElementNS(('blaA', 'c'), 'c', {}) 
+171          handler.endElementNS(  ('blaA', 'c'), 'c') 
+172          handler.endElementNS(  ('blaA', 'a'), 'a') 
+173          handler.endPrefixMapping(None) 
+174          handler.endDocument() 
+175   
+176          new_tree = handler.etree 
+177          root = new_tree.getroot() 
+178          self.assertEqual('{blaA}a', 
+179                           root.tag) 
+180          self.assertEqual('{blaB}b', 
+181                           root[0].tag) 
+182          self.assertEqual('{blaA}c', 
+183                           root[1].tag) 
+
184   
+185 -    def test_etree_sax_handler_default_ns_None(self): 
+
186          handler = sax.ElementTreeContentHandler() 
+187          handler.startDocument() 
+188          handler.startPrefixMapping(None, 'blaA') 
+189          handler.startElementNS((None, 'a'), 'a', {}) 
+190          handler.startPrefixMapping(None, 'blaB') 
+191          handler.startElementNS((None, 'b'), 'b', {}) 
+192          handler.endElementNS(  (None, 'b'), 'b') 
+193          handler.endPrefixMapping(None) 
+194          handler.startElementNS((None, 'c'), 'c', {}) 
+195          handler.endElementNS(  (None, 'c'), 'c') 
+196          handler.endElementNS(  (None, 'a'), 'a') 
+197          handler.endPrefixMapping(None) 
+198          handler.endDocument() 
+199   
+200          new_tree = handler.etree 
+201          root = new_tree.getroot() 
+202          self.assertEqual('{blaA}a', 
+203                           root.tag) 
+204          self.assertEqual('{blaB}b', 
+205                           root[0].tag) 
+206          self.assertEqual('{blaA}c', 
+207                           root[1].tag) 
+
208   
+209 -    def test_etree_sax_redefine_ns(self): 
+
210          handler = sax.ElementTreeContentHandler() 
+211          handler.startDocument() 
+212          handler.startPrefixMapping('ns', 'blaA') 
+213          handler.startElementNS(('blaA', 'a'), 'ns:a', {}) 
+214          handler.startPrefixMapping('ns', 'blaB') 
+215          handler.startElementNS(('blaB', 'b'), 'ns:b', {}) 
+216          handler.endElementNS(  ('blaB', 'b'), 'ns:b') 
+217          handler.endPrefixMapping('ns') 
+218          handler.startElementNS(('blaA', 'c'), 'ns:c', {}) 
+219          handler.endElementNS(  ('blaA', 'c'), 'ns:c') 
+220          handler.endElementNS(  ('blaA', 'a'), 'ns:a') 
+221          handler.endPrefixMapping('ns') 
+222          handler.endDocument() 
+223   
+224          new_tree = handler.etree 
+225          root = new_tree.getroot() 
+226          self.assertEqual('{blaA}a', 
+227                           root.tag) 
+228          self.assertEqual('{blaB}b', 
+229                           root[0].tag) 
+230          self.assertEqual('{blaA}c', 
+231                           root[1].tag) 
+
232   
+233 -    def test_etree_sax_no_ns(self): 
+
234          handler = sax.ElementTreeContentHandler() 
+235          handler.startDocument() 
+236          handler.startElement('a', {}) 
+237          handler.startElement('b', {}) 
+238          handler.endElement('b') 
+239          handler.startElement('c') # with empty attributes 
+240          handler.endElement('c') 
+241          handler.endElement('a') 
+242          handler.endDocument() 
+243   
+244          new_tree = handler.etree 
+245          root = new_tree.getroot() 
+246          self.assertEqual('a', root.tag) 
+247          self.assertEqual('b', root[0].tag) 
+248          self.assertEqual('c', root[1].tag) 
+
249   
+250 -    def test_etree_sax_no_ns_attributes(self): 
+
251          handler = sax.ElementTreeContentHandler() 
+252          handler.startDocument() 
+253          handler.startElement('a', {"attr_a1": "a1"}) 
+254          handler.startElement('b', {"attr_b1": "b1"}) 
+255          handler.endElement('b') 
+256          handler.endElement('a') 
+257          handler.endDocument() 
+258   
+259          new_tree = handler.etree 
+260          root = new_tree.getroot() 
+261          self.assertEqual('a', root.tag) 
+262          self.assertEqual('b', root[0].tag) 
+263          self.assertEqual('a1', root.attrib["attr_a1"]) 
+264          self.assertEqual('b1', root[0].attrib["attr_b1"]) 
+
265   
+266 -    def test_etree_sax_ns_attributes(self): 
+
267          handler = sax.ElementTreeContentHandler() 
+268          handler.startDocument() 
+269   
+270          self.assertRaises(ValueError, 
+271              handler.startElement, 
+272              'a', {"blaA:attr_a1": "a1"} 
+273          ) 
+
274   
+275 -    def test_etree_sax_error(self): 
+
276          handler = sax.ElementTreeContentHandler() 
+277          handler.startDocument() 
+278          handler.startElement('a') 
+279          self.assertRaises(sax.SaxError, handler.endElement, 'b') 
+
280   
+281 -    def test_etree_sax_error2(self): 
+
282          handler = sax.ElementTreeContentHandler() 
+283          handler.startDocument() 
+284          handler.startElement('a') 
+285          handler.startElement('b') 
+286          self.assertRaises(sax.SaxError, handler.endElement, 'a') 
+
287   
+288 -    def _saxify_unsaxify(self, saxifiable): 
+
289          handler = sax.ElementTreeContentHandler() 
+290          sax.ElementTreeProducer(saxifiable, handler).saxify() 
+291          return handler.etree 
+
292   
+293 -    def _saxify_serialize(self, tree): 
+
294          new_tree = self._saxify_unsaxify(tree) 
+295          f = BytesIO() 
+296          new_tree.write(f) 
+297          return f.getvalue().replace(_bytes('\n'), _bytes('')) 
+
298   
+299   
+300 -class SimpleContentHandler(ContentHandler, object): 
+
301      """A SAX content handler that just stores the events""" 
+302   
+303 -    def __init__(self): 
+
304          self.sax_events = [] 
+305          super(SimpleContentHandler, self).__init__() 
+
306   
+307 -    def startDocument(self): 
+
308          self.sax_events.append(('startDocument',)) 
+
309   
+310 -    def endDocument(self): 
+
311          self.sax_events.append(('endDocument',)) 
+
312   
+313 -    def startPrefixMapping(self, prefix, uri): 
+
314          self.sax_events.append(('startPrefixMapping', prefix, uri)) 
+
315   
+316 -    def endPrefixMapping(self, prefix): 
+
317          self.sax_events.append(('endPrefixMapping', prefix)) 
+
318   
+319 -    def startElement(self, name, attrs): 
+
320          self.sax_events.append(('startElement', name, dict(attrs))) 
+
321   
+322 -    def endElement(self, name): 
+
323          self.sax_events.append(('endElement', name)) 
+
324   
+325 -    def startElementNS(self, name, qname, attrs): 
+
326          self.sax_events.append(('startElementNS', name, qname, attrs._qnames)) 
+
327   
+328 -    def endElementNS(self, name, qname): 
+
329          self.sax_events.append(('endElementNS', name, qname)) 
+
330   
+331 -    def characters(self, content): 
+
332          self.sax_events.append(('characters', content)) 
+
333   
+334 -    def ignorableWhitespace(self, whitespace): 
+
335          self.sax_events.append(('ignorableWhitespace', whitespace)) 
+
336   
+337 -    def processingInstruction(self, target, data): 
+
338          self.sax_events.append(('processingInstruction', target, data)) 
+
339   
+340 -    def skippedEntity(self, name): 
+
341          self.sax_events.append(('skippedEntity', name)) 
+
342   
+343   
+344 -class NSPrefixSaxTestCase(HelperTestCase): 
+
345      """Testing that namespaces generate the right SAX events""" 
+346   
+347 -    def _saxify(self, tree): 
+
348          handler = SimpleContentHandler() 
+349          sax.ElementTreeProducer(tree, handler).saxify() 
+350          return handler.sax_events 
+
351   
+352 -    def test_element_sax_ns_prefix(self): 
+
353          # The name of the prefix should be preserved, if the uri is unique 
+354          tree = self.parse('<a:a xmlns:a="blaA" xmlns:c="blaC">' 
+355                            '<d a:attr="value" c:attr="value" /></a:a>') 
+356          a = tree.getroot() 
+357   
+358          self.assertEqual( 
+359              [('startElementNS', ('blaA', 'a'), 'a:a', {}), 
+360               ('startElementNS', (None, 'd'), 'd', 
+361                {('blaA', 'attr'): 'a:attr', ('blaC', 'attr'): 'c:attr'}), 
+362               ('endElementNS', (None, 'd'), 'd'), 
+363               ('endElementNS', ('blaA', 'a'), 'a:a'), 
+364              ], 
+365              self._saxify(a)[3:7]) 
+
366   
+367 -    def test_element_sax_default_ns_prefix(self): 
+
368          # Default prefixes should also not get a generated prefix 
+369          tree = self.parse('<a xmlns="blaA"><b attr="value" /></a>') 
+370          a = tree.getroot() 
+371   
+372          self.assertEqual( 
+373              [('startDocument',), 
+374               # NS prefix should be None: 
+375               ('startPrefixMapping', None, 'blaA'), 
+376               ('startElementNS', ('blaA', 'a'), 'a', {}), 
+377               # Attribute prefix should be None: 
+378               ('startElementNS', ('blaA', 'b'), 'b', {(None, 'attr'): 'attr'}), 
+379               ('endElementNS', ('blaA', 'b'), 'b'), 
+380               ('endElementNS', ('blaA', 'a'), 'a'), 
+381               # Prefix should be None again: 
+382               ('endPrefixMapping', None), 
+383               ('endDocument',)], 
+384              self._saxify(a)) 
+385   
+386          # Except for attributes, if there is both a default namespace 
+387          # and a named namespace with the same uri 
+388          tree = self.parse('<a xmlns="bla" xmlns:a="bla">' 
+389                            '<b a:attr="value" /></a>') 
+390          a = tree.getroot() 
+391   
+392          self.assertEqual( 
+393              ('startElementNS', ('bla', 'b'), 'b', {('bla', 'attr'): 'a:attr'}), 
+394              self._saxify(a)[4]) 
+
395   
+396 -    def test_element_sax_twin_ns_prefix(self): 
+
397          # Make an element with an doubly registered uri 
+398          tree = self.parse('<a xmlns:b="bla" xmlns:c="bla">' 
+399                            '<d c:attr="attr" /></a>') 
+400          a = tree.getroot() 
+401   
+402          self.assertEqual( 
+403              # It should get the b prefix in this case 
+404              ('startElementNS', (None, 'd'), 'd', {('bla', 'attr'): 'b:attr'}), 
+405              self._saxify(a)[4]) 
+
406   
+407   
+408 -def test_suite(): 
+
409      suite = unittest.TestSuite() 
+410      suite.addTests([unittest.makeSuite(ETreeSaxTestCase)]) 
+411      suite.addTests([unittest.makeSuite(NSPrefixSaxTestCase)]) 
+412      suite.addTests( 
+413          [make_doctest('../../../doc/sax.txt')]) 
+414      return suite 
+
415   
+416   
+417  if __name__ == '__main__': 
+418      print('to test use test.py %s' % __file__) 
+419   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeSaxTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               NSPrefixSaxTestCase
+
+xml.sax.handler.ContentHandler --+
+                                 |
+                        object --+
+                                 |
+                                SimpleContentHandler
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+ 1  # -*- coding: utf-8 -*- 
+ 2   
+ 3  """ 
+ 4  Test cases related to Schematron parsing and validation 
+ 5  """ 
+ 6   
+ 7  import unittest, sys, os.path 
+ 8   
+ 9  this_dir = os.path.dirname(__file__) 
+10  if this_dir not in sys.path: 
+11      sys.path.insert(0, this_dir) # needed for Py3 
+12   
+13  from common_imports import etree, HelperTestCase, fileInTestDir 
+14  from common_imports import doctest, make_doctest 
+15   
+16 -class ETreeSchematronTestCase(HelperTestCase): 
+
17 -    def test_schematron(self): 
+
18          tree_valid = self.parse('<AAA><BBB/><CCC/></AAA>') 
+19          tree_invalid = self.parse('<AAA><BBB/><CCC/><DDD/></AAA>') 
+20          schema = self.parse('''\ 
+21  <schema xmlns="http://purl.oclc.org/dsdl/schematron" > 
+22       <pattern name="Open model"> 
+23            <rule context="AAA"> 
+24                 <assert test="BBB"> BBB element is not present</assert> 
+25                 <assert test="CCC"> CCC element is not present</assert> 
+26            </rule> 
+27       </pattern> 
+28       <pattern name="Closed model"> 
+29            <rule context="AAA"> 
+30                 <assert test="BBB"> BBB element is not present</assert> 
+31                 <assert test="CCC"> CCC element is not present</assert> 
+32                 <assert test="count(BBB|CCC) = count (*)">There is an extra element</assert> 
+33            </rule> 
+34       </pattern> 
+35  </schema> 
+36  ''') 
+37          schema = etree.Schematron(schema) 
+38          self.assertTrue(schema.validate(tree_valid)) 
+39          self.assertFalse(schema.error_log.filter_from_errors()) 
+40   
+41          self.assertFalse(schema.validate(tree_invalid)) 
+42          self.assertTrue(schema.error_log.filter_from_errors()) 
+43   
+44          self.assertTrue(schema.validate(tree_valid))             # repeat valid 
+45          self.assertFalse(schema.error_log.filter_from_errors())  # repeat valid 
+
46   
+47 -    def test_schematron_elementtree_error(self): 
+
48          self.assertRaises(ValueError, etree.Schematron, etree.ElementTree()) 
+
49   
+50 -    def test_schematron_invalid_schema(self): 
+
51          schema = self.parse('''\ 
+52  <schema xmlns="http://purl.oclc.org/dsdl/schematron" > 
+53       <pattern name="Open model"> 
+54       </pattern> 
+55  </schema> 
+56  ''') 
+57          self.assertRaises(etree.SchematronParseError, 
+58                            etree.Schematron, schema) 
+
59   
+60 -    def test_schematron_invalid_schema_empty(self): 
+
61          schema = self.parse('''\ 
+62  <schema xmlns="http://purl.oclc.org/dsdl/schematron" /> 
+63  ''') 
+64          self.assertRaises(etree.SchematronParseError, 
+65                            etree.Schematron, schema) 
+
66   
+67 -    def test_schematron_invalid_schema_namespace(self): 
+
68          # segfault 
+69          schema = self.parse('''\ 
+70  <schema xmlns="mynamespace" /> 
+71  ''') 
+72          self.assertRaises(etree.SchematronParseError, 
+73                            etree.Schematron, schema) 
+
74   
+75   
+76 -def test_suite(): 
+
77      suite = unittest.TestSuite() 
+78      suite.addTests([unittest.makeSuite(ETreeSchematronTestCase)]) 
+79      suite.addTests( 
+80          [make_doctest('../../../doc/validation.txt')]) 
+81      return suite 
+
82   
+83  if __name__ == '__main__': 
+84      print('to test use test.py %s' % __file__) 
+85   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeSchematronTestCase
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Tests for thread usage in lxml.etree. 
+  5  """ 
+  6   
+  7  import re 
+  8  import sys 
+  9  import os.path 
+ 10  import unittest 
+ 11  import threading 
+ 12   
+ 13  this_dir = os.path.dirname(__file__) 
+ 14  if this_dir not in sys.path: 
+ 15      sys.path.insert(0, this_dir) # needed for Py3 
+ 16   
+ 17  from common_imports import etree, HelperTestCase, BytesIO, _bytes 
+ 18   
+ 19  try: 
+ 20      from Queue import Queue 
+ 21  except ImportError: 
+ 22      from queue import Queue # Py3 
+ 23   
+ 24   
+ 25 -class ThreadingTestCase(HelperTestCase): 
+
 26      """Threading tests""" 
+ 27      etree = etree 
+ 28   
+ 29 -    def _run_thread(self, func): 
+
 30          thread = threading.Thread(target=func) 
+ 31          thread.start() 
+ 32          thread.join() 
+
 33   
+ 34 -    def _run_threads(self, count, func, main_func=None): 
+
 35          sync = threading.Event() 
+ 36          lock = threading.Lock() 
+ 37          counter = dict(started=0, finished=0, failed=0) 
+ 38   
+ 39          def sync_start(func): 
+ 40              with lock: 
+ 41                  started = counter['started'] + 1 
+ 42                  counter['started'] = started 
+ 43              if started < count + (main_func is not None): 
+ 44                  sync.wait(4)  # wait until the other threads have started up 
+ 45                  assert sync.is_set() 
+ 46              sync.set()  # all waiting => go! 
+ 47              try: 
+ 48                  func() 
+ 49              except: 
+ 50                  with lock: 
+ 51                      counter['failed'] += 1 
+ 52                  raise 
+ 53              else: 
+ 54                  with lock: 
+ 55                      counter['finished'] += 1 
+
 56   
+ 57          threads = [threading.Thread(target=sync_start, args=(func,)) for _ in range(count)] 
+ 58          for thread in threads: 
+ 59              thread.start() 
+ 60          if main_func is not None: 
+ 61              sync_start(main_func) 
+ 62          for thread in threads: 
+ 63              thread.join() 
+ 64   
+ 65          self.assertEqual(0, counter['failed']) 
+ 66          self.assertEqual(counter['finished'], counter['started']) 
+
 67   
+ 68 -    def test_subtree_copy_thread(self): 
+
 69          tostring = self.etree.tostring 
+ 70          XML = self.etree.XML 
+ 71          xml = _bytes("<root><threadtag/></root>") 
+ 72          main_root = XML(_bytes("<root/>")) 
+ 73   
+ 74          def run_thread(): 
+ 75              thread_root = XML(xml) 
+ 76              main_root.append(thread_root[0]) 
+ 77              del thread_root 
+
 78   
+ 79          self._run_thread(run_thread) 
+ 80          self.assertEqual(xml, tostring(main_root)) 
+ 81   
+ 82 -    def test_main_xslt_in_thread(self): 
+
 83          XML = self.etree.XML 
+ 84          style = XML(_bytes('''\ 
+ 85  <xsl:stylesheet version="1.0" 
+ 86      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 87    <xsl:template match="*"> 
+ 88      <foo><xsl:copy><xsl:value-of select="/a/b/text()" /></xsl:copy></foo> 
+ 89    </xsl:template> 
+ 90  </xsl:stylesheet>''')) 
+ 91          st = etree.XSLT(style) 
+ 92   
+ 93          result = [] 
+ 94   
+ 95          def run_thread(): 
+ 96              root = XML(_bytes('<a><b>B</b><c>C</c></a>')) 
+ 97              result.append( st(root) ) 
+
 98   
+ 99          self._run_thread(run_thread) 
+100          self.assertEqual('''\ 
+101  <?xml version="1.0"?> 
+102  <foo><a>B</a></foo> 
+103  ''', 
+104                            str(result[0])) 
+105   
+106 -    def test_thread_xslt(self): 
+
107          XML = self.etree.XML 
+108          tostring = self.etree.tostring 
+109          root = XML(_bytes('<a><b>B</b><c>C</c></a>')) 
+110   
+111          def run_thread(): 
+112              style = XML(_bytes('''\ 
+113      <xsl:stylesheet version="1.0" 
+114          xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+115        <xsl:template match="*"> 
+116          <foo><xsl:copy><xsl:value-of select="/a/b/text()" /></xsl:copy></foo> 
+117        </xsl:template> 
+118      </xsl:stylesheet>''')) 
+119              st = etree.XSLT(style) 
+120              root.append( st(root).getroot() ) 
+
121   
+122          self._run_thread(run_thread) 
+123          self.assertEqual(_bytes('<a><b>B</b><c>C</c><foo><a>B</a></foo></a>'), 
+124                            tostring(root)) 
+125   
+126 -    def test_thread_xslt_parsing_error_log(self): 
+
127          style = self.parse('''\ 
+128  <xsl:stylesheet version="1.0" 
+129      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+130      <xsl:template match="tag" /> 
+131      <!-- extend time for parsing + transform --> 
+132  ''' + '\n'.join('<xsl:template match="tag%x" />' % i for i in range(200)) + ''' 
+133      <xsl:UnExpectedElement /> 
+134  </xsl:stylesheet>''') 
+135          self.assertRaises(etree.XSLTParseError, 
+136                            etree.XSLT, style) 
+137   
+138          error_logs = [] 
+139   
+140          def run_thread(): 
+141              try: 
+142                  etree.XSLT(style) 
+143              except etree.XSLTParseError as e: 
+144                  error_logs.append(e.error_log) 
+145              else: 
+146                  self.assertFalse(True, "XSLT parsing should have failed but didn't") 
+
147   
+148          self._run_threads(16, run_thread) 
+149   
+150          self.assertEqual(16, len(error_logs)) 
+151          last_log = None 
+152          for log in error_logs: 
+153              self.assertTrue(len(log)) 
+154              if last_log is not None: 
+155                  self.assertEqual(len(last_log), len(log)) 
+156              self.assertTrue(len(log) >= 2, len(log)) 
+157              for error in log: 
+158                  self.assertTrue(':ERROR:XSLT:' in str(error), str(error)) 
+159              self.assertTrue(any('UnExpectedElement' in str(error) for error in log), log) 
+160              last_log = log 
+161   
+162 -    def test_thread_xslt_apply_error_log(self): 
+
163          tree = self.parse('<tagFF/>') 
+164          style = self.parse('''\ 
+165  <xsl:stylesheet version="1.0" 
+166      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+167      <xsl:template name="tag0"> 
+168          <xsl:message terminate="yes">FAIL</xsl:message> 
+169      </xsl:template> 
+170      <!-- extend time for parsing + transform --> 
+171  ''' + '\n'.join('<xsl:template match="tag%X" name="tag%x"> <xsl:call-template name="tag%x" /> </xsl:template>' % (i, i, i-1) 
+172                  for i in range(1, 256)) + ''' 
+173  </xsl:stylesheet>''') 
+174          self.assertRaises(etree.XSLTApplyError, 
+175                            etree.XSLT(style), tree) 
+176   
+177          error_logs = [] 
+178   
+179          def run_thread(): 
+180              transform = etree.XSLT(style) 
+181              try: 
+182                  transform(tree) 
+183              except etree.XSLTApplyError: 
+184                  error_logs.append(transform.error_log) 
+185              else: 
+186                  self.assertFalse(True, "XSLT parsing should have failed but didn't") 
+
187   
+188          self._run_threads(16, run_thread) 
+189   
+190          self.assertEqual(16, len(error_logs)) 
+191          last_log = None 
+192          for log in error_logs: 
+193              self.assertTrue(len(log)) 
+194              if last_log is not None: 
+195                  self.assertEqual(len(last_log), len(log)) 
+196              self.assertEqual(1, len(log)) 
+197              for error in log: 
+198                  self.assertTrue(':ERROR:XSLT:' in str(error)) 
+199              last_log = log 
+200   
+201 -    def test_thread_xslt_attr_replace(self): 
+
202          # this is the only case in XSLT where the result tree can be 
+203          # modified in-place 
+204          XML = self.etree.XML 
+205          tostring = self.etree.tostring 
+206          style = self.etree.XSLT(XML(_bytes('''\ 
+207      <xsl:stylesheet version="1.0" 
+208          xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+209        <xsl:template match="*"> 
+210          <root class="abc"> 
+211            <xsl:copy-of select="@class" /> 
+212            <xsl:attribute name="class">xyz</xsl:attribute>  
+213          </root> 
+214        </xsl:template> 
+215      </xsl:stylesheet>'''))) 
+216   
+217          result = [] 
+218          def run_thread(): 
+219              root = XML(_bytes('<ROOT class="ABC" />')) 
+220              result.append( style(root).getroot() ) 
+
221   
+222          self._run_thread(run_thread) 
+223          self.assertEqual(_bytes('<root class="xyz"/>'), 
+224                            tostring(result[0])) 
+225   
+226 -    def test_thread_create_xslt(self): 
+
227          XML = self.etree.XML 
+228          tostring = self.etree.tostring 
+229          root = XML(_bytes('<a><b>B</b><c>C</c></a>')) 
+230   
+231          stylesheets = [] 
+232   
+233          def run_thread(): 
+234              style = XML(_bytes('''\ 
+235      <xsl:stylesheet 
+236          xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+237          version="1.0"> 
+238        <xsl:output method="xml" /> 
+239        <xsl:template match="/"> 
+240           <div id="test"> 
+241             <xsl:apply-templates/> 
+242           </div> 
+243        </xsl:template> 
+244      </xsl:stylesheet>''')) 
+245              stylesheets.append( etree.XSLT(style) ) 
+
246   
+247          self._run_thread(run_thread) 
+248   
+249          st = stylesheets[0] 
+250          result = tostring( st(root) ) 
+251   
+252          self.assertEqual(_bytes('<div id="test">BC</div>'), 
+253                            result) 
+254   
+255 -    def test_thread_error_log(self): 
+
256          XML = self.etree.XML 
+257          expected_error = [self.etree.ErrorTypes.ERR_TAG_NAME_MISMATCH] 
+258          children = "<a>test</a>" * 100 
+259   
+260          def parse_error_test(thread_no): 
+261              tag = "tag%d" % thread_no 
+262              xml = "<%s>%s</%s>" % (tag, children, tag.upper()) 
+263              parser = self.etree.XMLParser() 
+264              for _ in range(10): 
+265                  errors = None 
+266                  try: 
+267                      XML(xml, parser) 
+268                  except self.etree.ParseError: 
+269                      e = sys.exc_info()[1] 
+270                      errors = e.error_log.filter_types(expected_error) 
+271                  self.assertTrue(errors, "Expected error not found") 
+272                  for error in errors: 
+273                      self.assertTrue( 
+274                          tag in error.message and tag.upper() in error.message, 
+275                          "%s and %s not found in '%s'" % ( 
+276                          tag, tag.upper(), error.message)) 
+
277   
+278          self.etree.clear_error_log() 
+279          threads = [] 
+280          for thread_no in range(1, 10): 
+281              t = threading.Thread(target=parse_error_test, 
+282                                   args=(thread_no,)) 
+283              threads.append(t) 
+284              t.start() 
+285   
+286          parse_error_test(0) 
+287   
+288          for t in threads: 
+289              t.join() 
+290   
+291 -    def test_thread_mix(self): 
+
292          XML = self.etree.XML 
+293          Element = self.etree.Element 
+294          SubElement = self.etree.SubElement 
+295          tostring = self.etree.tostring 
+296          xml = _bytes('<a><b>B</b><c xmlns="test">C</c></a>') 
+297          root = XML(xml) 
+298          fragment = XML(_bytes("<other><tags/></other>")) 
+299   
+300          result = self.etree.Element("{myns}root", att = "someval") 
+301   
+302          def run_XML(): 
+303              thread_root = XML(xml) 
+304              result.append(thread_root[0]) 
+305              result.append(thread_root[-1]) 
+
306   
+307          def run_parse(): 
+308              thread_root = self.etree.parse(BytesIO(xml)).getroot() 
+309              result.append(thread_root[0]) 
+310              result.append(thread_root[-1]) 
+311   
+312          def run_move_main(): 
+313              result.append(fragment[0]) 
+314   
+315          def run_build(): 
+316              result.append( 
+317                  Element("{myns}foo", attrib={'{test}attr':'val'})) 
+318              SubElement(result, "{otherns}tasty") 
+319   
+320          def run_xslt(): 
+321              style = XML(_bytes('''\ 
+322      <xsl:stylesheet version="1.0" 
+323          xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+324        <xsl:template match="*"> 
+325          <xsl:copy><foo><xsl:value-of select="/a/b/text()" /></foo></xsl:copy> 
+326        </xsl:template> 
+327      </xsl:stylesheet>''')) 
+328              st = etree.XSLT(style) 
+329              result.append( st(root).getroot() ) 
+330   
+331          for test in (run_XML, run_parse, run_move_main, run_xslt, run_build): 
+332              tostring(result) 
+333              self._run_thread(test) 
+334   
+335          self.assertEqual( 
+336              _bytes('<ns0:root xmlns:ns0="myns" att="someval"><b>B</b>' 
+337                     '<c xmlns="test">C</c><b>B</b><c xmlns="test">C</c><tags/>' 
+338                     '<a><foo>B</foo></a>' 
+339                     '<ns0:foo xmlns:ns1="test" ns1:attr="val"/>' 
+340                     '<ns1:tasty xmlns:ns1="otherns"/></ns0:root>'), 
+341              tostring(result)) 
+342   
+343          def strip_first(): 
+344              root = Element("newroot") 
+345              root.append(result[0]) 
+346   
+347          while len(result): 
+348              self._run_thread(strip_first) 
+349   
+350          self.assertEqual( 
+351              _bytes('<ns0:root xmlns:ns0="myns" att="someval"/>'), 
+352              tostring(result)) 
+353   
+354 -    def test_concurrent_attribute_names_in_dicts(self): 
+
355          SubElement = self.etree.SubElement 
+356          names = list('abcdefghijklmnop') 
+357          runs_per_name = range(50) 
+358          result_matches = re.compile( 
+359              br'<thread_root>' 
+360              br'(?:<[a-p]{5} thread_attr_[a-p]="value" thread_attr2_[a-p]="value2"\s?/>)+' 
+361              br'</thread_root>').match 
+362   
+363          def testrun(): 
+364              for _ in range(3): 
+365                  root = self.etree.Element('thread_root') 
+366                  for name in names: 
+367                      tag_name = name * 5 
+368                      new = [] 
+369                      for _ in runs_per_name: 
+370                          el = SubElement(root, tag_name, {'thread_attr_' + name: 'value'}) 
+371                          new.append(el) 
+372                      for el in new: 
+373                          el.set('thread_attr2_' + name, 'value2') 
+374                  s = etree.tostring(root) 
+375                  self.assertTrue(result_matches(s)) 
+
376   
+377          # first, run only in sub-threads 
+378          self._run_threads(10, testrun) 
+379   
+380          # then, additionally include the main thread (and its parent dict) 
+381          self._run_threads(10, testrun, main_func=testrun) 
+382   
+383 -    def test_concurrent_proxies(self): 
+
384          XML = self.etree.XML 
+385          root = XML(_bytes('<root><a>A</a><b xmlns="test">B</b><c/></root>')) 
+386          child_count = len(root) 
+387          def testrun(): 
+388              for i in range(10000): 
+389                  el = root[i%child_count] 
+390                  del el 
+
391          self._run_threads(10, testrun) 
+392   
+393 -    def test_concurrent_class_lookup(self): 
+
394          XML = self.etree.XML 
+395   
+396          class TestElement(etree.ElementBase): 
+397              pass 
+
398   
+399          class MyLookup(etree.CustomElementClassLookup): 
+400              repeat = range(100) 
+401              def lookup(self, t, d, ns, name): 
+402                  count = 0 
+403                  for i in self.repeat: 
+404                      # allow other threads to run 
+405                      count += 1 
+406                  return TestElement 
+407   
+408          parser = self.etree.XMLParser() 
+409          parser.set_element_class_lookup(MyLookup()) 
+410   
+411          root = XML(_bytes('<root><a>A</a><b xmlns="test">B</b><c/></root>'), 
+412                     parser) 
+413   
+414          child_count = len(root) 
+415          def testrun(): 
+416              for i in range(1000): 
+417                  el = root[i%child_count] 
+418                  del el 
+419          self._run_threads(10, testrun) 
+420   
+421   
+422 -class ThreadPipelineTestCase(HelperTestCase): 
+
423      """Threading tests based on a thread worker pipeline. 
+424      """ 
+425      etree = etree 
+426      item_count = 40 
+427   
+428 -    class Worker(threading.Thread): 
+
429 -        def __init__(self, in_queue, in_count, **kwargs): 
+
430              threading.Thread.__init__(self) 
+431              self.in_queue = in_queue 
+432              self.in_count = in_count 
+433              self.out_queue = Queue(in_count) 
+434              self.__dict__.update(kwargs) 
+
435   
+436 -        def run(self): 
+
437              get, put = self.in_queue.get, self.out_queue.put 
+438              handle = self.handle 
+439              for _ in range(self.in_count): 
+440                  put(handle(get())) 
+
441   
+442 -        def handle(self, data): 
+
443              raise NotImplementedError() 
+
444   
+445 -    class ParseWorker(Worker): 
+
446 -        def handle(self, xml, _fromstring=etree.fromstring): 
+
447              return _fromstring(xml) 
+
448   
+449 -    class RotateWorker(Worker): 
+
450 -        def handle(self, element): 
+
451              first = element[0] 
+452              element[:] = element[1:] 
+453              element.append(first) 
+454              return element 
+
455   
+456 -    class ReverseWorker(Worker): 
+
457 -        def handle(self, element): 
+
458              element[:] = element[::-1] 
+459              return element 
+
460   
+461 -    class ParseAndExtendWorker(Worker): 
+
462 -        def handle(self, element, _fromstring=etree.fromstring): 
+
463              element.extend(_fromstring(self.xml)) 
+464              return element 
+
465   
+466 -    class ParseAndInjectWorker(Worker): 
+
467 -        def handle(self, element, _fromstring=etree.fromstring): 
+
468              root = _fromstring(self.xml) 
+469              root.extend(element) 
+470              return root 
+
471   
+472 -    class Validate(Worker): 
+
473 -        def handle(self, element): 
+
474              element.getroottree().docinfo.internalDTD.assertValid(element) 
+475              return element 
+
476   
+477 -    class SerialiseWorker(Worker): 
+
478 -        def handle(self, element): 
+
479              return etree.tostring(element) 
+
480   
+481      xml = (b'''\ 
+482  <!DOCTYPE threadtest [ 
+483      <!ELEMENT threadtest (thread-tag1,thread-tag2)+> 
+484      <!ATTLIST threadtest 
+485          version    CDATA  "1.0" 
+486      > 
+487      <!ELEMENT thread-tag1 EMPTY> 
+488      <!ELEMENT thread-tag2 (div)> 
+489      <!ELEMENT div (threaded)> 
+490      <!ATTLIST div 
+491          huhu  CDATA  #IMPLIED 
+492      > 
+493      <!ELEMENT threaded EMPTY> 
+494      <!ATTLIST threaded 
+495          host  CDATA  #REQUIRED 
+496      > 
+497  ]> 
+498  <threadtest version="123"> 
+499  ''' + (b''' 
+500    <thread-tag1 /> 
+501    <thread-tag2> 
+502      <div huhu="true"> 
+503         <threaded host="here" /> 
+504      </div> 
+505    </thread-tag2> 
+506  ''') * 20 + b''' 
+507  </threadtest>''') 
+508   
+509 -    def _build_pipeline(self, item_count, *classes, **kwargs): 
+
510          in_queue = Queue(item_count) 
+511          start = last = classes[0](in_queue, item_count, **kwargs) 
+512          start.setDaemon(True) 
+513          for worker_class in classes[1:]: 
+514              last = worker_class(last.out_queue, item_count, **kwargs) 
+515              last.setDaemon(True) 
+516              last.start() 
+517          return in_queue, start, last 
+
518   
+519 -    def test_thread_pipeline_thread_parse(self): 
+
520          item_count = self.item_count 
+521          xml = self.xml.replace(b'thread', b'THREAD')  # use fresh tag names 
+522   
+523          # build and start the pipeline 
+524          in_queue, start, last = self._build_pipeline( 
+525              item_count, 
+526              self.ParseWorker, 
+527              self.RotateWorker, 
+528              self.ReverseWorker, 
+529              self.ParseAndExtendWorker, 
+530              self.Validate, 
+531              self.ParseAndInjectWorker, 
+532              self.SerialiseWorker, 
+533              xml=xml) 
+534   
+535          # fill the queue 
+536          put = start.in_queue.put 
+537          for _ in range(item_count): 
+538              put(xml) 
+539   
+540          # start the first thread and thus everything 
+541          start.start() 
+542          # make sure the last thread has terminated 
+543          last.join(60)  # time out after 60 seconds 
+544          self.assertEqual(item_count, last.out_queue.qsize()) 
+545          # read the results 
+546          get = last.out_queue.get 
+547          results = [get() for _ in range(item_count)] 
+548   
+549          comparison = results[0] 
+550          for i, result in enumerate(results[1:]): 
+551              self.assertEqual(comparison, result) 
+
552   
+553 -    def test_thread_pipeline_global_parse(self): 
+
554          item_count = self.item_count 
+555          xml = self.xml.replace(b'thread', b'GLOBAL')  # use fresh tag names 
+556          XML = self.etree.XML 
+557          # build and start the pipeline 
+558          in_queue, start, last = self._build_pipeline( 
+559              item_count, 
+560              self.RotateWorker, 
+561              self.ReverseWorker, 
+562              self.ParseAndExtendWorker, 
+563              self.Validate, 
+564              self.SerialiseWorker, 
+565              xml=xml) 
+566   
+567          # fill the queue 
+568          put = start.in_queue.put 
+569          for _ in range(item_count): 
+570              put(XML(xml)) 
+571   
+572          # start the first thread and thus everything 
+573          start.start() 
+574          # make sure the last thread has terminated 
+575          last.join(60)  # time out after 90 seconds 
+576          self.assertEqual(item_count, last.out_queue.qsize()) 
+577          # read the results 
+578          get = last.out_queue.get 
+579          results = [get() for _ in range(item_count)] 
+580   
+581          comparison = results[0] 
+582          for i, result in enumerate(results[1:]): 
+583              self.assertEqual(comparison, result) 
+
584   
+585   
+586 -def test_suite(): 
+
587      suite = unittest.TestSuite() 
+588      suite.addTests([unittest.makeSuite(ThreadingTestCase)]) 
+589      suite.addTests([unittest.makeSuite(ThreadPipelineTestCase)]) 
+590      return suite 
+
591   
+592  if __name__ == '__main__': 
+593      print('to test use test.py %s' % __file__) 
+594   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ThreadPipelineTestCase
+
lxml.etree
lxml.etree
+'''<!DOCTYPE threadtest [
+    <!ELEMENT threadtest (thread-tag1,thread-tag2)+>
+    <!ATTLIST threadtest
+        version    CDATA  "1.0"
+    >
+    <!ELEMENT thread-tag1 EMPTY>
+    <!ELEMENT thread-tag2 (div)>
+    <!ELEMENT div (threaded)>
+...
+
+           object --+            
+                    |            
+   threading._Verbose --+        
+                        |        
+         threading.Thread --+    
+                            |    
+ThreadPipelineTestCase.Worker --+
+                                |
+                               ThreadPipelineTestCase.ParseAndExtendWorker
+
+           object --+            
+                    |            
+   threading._Verbose --+        
+                        |        
+         threading.Thread --+    
+                            |    
+ThreadPipelineTestCase.Worker --+
+                                |
+                               ThreadPipelineTestCase.ParseAndInjectWorker
+
+           object --+            
+                    |            
+   threading._Verbose --+        
+                        |        
+         threading.Thread --+    
+                            |    
+ThreadPipelineTestCase.Worker --+
+                                |
+                               ThreadPipelineTestCase.ParseWorker
+
+           object --+            
+                    |            
+   threading._Verbose --+        
+                        |        
+         threading.Thread --+    
+                            |    
+ThreadPipelineTestCase.Worker --+
+                                |
+                               ThreadPipelineTestCase.ReverseWorker
+
+           object --+            
+                    |            
+   threading._Verbose --+        
+                        |        
+         threading.Thread --+    
+                            |    
+ThreadPipelineTestCase.Worker --+
+                                |
+                               ThreadPipelineTestCase.RotateWorker
+
+           object --+            
+                    |            
+   threading._Verbose --+        
+                        |        
+         threading.Thread --+    
+                            |    
+ThreadPipelineTestCase.Worker --+
+                                |
+                               ThreadPipelineTestCase.SerialiseWorker
+
+           object --+            
+                    |            
+   threading._Verbose --+        
+                        |        
+         threading.Thread --+    
+                            |    
+ThreadPipelineTestCase.Worker --+
+                                |
+                               ThreadPipelineTestCase.Validate
+
+        object --+        
+                 |        
+threading._Verbose --+    
+                     |    
+      threading.Thread --+
+                         |
+                        ThreadPipelineTestCase.Worker
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ThreadingTestCase
+
lxml.etree
lxml.etree
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+u'<test><title>test Ã¡ㄠ</title><h1>page Ã¡ㄠ title</h1></test>'
+
+  1  # -*- coding: utf-8 -*- 
+  2  import unittest 
+  3  import sys 
+  4  import os.path 
+  5   
+  6  this_dir = os.path.dirname(__file__) 
+  7  if this_dir not in sys.path: 
+  8      sys.path.insert(0, this_dir)  # needed for Py3 
+  9   
+ 10  from common_imports import StringIO, etree, SillyFileLike, HelperTestCase 
+ 11  from common_imports import _str, _bytes, _chr 
+ 12   
+ 13  try: 
+ 14      unicode 
+ 15  except NameError: 
+ 16      unicode = str 
+ 17   
+ 18  ascii_uni = _bytes('a').decode('utf8') 
+ 19   
+ 20  klingon = _bytes("\\uF8D2").decode("unicode_escape") # not valid for XML names 
+ 21   
+ 22  invalid_tag = _bytes("test").decode('utf8') + klingon 
+ 23   
+ 24  uni = _bytes('\\xc3\\u0680\\u3120').decode("unicode_escape") # some non-ASCII characters 
+ 25   
+ 26  uxml = _bytes("<test><title>test \\xc3\\xa1\\u3120</title><h1>page \\xc3\\xa1\\u3120 title</h1></test>" 
+ 27                ).decode("unicode_escape") 
+ 28   
+ 29   
+ 30 -class UnicodeTestCase(HelperTestCase): 
+
 31 -    def test__str(self): 
+
 32          # test the testing framework, namely _str from common_imports 
+ 33          self.assertEqual(_str('\x10'), _str('\u0010')) 
+ 34          self.assertEqual(_str('\x10'), _str('\U00000010')) 
+ 35          self.assertEqual(_str('\u1234'), _str('\U00001234')) 
+
 36   
+ 37 -    def test_unicode_xml(self): 
+
 38          tree = etree.XML('<p>%s</p>' % uni) 
+ 39          self.assertEqual(uni, tree.text) 
+
 40   
+ 41 -    def test_wide_unicode_xml(self): 
+
 42          if sys.maxunicode < 1114111: 
+ 43              return  # skip test 
+ 44          tree = etree.XML(_bytes('<p>\\U00026007</p>').decode('unicode_escape')) 
+ 45          self.assertEqual(1, len(tree.text)) 
+ 46          self.assertEqual(_bytes('\\U00026007').decode('unicode_escape'), 
+ 47                           tree.text) 
+
 48   
+ 49 -    def test_unicode_xml_broken(self): 
+
 50          uxml = ('<?xml version="1.0" encoding="UTF-8"?>' + 
+ 51                  '<p>%s</p>' % uni) 
+ 52          self.assertRaises(ValueError, etree.XML, uxml) 
+
 53   
+ 54 -    def test_unicode_tag(self): 
+
 55          el = etree.Element(uni) 
+ 56          self.assertEqual(uni, el.tag) 
+
 57   
+ 58 -    def test_unicode_tag_invalid(self): 
+
 59          # sadly, Klingon is not well-formed 
+ 60          self.assertRaises(ValueError, etree.Element, invalid_tag) 
+
 61   
+ 62 -    def test_unicode_nstag(self): 
+
 63          tag = "{http://abc/}%s" % uni 
+ 64          el = etree.Element(tag) 
+ 65          self.assertEqual(tag, el.tag) 
+
 66   
+ 67 -    def test_unicode_ns_invalid(self): 
+
 68          # namespace URIs must conform to RFC 3986 
+ 69          tag = "{http://%s/}abc" % uni 
+ 70          self.assertRaises(ValueError, etree.Element, tag) 
+
 71   
+ 72 -    def test_unicode_nstag_invalid(self): 
+
 73          # sadly, Klingon is not well-formed 
+ 74          tag = "{http://abc/}%s" % invalid_tag 
+ 75          self.assertRaises(ValueError, etree.Element, tag) 
+
 76   
+ 77 -    def test_unicode_qname(self): 
+
 78          qname = etree.QName(uni, uni) 
+ 79          tag = "{%s}%s" % (uni, uni) 
+ 80          self.assertEqual(qname.text, tag) 
+ 81          self.assertEqual(unicode(qname), tag) 
+
 82   
+ 83 -    def test_unicode_qname_invalid(self): 
+
 84          self.assertRaises(ValueError, etree.QName, invalid_tag) 
+
 85   
+ 86 -    def test_unicode_attr(self): 
+
 87          el = etree.Element('foo', {'bar': uni}) 
+ 88          self.assertEqual(uni, el.attrib['bar']) 
+
 89   
+ 90 -    def test_unicode_comment(self): 
+
 91          el = etree.Comment(uni) 
+ 92          self.assertEqual(uni, el.text) 
+
 93   
+ 94 -    def test_unicode_repr1(self): 
+
 95          x = etree.Element(_str('å')) 
+ 96          # must not raise UnicodeEncodeError 
+ 97          repr(x) 
+
 98   
+ 99 -    def test_unicode_repr2(self): 
+
100          x = etree.Comment(_str('ö')) 
+101          repr(x) 
+
102   
+103 -    def test_unicode_repr3(self): 
+
104          x = etree.ProcessingInstruction(_str('Å'), _str('\u0131')) 
+105          repr(x) 
+
106   
+107 -    def test_unicode_repr4(self): 
+
108          x = etree.Entity(_str('ä')) 
+109          repr(x) 
+
110   
+111 -    def test_unicode_text(self): 
+
112          e = etree.Element('e') 
+113   
+114          def settext(text): 
+115              e.text = text 
+
116   
+117          self.assertRaises(ValueError, settext, _str('ab\ufffe')) 
+118          self.assertRaises(ValueError, settext, _str('ö\ffff')) 
+119          self.assertRaises(ValueError, settext, _str('\u0123\ud800')) 
+120          self.assertRaises(ValueError, settext, _str('x\ud8ff')) 
+121          self.assertRaises(ValueError, settext, _str('\U00010000\udfff')) 
+122          self.assertRaises(ValueError, settext, _str('abd\x00def')) 
+123          # should not Raise 
+124          settext(_str('\ud7ff\ue000\U00010000\U0010FFFFäöas')) 
+125   
+126          for char_val in range(0xD800, 0xDFFF+1): 
+127              self.assertRaises(ValueError, settext, 'abc' + _chr(char_val)) 
+128              self.assertRaises(ValueError, settext, _chr(char_val)) 
+129              self.assertRaises(ValueError, settext, _chr(char_val) + 'abc') 
+130   
+131          self.assertRaises(ValueError, settext, _bytes('\xe4')) 
+132          self.assertRaises(ValueError, settext, _bytes('\x80')) 
+133          self.assertRaises(ValueError, settext, _bytes('\xff')) 
+134          self.assertRaises(ValueError, settext, _bytes('\x08')) 
+135          self.assertRaises(ValueError, settext, _bytes('\x19')) 
+136          self.assertRaises(ValueError, settext, _bytes('\x20\x00')) 
+137          # should not Raise 
+138          settext(_bytes('\x09\x0A\x0D\x20\x60\x7f')) 
+
139   
+140 -    def test_uniname(self): 
+
141          Element = etree.Element 
+142          def el(name): 
+143              return Element(name) 
+
144   
+145          self.assertRaises(ValueError, el, ':') 
+146          self.assertRaises(ValueError, el, '0a') 
+147          self.assertRaises(ValueError, el, _str('\u203f')) 
+148          # should not Raise 
+149          el(_str('\u0132')) 
+150   
+151   
+152   
+153 -    def test_unicode_parse_stringio(self): 
+
154          el = etree.parse(StringIO('<p>%s</p>' % uni)).getroot() 
+155          self.assertEqual(uni, el.text) 
+
156   
+157  ##     def test_parse_fileobject_unicode(self): 
+158  ##         # parse unicode from unamed file object (not support by ElementTree) 
+159  ##         f = SillyFileLike(uxml) 
+160  ##         root = etree.parse(f).getroot() 
+161  ##         self.assertEqual(unicode(etree.tostring(root, 'UTF-8'), 'UTF-8'), 
+162  ##                           uxml) 
+163   
+164   
+165 -class EncodingsTestCase(HelperTestCase): 
+
166 -    def test_illegal_utf8(self): 
+
167          data = _bytes('<test>\x80\x80\x80</test>', encoding='iso8859-1') 
+168          self.assertRaises(etree.XMLSyntaxError, etree.fromstring, data) 
+
169   
+170 -    def test_illegal_utf8_recover(self): 
+
171          data = _bytes('<test>\x80\x80\x80</test>', encoding='iso8859-1') 
+172          parser = etree.XMLParser(recover=True) 
+173          self.assertRaises(etree.XMLSyntaxError, etree.fromstring, data, parser) 
+
174   
+175 -    def _test_encoding(self, encoding, xml_encoding_name=None): 
+
176          foo = """<?xml version='1.0' encoding='%s'?>\n<tag attrib='123'></tag>""" % ( 
+177              xml_encoding_name or encoding) 
+178          root = etree.fromstring(foo.encode(encoding)) 
+179          self.assertEqual('tag', root.tag) 
+180   
+181          doc_encoding = root.getroottree().docinfo.encoding 
+182          self.assertTrue( 
+183              doc_encoding.lower().rstrip('lbe'), 
+184              (xml_encoding_name or encoding).lower().rstrip('lbe')) 
+
185   
+186 -    def test_utf8_fromstring(self): 
+
187          self._test_encoding('utf-8') 
+
188   
+189 -    def test_utf8sig_fromstring(self): 
+
190          self._test_encoding('utf_8_sig', 'utf-8') 
+
191   
+192 -    def test_utf16_fromstring(self): 
+
193          self._test_encoding('utf-16') 
+
194   
+195 -    def test_utf16LE_fromstring(self): 
+
196          self._test_encoding('utf-16le', 'utf-16') 
+
197   
+198 -    def test_utf16BE_fromstring(self): 
+
199          self._test_encoding('utf-16be', 'utf-16') 
+
200   
+201 -    def test_utf32_fromstring(self): 
+
202          self._test_encoding('utf-32', 'utf-32') 
+
203   
+204 -    def test_utf32LE_fromstring(self): 
+
205          self._test_encoding('utf-32le', 'utf-32') 
+
206   
+207 -    def test_utf32BE_fromstring(self): 
+
208          self._test_encoding('utf-32be', 'utf-32') 
+
209   
+210   
+211 -def test_suite(): 
+
212      suite = unittest.TestSuite() 
+213      suite.addTests([unittest.makeSuite(UnicodeTestCase)]) 
+214      suite.addTests([unittest.makeSuite(EncodingsTestCase)]) 
+215      return suite 
+
216   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               EncodingsTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               UnicodeTestCase
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Test cases related to XML Schema parsing and validation 
+  5  """ 
+  6   
+  7  import unittest, sys, os.path 
+  8   
+  9  this_dir = os.path.dirname(__file__) 
+ 10  if this_dir not in sys.path: 
+ 11      sys.path.insert(0, this_dir) # needed for Py3 
+ 12   
+ 13  from common_imports import etree, BytesIO, HelperTestCase, fileInTestDir 
+ 14  from common_imports import doctest, make_doctest 
+ 15   
+ 16   
+ 17 -class ETreeXMLSchemaTestCase(HelperTestCase): 
+
 18 -    def test_xmlschema(self): 
+
 19          tree_valid = self.parse('<a><b></b></a>') 
+ 20          tree_invalid = self.parse('<a><c></c></a>') 
+ 21          schema = self.parse(''' 
+ 22  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+ 23    <xsd:element name="a" type="AType"/> 
+ 24    <xsd:complexType name="AType"> 
+ 25      <xsd:sequence> 
+ 26        <xsd:element name="b" type="xsd:string" /> 
+ 27      </xsd:sequence> 
+ 28    </xsd:complexType> 
+ 29  </xsd:schema> 
+ 30  ''') 
+ 31          schema = etree.XMLSchema(schema) 
+ 32          self.assertTrue(schema.validate(tree_valid)) 
+ 33          self.assertFalse(schema.validate(tree_invalid)) 
+ 34          self.assertTrue(schema.validate(tree_valid))     # retry valid 
+ 35          self.assertFalse(schema.validate(tree_invalid))  # retry invalid 
+
 36   
+ 37 -    def test_xmlschema_error_log(self): 
+
 38          tree_valid = self.parse('<a><b></b></a>') 
+ 39          tree_invalid = self.parse('<a><c></c></a>') 
+ 40          schema = self.parse(''' 
+ 41  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+ 42    <xsd:element name="a" type="AType"/> 
+ 43    <xsd:complexType name="AType"> 
+ 44      <xsd:sequence> 
+ 45        <xsd:element name="b" type="xsd:string" /> 
+ 46      </xsd:sequence> 
+ 47    </xsd:complexType> 
+ 48  </xsd:schema> 
+ 49  ''') 
+ 50          schema = etree.XMLSchema(schema) 
+ 51          self.assertTrue(schema.validate(tree_valid)) 
+ 52          self.assertFalse(schema.error_log.filter_from_errors()) 
+ 53   
+ 54          self.assertFalse(schema.validate(tree_invalid)) 
+ 55          self.assertTrue(schema.error_log.filter_from_errors()) 
+ 56          self.assertTrue(schema.error_log.filter_types( 
+ 57              etree.ErrorTypes.SCHEMAV_ELEMENT_CONTENT)) 
+ 58   
+ 59          self.assertTrue(schema.validate(tree_valid)) 
+ 60          self.assertFalse(schema.error_log.filter_from_errors()) 
+ 61   
+ 62          self.assertFalse(schema.validate(tree_invalid)) 
+ 63          self.assertTrue(schema.error_log.filter_from_errors()) 
+ 64          self.assertTrue(schema.error_log.filter_types( 
+ 65              etree.ErrorTypes.SCHEMAV_ELEMENT_CONTENT)) 
+
 66   
+ 67 -    def test_xmlschema_error_log_path(self): 
+
 68          """We don't have a guarantee that there will always be a path 
+ 69          for a _LogEntry object (or even a node for which to determine 
+ 70          a path), but at least when this test was created schema validation 
+ 71          errors always got a node and an XPath value. If that ever changes, 
+ 72          we can modify this test to something like: 
+ 73              self.assertTrue(error_path is None or tree_path == error_path) 
+ 74          That way, we can at least verify that if we did get a path value 
+ 75          it wasn't bogus. 
+ 76          """ 
+ 77          tree = self.parse('<a><b>42</b><b>dada</b></a>') 
+ 78          schema = self.parse(''' 
+ 79  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+ 80    <xsd:element name="a" type="AType"/> 
+ 81    <xsd:complexType name="AType"> 
+ 82      <xsd:sequence> 
+ 83        <xsd:element name="b" type="xsd:integer" maxOccurs="2"/> 
+ 84      </xsd:sequence> 
+ 85    </xsd:complexType> 
+ 86  </xsd:schema> 
+ 87  ''') 
+ 88          schema = etree.XMLSchema(schema) 
+ 89          schema.validate(tree) 
+ 90          tree_path = tree.getpath(tree.findall('b')[1]) 
+ 91          error_path = schema.error_log[0].path 
+ 92          self.assertTrue(tree_path == error_path) 
+
 93   
+ 94 -    def test_xmlschema_default_attributes(self): 
+
 95          schema = self.parse(''' 
+ 96  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+ 97    <xsd:element name="a" type="AType"/> 
+ 98    <xsd:complexType name="AType"> 
+ 99      <xsd:sequence minOccurs="4" maxOccurs="4"> 
+100        <xsd:element name="b" type="BType" /> 
+101      </xsd:sequence> 
+102    </xsd:complexType> 
+103    <xsd:complexType name="BType"> 
+104      <xsd:attribute name="hardy" type="xsd:string" default="hey" /> 
+105    </xsd:complexType> 
+106  </xsd:schema> 
+107  ''') 
+108          schema = etree.XMLSchema(schema, attribute_defaults=True) 
+109   
+110          tree = self.parse('<a><b hardy="ho"/><b/><b hardy="ho"/><b/></a>') 
+111   
+112          root = tree.getroot() 
+113          self.assertEqual('ho', root[0].get('hardy')) 
+114          self.assertEqual(None, root[1].get('hardy')) 
+115          self.assertEqual('ho', root[2].get('hardy')) 
+116          self.assertEqual(None, root[3].get('hardy')) 
+117   
+118          self.assertTrue(schema(tree)) 
+119   
+120          root = tree.getroot() 
+121          self.assertEqual('ho', root[0].get('hardy')) 
+122          self.assertEqual('hey', root[1].get('hardy')) 
+123          self.assertEqual('ho', root[2].get('hardy')) 
+124          self.assertEqual('hey', root[3].get('hardy')) 
+
125   
+126 -    def test_xmlschema_parse(self): 
+
127          schema = self.parse(''' 
+128  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+129    <xsd:element name="a" type="AType"/> 
+130    <xsd:complexType name="AType"> 
+131      <xsd:sequence> 
+132        <xsd:element name="b" type="xsd:string" /> 
+133      </xsd:sequence> 
+134    </xsd:complexType> 
+135  </xsd:schema> 
+136  ''') 
+137          schema = etree.XMLSchema(schema) 
+138          parser = etree.XMLParser(schema=schema) 
+139   
+140          tree_valid = self.parse('<a><b></b></a>', parser=parser) 
+141          self.assertEqual('a', tree_valid.getroot().tag) 
+142   
+143          self.assertRaises(etree.XMLSyntaxError, 
+144                            self.parse, '<a><c></c></a>', parser=parser) 
+
145   
+146 -    def test_xmlschema_parse_default_attributes(self): 
+
147          # does not work as of libxml2 2.7.3 
+148          schema = self.parse(''' 
+149  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+150    <xsd:element name="a" type="AType"/> 
+151    <xsd:complexType name="AType"> 
+152      <xsd:sequence minOccurs="4" maxOccurs="4"> 
+153        <xsd:element name="b" type="BType" /> 
+154      </xsd:sequence> 
+155    </xsd:complexType> 
+156    <xsd:complexType name="BType"> 
+157      <xsd:attribute name="hardy" type="xsd:string" default="hey" /> 
+158    </xsd:complexType> 
+159  </xsd:schema> 
+160  ''') 
+161          schema = etree.XMLSchema(schema) 
+162          parser = etree.XMLParser(schema=schema, attribute_defaults=True) 
+163   
+164          tree_valid = self.parse('<a><b hardy="ho"/><b/><b hardy="ho"/><b/></a>', 
+165                                  parser=parser) 
+166          root = tree_valid.getroot() 
+167          self.assertEqual('ho', root[0].get('hardy')) 
+168          self.assertEqual('hey', root[1].get('hardy')) 
+169          self.assertEqual('ho', root[2].get('hardy')) 
+170          self.assertEqual('hey', root[3].get('hardy')) 
+
171   
+172 -    def test_xmlschema_parse_default_attributes_schema_config(self): 
+
173          # does not work as of libxml2 2.7.3 
+174          schema = self.parse(''' 
+175  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+176    <xsd:element name="a" type="AType"/> 
+177    <xsd:complexType name="AType"> 
+178      <xsd:sequence minOccurs="4" maxOccurs="4"> 
+179        <xsd:element name="b" type="BType" /> 
+180      </xsd:sequence> 
+181    </xsd:complexType> 
+182    <xsd:complexType name="BType"> 
+183      <xsd:attribute name="hardy" type="xsd:string" default="hey" /> 
+184    </xsd:complexType> 
+185  </xsd:schema> 
+186  ''') 
+187          schema = etree.XMLSchema(schema, attribute_defaults=True) 
+188          parser = etree.XMLParser(schema=schema) 
+189   
+190          tree_valid = self.parse('<a><b hardy="ho"/><b/><b hardy="ho"/><b/></a>', 
+191                                  parser=parser) 
+192          root = tree_valid.getroot() 
+193          self.assertEqual('ho', root[0].get('hardy')) 
+194          self.assertEqual('hey', root[1].get('hardy')) 
+195          self.assertEqual('ho', root[2].get('hardy')) 
+196          self.assertEqual('hey', root[3].get('hardy')) 
+
197   
+198 -    def test_xmlschema_parse_fixed_attributes(self): 
+
199          # does not work as of libxml2 2.7.3 
+200          schema = self.parse(''' 
+201  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+202    <xsd:element name="a" type="AType"/> 
+203    <xsd:complexType name="AType"> 
+204      <xsd:sequence minOccurs="3" maxOccurs="3"> 
+205        <xsd:element name="b" type="BType" /> 
+206      </xsd:sequence> 
+207    </xsd:complexType> 
+208    <xsd:complexType name="BType"> 
+209      <xsd:attribute name="hardy" type="xsd:string" fixed="hey" /> 
+210    </xsd:complexType> 
+211  </xsd:schema> 
+212  ''') 
+213          schema = etree.XMLSchema(schema) 
+214          parser = etree.XMLParser(schema=schema, attribute_defaults=True) 
+215   
+216          tree_valid = self.parse('<a><b/><b hardy="hey"/><b/></a>', 
+217                                  parser=parser) 
+218          root = tree_valid.getroot() 
+219          self.assertEqual('hey', root[0].get('hardy')) 
+220          self.assertEqual('hey', root[1].get('hardy')) 
+221          self.assertEqual('hey', root[2].get('hardy')) 
+
222   
+223 -    def test_xmlschema_stringio(self): 
+
224          schema_file = BytesIO(''' 
+225  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+226    <xsd:element name="a" type="AType"/> 
+227    <xsd:complexType name="AType"> 
+228      <xsd:sequence> 
+229        <xsd:element name="b" type="xsd:string" /> 
+230      </xsd:sequence> 
+231    </xsd:complexType> 
+232  </xsd:schema> 
+233  ''') 
+234          schema = etree.XMLSchema(file=schema_file) 
+235          parser = etree.XMLParser(schema=schema) 
+236   
+237          tree_valid = self.parse('<a><b></b></a>', parser=parser) 
+238          self.assertEqual('a', tree_valid.getroot().tag) 
+239   
+240          self.assertRaises(etree.XMLSyntaxError, 
+241                            self.parse, '<a><c></c></a>', parser=parser) 
+
242   
+243 -    def test_xmlschema_iterparse(self): 
+
244          schema = self.parse(''' 
+245  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+246    <xsd:element name="a" type="AType"/> 
+247    <xsd:complexType name="AType"> 
+248      <xsd:sequence> 
+249        <xsd:element name="b" type="xsd:string" /> 
+250      </xsd:sequence> 
+251    </xsd:complexType> 
+252  </xsd:schema> 
+253  ''') 
+254          schema = etree.XMLSchema(schema) 
+255          xml = BytesIO('<a><b></b></a>') 
+256          events = [ (event, el.tag) 
+257                     for (event, el) in etree.iterparse(xml, schema=schema) ] 
+258   
+259          self.assertEqual([('end', 'b'), ('end', 'a')], 
+260                            events) 
+
261   
+262 -    def test_xmlschema_iterparse_incomplete(self): 
+
263          schema = self.parse(''' 
+264  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+265    <xsd:element name="a" type="AType"/> 
+266    <xsd:complexType name="AType"> 
+267      <xsd:sequence> 
+268        <xsd:element name="b" type="xsd:string" /> 
+269      </xsd:sequence> 
+270    </xsd:complexType> 
+271  </xsd:schema> 
+272  ''') 
+273          schema = etree.XMLSchema(schema) 
+274          xml = BytesIO('<a><b></b></a>') 
+275          event, element = next(iter(etree.iterparse(xml, schema=schema))) 
+276          self.assertEqual('end', event) 
+277          self.assertEqual('b', element.tag) 
+
278   
+279 -    def test_xmlschema_iterparse_fail(self): 
+
280          schema = self.parse(''' 
+281  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+282    <xsd:element name="a" type="AType"/> 
+283    <xsd:complexType name="AType"> 
+284      <xsd:sequence> 
+285        <xsd:element name="b" type="xsd:string" /> 
+286      </xsd:sequence> 
+287    </xsd:complexType> 
+288  </xsd:schema> 
+289  ''') 
+290          schema = etree.XMLSchema(schema) 
+291          self.assertRaises( 
+292              etree.XMLSyntaxError, 
+293              list, etree.iterparse(BytesIO('<a><c></c></a>'), schema=schema)) 
+
294   
+295 -    def test_xmlschema_elementtree_error(self): 
+
296          self.assertRaises(ValueError, etree.XMLSchema, etree.ElementTree()) 
+
297   
+298 -    def test_xmlschema_comment_error(self): 
+
299          self.assertRaises(ValueError, etree.XMLSchema, etree.Comment('TEST')) 
+
300   
+301 -    def test_xmlschema_illegal_validation_error(self): 
+
302          schema = self.parse(''' 
+303  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+304    <xsd:element name="a" type="xsd:string"/> 
+305  </xsd:schema> 
+306  ''') 
+307          schema = etree.XMLSchema(schema) 
+308   
+309          root = etree.Element('a') 
+310          root.text = 'TEST' 
+311          self.assertTrue(schema(root)) 
+312   
+313          self.assertRaises(ValueError, schema, etree.Comment('TEST')) 
+314          self.assertRaises(ValueError, schema, etree.PI('a', 'text')) 
+315          self.assertRaises(ValueError, schema, etree.Entity('text')) 
+
316   
+317 -    def test_xmlschema_invalid_schema1(self): 
+
318          schema = self.parse('''\ 
+319  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+320    <element name="a" type="AType"/> 
+321    <xsd:complexType name="AType"> 
+322      <xsd:sequence> 
+323        <xsd:element name="b" type="xsd:string" /> 
+324      </xsd:sequence> 
+325    </xsd:complexType> 
+326  </xsd:schema> 
+327  ''') 
+328          self.assertRaises(etree.XMLSchemaParseError, 
+329                            etree.XMLSchema, schema) 
+
330   
+331 -    def test_xmlschema_invalid_schema2(self): 
+
332          schema = self.parse('<test/>') 
+333          self.assertRaises(etree.XMLSchemaParseError, 
+334                            etree.XMLSchema, schema) 
+
335   
+336 -    def test_xmlschema_file(self): 
+
337          # this will only work if we access the file through path or 
+338          # file object.. 
+339          f = open(fileInTestDir('test.xsd'), 'rb') 
+340          try: 
+341              schema = etree.XMLSchema(file=f) 
+342          finally: 
+343              f.close() 
+344          tree_valid = self.parse('<a><b></b></a>') 
+345          self.assertTrue(schema.validate(tree_valid)) 
+
346   
+347 -    def test_xmlschema_import_file(self): 
+
348          # this will only work if we access the file through path or 
+349          # file object.. 
+350          schema = etree.XMLSchema(file=fileInTestDir('test_import.xsd')) 
+351          tree_valid = self.parse( 
+352              '<a:x xmlns:a="http://codespeak.net/lxml/schema/ns1"><b></b></a:x>') 
+353          self.assertTrue(schema.validate(tree_valid)) 
+
354   
+355 -    def test_xmlschema_shortcut(self): 
+
356          tree_valid = self.parse('<a><b></b></a>') 
+357          tree_invalid = self.parse('<a><c></c></a>') 
+358          schema = self.parse('''\ 
+359  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
+360    <xsd:element name="a" type="AType"/> 
+361    <xsd:complexType name="AType"> 
+362      <xsd:sequence> 
+363        <xsd:element name="b" type="xsd:string" /> 
+364      </xsd:sequence> 
+365    </xsd:complexType> 
+366  </xsd:schema> 
+367  ''') 
+368          self.assertTrue(tree_valid.xmlschema(schema)) 
+369          self.assertFalse(tree_invalid.xmlschema(schema)) 
+
370   
+371 -    def test_create_from_partial_doc(self): 
+
372          # this used to crash because the schema part was not properly copied out 
+373          wsdl = self.parse('''\ 
+374  <wsdl:definitions 
+375     xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
+376     xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
+377   <wsdl:types> 
+378    <xs:schema> 
+379    </xs:schema> 
+380   </wsdl:types> 
+381  </wsdl:definitions> 
+382          ''') 
+383          schema_element = wsdl.find( 
+384              "{http://schemas.xmlsoap.org/wsdl/}types/" 
+385              "{http://www.w3.org/2001/XMLSchema}schema" 
+386          ) 
+387          etree.XMLSchema(schema_element) 
+388          etree.XMLSchema(schema_element) 
+389          etree.XMLSchema(schema_element) 
+
390   
+391   
+392 -class ETreeXMLSchemaResolversTestCase(HelperTestCase): 
+
393      resolver_schema_int = BytesIO("""\ 
+394  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+395      xmlns:etype="http://codespeak.net/lxml/test/external" 
+396      targetNamespace="http://codespeak.net/lxml/test/internal"> 
+397          <xsd:import namespace="http://codespeak.net/lxml/test/external" schemaLocation="XXX.xsd" /> 
+398          <xsd:element name="a" type="etype:AType"/> 
+399  </xsd:schema>""") 
+400   
+401      resolver_schema_int2 = BytesIO("""\ 
+402  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+403      xmlns:etype="http://codespeak.net/lxml/test/external" 
+404      targetNamespace="http://codespeak.net/lxml/test/internal"> 
+405          <xsd:import namespace="http://codespeak.net/lxml/test/external" schemaLocation="YYY.xsd" /> 
+406          <xsd:element name="a" type="etype:AType"/> 
+407  </xsd:schema>""") 
+408   
+409      resolver_schema_ext = """\ 
+410  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+411      targetNamespace="http://codespeak.net/lxml/test/external"> 
+412      <xsd:complexType name="AType"> 
+413        <xsd:sequence><xsd:element name="b" type="xsd:string" minOccurs="0" maxOccurs="unbounded" /></xsd:sequence> 
+414      </xsd:complexType> 
+415  </xsd:schema>""" 
+416   
+417 -    class simple_resolver(etree.Resolver): 
+
418 -        def __init__(self, schema): 
+
419              self.schema = schema 
+
420   
+421 -        def resolve(self, url, id, context): 
+
422              assert url == 'XXX.xsd' 
+423              return self.resolve_string(self.schema, context) 
+
424   
+425      # tests: 
+426   
+427 -    def test_xmlschema_resolvers(self): 
+
428          # test that resolvers work with schema. 
+429          parser = etree.XMLParser() 
+430          parser.resolvers.add(self.simple_resolver(self.resolver_schema_ext)) 
+431          schema_doc = etree.parse(self.resolver_schema_int, parser = parser) 
+432          schema = etree.XMLSchema(schema_doc) 
+
433   
+434 -    def test_xmlschema_resolvers_root(self): 
+
435          # test that the default resolver will get called if there's no 
+436          # specific parser resolver. 
+437          root_resolver = self.simple_resolver(self.resolver_schema_ext) 
+438          etree.get_default_parser().resolvers.add(root_resolver) 
+439          schema_doc = etree.parse(self.resolver_schema_int) 
+440          schema = etree.XMLSchema(schema_doc) 
+441          etree.get_default_parser().resolvers.remove(root_resolver) 
+
442   
+443 -    def test_xmlschema_resolvers_noroot(self): 
+
444          # test that the default resolver will not get called when a 
+445          # more specific resolver is registered. 
+446   
+447          class res_root(etree.Resolver): 
+448              def resolve(self, url, id, context): 
+449                  assert False 
+450                  return None 
+
451   
+452          root_resolver = res_root() 
+453          etree.get_default_parser().resolvers.add(root_resolver) 
+454   
+455          parser = etree.XMLParser() 
+456          parser.resolvers.add(self.simple_resolver(self.resolver_schema_ext)) 
+457   
+458          schema_doc = etree.parse(self.resolver_schema_int, parser = parser) 
+459          schema = etree.XMLSchema(schema_doc) 
+460          etree.get_default_parser().resolvers.remove(root_resolver) 
+461   
+462 -    def test_xmlschema_nested_resolvers(self): 
+
463          # test that resolvers work in a nested fashion. 
+464   
+465          resolver_schema = self.resolver_schema_ext 
+466   
+467          class res_nested(etree.Resolver): 
+468              def __init__(self, ext_schema): 
+469                  self.ext_schema = ext_schema 
+
470   
+471              def resolve(self, url, id, context): 
+472                  assert url == 'YYY.xsd' 
+473                  return self.resolve_string(self.ext_schema, context) 
+474   
+475          class res(etree.Resolver): 
+476              def __init__(self, ext_schema_1, ext_schema_2): 
+477                  self.ext_schema_1 = ext_schema_1 
+478                  self.ext_schema_2 = ext_schema_2 
+479   
+480              def resolve(self, url, id, context): 
+481                  assert url == 'XXX.xsd' 
+482   
+483                  new_parser = etree.XMLParser() 
+484                  new_parser.resolvers.add(res_nested(self.ext_schema_2)) 
+485                  new_schema_doc = etree.parse(self.ext_schema_1, parser = new_parser) 
+486                  new_schema = etree.XMLSchema(new_schema_doc) 
+487   
+488                  return self.resolve_string(resolver_schema, context) 
+489   
+490          parser = etree.XMLParser() 
+491          parser.resolvers.add(res(self.resolver_schema_int2, self.resolver_schema_ext)) 
+492          schema_doc = etree.parse(self.resolver_schema_int, parser = parser) 
+493          schema = etree.XMLSchema(schema_doc) 
+494   
+495   
+496 -def test_suite(): 
+
497      suite = unittest.TestSuite() 
+498      suite.addTests([unittest.makeSuite(ETreeXMLSchemaTestCase)]) 
+499      suite.addTests([unittest.makeSuite(ETreeXMLSchemaResolversTestCase)]) 
+500      suite.addTests( 
+501          [make_doctest('../../../doc/validation.txt')]) 
+502      return suite 
+
503   
+504   
+505  if __name__ == '__main__': 
+506      print('to test use test.py %s' % __file__) 
+507   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeXMLSchemaResolversTestCase
+
+'''<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    targetNamespace="http://codespeak.net/lxml/test/external">
+    <xsd:complexType name="AType">
+      <xsd:sequence><xsd:element name="b" type="xsd:string" minOccurs=
+"0" maxOccurs="unbounded" /></xsd:sequence>
+    </xsd:complexType>
+</xsd:schema>'''
+
+    object --+    
+             |    
+etree.Resolver --+
+                 |
+                ETreeXMLSchemaResolversTestCase.simple_resolver
+
system_url
public_id
system_url
public_id
resolve_*()
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeXMLSchemaTestCase
+
+We don't have a guarantee that there will always be a path
+for a _LogEntry object (or even a node for which to determine
+a path), but at least when this test was created schema validation
+errors always got a node and an XPath value. If that ever changes,
+we can modify this test to something like:
+    self.assertTrue(error_path is None or tree_path == error_path)
+That way, we can at least verify that if we did get a path value
+it wasn't bogus.
+
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+{(None, 'argsTest1'): <__builtin__.function object>,
+ (None, 'argsTest2'): <__builtin__.function object>,
+ (None, 'booleanTest'): <__builtin__.function object>,
+ (None, 'floatTest'): <__builtin__.function object>,
+ (None, 'resultTypesTest'): <__builtin__.function object>,
+ (None, 'resultTypesTest2'): <__builtin__.function object>,
+ (None, 'setTest'): <__builtin__.function object>,
+ (None, 'setTest2'): <__builtin__.function object>,
+...
+
+  1  # -*- coding: utf-8 -*- 
+  2   
+  3  """ 
+  4  Test cases related to XPath evaluation and the XPath class 
+  5  """ 
+  6   
+  7  import unittest, sys, os.path 
+  8   
+  9  this_dir = os.path.dirname(__file__) 
+ 10  if this_dir not in sys.path: 
+ 11      sys.path.insert(0, this_dir) # needed for Py3 
+ 12   
+ 13  from common_imports import etree, HelperTestCase, _bytes, BytesIO 
+ 14  from common_imports import doctest, make_doctest 
+ 15   
+ 16 -class ETreeXPathTestCase(HelperTestCase): 
+
 17      """XPath tests etree""" 
+ 18   
+ 19 -    def test_xpath_boolean(self): 
+
 20          tree = self.parse('<a><b></b><b></b></a>') 
+ 21          self.assertTrue(tree.xpath('boolean(/a/b)')) 
+ 22          self.assertTrue(not tree.xpath('boolean(/a/c)')) 
+
 23   
+ 24 -    def test_xpath_number(self): 
+
 25          tree = self.parse('<a>1</a>') 
+ 26          self.assertEqual(1., 
+ 27                            tree.xpath('number(/a)')) 
+ 28          tree = self.parse('<a>A</a>') 
+ 29          actual = str(tree.xpath('number(/a)')) 
+ 30          expected = ['nan', '1.#qnan', 'nanq'] 
+ 31          if not actual.lower() in expected: 
+ 32              self.fail('Expected a NAN value, got %s' % actual) 
+
 33           
+ 34 -    def test_xpath_string(self): 
+
 35          tree = self.parse('<a>Foo</a>') 
+ 36          self.assertEqual('Foo', 
+ 37                            tree.xpath('string(/a/text())')) 
+
 38   
+ 39 -    def test_xpath_document_root(self): 
+
 40          tree = self.parse('<a><b/></a>') 
+ 41          self.assertEqual([], 
+ 42                            tree.xpath('/')) 
+
 43   
+ 44 -    def test_xpath_namespace(self): 
+
 45          tree = self.parse('<a xmlns="test" xmlns:p="myURI"/>') 
+ 46          self.assertTrue((None, "test") in tree.xpath('namespace::*')) 
+ 47          self.assertTrue(('p', 'myURI') in tree.xpath('namespace::*')) 
+
 48   
+ 49 -    def test_xpath_namespace_empty(self): 
+
 50          tree = self.parse('<a/>') 
+ 51          self.assertEqual([('xml', 'http://www.w3.org/XML/1998/namespace')], 
+ 52                            tree.xpath('namespace::*')) 
+
 53   
+ 54 -    def test_xpath_list_elements(self): 
+
 55          tree = self.parse('<a><b>Foo</b><b>Bar</b></a>') 
+ 56          root = tree.getroot() 
+ 57          self.assertEqual([root[0], root[1]], 
+ 58                            tree.xpath('/a/b')) 
+
 59   
+ 60 -    def test_xpath_list_nothing(self): 
+
 61          tree = self.parse('<a><b/></a>') 
+ 62          self.assertEqual([], 
+ 63                            tree.xpath('/a/c')) 
+ 64          # this seems to pass a different code path, also should return nothing 
+ 65          self.assertEqual([], 
+ 66                            tree.xpath('/a/c/text()')) 
+
 67       
+ 68 -    def test_xpath_list_text(self): 
+
 69          tree = self.parse('<a><b>Foo</b><b>Bar</b></a>') 
+ 70          root = tree.getroot() 
+ 71          self.assertEqual(['Foo', 'Bar'], 
+ 72                            tree.xpath('/a/b/text()')) 
+
 73   
+ 74 -    def test_xpath_list_text_parent(self): 
+
 75          tree = self.parse('<a><b>FooBar</b><b>BarFoo</b></a>') 
+ 76          root = tree.getroot() 
+ 77          self.assertEqual(['FooBar', 'BarFoo'], 
+ 78                            tree.xpath('/a/b/text()')) 
+ 79          self.assertEqual([root[0], root[1]], 
+ 80                            [r.getparent() for r in tree.xpath('/a/b/text()')]) 
+
 81   
+ 82 -    def test_xpath_list_text_parent_no_smart_strings(self): 
+
 83          tree = self.parse('<a><b>FooBar</b><b>BarFoo</b></a>') 
+ 84          root = tree.getroot() 
+ 85          self.assertEqual(['FooBar', 'BarFoo'], 
+ 86                            tree.xpath('/a/b/text()', smart_strings=True)) 
+ 87          self.assertEqual([root[0], root[1]], 
+ 88                            [r.getparent() for r in 
+ 89                             tree.xpath('/a/b/text()', smart_strings=True)]) 
+ 90          self.assertEqual([None, None], 
+ 91                            [r.attrname for r in 
+ 92                             tree.xpath('/a/b/text()', smart_strings=True)]) 
+ 93   
+ 94          self.assertEqual(['FooBar', 'BarFoo'], 
+ 95                            tree.xpath('/a/b/text()', smart_strings=False)) 
+ 96          self.assertEqual([False, False], 
+ 97                            [hasattr(r, 'getparent') for r in 
+ 98                             tree.xpath('/a/b/text()', smart_strings=False)]) 
+ 99          self.assertEqual([None, None], 
+100                            [r.attrname for r in 
+101                             tree.xpath('/a/b/text()', smart_strings=True)]) 
+
102   
+103 -    def test_xpath_list_unicode_text_parent(self): 
+
104          xml = _bytes('<a><b>FooBar\\u0680\\u3120</b><b>BarFoo\\u0680\\u3120</b></a>').decode("unicode_escape") 
+105          tree = self.parse(xml.encode('utf-8')) 
+106          root = tree.getroot() 
+107          self.assertEqual([_bytes('FooBar\\u0680\\u3120').decode("unicode_escape"), 
+108                             _bytes('BarFoo\\u0680\\u3120').decode("unicode_escape")], 
+109                            tree.xpath('/a/b/text()')) 
+110          self.assertEqual([root[0], root[1]], 
+111                            [r.getparent() for r in tree.xpath('/a/b/text()')]) 
+
112   
+113 -    def test_xpath_list_attribute(self): 
+
114          tree = self.parse('<a b="B" c="C"/>') 
+115          self.assertEqual(['B'], 
+116                            tree.xpath('/a/@b')) 
+
117   
+118 -    def test_xpath_list_attribute_parent(self): 
+
119          tree = self.parse('<a b="BaSdFgHjKl" c="CqWeRtZuI"/>') 
+120          results = tree.xpath('/a/@c') 
+121          self.assertEqual(1, len(results)) 
+122          self.assertEqual('CqWeRtZuI', results[0]) 
+123          self.assertEqual(tree.getroot().tag, results[0].getparent().tag) 
+
124   
+125 -    def test_xpath_list_attribute_parent_no_smart_strings(self): 
+
126          tree = self.parse('<a b="BaSdFgHjKl" c="CqWeRtZuI"/>') 
+127   
+128          results = tree.xpath('/a/@c', smart_strings=True) 
+129          self.assertEqual(1, len(results)) 
+130          self.assertEqual('CqWeRtZuI', results[0]) 
+131          self.assertEqual('c', results[0].attrname) 
+132          self.assertEqual(tree.getroot().tag, results[0].getparent().tag) 
+133   
+134          results = tree.xpath('/a/@c', smart_strings=False) 
+135          self.assertEqual(1, len(results)) 
+136          self.assertEqual('CqWeRtZuI', results[0]) 
+137          self.assertEqual(False, hasattr(results[0], 'getparent')) 
+138          self.assertEqual(False, hasattr(results[0], 'attrname')) 
+
139   
+140 -    def test_xpath_text_from_other_document(self): 
+
141          xml_data = ''' 
+142          <table> 
+143                  <item xml:id="k1"><value>v1</value></item> 
+144                  <item xml:id="k2"><value>v2</value></item> 
+145          </table> 
+146          ''' 
+147   
+148          def lookup(dummy, id): 
+149              return etree.XML(xml_data).xpath('id(%r)' % id) 
+
150          functions = {(None, 'lookup') : lookup} 
+151   
+152          root = etree.XML('<dummy/>') 
+153          values = root.xpath("lookup('k1')/value/text()", 
+154                             extensions=functions) 
+155          self.assertEqual(['v1'], values) 
+156          self.assertEqual('value', values[0].getparent().tag) 
+
157   
+158 -    def test_xpath_list_comment(self): 
+
159          tree = self.parse('<a><!-- Foo --></a>') 
+160          self.assertEqual(['<!-- Foo -->'], 
+161                            list(map(repr, tree.xpath('/a/node()')))) 
+
162   
+163 -    def test_rel_xpath_boolean(self): 
+
164          root = etree.XML('<a><b><c/></b></a>') 
+165          el = root[0] 
+166          self.assertTrue(el.xpath('boolean(c)')) 
+167          self.assertTrue(not el.xpath('boolean(d)')) 
+
168   
+169 -    def test_rel_xpath_list_elements(self): 
+
170          tree = self.parse('<a><c><b>Foo</b><b>Bar</b></c><c><b>Hey</b></c></a>') 
+171          root = tree.getroot() 
+172          c = root[0] 
+173          self.assertEqual([c[0], c[1]], 
+174                            c.xpath('b')) 
+175          self.assertEqual([c[0], c[1], root[1][0]], 
+176                            c.xpath('//b')) 
+
177   
+178 -    def test_xpath_ns(self): 
+
179          tree = self.parse('<a xmlns="uri:a"><b></b></a>') 
+180          root = tree.getroot() 
+181          self.assertEqual( 
+182              [root[0]], 
+183              tree.xpath('//foo:b', namespaces={'foo': 'uri:a'})) 
+184          self.assertEqual( 
+185              [], 
+186              tree.xpath('//foo:b', namespaces={'foo': 'uri:c'})) 
+187          self.assertEqual( 
+188              [root[0]], 
+189              root.xpath('//baz:b', namespaces={'baz': 'uri:a'})) 
+
190   
+191 -    def test_xpath_ns_none(self): 
+
192          tree = self.parse('<a xmlns="uri:a"><b></b></a>') 
+193          root = tree.getroot() 
+194          self.assertRaises( 
+195              TypeError, 
+196              root.xpath, '//b', namespaces={None: 'uri:a'}) 
+
197   
+198 -    def test_xpath_ns_empty(self): 
+
199          tree = self.parse('<a xmlns="uri:a"><b></b></a>') 
+200          root = tree.getroot() 
+201          self.assertRaises( 
+202              TypeError, 
+203              root.xpath, '//b', namespaces={'': 'uri:a'}) 
+
204   
+205 -    def test_xpath_error(self): 
+
206          tree = self.parse('<a/>') 
+207          self.assertRaises(etree.XPathEvalError, tree.xpath, '\\fad') 
+
208   
+209 -    def test_xpath_class_error(self): 
+
210          self.assertRaises(SyntaxError, etree.XPath, '\\fad') 
+211          self.assertRaises(etree.XPathSyntaxError, etree.XPath, '\\fad') 
+
212   
+213 -    def test_xpath_prefix_error(self): 
+
214          tree = self.parse('<a/>') 
+215          self.assertRaises(etree.XPathEvalError, tree.xpath, '/fa:d') 
+
216   
+217 -    def test_xpath_class_prefix_error(self): 
+
218          tree = self.parse('<a/>') 
+219          xpath = etree.XPath("/fa:d") 
+220          self.assertRaises(etree.XPathEvalError, xpath, tree) 
+
221   
+222 -    def test_elementtree_getpath(self): 
+
223          a  = etree.Element("a") 
+224          b  = etree.SubElement(a, "b") 
+225          c  = etree.SubElement(a, "c") 
+226          d1 = etree.SubElement(c, "d") 
+227          d2 = etree.SubElement(c, "d") 
+228   
+229          tree = etree.ElementTree(a) 
+230          self.assertEqual('/a/c/d', 
+231                           tree.getpath(d2)[:6]) 
+232          self.assertEqual([d2], 
+233                           tree.xpath(tree.getpath(d2))) 
+
234   
+235 -    def test_elementtree_getpath_partial(self): 
+
236          a  = etree.Element("a") 
+237          b  = etree.SubElement(a, "b") 
+238          c  = etree.SubElement(a, "c") 
+239          d1 = etree.SubElement(c, "d") 
+240          d2 = etree.SubElement(c, "d") 
+241   
+242          tree = etree.ElementTree(c) 
+243          self.assertEqual('/c/d', 
+244                           tree.getpath(d2)[:4]) 
+245          self.assertEqual([d2], 
+246                           tree.xpath(tree.getpath(d2))) 
+
247   
+248 -    def test_xpath_evaluator(self): 
+
249          tree = self.parse('<a><b><c></c></b></a>') 
+250          e = etree.XPathEvaluator(tree) 
+251          root = tree.getroot() 
+252          self.assertEqual( 
+253              [root], 
+254              e('//a')) 
+
255   
+256 -    def test_xpath_evaluator_tree(self): 
+
257          tree = self.parse('<a><b><c></c></b></a>') 
+258          child_tree = etree.ElementTree(tree.getroot()[0]) 
+259          e = etree.XPathEvaluator(child_tree) 
+260          self.assertEqual( 
+261              [], 
+262              e('a')) 
+263          root = child_tree.getroot() 
+264          self.assertEqual( 
+265              [root[0]], 
+266              e('c')) 
+
267   
+268 -    def test_xpath_evaluator_tree_absolute(self): 
+
269          tree = self.parse('<a><b><c></c></b></a>') 
+270          child_tree = etree.ElementTree(tree.getroot()[0]) 
+271          e = etree.XPathEvaluator(child_tree) 
+272          self.assertEqual( 
+273              [], 
+274              e('/a')) 
+275          root = child_tree.getroot() 
+276          self.assertEqual( 
+277              [root], 
+278              e('/b')) 
+279          self.assertEqual( 
+280              [], 
+281              e('/c')) 
+
282   
+283 -    def test_xpath_evaluator_element(self): 
+
284          tree = self.parse('<a><b><c></c></b></a>') 
+285          root = tree.getroot() 
+286          e = etree.XPathEvaluator(root[0]) 
+287          self.assertEqual( 
+288              [root[0][0]], 
+289              e('c')) 
+
290           
+291 -    def test_xpath_extensions(self): 
+
292          def foo(evaluator, a): 
+293              return 'hello %s' % a 
+
294          extension = {(None, 'foo'): foo} 
+295          tree = self.parse('<a><b></b></a>') 
+296          e = etree.XPathEvaluator(tree, extensions=[extension]) 
+297          self.assertEqual( 
+298              "hello you", e("foo('you')")) 
+299   
+300 -    def test_xpath_extensions_wrong_args(self): 
+
301          def foo(evaluator, a, b): 
+302              return "hello %s and %s" % (a, b) 
+
303          extension = {(None, 'foo'): foo} 
+304          tree = self.parse('<a><b></b></a>') 
+305          e = etree.XPathEvaluator(tree, extensions=[extension]) 
+306          self.assertRaises(TypeError, e, "foo('you')") 
+307   
+308 -    def test_xpath_extensions_error(self): 
+
309          def foo(evaluator, a): 
+310              return 1/0 
+
311          extension = {(None, 'foo'): foo} 
+312          tree = self.parse('<a/>') 
+313          e = etree.XPathEvaluator(tree, extensions=[extension]) 
+314          self.assertRaises(ZeroDivisionError, e, "foo('test')") 
+315   
+316 -    def test_xpath_extensions_nodes(self): 
+
317          def f(evaluator, arg): 
+318              r = etree.Element('results') 
+319              b = etree.SubElement(r, 'result') 
+320              b.text = 'Hoi' 
+321              b = etree.SubElement(r, 'result') 
+322              b.text = 'Dag' 
+323              return r 
+
324   
+325          x = self.parse('<a/>') 
+326          e = etree.XPathEvaluator(x, extensions=[{(None, 'foo'): f}]) 
+327          r = e("foo('World')/result") 
+328          self.assertEqual(2, len(r)) 
+329          self.assertEqual('Hoi', r[0].text) 
+330          self.assertEqual('Dag', r[1].text) 
+331   
+332 -    def test_xpath_extensions_nodes_append(self): 
+
333          def f(evaluator, nodes): 
+334              r = etree.SubElement(nodes[0], 'results') 
+335              b = etree.SubElement(r, 'result') 
+336              b.text = 'Hoi' 
+337              b = etree.SubElement(r, 'result') 
+338              b.text = 'Dag' 
+339              return r 
+
340   
+341          x = self.parse('<a/>') 
+342          e = etree.XPathEvaluator(x, extensions=[{(None, 'foo'): f}]) 
+343          r = e("foo(/*)/result") 
+344          self.assertEqual(2, len(r)) 
+345          self.assertEqual('Hoi', r[0].text) 
+346          self.assertEqual('Dag', r[1].text) 
+347   
+348 -    def test_xpath_extensions_nodes_append2(self): 
+
349          def f(evaluator, nodes): 
+350              r = etree.Element('results') 
+351              b = etree.SubElement(r, 'result') 
+352              b.text = 'Hoi' 
+353              b = etree.SubElement(r, 'result') 
+354              b.text = 'Dag' 
+355              r.append(nodes[0]) 
+356              return r 
+
357   
+358          x = self.parse('<result>Honk</result>') 
+359          e = etree.XPathEvaluator(x, extensions=[{(None, 'foo'): f}]) 
+360          r = e("foo(/*)/result") 
+361          self.assertEqual(3, len(r)) 
+362          self.assertEqual('Hoi',  r[0].text) 
+363          self.assertEqual('Dag',  r[1].text) 
+364          self.assertEqual('Honk', r[2].text) 
+365   
+366 -    def test_xpath_context_node(self): 
+
367          tree = self.parse('<root><a/><b><c/></b></root>') 
+368   
+369          check_call = [] 
+370          def check_context(ctxt, nodes): 
+371              self.assertEqual(len(nodes), 1) 
+372              check_call.append(nodes[0].tag) 
+373              self.assertEqual(ctxt.context_node, nodes[0]) 
+374              return True 
+
375   
+376          find = etree.XPath("//*[p:foo(.)]", 
+377                             namespaces={'p' : 'ns'}, 
+378                             extensions=[{('ns', 'foo') : check_context}]) 
+379          find(tree) 
+380   
+381          check_call.sort() 
+382          self.assertEqual(check_call, ["a", "b", "c", "root"]) 
+383   
+384 -    def test_xpath_eval_context_propagation(self): 
+
385          tree = self.parse('<root><a/><b><c/></b></root>') 
+386   
+387          check_call = {} 
+388          def check_context(ctxt, nodes): 
+389              self.assertEqual(len(nodes), 1) 
+390              tag = nodes[0].tag 
+391              # empty during the "b" call, a "b" during the "c" call 
+392              check_call[tag] = ctxt.eval_context.get("b") 
+393              ctxt.eval_context[tag] = tag 
+394              return True 
+
395   
+396          find = etree.XPath("//b[p:foo(.)]/c[p:foo(.)]", 
+397                             namespaces={'p' : 'ns'}, 
+398                             extensions=[{('ns', 'foo') : check_context}]) 
+399          result = find(tree) 
+400   
+401          self.assertEqual(result, [tree.getroot()[1][0]]) 
+402          self.assertEqual(check_call, {'b':None, 'c':'b'}) 
+403   
+404 -    def test_xpath_eval_context_clear(self): 
+
405          tree = self.parse('<root><a/><b><c/></b></root>') 
+406   
+407          check_call = {} 
+408          def check_context(ctxt): 
+409              check_call["done"] = True 
+410              # context must be empty for each new evaluation 
+411              self.assertEqual(len(ctxt.eval_context), 0) 
+412              ctxt.eval_context["test"] = True 
+413              return True 
+
414   
+415          find = etree.XPath("//b[p:foo()]", 
+416                             namespaces={'p' : 'ns'}, 
+417                             extensions=[{('ns', 'foo') : check_context}]) 
+418          result = find(tree) 
+419   
+420          self.assertEqual(result, [tree.getroot()[1]]) 
+421          self.assertEqual(check_call["done"], True) 
+422   
+423          check_call.clear() 
+424          find = etree.XPath("//b[p:foo()]", 
+425                             namespaces={'p' : 'ns'}, 
+426                             extensions=[{('ns', 'foo') : check_context}]) 
+427          result = find(tree) 
+428   
+429          self.assertEqual(result, [tree.getroot()[1]]) 
+430          self.assertEqual(check_call["done"], True) 
+431   
+432 -    def test_xpath_variables(self): 
+
433          x = self.parse('<a attr="true"/>') 
+434          e = etree.XPathEvaluator(x) 
+435   
+436          expr = "/a[@attr=$aval]" 
+437          r = e(expr, aval=1) 
+438          self.assertEqual(0, len(r)) 
+439   
+440          r = e(expr, aval="true") 
+441          self.assertEqual(1, len(r)) 
+442          self.assertEqual("true", r[0].get('attr')) 
+443   
+444          r = e(expr, aval=True) 
+445          self.assertEqual(1, len(r)) 
+446          self.assertEqual("true", r[0].get('attr')) 
+
447   
+448 -    def test_xpath_variables_nodeset(self): 
+
449          x = self.parse('<a attr="true"/>') 
+450          e = etree.XPathEvaluator(x) 
+451   
+452          element = etree.Element("test-el") 
+453          etree.SubElement(element, "test-sub") 
+454          expr = "$value" 
+455          r = e(expr, value=element) 
+456          self.assertEqual(1, len(r)) 
+457          self.assertEqual(element.tag, r[0].tag) 
+458          self.assertEqual(element[0].tag, r[0][0].tag) 
+
459   
+460 -    def test_xpath_extensions_mix(self): 
+
461          x = self.parse('<a attr="true"><test/></a>') 
+462   
+463          class LocalException(Exception): 
+464              pass 
+
465   
+466          def foo(evaluator, a, varval): 
+467              etree.Element("DUMMY") 
+468              if varval == 0: 
+469                  raise LocalException 
+470              elif varval == 1: 
+471                  return () 
+472              elif varval == 2: 
+473                  return None 
+474              elif varval == 3: 
+475                  return a[0][0] 
+476              a = a[0] 
+477              if a.get("attr") == str(varval): 
+478                  return a 
+479              else: 
+480                  return etree.Element("NODE") 
+481   
+482          extension = {(None, 'foo'): foo} 
+483          e = etree.XPathEvaluator(x, extensions=[extension]) 
+484          del x 
+485   
+486          self.assertRaises(LocalException, e, "foo(., 0)") 
+487          self.assertRaises(LocalException, e, "foo(., $value)", value=0) 
+488   
+489          r = e("foo(., $value)", value=1) 
+490          self.assertEqual(len(r), 0) 
+491   
+492          r = e("foo(.,  1)") 
+493          self.assertEqual(len(r), 0) 
+494   
+495          r = e("foo(., $value)", value=2) 
+496          self.assertEqual(len(r), 0) 
+497   
+498          r = e("foo(., $value)", value=3) 
+499          self.assertEqual(len(r), 1) 
+500          self.assertEqual(r[0].tag, "test") 
+501   
+502          r = e("foo(., $value)", value="false") 
+503          self.assertEqual(len(r), 1) 
+504          self.assertEqual(r[0].tag, "NODE") 
+505   
+506          r = e("foo(., 'false')") 
+507          self.assertEqual(len(r), 1) 
+508          self.assertEqual(r[0].tag, "NODE") 
+509   
+510          r = e("foo(., 'true')") 
+511          self.assertEqual(len(r), 1) 
+512          self.assertEqual(r[0].tag, "a") 
+513          self.assertEqual(r[0][0].tag, "test") 
+514   
+515          r = e("foo(., $value)", value="true") 
+516          self.assertEqual(len(r), 1) 
+517          self.assertEqual(r[0].tag, "a") 
+518   
+519          self.assertRaises(LocalException, e, "foo(., 0)") 
+520          self.assertRaises(LocalException, e, "foo(., $value)", value=0) 
+521   
+522   
+523 -class ETreeXPathClassTestCase(HelperTestCase): 
+
524      "Tests for the XPath class" 
+525 -    def test_xpath_compile_doc(self): 
+
526          x = self.parse('<a attr="true"/>') 
+527   
+528          expr = etree.XPath("/a[@attr != 'true']") 
+529          r = expr(x) 
+530          self.assertEqual(0, len(r)) 
+531   
+532          expr = etree.XPath("/a[@attr = 'true']") 
+533          r = expr(x) 
+534          self.assertEqual(1, len(r)) 
+535   
+536          expr = etree.XPath( expr.path ) 
+537          r = expr(x) 
+538          self.assertEqual(1, len(r)) 
+
539   
+540 -    def test_xpath_compile_element(self): 
+
541          x = self.parse('<a><b/><c/></a>') 
+542          root = x.getroot() 
+543   
+544          expr = etree.XPath("./b") 
+545          r = expr(root) 
+546          self.assertEqual(1, len(r)) 
+547          self.assertEqual('b', r[0].tag) 
+548   
+549          expr = etree.XPath("./*") 
+550          r = expr(root) 
+551          self.assertEqual(2, len(r)) 
+
552   
+553 -    def test_xpath_compile_vars(self): 
+
554          x = self.parse('<a attr="true"/>') 
+555   
+556          expr = etree.XPath("/a[@attr=$aval]") 
+557          r = expr(x, aval=False) 
+558          self.assertEqual(0, len(r)) 
+559   
+560          r = expr(x, aval=True) 
+561          self.assertEqual(1, len(r)) 
+
562   
+563 -    def test_xpath_compile_error(self): 
+
564          self.assertRaises(SyntaxError, etree.XPath, '\\fad') 
+
565   
+566 -    def test_xpath_elementtree_error(self): 
+
567          self.assertRaises(ValueError, etree.XPath('*'), etree.ElementTree()) 
+
568   
+569   
+570 -class ETreeXPathExsltTestCase(HelperTestCase): 
+
571      "Tests for the EXSLT support in XPath (requires libxslt 1.1.25+)" 
+572   
+573      NSMAP = dict( 
+574          date = "http://exslt.org/dates-and-times", 
+575          math = "http://exslt.org/math", 
+576          set  = "http://exslt.org/sets", 
+577          str  = "http://exslt.org/strings", 
+578          ) 
+579   
+580 -    def test_xpath_exslt_functions_date(self): 
+
581          tree = self.parse('<a><b>2009-11-12</b><b>2008-12-11</b></a>') 
+582   
+583          match_dates = tree.xpath('//b[date:year(string()) = 2009]', 
+584                                   namespaces=self.NSMAP) 
+585          self.assertTrue(match_dates, str(match_dates)) 
+586          self.assertEqual(len(match_dates), 1, str(match_dates)) 
+587          self.assertEqual(match_dates[0].text, '2009-11-12') 
+
588   
+589 -    def test_xpath_exslt_functions_strings(self): 
+
590          tree = self.parse('<a><b>2009-11-12</b><b>2008-12-11</b></a>') 
+591   
+592          aligned_date = tree.xpath( 
+593              'str:align(string(//b[1]), "%s", "center")' % ('-'*20), 
+594              namespaces=self.NSMAP) 
+595          self.assertTrue(aligned_date, str(aligned_date)) 
+596          self.assertEqual(aligned_date, '-----2009-11-12-----') 
+
597   
+598   
+599 -class ETreeETXPathClassTestCase(HelperTestCase): 
+
600      "Tests for the ETXPath class" 
+601 -    def test_xpath_compile_ns(self): 
+
602          x = self.parse('<a><b xmlns="nsa"/><b xmlns="nsb"/></a>') 
+603   
+604          expr = etree.ETXPath("/a/{nsa}b") 
+605          r = expr(x) 
+606          self.assertEqual(1, len(r)) 
+607          self.assertEqual('{nsa}b', r[0].tag) 
+608   
+609          expr = etree.ETXPath("/a/{nsb}b") 
+610          r = expr(x) 
+611          self.assertEqual(1, len(r)) 
+612          self.assertEqual('{nsb}b', r[0].tag) 
+
613   
+614      # disabled this test as non-ASCII characters in namespace URIs are 
+615      # not acceptable 
+616 -    def _test_xpath_compile_unicode(self): 
+
617          x = self.parse(_bytes('<a><b xmlns="http://nsa/\\uf8d2"/><b xmlns="http://nsb/\\uf8d1"/></a>' 
+618                                ).decode("unicode_escape")) 
+619   
+620          expr = etree.ETXPath(_bytes("/a/{http://nsa/\\uf8d2}b").decode("unicode_escape")) 
+621          r = expr(x) 
+622          self.assertEqual(1, len(r)) 
+623          self.assertEqual(_bytes('{http://nsa/\\uf8d2}b').decode("unicode_escape"), r[0].tag) 
+624   
+625          expr = etree.ETXPath(_bytes("/a/{http://nsb/\\uf8d1}b").decode("unicode_escape")) 
+626          r = expr(x) 
+627          self.assertEqual(1, len(r)) 
+628          self.assertEqual(_bytes('{http://nsb/\\uf8d1}b').decode("unicode_escape"), r[0].tag) 
+
629   
+630  SAMPLE_XML = etree.parse(BytesIO(""" 
+631  <body> 
+632    <tag>text</tag> 
+633    <section> 
+634      <tag>subtext</tag> 
+635    </section> 
+636    <tag /> 
+637    <tag /> 
+638  </body> 
+639  """)) 
+640   
+641 -def tag(elem): 
+
642      return elem.tag 
+
643   
+644 -def tag_or_value(elem): 
+
645      return getattr(elem, 'tag', elem) 
+
646   
+647 -def stringTest(ctxt, s1): 
+
648      return "Hello "+s1 
+
649   
+650 -def stringListTest(ctxt, s1): 
+
651      return ["Hello "] + list(s1) +  ["!"] 
+
652       
+653 -def floatTest(ctxt, f1): 
+
654      return f1+4 
+
655   
+656 -def booleanTest(ctxt, b1): 
+
657      return not b1 
+
658       
+659 -def setTest(ctxt, st1): 
+
660      return st1[0] 
+
661       
+662 -def setTest2(ctxt, st1): 
+
663      return st1[0:2] 
+
664   
+665 -def argsTest1(ctxt, s, f, b, st): 
+
666      return ", ".join(map(str, (s, f, b, list(map(tag, st))))) 
+
667   
+668 -def argsTest2(ctxt, st1, st2): 
+
669      st1.extend(st2) 
+670      return st1 
+
671   
+672 -def resultTypesTest(ctxt): 
+
673      return [None,None] 
+
674   
+675 -def resultTypesTest2(ctxt): 
+
676      return resultTypesTest 
+
677       
+678  uri = "http://www.example.com/" 
+679   
+680  extension = {(None, 'stringTest'): stringTest, 
+681               (None, 'stringListTest'): stringListTest, 
+682               (None, 'floatTest'): floatTest, 
+683               (None, 'booleanTest'): booleanTest, 
+684               (None, 'setTest'): setTest, 
+685               (None, 'setTest2'): setTest2, 
+686               (None, 'argsTest1'): argsTest1, 
+687               (None, 'argsTest2'): argsTest2, 
+688               (None, 'resultTypesTest'): resultTypesTest, 
+689               (None, 'resultTypesTest2'): resultTypesTest2,} 
+690   
+691 -def xpath(): 
+
692      """ 
+693      Test xpath extension functions. 
+694       
+695      >>> root = SAMPLE_XML 
+696      >>> e = etree.XPathEvaluator(root, extensions=[extension]) 
+697      >>> e("stringTest('you')") 
+698      'Hello you' 
+699      >>> e(_bytes("stringTest('\\\\xe9lan')").decode("unicode_escape")) 
+700      u'Hello \\xe9lan' 
+701      >>> e("stringTest('you','there')")   #doctest: +ELLIPSIS 
+702      Traceback (most recent call last): 
+703      ... 
+704      TypeError: stringTest() takes... 2 ...arguments ... 
+705      >>> e("floatTest(2)") 
+706      6.0 
+707      >>> e("booleanTest(true())") 
+708      False 
+709      >>> list(map(tag, e("setTest(/body/tag)"))) 
+710      ['tag'] 
+711      >>> list(map(tag, e("setTest2(/body/*)"))) 
+712      ['tag', 'section'] 
+713      >>> list(map(tag_or_value, e("stringListTest(/body/tag)"))) 
+714      ['Hello ', 'tag', 'tag', 'tag', '!'] 
+715      >>> e("argsTest1('a',1.5,true(),/body/tag)") 
+716      "a, 1.5, True, ['tag', 'tag', 'tag']" 
+717      >>> list(map(tag, e("argsTest2(/body/tag, /body/section)"))) 
+718      ['tag', 'section', 'tag', 'tag'] 
+719      >>> e("resultTypesTest()") 
+720      Traceback (most recent call last): 
+721      ... 
+722      XPathResultError: This is not a supported node-set result: None 
+723      >>> try: 
+724      ...     e("resultTypesTest2()") 
+725      ... except etree.XPathResultError: 
+726      ...     print("Got error") 
+727      Got error 
+728      """ 
+
729   
+730  if sys.version_info[0] >= 3: 
+731      xpath.__doc__ = xpath.__doc__.replace(" u'", " '") 
+732      xpath.__doc__ = xpath.__doc__.replace(" XPathResultError", 
+733                                            " lxml.etree.XPathResultError") 
+734      xpath.__doc__ = xpath.__doc__.replace(" exactly 2 arguments", 
+735                                            " exactly 2 positional arguments") 
+736   
+737 -def test_suite(): 
+
738      suite = unittest.TestSuite() 
+739      suite.addTests([unittest.makeSuite(ETreeXPathTestCase)]) 
+740      suite.addTests([unittest.makeSuite(ETreeXPathClassTestCase)]) 
+741      if etree.LIBXSLT_COMPILED_VERSION >= (1,1,25): 
+742          suite.addTests([unittest.makeSuite(ETreeXPathExsltTestCase)]) 
+743      suite.addTests([unittest.makeSuite(ETreeETXPathClassTestCase)]) 
+744      suite.addTests([doctest.DocTestSuite()]) 
+745      suite.addTests( 
+746          [make_doctest('../../../doc/xpathxslt.txt')]) 
+747      return suite 
+
748   
+749  if __name__ == '__main__': 
+750      print('to test use test.py %s' % __file__) 
+751   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeETXPathClassTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeXPathClassTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeXPathExsltTestCase
+
+{'date': 'http://exslt.org/dates-and-times',
+ 'math': 'http://exslt.org/math',
+ 'set': 'http://exslt.org/sets',
+ 'str': 'http://exslt.org/strings'}
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeXPathTestCase
+
+'/home/stefan/source/Python/lxml/lxml-release/src/lxml/tests'
+
+   1  # -*- coding: utf-8 -*- 
+   2   
+   3  """ 
+   4  Test cases related to XSLT processing 
+   5  """ 
+   6   
+   7  import io 
+   8  import sys 
+   9  import copy 
+  10  import gzip 
+  11  import os.path 
+  12  import unittest 
+  13  import contextlib 
+  14  from textwrap import dedent 
+  15  from tempfile import NamedTemporaryFile, mkdtemp 
+  16   
+  17  this_dir = os.path.dirname(__file__) 
+  18  if this_dir not in sys.path: 
+  19      sys.path.insert(0, this_dir) # needed for Py3 
+  20   
+  21  is_python3 = sys.version_info[0] >= 3 
+  22   
+  23  try: 
+  24      unicode 
+  25  except NameError: # Python 3 
+  26      unicode = str 
+  27   
+  28  try: 
+  29      basestring 
+  30  except NameError: # Python 3 
+  31      basestring = str 
+  32   
+  33  from .common_imports import etree, BytesIO, HelperTestCase, fileInTestDir 
+  34  from .common_imports import doctest, _bytes, _str, make_doctest, skipif 
+  35   
+  36 -class ETreeXSLTTestCase(HelperTestCase): 
+
  37      """XSLT tests etree""" 
+  38           
+  39 -    def test_xslt(self): 
+
  40          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+  41          style = self.parse('''\ 
+  42  <xsl:stylesheet version="1.0" 
+  43      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+  44    <xsl:template match="*" /> 
+  45    <xsl:template match="/"> 
+  46      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+  47    </xsl:template> 
+  48  </xsl:stylesheet>''') 
+  49   
+  50          st = etree.XSLT(style) 
+  51          res = st(tree) 
+  52          self.assertEqual('''\ 
+  53  <?xml version="1.0"?> 
+  54  <foo>B</foo> 
+  55  ''', 
+  56                            str(res)) 
+
  57   
+  58 -    def test_xslt_elementtree_error(self): 
+
  59          self.assertRaises(ValueError, etree.XSLT, etree.ElementTree()) 
+
  60   
+  61 -    def test_xslt_input_none(self): 
+
  62          self.assertRaises(TypeError, etree.XSLT, None) 
+
  63   
+  64 -    def test_xslt_invalid_stylesheet(self): 
+
  65          style = self.parse('''\ 
+  66  <xsl:stylesheet version="1.0" 
+  67          xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+  68      <xsl:stylesheet /> 
+  69  </xsl:stylesheet>''') 
+  70   
+  71          self.assertRaises( 
+  72              etree.XSLTParseError, etree.XSLT, style) 
+
  73   
+  74 -    def test_xslt_copy(self): 
+
  75          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+  76          style = self.parse('''\ 
+  77  <xsl:stylesheet version="1.0" 
+  78      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+  79    <xsl:template match="*" /> 
+  80    <xsl:template match="/"> 
+  81      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+  82    </xsl:template> 
+  83  </xsl:stylesheet>''') 
+  84   
+  85          transform = etree.XSLT(style) 
+  86          res = transform(tree) 
+  87          self.assertEqual('''\ 
+  88  <?xml version="1.0"?> 
+  89  <foo>B</foo> 
+  90  ''', 
+  91                            str(res)) 
+  92   
+  93          transform_copy = copy.deepcopy(transform) 
+  94          res = transform_copy(tree) 
+  95          self.assertEqual('''\ 
+  96  <?xml version="1.0"?> 
+  97  <foo>B</foo> 
+  98  ''', 
+  99                            str(res)) 
+ 100   
+ 101          transform = etree.XSLT(style) 
+ 102          res = transform(tree) 
+ 103          self.assertEqual('''\ 
+ 104  <?xml version="1.0"?> 
+ 105  <foo>B</foo> 
+ 106  ''', 
+ 107                            str(res)) 
+
 108   
+ 109      @contextlib.contextmanager 
+ 110 -    def _xslt_setup( 
+ 111              self, encoding='UTF-16', expected_encoding=None, 
+ 112              expected='<?xml version="1.0" encoding="%(ENCODING)s"?><foo>\\uF8D2</foo>'): 
+
 113          tree = self.parse(_bytes('<a><b>\\uF8D2</b><c>\\uF8D2</c></a>' 
+ 114                                   ).decode("unicode_escape")) 
+ 115          style = self.parse('''\ 
+ 116  <xsl:stylesheet version="1.0" 
+ 117      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 118    <xsl:output encoding="%(ENCODING)s"/> 
+ 119    <xsl:template match="/"> 
+ 120      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+ 121    </xsl:template> 
+ 122  </xsl:stylesheet>''' % {'ENCODING': encoding}) 
+ 123   
+ 124          st = etree.XSLT(style) 
+ 125          res = st(tree) 
+ 126          expected = _bytes(dedent(expected).strip()).decode("unicode_escape").replace('\n', '') % { 
+ 127              'ENCODING': expected_encoding or encoding, 
+ 128          } 
+ 129   
+ 130          data = [res] 
+ 131          yield data 
+ 132          self.assertEqual(expected, data[0].replace('\n', '')) 
+
 133   
+ 134 -    def test_xslt_utf8(self): 
+
 135          with self._xslt_setup(encoding='UTF-8') as res: 
+ 136              res[0] = unicode(bytes(res[0]), 'UTF-8') 
+ 137              assert 'UTF-8' in res[0] 
+
 138   
+ 139 -    def test_xslt_encoding(self): 
+
 140          with self._xslt_setup() as res: 
+ 141              res[0] = unicode(bytes(res[0]), 'UTF-16') 
+ 142              assert 'UTF-16' in res[0] 
+
 143   
+ 144 -    def test_xslt_encoding_override(self): 
+
 145          with self._xslt_setup(encoding='UTF-8', expected_encoding='UTF-16') as res: 
+ 146              f = BytesIO() 
+ 147              res[0].write(f, encoding='UTF-16') 
+ 148              if is_python3: 
+ 149                  output = str(f.getvalue(), 'UTF-16') 
+ 150              else: 
+ 151                  output = unicode(str(f.getvalue()), 'UTF-16') 
+ 152              res[0] = output.replace("'", '"') 
+
 153   
+ 154 -    def test_xslt_write_output_bytesio(self): 
+
 155          with self._xslt_setup() as res: 
+ 156              f = BytesIO() 
+ 157              res[0].write_output(f) 
+ 158              res[0] = f.getvalue().decode('UTF-16') 
+
 159   
+ 160 -    def test_xslt_write_output_failure(self): 
+
 161          class Writer(object): 
+ 162              def write(self, data): 
+ 163                  raise ValueError("FAILED!") 
+
 164   
+ 165          try: 
+ 166              with self._xslt_setup() as res: 
+ 167                  res[0].write_output(Writer()) 
+ 168          except ValueError as exc: 
+ 169              self.assertTrue("FAILED!" in str(exc), exc) 
+ 170          else: 
+ 171              self.assertTrue(False, "exception not raised") 
+ 172   
+ 173 -    def test_xslt_write_output_file(self): 
+
 174          with self._xslt_setup() as res: 
+ 175              f = NamedTemporaryFile(delete=False) 
+ 176              try: 
+ 177                  try: 
+ 178                      res[0].write_output(f) 
+ 179                  finally: 
+ 180                      f.close() 
+ 181                  with io.open(f.name, encoding='UTF-16') as f: 
+ 182                      res[0] = f.read() 
+ 183              finally: 
+ 184                  os.unlink(f.name) 
+
 185   
+ 186 -    def test_xslt_write_output_file_path(self): 
+
 187          with self._xslt_setup() as res: 
+ 188              f = NamedTemporaryFile(delete=False) 
+ 189              try: 
+ 190                  try: 
+ 191                      res[0].write_output(f.name, compression=9) 
+ 192                  finally: 
+ 193                      f.close() 
+ 194                  with gzip.GzipFile(f.name) as f: 
+ 195                      res[0] = f.read().decode("UTF-16") 
+ 196              finally: 
+ 197                  os.unlink(f.name) 
+
 198   
+ 199 -    def test_xslt_write_output_file_path_urlescaped(self): 
+
 200          # libxml2 should not unescape file paths. 
+ 201          with self._xslt_setup() as res: 
+ 202              f = NamedTemporaryFile(prefix='tmp%2e', suffix='.xml.gz', delete=False) 
+ 203              try: 
+ 204                  try: 
+ 205                      res[0].write_output(f.name, compression=3) 
+ 206                  finally: 
+ 207                      f.close() 
+ 208                  with gzip.GzipFile(f.name) as f: 
+ 209                      res[0] = f.read().decode("UTF-16") 
+ 210              finally: 
+ 211                  os.unlink(f.name) 
+
 212   
+ 213 -    def test_xslt_write_output_file_path_urlescaped_plus(self): 
+
 214          with self._xslt_setup() as res: 
+ 215              f = NamedTemporaryFile(prefix='p+%2e', suffix='.xml.gz', delete=False) 
+ 216              try: 
+ 217                  try: 
+ 218                      res[0].write_output(f.name, compression=1) 
+ 219                  finally: 
+ 220                      f.close() 
+ 221                  with gzip.GzipFile(f.name) as f: 
+ 222                      res[0] = f.read().decode("UTF-16") 
+ 223              finally: 
+ 224                  os.unlink(f.name) 
+
 225   
+ 226 -    def test_xslt_write_output_file_oserror(self): 
+
 227          with self._xslt_setup(expected='') as res: 
+ 228              tempdir = mkdtemp() 
+ 229              try: 
+ 230                  res[0].write_output(os.path.join(tempdir, 'missing_subdir', 'out.xml')) 
+ 231              except IOError: 
+ 232                  res[0] = '' 
+ 233              else: 
+ 234                  self.fail("IOError not raised") 
+ 235              finally: 
+ 236                  os.rmdir(tempdir) 
+
 237   
+ 238 -    def test_xslt_unicode(self): 
+
 239          expected = ''' 
+ 240              <?xml version="1.0"?> 
+ 241              <foo>\\uF8D2</foo> 
+ 242          ''' 
+ 243          with self._xslt_setup(expected=expected) as res: 
+ 244              res[0] = unicode(res[0]) 
+
 245   
+ 246 -    def test_xslt_unicode_standalone(self): 
+
 247          tree = self.parse(_bytes('<a><b>\\uF8D2</b><c>\\uF8D2</c></a>' 
+ 248          ).decode("unicode_escape")) 
+ 249          style = self.parse('''\ 
+ 250  <xsl:stylesheet version="1.0" 
+ 251      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 252    <xsl:output encoding="UTF-16" standalone="no"/> 
+ 253    <xsl:template match="/"> 
+ 254      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+ 255    </xsl:template> 
+ 256  </xsl:stylesheet>''') 
+ 257   
+ 258          st = etree.XSLT(style) 
+ 259          res = st(tree) 
+ 260          expected = _bytes('''\ 
+ 261  <?xml version="1.0" standalone="no"?> 
+ 262  <foo>\\uF8D2</foo> 
+ 263  ''').decode("unicode_escape") 
+ 264          self.assertEqual(expected, 
+ 265                           unicode(res)) 
+
 266   
+ 267 -    def test_xslt_input(self): 
+
 268          style = self.parse('''\ 
+ 269  <xsl:stylesheet version="1.0" 
+ 270      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 271    <xsl:template match="*" /> 
+ 272    <xsl:template match="/"> 
+ 273      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+ 274    </xsl:template> 
+ 275  </xsl:stylesheet>''') 
+ 276   
+ 277          st = etree.XSLT(style) 
+ 278          st = etree.XSLT(style.getroot()) 
+
 279   
+ 280 -    def test_xslt_input_partial_doc(self): 
+
 281          style = self.parse('''\ 
+ 282  <otherroot> 
+ 283  <xsl:stylesheet version="1.0" 
+ 284      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 285    <xsl:template match="*" /> 
+ 286    <xsl:template match="/"> 
+ 287      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+ 288    </xsl:template> 
+ 289  </xsl:stylesheet> 
+ 290  </otherroot>''') 
+ 291   
+ 292          self.assertRaises(etree.XSLTParseError, etree.XSLT, style) 
+ 293          root_node = style.getroot() 
+ 294          self.assertRaises(etree.XSLTParseError, etree.XSLT, root_node) 
+ 295          st = etree.XSLT(root_node[0]) 
+
 296   
+ 297 -    def test_xslt_broken(self): 
+
 298          style = self.parse('''\ 
+ 299  <xsl:stylesheet version="1.0" 
+ 300      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 301      <xsl:foo /> 
+ 302  </xsl:stylesheet>''') 
+ 303          self.assertRaises(etree.XSLTParseError, 
+ 304                            etree.XSLT, style) 
+
 305   
+ 306 -    def test_xslt_parsing_error_log(self): 
+
 307          tree = self.parse('<a/>') 
+ 308          style = self.parse('''\ 
+ 309  <xsl:stylesheet version="1.0" 
+ 310      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 311      <xsl:foo /> 
+ 312  </xsl:stylesheet>''') 
+ 313          self.assertRaises(etree.XSLTParseError, 
+ 314                            etree.XSLT, style) 
+ 315          exc = None 
+ 316          try: 
+ 317              etree.XSLT(style) 
+ 318          except etree.XSLTParseError as e: 
+ 319              exc = e 
+ 320          else: 
+ 321              self.assertFalse(True, "XSLT processing should have failed but didn't") 
+ 322          self.assertTrue(exc is not None) 
+ 323          self.assertTrue(len(exc.error_log)) 
+ 324          for error in exc.error_log: 
+ 325              self.assertTrue(':ERROR:XSLT:' in str(error)) 
+
 326   
+ 327 -    def test_xslt_apply_error_log(self): 
+
 328          tree = self.parse('<a/>') 
+ 329          style = self.parse('''\ 
+ 330  <xsl:stylesheet version="1.0" 
+ 331      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 332      <xsl:template match="a"> 
+ 333          <xsl:copy> 
+ 334              <xsl:message terminate="yes">FAIL</xsl:message> 
+ 335          </xsl:copy> 
+ 336      </xsl:template> 
+ 337  </xsl:stylesheet>''') 
+ 338          self.assertRaises(etree.XSLTApplyError, 
+ 339                            etree.XSLT(style), tree) 
+ 340   
+ 341          transform = etree.XSLT(style) 
+ 342          exc = None 
+ 343          try: 
+ 344              transform(tree) 
+ 345          except etree.XSLTApplyError as e: 
+ 346              exc = e 
+ 347          else: 
+ 348              self.assertFalse(True, "XSLT processing should have failed but didn't") 
+ 349   
+ 350          self.assertTrue(exc is not None) 
+ 351          self.assertTrue(len(exc.error_log)) 
+ 352          self.assertEqual(len(transform.error_log), len(exc.error_log)) 
+ 353          for error in exc.error_log: 
+ 354              self.assertTrue(':ERROR:XSLT:' in str(error)) 
+ 355          for error in transform.error_log: 
+ 356              self.assertTrue(':ERROR:XSLT:' in str(error)) 
+
 357   
+ 358 -    def test_xslt_parameters(self): 
+
 359          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 360          style = self.parse('''\ 
+ 361  <xsl:stylesheet version="1.0" 
+ 362      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 363    <xsl:template match="/"> 
+ 364      <foo><xsl:value-of select="$bar" /></foo> 
+ 365    </xsl:template> 
+ 366  </xsl:stylesheet>''') 
+ 367   
+ 368          st = etree.XSLT(style) 
+ 369          res = st(tree, bar="'Bar'") 
+ 370          self.assertEqual('''\ 
+ 371  <?xml version="1.0"?> 
+ 372  <foo>Bar</foo> 
+ 373  ''', 
+ 374                            str(res)) 
+
 375   
+ 376 -    def test_xslt_string_parameters(self): 
+
 377          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 378          style = self.parse('''\ 
+ 379  <xsl:stylesheet version="1.0" 
+ 380      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 381    <xsl:template match="/"> 
+ 382      <foo><xsl:value-of select="$bar" /></foo> 
+ 383    </xsl:template> 
+ 384  </xsl:stylesheet>''') 
+ 385   
+ 386          st = etree.XSLT(style) 
+ 387          res = st(tree, bar=etree.XSLT.strparam('''it's me, "Bar"''')) 
+ 388          self.assertEqual('''\ 
+ 389  <?xml version="1.0"?> 
+ 390  <foo>it's me, "Bar"</foo> 
+ 391  ''', 
+ 392                            str(res)) 
+
 393   
+ 394 -    def test_xslt_parameter_invalid(self): 
+
 395          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 396          style = self.parse('''\ 
+ 397  <xsl:stylesheet version="1.0" 
+ 398      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 399    <xsl:param name="bar"/> 
+ 400    <xsl:template match="/"> 
+ 401      <foo><xsl:value-of select="$bar" /></foo> 
+ 402    </xsl:template> 
+ 403  </xsl:stylesheet>''') 
+ 404   
+ 405          st = etree.XSLT(style) 
+ 406          res = self.assertRaises(etree.XSLTApplyError, 
+ 407                                  st, tree, bar="<test/>") 
+ 408          res = self.assertRaises(etree.XSLTApplyError, 
+ 409                                  st, tree, bar="....") 
+
 410   
+ 411 -    def test_xslt_parameter_missing(self): 
+
 412          # apply() without needed parameter will lead to XSLTApplyError 
+ 413          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 414          style = self.parse('''\ 
+ 415  <xsl:stylesheet version="1.0" 
+ 416      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 417    <xsl:template match="/"> 
+ 418      <foo><xsl:value-of select="$bar" /></foo> 
+ 419    </xsl:template> 
+ 420  </xsl:stylesheet>''') 
+ 421   
+ 422          st = etree.XSLT(style) 
+ 423          # at least libxslt 1.1.28 produces this error, earlier ones (e.g. 1.1.18) might not ... 
+ 424          self.assertRaises(etree.XSLTApplyError, st.apply, tree) 
+
 425   
+ 426 -    def test_xslt_multiple_parameters(self): 
+
 427          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 428          style = self.parse('''\ 
+ 429  <xsl:stylesheet version="1.0" 
+ 430      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 431    <xsl:template match="*" /> 
+ 432    <xsl:template match="/"> 
+ 433      <foo><xsl:value-of select="$bar" /></foo> 
+ 434      <foo><xsl:value-of select="$baz" /></foo> 
+ 435    </xsl:template> 
+ 436  </xsl:stylesheet>''') 
+ 437   
+ 438          st = etree.XSLT(style) 
+ 439          res = st(tree, bar="'Bar'", baz="'Baz'") 
+ 440          self.assertEqual('''\ 
+ 441  <?xml version="1.0"?> 
+ 442  <foo>Bar</foo><foo>Baz</foo> 
+ 443  ''', 
+ 444                            str(res)) 
+
 445           
+ 446 -    def test_xslt_parameter_xpath(self): 
+
 447          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 448          style = self.parse('''\ 
+ 449  <xsl:stylesheet version="1.0" 
+ 450      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 451    <xsl:template match="*" /> 
+ 452    <xsl:template match="/"> 
+ 453      <foo><xsl:value-of select="$bar" /></foo> 
+ 454    </xsl:template> 
+ 455  </xsl:stylesheet>''') 
+ 456   
+ 457          st = etree.XSLT(style) 
+ 458          res = st(tree, bar="/a/b/text()") 
+ 459          self.assertEqual('''\ 
+ 460  <?xml version="1.0"?> 
+ 461  <foo>B</foo> 
+ 462  ''', 
+ 463                            str(res)) 
+
 464   
+ 465 -    def test_xslt_parameter_xpath_object(self): 
+
 466          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 467          style = self.parse('''\ 
+ 468  <xsl:stylesheet version="1.0" 
+ 469      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 470    <xsl:template match="*" /> 
+ 471    <xsl:template match="/"> 
+ 472      <foo><xsl:value-of select="$bar" /></foo> 
+ 473    </xsl:template> 
+ 474  </xsl:stylesheet>''') 
+ 475   
+ 476          st = etree.XSLT(style) 
+ 477          res = st(tree, bar=etree.XPath("/a/b/text()")) 
+ 478          self.assertEqual('''\ 
+ 479  <?xml version="1.0"?> 
+ 480  <foo>B</foo> 
+ 481  ''', 
+ 482                            str(res)) 
+
 483           
+ 484 -    def test_xslt_default_parameters(self): 
+
 485          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 486          style = self.parse('''\ 
+ 487  <xsl:stylesheet version="1.0" 
+ 488      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 489    <xsl:param name="bar" select="'Default'" /> 
+ 490    <xsl:template match="*" /> 
+ 491    <xsl:template match="/"> 
+ 492      <foo><xsl:value-of select="$bar" /></foo> 
+ 493    </xsl:template> 
+ 494  </xsl:stylesheet>''') 
+ 495   
+ 496          st = etree.XSLT(style) 
+ 497          res = st(tree, bar="'Bar'") 
+ 498          self.assertEqual('''\ 
+ 499  <?xml version="1.0"?> 
+ 500  <foo>Bar</foo> 
+ 501  ''', 
+ 502                            str(res)) 
+ 503          res = st(tree) 
+ 504          self.assertEqual('''\ 
+ 505  <?xml version="1.0"?> 
+ 506  <foo>Default</foo> 
+ 507  ''', 
+ 508                            str(res)) 
+
 509           
+ 510 -    def test_xslt_html_output(self): 
+
 511          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 512          style = self.parse('''\ 
+ 513  <xsl:stylesheet version="1.0" 
+ 514      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 515    <xsl:output method="html"/> 
+ 516    <xsl:strip-space elements="*"/> 
+ 517    <xsl:template match="/"> 
+ 518      <html><body><xsl:value-of select="/a/b/text()" /></body></html> 
+ 519    </xsl:template> 
+ 520  </xsl:stylesheet>''') 
+ 521   
+ 522          st = etree.XSLT(style) 
+ 523          res = st(tree) 
+ 524          self.assertEqual('<html><body>B</body></html>', 
+ 525                            str(res).strip()) 
+
 526   
+ 527 -    def test_xslt_include(self): 
+
 528          tree = etree.parse(fileInTestDir('test1.xslt')) 
+ 529          st = etree.XSLT(tree) 
+
 530   
+ 531 -    def test_xslt_include_from_filelike(self): 
+
 532          f = open(fileInTestDir('test1.xslt'), 'rb') 
+ 533          tree = etree.parse(f) 
+ 534          f.close() 
+ 535          st = etree.XSLT(tree) 
+
 536   
+ 537 -    def test_xslt_multiple_transforms(self): 
+
 538          xml = '<a/>' 
+ 539          xslt = '''\ 
+ 540  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> 
+ 541      <xsl:template match="/"> 
+ 542          <response>Some text</response> 
+ 543      </xsl:template> 
+ 544  </xsl:stylesheet> 
+ 545  ''' 
+ 546          source = self.parse(xml) 
+ 547          styledoc = self.parse(xslt) 
+ 548          style = etree.XSLT(styledoc) 
+ 549          result = style(source) 
+ 550   
+ 551          etree.tostring(result.getroot()) 
+ 552           
+ 553          source = self.parse(xml) 
+ 554          styledoc = self.parse(xslt) 
+ 555          style = etree.XSLT(styledoc) 
+ 556          result = style(source) 
+ 557           
+ 558          etree.tostring(result.getroot()) 
+
 559   
+ 560 -    def test_xslt_repeat_transform(self): 
+
 561          xml = '<a/>' 
+ 562          xslt = '''\ 
+ 563  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> 
+ 564      <xsl:template match="/"> 
+ 565          <response>Some text</response> 
+ 566      </xsl:template> 
+ 567  </xsl:stylesheet> 
+ 568  ''' 
+ 569          source = self.parse(xml) 
+ 570          styledoc = self.parse(xslt) 
+ 571          transform = etree.XSLT(styledoc) 
+ 572          result = transform(source) 
+ 573          result = transform(source) 
+ 574          etree.tostring(result.getroot()) 
+ 575          result = transform(source) 
+ 576          etree.tostring(result.getroot()) 
+ 577          str(result) 
+ 578   
+ 579          result1 = transform(source) 
+ 580          result2 = transform(source) 
+ 581          self.assertEqual(str(result1), str(result2)) 
+ 582          result = transform(source) 
+ 583          str(result) 
+
 584   
+ 585 -    def test_xslt_empty(self): 
+
 586          # could segfault if result contains "empty document" 
+ 587          xml = '<blah/>' 
+ 588          xslt = ''' 
+ 589          <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> 
+ 590            <xsl:template match="/" /> 
+ 591          </xsl:stylesheet> 
+ 592          ''' 
+ 593   
+ 594          source = self.parse(xml) 
+ 595          styledoc = self.parse(xslt) 
+ 596          style = etree.XSLT(styledoc) 
+ 597          result = style(source) 
+ 598          self.assertEqual('', str(result)) 
+
 599   
+ 600 -    def test_xslt_message(self): 
+
 601          xml = '<blah/>' 
+ 602          xslt = ''' 
+ 603          <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> 
+ 604            <xsl:template match="/"> 
+ 605              <xsl:message>TEST TEST TEST</xsl:message> 
+ 606            </xsl:template> 
+ 607          </xsl:stylesheet> 
+ 608          ''' 
+ 609   
+ 610          source = self.parse(xml) 
+ 611          styledoc = self.parse(xslt) 
+ 612          style = etree.XSLT(styledoc) 
+ 613          result = style(source) 
+ 614          self.assertEqual('', str(result)) 
+ 615          self.assertTrue("TEST TEST TEST" in [entry.message 
+ 616                                            for entry in style.error_log]) 
+
 617   
+ 618 -    def test_xslt_message_terminate(self): 
+
 619          xml = '<blah/>' 
+ 620          xslt = ''' 
+ 621          <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> 
+ 622            <xsl:template match="/"> 
+ 623              <xsl:message terminate="yes">TEST TEST TEST</xsl:message> 
+ 624            </xsl:template> 
+ 625          </xsl:stylesheet> 
+ 626          ''' 
+ 627   
+ 628          source = self.parse(xml) 
+ 629          styledoc = self.parse(xslt) 
+ 630          style = etree.XSLT(styledoc) 
+ 631   
+ 632          self.assertRaises(etree.XSLTApplyError, style, source) 
+ 633          self.assertTrue("TEST TEST TEST" in [entry.message 
+ 634                                            for entry in style.error_log]) 
+
 635   
+ 636 -    def test_xslt_shortcut(self): 
+
 637          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 638          style = self.parse('''\ 
+ 639  <xsl:stylesheet version="1.0" 
+ 640      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 641    <xsl:template match="*" /> 
+ 642    <xsl:template match="/"> 
+ 643      <doc> 
+ 644      <foo><xsl:value-of select="$bar" /></foo> 
+ 645      <foo><xsl:value-of select="$baz" /></foo> 
+ 646      </doc> 
+ 647    </xsl:template> 
+ 648  </xsl:stylesheet>''') 
+ 649   
+ 650          result = tree.xslt(style, bar="'Bar'", baz="'Baz'") 
+ 651          self.assertEqual( 
+ 652              _bytes('<doc><foo>Bar</foo><foo>Baz</foo></doc>'), 
+ 653              etree.tostring(result.getroot())) 
+
 654           
+ 655 -    def test_multiple_elementrees(self): 
+
 656          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+ 657          style = self.parse('''\ 
+ 658  <xsl:stylesheet version="1.0" 
+ 659      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 660    <xsl:template match="a"><A><xsl:apply-templates/></A></xsl:template> 
+ 661    <xsl:template match="b"><B><xsl:apply-templates/></B></xsl:template> 
+ 662    <xsl:template match="c"><C><xsl:apply-templates/></C></xsl:template> 
+ 663  </xsl:stylesheet>''') 
+ 664   
+ 665          self.assertEqual(self._rootstring(tree), 
+ 666                            _bytes('<a><b>B</b><c>C</c></a>')) 
+ 667          result = tree.xslt(style) 
+ 668          self.assertEqual(self._rootstring(tree), 
+ 669                            _bytes('<a><b>B</b><c>C</c></a>')) 
+ 670          self.assertEqual(self._rootstring(result), 
+ 671                            _bytes('<A><B>B</B><C>C</C></A>')) 
+ 672   
+ 673          b_tree = etree.ElementTree(tree.getroot()[0]) 
+ 674          self.assertEqual(self._rootstring(b_tree), 
+ 675                            _bytes('<b>B</b>')) 
+ 676          result = b_tree.xslt(style) 
+ 677          self.assertEqual(self._rootstring(tree), 
+ 678                            _bytes('<a><b>B</b><c>C</c></a>')) 
+ 679          self.assertEqual(self._rootstring(result), 
+ 680                            _bytes('<B>B</B>')) 
+ 681   
+ 682          c_tree = etree.ElementTree(tree.getroot()[1]) 
+ 683          self.assertEqual(self._rootstring(c_tree), 
+ 684                            _bytes('<c>C</c>')) 
+ 685          result = c_tree.xslt(style) 
+ 686          self.assertEqual(self._rootstring(tree), 
+ 687                            _bytes('<a><b>B</b><c>C</c></a>')) 
+ 688          self.assertEqual(self._rootstring(result), 
+ 689                            _bytes('<C>C</C>')) 
+
 690   
+ 691 -    def test_xslt_document_XML(self): 
+
 692          # make sure document('') works from parsed strings 
+ 693          xslt = etree.XSLT(etree.XML("""\ 
+ 694  <xsl:stylesheet version="1.0" 
+ 695     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 696    <xsl:template match="/"> 
+ 697      <test>TEXT<xsl:copy-of select="document('')//test"/></test> 
+ 698    </xsl:template> 
+ 699  </xsl:stylesheet> 
+ 700  """)) 
+ 701          result = xslt(etree.XML('<a/>')) 
+ 702          root = result.getroot() 
+ 703          self.assertEqual(root.tag, 
+ 704                            'test') 
+ 705          self.assertEqual(root[0].tag, 
+ 706                            'test') 
+ 707          self.assertEqual(root[0].text, 
+ 708                            'TEXT') 
+ 709          self.assertEqual(root[0][0].tag, 
+ 710                            '{http://www.w3.org/1999/XSL/Transform}copy-of') 
+
 711   
+ 712 -    def test_xslt_document_parse(self): 
+
 713          # make sure document('') works from loaded files 
+ 714          xslt = etree.XSLT(etree.parse(fileInTestDir("test-document.xslt"))) 
+ 715          result = xslt(etree.XML('<a/>')) 
+ 716          root = result.getroot() 
+ 717          self.assertEqual(root.tag, 
+ 718                            'test') 
+ 719          self.assertEqual(root[0].tag, 
+ 720                            '{http://www.w3.org/1999/XSL/Transform}stylesheet') 
+
 721   
+ 722 -    def test_xslt_document_elementtree(self): 
+
 723          # make sure document('') works from loaded files 
+ 724          xslt = etree.XSLT(etree.ElementTree(file=fileInTestDir("test-document.xslt"))) 
+ 725          result = xslt(etree.XML('<a/>')) 
+ 726          root = result.getroot() 
+ 727          self.assertEqual(root.tag, 
+ 728                            'test') 
+ 729          self.assertEqual(root[0].tag, 
+ 730                            '{http://www.w3.org/1999/XSL/Transform}stylesheet') 
+
 731   
+ 732 -    def test_xslt_document_error(self): 
+
 733          xslt = etree.XSLT(etree.XML("""\ 
+ 734  <xsl:stylesheet version="1.0" 
+ 735     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 736    <xsl:template match="/"> 
+ 737      <test>TEXT<xsl:copy-of select="document('uri:__junkfood__is__evil__')//test"/></test> 
+ 738    </xsl:template> 
+ 739  </xsl:stylesheet> 
+ 740  """)) 
+ 741   
+ 742          errors = None 
+ 743          try: 
+ 744              xslt(etree.XML('<a/>')) 
+ 745          except etree.XSLTApplyError as exc: 
+ 746              errors = exc.error_log 
+ 747          else: 
+ 748              self.assertFalse(True, "XSLT processing should have failed but didn't") 
+ 749   
+ 750          self.assertTrue(len(errors)) 
+ 751          for error in errors: 
+ 752              if ':ERROR:XSLT:' in str(error): 
+ 753                  break 
+ 754          else: 
+ 755              self.assertFalse(True, 'No XSLT errors found in error log:\n%s' % errors) 
+
 756   
+ 757 -    def test_xslt_document_XML_resolver(self): 
+
 758          # make sure document('') works when custom resolvers are in use 
+ 759          assertEqual = self.assertEqual 
+ 760          called = {'count' : 0} 
+ 761          class TestResolver(etree.Resolver): 
+ 762              def resolve(self, url, id, context): 
+ 763                  assertEqual(url, 'file://ANYTHING') 
+ 764                  called['count'] += 1 
+ 765                  return self.resolve_string('<CALLED/>', context) 
+
 766   
+ 767          parser = etree.XMLParser() 
+ 768          parser.resolvers.add(TestResolver()) 
+ 769   
+ 770          xslt = etree.XSLT(etree.XML(_bytes("""\ 
+ 771  <xsl:stylesheet version="1.0" 
+ 772     xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+ 773     xmlns:l="local"> 
+ 774    <xsl:template match="/"> 
+ 775      <test> 
+ 776        <xsl:for-each select="document('')//l:data/l:entry"> 
+ 777          <xsl:copy-of select="document('file://ANYTHING')"/> 
+ 778          <xsl:copy> 
+ 779            <xsl:attribute name="value"> 
+ 780              <xsl:value-of select="."/> 
+ 781            </xsl:attribute> 
+ 782          </xsl:copy> 
+ 783        </xsl:for-each> 
+ 784      </test> 
+ 785    </xsl:template> 
+ 786    <l:data> 
+ 787      <l:entry>A</l:entry> 
+ 788      <l:entry>B</l:entry> 
+ 789    </l:data> 
+ 790  </xsl:stylesheet> 
+ 791  """), parser)) 
+ 792   
+ 793          self.assertEqual(called['count'], 0) 
+ 794          result = xslt(etree.XML('<a/>')) 
+ 795          self.assertEqual(called['count'], 1) 
+ 796   
+ 797          root = result.getroot() 
+ 798          self.assertEqual(root.tag, 
+ 799                            'test') 
+ 800          self.assertEqual(len(root), 4) 
+ 801   
+ 802          self.assertEqual(root[0].tag, 
+ 803                            'CALLED') 
+ 804          self.assertEqual(root[1].tag, 
+ 805                            '{local}entry') 
+ 806          self.assertEqual(root[1].text, 
+ 807                            None) 
+ 808          self.assertEqual(root[1].get("value"), 
+ 809                            'A') 
+ 810          self.assertEqual(root[2].tag, 
+ 811                            'CALLED') 
+ 812          self.assertEqual(root[3].tag, 
+ 813                            '{local}entry') 
+ 814          self.assertEqual(root[3].text, 
+ 815                            None) 
+ 816          self.assertEqual(root[3].get("value"), 
+ 817                            'B') 
+ 818   
+ 819 -    def test_xslt_resolver_url_building(self): 
+
 820          assertEqual = self.assertEqual 
+ 821          called = {'count' : 0} 
+ 822          expected_url = None 
+ 823          class TestResolver(etree.Resolver): 
+ 824              def resolve(self, url, id, context): 
+ 825                  assertEqual(url, expected_url) 
+ 826                  called['count'] += 1 
+ 827                  return self.resolve_string('<CALLED/>', context) 
+
 828   
+ 829          stylesheet_xml = _bytes("""\ 
+ 830  <xsl:stylesheet version="1.0" 
+ 831     xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+ 832     xmlns:l="local"> 
+ 833    <xsl:template match="/"> 
+ 834      <xsl:copy-of select="document('test.xml')"/> 
+ 835    </xsl:template> 
+ 836  </xsl:stylesheet> 
+ 837  """) 
+ 838   
+ 839          parser = etree.XMLParser() 
+ 840          parser.resolvers.add(TestResolver()) 
+ 841   
+ 842          # test without base_url => relative path only 
+ 843          expected_url = 'test.xml' 
+ 844          xslt = etree.XSLT(etree.XML(stylesheet_xml, parser)) 
+ 845   
+ 846          self.assertEqual(called['count'], 0) 
+ 847          result = xslt(etree.XML('<a/>')) 
+ 848          self.assertEqual(called['count'], 1) 
+ 849   
+ 850          # now the same thing with a stylesheet base URL on the filesystem 
+ 851          called['count'] = 0 
+ 852          expected_url = 'MY/BASE/test.xml'  # seems to be the same on Windows 
+ 853          xslt = etree.XSLT(etree.XML( 
+ 854              stylesheet_xml, parser, 
+ 855              base_url=os.path.join('MY', 'BASE', 'FILE'))) 
+ 856   
+ 857          self.assertEqual(called['count'], 0) 
+ 858          result = xslt(etree.XML('<a/>')) 
+ 859          self.assertEqual(called['count'], 1) 
+ 860   
+ 861          # now the same thing with a stylesheet base URL 
+ 862          called['count'] = 0 
+ 863          expected_url = 'http://server.com/BASE/DIR/test.xml' 
+ 864          xslt = etree.XSLT(etree.XML( 
+ 865              stylesheet_xml, parser, 
+ 866              base_url='http://server.com/BASE/DIR/FILE')) 
+ 867   
+ 868          self.assertEqual(called['count'], 0) 
+ 869          result = xslt(etree.XML('<a/>')) 
+ 870          self.assertEqual(called['count'], 1) 
+ 871   
+ 872          # now the same thing with a stylesheet base file:// URL 
+ 873          called['count'] = 0 
+ 874          expected_url = 'file://BASE/DIR/test.xml' 
+ 875          xslt = etree.XSLT(etree.XML( 
+ 876              stylesheet_xml, parser, 
+ 877              base_url='file://BASE/DIR/FILE')) 
+ 878   
+ 879          self.assertEqual(called['count'], 0) 
+ 880          result = xslt(etree.XML('<a/>')) 
+ 881          self.assertEqual(called['count'], 1) 
+ 882   
+ 883 -    def test_xslt_document_parse_allow(self): 
+
 884          access_control = etree.XSLTAccessControl(read_file=True) 
+ 885          xslt = etree.XSLT(etree.parse(fileInTestDir("test-document.xslt")), 
+ 886                            access_control=access_control) 
+ 887          result = xslt(etree.XML('<a/>')) 
+ 888          root = result.getroot() 
+ 889          self.assertEqual(root.tag, 
+ 890                           'test') 
+ 891          self.assertEqual(root[0].tag, 
+ 892                           '{http://www.w3.org/1999/XSL/Transform}stylesheet') 
+
 893   
+ 894 -    def test_xslt_document_parse_deny(self): 
+
 895          access_control = etree.XSLTAccessControl(read_file=False) 
+ 896          xslt = etree.XSLT(etree.parse(fileInTestDir("test-document.xslt")), 
+ 897                            access_control=access_control) 
+ 898          self.assertRaises(etree.XSLTApplyError, xslt, etree.XML('<a/>')) 
+
 899   
+ 900 -    def test_xslt_document_parse_deny_all(self): 
+
 901          access_control = etree.XSLTAccessControl.DENY_ALL 
+ 902          xslt = etree.XSLT(etree.parse(fileInTestDir("test-document.xslt")), 
+ 903                            access_control=access_control) 
+ 904          self.assertRaises(etree.XSLTApplyError, xslt, etree.XML('<a/>')) 
+
 905   
+ 906 -    def test_xslt_access_control_repr(self): 
+
 907          access_control = etree.XSLTAccessControl.DENY_ALL 
+ 908          self.assertTrue(repr(access_control).startswith(type(access_control).__name__)) 
+ 909          self.assertEqual(repr(access_control), repr(access_control)) 
+ 910          self.assertNotEqual(repr(etree.XSLTAccessControl.DENY_ALL), 
+ 911                              repr(etree.XSLTAccessControl.DENY_WRITE)) 
+ 912          self.assertNotEqual(repr(etree.XSLTAccessControl.DENY_ALL), 
+ 913                              repr(etree.XSLTAccessControl())) 
+
 914   
+ 915 -    def test_xslt_move_result(self): 
+
 916          root = etree.XML(_bytes('''\ 
+ 917          <transform> 
+ 918            <widget displayType="fieldset"/> 
+ 919          </transform>''')) 
+ 920   
+ 921          xslt = etree.XSLT(etree.XML(_bytes('''\ 
+ 922          <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 923            <xsl:output method="html" indent="no"/> 
+ 924            <xsl:template match="/"> 
+ 925              <html> 
+ 926                <xsl:apply-templates/> 
+ 927              </html> 
+ 928            </xsl:template> 
+ 929   
+ 930            <xsl:template match="widget"> 
+ 931              <xsl:element name="{@displayType}"/> 
+ 932            </xsl:template> 
+ 933   
+ 934          </xsl:stylesheet>'''))) 
+ 935   
+ 936          result = xslt(root[0]) 
+ 937          root[:] = result.getroot()[:] 
+ 938          del root # segfaulted before 
+
 939           
+ 940 -    def test_xslt_pi(self): 
+
 941          tree = self.parse('''\ 
+ 942  <?xml version="1.0"?> 
+ 943  <?xml-stylesheet type="text/xsl" href="%s"?> 
+ 944  <a> 
+ 945    <b>B</b> 
+ 946    <c>C</c> 
+ 947  </a>''' % fileInTestDir("test1.xslt")) 
+ 948   
+ 949          style_root = tree.getroot().getprevious().parseXSL().getroot() 
+ 950          self.assertEqual("{http://www.w3.org/1999/XSL/Transform}stylesheet", 
+ 951                            style_root.tag) 
+
 952   
+ 953 -    def test_xslt_pi_embedded_xmlid(self): 
+
 954          # test xml:id dictionary lookup mechanism 
+ 955          tree = self.parse('''\ 
+ 956  <?xml version="1.0"?> 
+ 957  <?xml-stylesheet type="text/xsl" href="#style"?> 
+ 958  <a> 
+ 959    <b>B</b> 
+ 960    <c>C</c> 
+ 961    <xsl:stylesheet version="1.0" xml:id="style" 
+ 962        xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 963      <xsl:template match="*" /> 
+ 964      <xsl:template match="/"> 
+ 965        <foo><xsl:value-of select="/a/b/text()" /></foo> 
+ 966      </xsl:template> 
+ 967    </xsl:stylesheet> 
+ 968  </a>''') 
+ 969   
+ 970          style_root = tree.getroot().getprevious().parseXSL().getroot() 
+ 971          self.assertEqual("{http://www.w3.org/1999/XSL/Transform}stylesheet", 
+ 972                            style_root.tag) 
+ 973   
+ 974          st = etree.XSLT(style_root) 
+ 975          res = st(tree) 
+ 976          self.assertEqual('''\ 
+ 977  <?xml version="1.0"?> 
+ 978  <foo>B</foo> 
+ 979  ''', 
+ 980                            str(res)) 
+
 981   
+ 982 -    def test_xslt_pi_embedded_id(self): 
+
 983          # test XPath lookup mechanism 
+ 984          tree = self.parse('''\ 
+ 985  <?xml version="1.0"?> 
+ 986  <?xml-stylesheet type="text/xsl" href="#style"?> 
+ 987  <a> 
+ 988    <b>B</b> 
+ 989    <c>C</c> 
+ 990  </a>''') 
+ 991   
+ 992          style = self.parse('''\ 
+ 993  <xsl:stylesheet version="1.0" xml:id="style" 
+ 994      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+ 995    <xsl:template match="*" /> 
+ 996    <xsl:template match="/"> 
+ 997      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+ 998    </xsl:template> 
+ 999  </xsl:stylesheet> 
+1000  ''') 
+1001   
+1002          tree.getroot().append(style.getroot()) 
+1003   
+1004          style_root = tree.getroot().getprevious().parseXSL().getroot() 
+1005          self.assertEqual("{http://www.w3.org/1999/XSL/Transform}stylesheet", 
+1006                            style_root.tag) 
+1007   
+1008          st = etree.XSLT(style_root) 
+1009          res = st(tree) 
+1010          self.assertEqual('''\ 
+1011  <?xml version="1.0"?> 
+1012  <foo>B</foo> 
+1013  ''', 
+1014                            str(res)) 
+
1015   
+1016 -    def test_xslt_pi_get(self): 
+
1017          tree = self.parse('''\ 
+1018  <?xml version="1.0"?> 
+1019  <?xml-stylesheet type="text/xsl" href="TEST"?> 
+1020  <a> 
+1021    <b>B</b> 
+1022    <c>C</c> 
+1023  </a>''') 
+1024   
+1025          pi = tree.getroot().getprevious() 
+1026          self.assertEqual("TEST", pi.get("href")) 
+
1027   
+1028 -    def test_xslt_pi_get_all(self): 
+
1029          tree = self.parse('''\ 
+1030  <?xml version="1.0"?> 
+1031  <?xml-stylesheet type="text/xsl" href="TEST"?> 
+1032  <a> 
+1033    <b>B</b> 
+1034    <c>C</c> 
+1035  </a>''') 
+1036   
+1037          pi = tree.getroot().getprevious() 
+1038          self.assertEqual("TEST", pi.get("href")) 
+1039          self.assertEqual("text/xsl", pi.get("type")) 
+1040          self.assertEqual(None, pi.get("motz")) 
+
1041   
+1042 -    def test_xslt_pi_get_all_reversed(self): 
+
1043          tree = self.parse('''\ 
+1044  <?xml version="1.0"?> 
+1045  <?xml-stylesheet href="TEST" type="text/xsl"?> 
+1046  <a> 
+1047    <b>B</b> 
+1048    <c>C</c> 
+1049  </a>''') 
+1050   
+1051          pi = tree.getroot().getprevious() 
+1052          self.assertEqual("TEST", pi.get("href")) 
+1053          self.assertEqual("text/xsl", pi.get("type")) 
+1054          self.assertEqual(None, pi.get("motz")) 
+
1055   
+1056 -    def test_xslt_pi_get_unknown(self): 
+
1057          tree = self.parse('''\ 
+1058  <?xml version="1.0"?> 
+1059  <?xml-stylesheet type="text/xsl" href="TEST"?> 
+1060  <a> 
+1061    <b>B</b> 
+1062    <c>C</c> 
+1063  </a>''') 
+1064   
+1065          pi = tree.getroot().getprevious() 
+1066          self.assertEqual(None, pi.get("unknownattribute")) 
+
1067   
+1068 -    def test_xslt_pi_set_replace(self): 
+
1069          tree = self.parse('''\ 
+1070  <?xml version="1.0"?> 
+1071  <?xml-stylesheet type="text/xsl" href="TEST"?> 
+1072  <a> 
+1073    <b>B</b> 
+1074    <c>C</c> 
+1075  </a>''') 
+1076   
+1077          pi = tree.getroot().getprevious() 
+1078          self.assertEqual("TEST", pi.get("href")) 
+1079   
+1080          pi.set("href", "TEST123") 
+1081          self.assertEqual("TEST123", pi.get("href")) 
+
1082   
+1083 -    def test_xslt_pi_set_new(self): 
+
1084          tree = self.parse('''\ 
+1085  <?xml version="1.0"?> 
+1086  <?xml-stylesheet type="text/xsl"?> 
+1087  <a> 
+1088    <b>B</b> 
+1089    <c>C</c> 
+1090  </a>''') 
+1091   
+1092          pi = tree.getroot().getprevious() 
+1093          self.assertEqual(None, pi.get("href")) 
+1094   
+1095          pi.set("href", "TEST") 
+1096          self.assertEqual("TEST", pi.get("href")) 
+
1097   
+1098 -class ETreeEXSLTTestCase(HelperTestCase): 
+
1099      """EXSLT tests""" 
+1100   
+1101 -    def test_exslt_str(self): 
+
1102          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+1103          style = self.parse('''\ 
+1104  <xsl:stylesheet version="1.0" 
+1105      xmlns:str="http://exslt.org/strings" 
+1106      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1107      exclude-result-prefixes="str xsl"> 
+1108    <xsl:template match="text()"> 
+1109      <xsl:value-of select="str:align(string(.), '***', 'center')" /> 
+1110    </xsl:template> 
+1111    <xsl:template match="*"> 
+1112      <xsl:copy> 
+1113        <xsl:apply-templates/> 
+1114      </xsl:copy> 
+1115    </xsl:template> 
+1116  </xsl:stylesheet>''') 
+1117   
+1118          st = etree.XSLT(style) 
+1119          res = st(tree) 
+1120          self.assertEqual('''\ 
+1121  <?xml version="1.0"?> 
+1122  <a><b>*B*</b><c>*C*</c></a> 
+1123  ''', 
+1124                            str(res)) 
+
1125   
+1126 -    def test_exslt_str_attribute_replace(self): 
+
1127          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+1128          style = self.parse('''\ 
+1129            <xsl:stylesheet version = "1.0" 
+1130                xmlns:xsl='http://www.w3.org/1999/XSL/Transform' 
+1131                xmlns:str="http://exslt.org/strings" 
+1132                extension-element-prefixes="str"> 
+1133   
+1134                <xsl:template match="/"> 
+1135                  <h1 class="{str:replace('abc', 'b', 'x')}">test</h1> 
+1136                </xsl:template> 
+1137   
+1138            </xsl:stylesheet>''') 
+1139   
+1140          st = etree.XSLT(style) 
+1141          res = st(tree) 
+1142          self.assertEqual(str(res), '''\ 
+1143  <?xml version="1.0"?> 
+1144  <h1 class="axc">test</h1> 
+1145  ''') 
+
1146   
+1147 -    def test_exslt_math(self): 
+
1148          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+1149          style = self.parse('''\ 
+1150  <xsl:stylesheet version="1.0" 
+1151      xmlns:math="http://exslt.org/math" 
+1152      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1153      exclude-result-prefixes="math xsl"> 
+1154    <xsl:template match="*"> 
+1155      <xsl:copy> 
+1156        <xsl:attribute name="pi"> 
+1157          <xsl:value-of select="math:constant('PI', count(*)+2)"/> 
+1158        </xsl:attribute> 
+1159        <xsl:apply-templates/> 
+1160      </xsl:copy> 
+1161    </xsl:template> 
+1162  </xsl:stylesheet>''') 
+1163   
+1164          st = etree.XSLT(style) 
+1165          res = st(tree) 
+1166          self.assertEqual('''\ 
+1167  <?xml version="1.0"?> 
+1168  <a pi="3.14"><b pi="3">B</b><c pi="3">C</c></a> 
+1169  ''', 
+1170                            str(res)) 
+
1171   
+1172 -    def test_exslt_regexp_test(self): 
+
1173          xslt = etree.XSLT(etree.XML(_bytes("""\ 
+1174  <xsl:stylesheet version="1.0" 
+1175     xmlns:regexp="http://exslt.org/regular-expressions" 
+1176     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+1177    <xsl:template match="*"> 
+1178      <test><xsl:copy-of select="*[regexp:test(string(.), '8.')]"/></test> 
+1179    </xsl:template> 
+1180  </xsl:stylesheet> 
+1181  """))) 
+1182          result = xslt(etree.XML(_bytes('<a><b>123</b><b>098</b><b>987</b></a>'))) 
+1183          root = result.getroot() 
+1184          self.assertEqual(root.tag, 
+1185                            'test') 
+1186          self.assertEqual(len(root), 1) 
+1187          self.assertEqual(root[0].tag, 
+1188                            'b') 
+1189          self.assertEqual(root[0].text, 
+1190                            '987') 
+
1191   
+1192 -    def test_exslt_regexp_replace(self): 
+
1193          xslt = etree.XSLT(etree.XML("""\ 
+1194  <xsl:stylesheet version="1.0" 
+1195     xmlns:regexp="http://exslt.org/regular-expressions" 
+1196     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+1197    <xsl:template match="*"> 
+1198      <test> 
+1199        <xsl:copy-of select="regexp:replace(string(.), 'd.', '',   'XX')"/> 
+1200        <xsl:text>-</xsl:text> 
+1201        <xsl:copy-of select="regexp:replace(string(.), 'd.', 'gi', 'XX')"/> 
+1202      </test> 
+1203    </xsl:template> 
+1204  </xsl:stylesheet> 
+1205  """)) 
+1206          result = xslt(etree.XML(_bytes('<a>abdCdEeDed</a>'))) 
+1207          root = result.getroot() 
+1208          self.assertEqual(root.tag, 
+1209                            'test') 
+1210          self.assertEqual(len(root), 0) 
+1211          self.assertEqual(root.text, 'abXXdEeDed-abXXXXeXXd') 
+
1212   
+1213 -    def test_exslt_regexp_match(self): 
+
1214          xslt = etree.XSLT(etree.XML("""\ 
+1215  <xsl:stylesheet version="1.0" 
+1216     xmlns:regexp="http://exslt.org/regular-expressions" 
+1217     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+1218    <xsl:template match="*"> 
+1219      <test> 
+1220        <test1><xsl:copy-of  select="regexp:match(string(.), 'd.')"/></test1> 
+1221        <test2><xsl:copy-of  select="regexp:match(string(.), 'd.', 'g')"/></test2> 
+1222        <test2i><xsl:copy-of select="regexp:match(string(.), 'd.', 'gi')"/></test2i> 
+1223      </test> 
+1224    </xsl:template> 
+1225  </xsl:stylesheet> 
+1226  """)) 
+1227          result = xslt(etree.XML(_bytes('<a>abdCdEeDed</a>'))) 
+1228          root = result.getroot() 
+1229          self.assertEqual(root.tag,  'test') 
+1230          self.assertEqual(len(root), 3) 
+1231   
+1232          self.assertEqual(len(root[0]), 1) 
+1233          self.assertEqual(root[0][0].tag, 'match') 
+1234          self.assertEqual(root[0][0].text, 'dC') 
+1235   
+1236          self.assertEqual(len(root[1]), 2) 
+1237          self.assertEqual(root[1][0].tag, 'match') 
+1238          self.assertEqual(root[1][0].text, 'dC') 
+1239          self.assertEqual(root[1][1].tag, 'match') 
+1240          self.assertEqual(root[1][1].text, 'dE') 
+1241   
+1242          self.assertEqual(len(root[2]), 3) 
+1243          self.assertEqual(root[2][0].tag, 'match') 
+1244          self.assertEqual(root[2][0].text, 'dC') 
+1245          self.assertEqual(root[2][1].tag, 'match') 
+1246          self.assertEqual(root[2][1].text, 'dE') 
+1247          self.assertEqual(root[2][2].tag, 'match') 
+1248          self.assertEqual(root[2][2].text, 'De') 
+
1249   
+1250 -    def test_exslt_regexp_match_groups(self): 
+
1251          xslt = etree.XSLT(etree.XML(_bytes("""\ 
+1252  <xsl:stylesheet version="1.0" 
+1253     xmlns:regexp="http://exslt.org/regular-expressions" 
+1254     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+1255    <xsl:template match="/"> 
+1256      <test> 
+1257        <xsl:for-each select="regexp:match( 
+1258              '123abc567', '([0-9]+)([a-z]+)([0-9]+)' )"> 
+1259          <test1><xsl:value-of select="."/></test1> 
+1260        </xsl:for-each> 
+1261      </test> 
+1262    </xsl:template> 
+1263  </xsl:stylesheet> 
+1264  """))) 
+1265          result = xslt(etree.XML(_bytes('<a/>'))) 
+1266          root = result.getroot() 
+1267          self.assertEqual(root.tag,  'test') 
+1268          self.assertEqual(len(root), 4) 
+1269   
+1270          self.assertEqual(root[0].text, "123abc567") 
+1271          self.assertEqual(root[1].text, "123") 
+1272          self.assertEqual(root[2].text, "abc") 
+1273          self.assertEqual(root[3].text, "567") 
+
1274   
+1275 -    def test_exslt_regexp_match1(self): 
+
1276          # taken from http://www.exslt.org/regexp/functions/match/index.html 
+1277          xslt = etree.XSLT(etree.XML(_bytes("""\ 
+1278  <xsl:stylesheet version="1.0" 
+1279     xmlns:regexp="http://exslt.org/regular-expressions" 
+1280     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+1281    <xsl:template match="/"> 
+1282      <test> 
+1283        <xsl:for-each select="regexp:match( 
+1284              'http://www.bayes.co.uk/xml/index.xml?/xml/utils/rechecker.xml', 
+1285              '(\\w+):\\/\\/([^/:]+)(:\\d*)?([^# ]*)')"> 
+1286          <test1><xsl:value-of select="."/></test1> 
+1287        </xsl:for-each> 
+1288      </test> 
+1289    </xsl:template> 
+1290  </xsl:stylesheet> 
+1291  """))) 
+1292          result = xslt(etree.XML(_bytes('<a/>'))) 
+1293          root = result.getroot() 
+1294          self.assertEqual(root.tag,  'test') 
+1295          self.assertEqual(len(root), 5) 
+1296   
+1297          self.assertEqual( 
+1298              root[0].text, 
+1299              "http://www.bayes.co.uk/xml/index.xml?/xml/utils/rechecker.xml") 
+1300          self.assertEqual( 
+1301              root[1].text, 
+1302              "http") 
+1303          self.assertEqual( 
+1304              root[2].text, 
+1305              "www.bayes.co.uk") 
+1306          self.assertFalse(root[3].text) 
+1307          self.assertEqual( 
+1308              root[4].text, 
+1309              "/xml/index.xml?/xml/utils/rechecker.xml") 
+
1310   
+1311 -    def test_exslt_regexp_match2(self): 
+
1312          # taken from http://www.exslt.org/regexp/functions/match/index.html 
+1313          xslt = etree.XSLT(self.parse("""\ 
+1314  <xsl:stylesheet version="1.0" 
+1315     xmlns:regexp="http://exslt.org/regular-expressions" 
+1316     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+1317    <xsl:template match="/"> 
+1318      <test> 
+1319        <xsl:for-each select="regexp:match( 
+1320              'This is a test string', '(\\w+)', 'g')"> 
+1321          <test1><xsl:value-of select="."/></test1> 
+1322        </xsl:for-each> 
+1323      </test> 
+1324    </xsl:template> 
+1325  </xsl:stylesheet> 
+1326  """)) 
+1327          result = xslt(etree.XML(_bytes('<a/>'))) 
+1328          root = result.getroot() 
+1329          self.assertEqual(root.tag,  'test') 
+1330          self.assertEqual(len(root), 5) 
+1331   
+1332          self.assertEqual(root[0].text, "This") 
+1333          self.assertEqual(root[1].text, "is") 
+1334          self.assertEqual(root[2].text, "a") 
+1335          self.assertEqual(root[3].text, "test") 
+1336          self.assertEqual(root[4].text, "string") 
+
1337   
+1338 -    def _test_exslt_regexp_match3(self): 
+
1339          # taken from http://www.exslt.org/regexp/functions/match/index.html 
+1340          # THIS IS NOT SUPPORTED! 
+1341          xslt = etree.XSLT(etree.XML(_bytes("""\ 
+1342  <xsl:stylesheet version="1.0" 
+1343     xmlns:regexp="http://exslt.org/regular-expressions" 
+1344     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+1345    <xsl:template match="/"> 
+1346      <test> 
+1347        <xsl:for-each select="regexp:match( 
+1348              'This is a test string', '([a-z])+ ', 'g')"> 
+1349          <test1><xsl:value-of select="."/></test1> 
+1350        </xsl:for-each> 
+1351      </test> 
+1352    </xsl:template> 
+1353  </xsl:stylesheet> 
+1354  """))) 
+1355          result = xslt(etree.XML(_bytes('<a/>'))) 
+1356          root = result.getroot() 
+1357          self.assertEqual(root.tag,  'test') 
+1358          self.assertEqual(len(root), 4) 
+1359   
+1360          self.assertEqual(root[0].text, "his") 
+1361          self.assertEqual(root[1].text, "is") 
+1362          self.assertEqual(root[2].text, "a") 
+1363          self.assertEqual(root[3].text, "test") 
+
1364   
+1365 -    def _test_exslt_regexp_match4(self): 
+
1366          # taken from http://www.exslt.org/regexp/functions/match/index.html 
+1367          # THIS IS NOT SUPPORTED! 
+1368          xslt = etree.XSLT(etree.XML(_bytes("""\ 
+1369  <xsl:stylesheet version="1.0" 
+1370     xmlns:regexp="http://exslt.org/regular-expressions" 
+1371     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+1372    <xsl:template match="/"> 
+1373      <test> 
+1374        <xsl:for-each select="regexp:match( 
+1375              'This is a test string', '([a-z])+ ', 'gi')"> 
+1376          <test1><xsl:value-of select="."/></test1> 
+1377        </xsl:for-each> 
+1378      </test> 
+1379    </xsl:template> 
+1380  </xsl:stylesheet> 
+1381  """))) 
+1382          result = xslt(etree.XML(_bytes('<a/>'))) 
+1383          root = result.getroot() 
+1384          self.assertEqual(root.tag,  'test') 
+1385          self.assertEqual(len(root), 4) 
+1386   
+1387          self.assertEqual(root[0].text, "This") 
+1388          self.assertEqual(root[1].text, "is") 
+1389          self.assertEqual(root[2].text, "a") 
+1390          self.assertEqual(root[3].text, "test") 
+
1391   
+1392   
+1393 -class ETreeXSLTExtFuncTestCase(HelperTestCase): 
+
1394      """Tests for XPath extension functions in XSLT.""" 
+1395   
+1396 -    def test_extensions1(self): 
+
1397          tree = self.parse('<a><b>B</b></a>') 
+1398          style = self.parse('''\ 
+1399  <xsl:stylesheet version="1.0" 
+1400      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1401      xmlns:myns="testns" 
+1402      exclude-result-prefixes="myns"> 
+1403    <xsl:template match="a"><A><xsl:value-of select="myns:mytext(b)"/></A></xsl:template> 
+1404  </xsl:stylesheet>''') 
+1405   
+1406          def mytext(ctxt, values): 
+1407              return 'X' * len(values) 
+
1408   
+1409          result = tree.xslt(style, {('testns', 'mytext') : mytext}) 
+1410          self.assertEqual(self._rootstring(result), 
+1411                            _bytes('<A>X</A>')) 
+
1412   
+1413 -    def test_extensions2(self): 
+
1414          tree = self.parse('<a><b>B</b></a>') 
+1415          style = self.parse('''\ 
+1416  <xsl:stylesheet version="1.0" 
+1417      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1418      xmlns:myns="testns" 
+1419      exclude-result-prefixes="myns"> 
+1420    <xsl:template match="a"><A><xsl:value-of select="myns:mytext(b)"/></A></xsl:template> 
+1421  </xsl:stylesheet>''') 
+1422   
+1423          def mytext(ctxt, values): 
+1424              return 'X' * len(values) 
+
1425   
+1426          namespace = etree.FunctionNamespace('testns') 
+1427          namespace['mytext'] = mytext 
+1428   
+1429          result = tree.xslt(style) 
+1430          self.assertEqual(self._rootstring(result), 
+1431                            _bytes('<A>X</A>')) 
+1432   
+1433 -    def test_variable_result_tree_fragment(self): 
+
1434          tree = self.parse('<a><b>B</b><b/></a>') 
+1435          style = self.parse('''\ 
+1436  <xsl:stylesheet version="1.0" 
+1437      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1438      xmlns:myns="testns" 
+1439      exclude-result-prefixes="myns"> 
+1440    <xsl:template match="a"> 
+1441      <xsl:variable name="content"> 
+1442         <xsl:apply-templates/> 
+1443      </xsl:variable> 
+1444      <A><xsl:value-of select="myns:mytext($content)"/></A> 
+1445    </xsl:template> 
+1446    <xsl:template match="b"><xsl:copy>BBB</xsl:copy></xsl:template> 
+1447  </xsl:stylesheet>''') 
+1448   
+1449          def mytext(ctxt, values): 
+1450              for value in values: 
+1451                  self.assertTrue(hasattr(value, 'tag'), 
+1452                               "%s is not an Element" % type(value)) 
+1453                  self.assertEqual(value.tag, 'b') 
+1454                  self.assertEqual(value.text, 'BBB') 
+1455              return 'X'.join([el.tag for el in values]) 
+
1456   
+1457          namespace = etree.FunctionNamespace('testns') 
+1458          namespace['mytext'] = mytext 
+1459   
+1460          result = tree.xslt(style) 
+1461          self.assertEqual(self._rootstring(result), 
+1462                           _bytes('<A>bXb</A>')) 
+1463   
+1464 -    def test_xpath_on_context_node(self): 
+
1465          tree = self.parse('<a><b>B<c/>C</b><b/></a>') 
+1466          style = self.parse('''\ 
+1467  <xsl:stylesheet version="1.0" 
+1468      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1469      xmlns:myns="testns" 
+1470      exclude-result-prefixes="myns"> 
+1471    <xsl:template match="b"> 
+1472      <A><xsl:value-of select="myns:myext()"/></A> 
+1473    </xsl:template> 
+1474  </xsl:stylesheet>''') 
+1475   
+1476          def extfunc(ctxt): 
+1477              text_content = ctxt.context_node.xpath('text()') 
+1478              return 'x'.join(text_content) 
+
1479   
+1480          namespace = etree.FunctionNamespace('testns') 
+1481          namespace['myext'] = extfunc 
+1482   
+1483          result = tree.xslt(style) 
+1484          self.assertEqual(self._rootstring(result), 
+1485                           _bytes('<A>BxC</A>')) 
+1486   
+1487 -    def test_xpath_on_foreign_context_node(self): 
+
1488          # LP ticket 1354652 
+1489          class Resolver(etree.Resolver): 
+1490              def resolve(self, system_url, public_id, context): 
+1491                  assert system_url == 'extdoc.xml' 
+1492                  return self.resolve_string(b'<a><b>B<c/>C</b><b/></a>', context) 
+
1493   
+1494          parser = etree.XMLParser() 
+1495          parser.resolvers.add(Resolver()) 
+1496   
+1497          tree = self.parse(b'<a><b/><b/></a>') 
+1498          transform = etree.XSLT(self.parse(b'''\ 
+1499  <xsl:stylesheet version="1.0" 
+1500      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1501      xmlns:mypre="testns" 
+1502      exclude-result-prefixes="mypre"> 
+1503    <xsl:template match="b"> 
+1504      <B><xsl:value-of select="mypre:myext()"/></B> 
+1505    </xsl:template> 
+1506    <xsl:template match="a"> 
+1507      <A><xsl:apply-templates select="document('extdoc.xml')//b" /></A> 
+1508    </xsl:template> 
+1509  </xsl:stylesheet>''', parser=parser)) 
+1510   
+1511          def extfunc(ctxt): 
+1512              text_content = ctxt.context_node.xpath('text()') 
+1513              return 'x'.join(text_content) 
+1514   
+1515          namespace = etree.FunctionNamespace('testns') 
+1516          namespace['myext'] = extfunc 
+1517   
+1518          result = transform(tree) 
+1519          self.assertEqual(self._rootstring(result), 
+1520                           _bytes('<A><B>BxC</B><B/></A>')) 
+1521   
+1522   
+1523 -class ETreeXSLTExtElementTestCase(HelperTestCase): 
+
1524      """Tests for extension elements in XSLT.""" 
+1525   
+1526 -    def test_extension_element(self): 
+
1527          tree = self.parse('<a><b>B</b></a>') 
+1528          style = self.parse('''\ 
+1529  <xsl:stylesheet version="1.0" 
+1530      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1531      xmlns:myns="testns" 
+1532      extension-element-prefixes="myns" 
+1533      exclude-result-prefixes="myns"> 
+1534    <xsl:template match="a"> 
+1535      <A><myns:myext>b</myns:myext></A> 
+1536    </xsl:template> 
+1537  </xsl:stylesheet>''') 
+1538   
+1539          class MyExt(etree.XSLTExtension): 
+1540              def execute(self, context, self_node, input_node, output_parent): 
+1541                  child = etree.Element(self_node.text) 
+1542                  child.text = 'X' 
+1543                  output_parent.append(child) 
+
1544   
+1545          extensions = { ('testns', 'myext') : MyExt() } 
+1546   
+1547          result = tree.xslt(style, extensions=extensions) 
+1548          self.assertEqual(self._rootstring(result), 
+1549                            _bytes('<A><b>X</b></A>')) 
+1550   
+1551 -    def test_extension_element_doc_context(self): 
+
1552          tree = self.parse('<a><b>B</b></a>') 
+1553          style = self.parse('''\ 
+1554  <xsl:stylesheet version="1.0" 
+1555      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1556      xmlns:myns="testns" 
+1557      extension-element-prefixes="myns" 
+1558      exclude-result-prefixes="myns"> 
+1559    <xsl:template match="/"> 
+1560      <A><myns:myext>b</myns:myext></A> 
+1561    </xsl:template> 
+1562  </xsl:stylesheet>''') 
+1563   
+1564          tags = [] 
+1565   
+1566          class MyExt(etree.XSLTExtension): 
+1567              def execute(self, context, self_node, input_node, output_parent): 
+1568                  tags.append(input_node.tag) 
+
1569   
+1570          extensions = { ('testns', 'myext') : MyExt() } 
+1571   
+1572          result = tree.xslt(style, extensions=extensions) 
+1573          self.assertEqual(tags, ['a']) 
+1574   
+1575 -    def test_extension_element_comment_pi_context(self): 
+
1576          tree = self.parse('<?test toast?><a><!--a comment--><?another pi?></a>') 
+1577          style = self.parse('''\ 
+1578  <xsl:stylesheet version="1.0" 
+1579      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1580      xmlns:myns="testns" 
+1581      extension-element-prefixes="myns" 
+1582      exclude-result-prefixes="myns"> 
+1583    <xsl:template match="/"> 
+1584      <ROOT><xsl:apply-templates /></ROOT> 
+1585    </xsl:template> 
+1586    <xsl:template match="comment()"> 
+1587      <A><myns:myext>b</myns:myext></A> 
+1588    </xsl:template> 
+1589    <xsl:template match="processing-instruction()"> 
+1590      <A><myns:myext>b</myns:myext></A> 
+1591    </xsl:template> 
+1592  </xsl:stylesheet>''') 
+1593   
+1594          text = [] 
+1595   
+1596          class MyExt(etree.XSLTExtension): 
+1597              def execute(self, context, self_node, input_node, output_parent): 
+1598                  text.append(input_node.text) 
+
1599   
+1600          extensions = { ('testns', 'myext') : MyExt() } 
+1601   
+1602          result = tree.xslt(style, extensions=extensions) 
+1603          self.assertEqual(text, ['toast', 'a comment', 'pi']) 
+1604   
+1605 -    def _test_extension_element_attribute_context(self): 
+
1606          # currently not supported 
+1607          tree = self.parse('<a test="A"><b attr="B"/></a>') 
+1608          style = self.parse('''\ 
+1609  <xsl:stylesheet version="1.0" 
+1610      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1611      xmlns:myns="testns" 
+1612      extension-element-prefixes="myns" 
+1613      exclude-result-prefixes="myns"> 
+1614    <xsl:template match="@test"> 
+1615      <A><myns:myext>b</myns:myext></A> 
+1616    </xsl:template> 
+1617    <xsl:template match="@attr"> 
+1618      <A><myns:myext>b</myns:myext></A> 
+1619    </xsl:template> 
+1620  </xsl:stylesheet>''') 
+1621   
+1622          text = [] 
+1623   
+1624          class MyExt(etree.XSLTExtension): 
+1625              def execute(self, context, self_node, attr_value, output_parent): 
+1626                  text.append(attr_value) 
+
1627   
+1628          extensions = { ('testns', 'myext') : MyExt() } 
+1629   
+1630          result = tree.xslt(style, extensions=extensions) 
+1631          self.assertEqual(text, ['A', 'B']) 
+1632   
+1633 -    def test_extension_element_content(self): 
+
1634          tree = self.parse('<a><b>B</b></a>') 
+1635          style = self.parse('''\ 
+1636  <xsl:stylesheet version="1.0" 
+1637      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1638      xmlns:myns="testns" 
+1639      extension-element-prefixes="myns"> 
+1640    <xsl:template match="a"> 
+1641      <A><myns:myext><x>X</x><y>Y</y><z/></myns:myext></A> 
+1642    </xsl:template> 
+1643  </xsl:stylesheet>''') 
+1644   
+1645          class MyExt(etree.XSLTExtension): 
+1646              def execute(self, context, self_node, input_node, output_parent): 
+1647                  output_parent.extend(list(self_node)[1:]) 
+
1648   
+1649          extensions = { ('testns', 'myext') : MyExt() } 
+1650   
+1651          result = tree.xslt(style, extensions=extensions) 
+1652          self.assertEqual(self._rootstring(result), 
+1653                            _bytes('<A><y>Y</y><z/></A>')) 
+1654   
+1655 -    def test_extension_element_apply_templates(self): 
+
1656          tree = self.parse('<a><b>B</b></a>') 
+1657          style = self.parse('''\ 
+1658  <xsl:stylesheet version="1.0" 
+1659      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1660      xmlns:myns="testns" 
+1661      extension-element-prefixes="myns"> 
+1662    <xsl:template match="a"> 
+1663      <A><myns:myext><x>X</x><y>Y</y><z/></myns:myext></A> 
+1664    </xsl:template> 
+1665    <xsl:template match="x" /> 
+1666    <xsl:template match="z">XYZ</xsl:template> 
+1667  </xsl:stylesheet>''') 
+1668   
+1669          class MyExt(etree.XSLTExtension): 
+1670              def execute(self, context, self_node, input_node, output_parent): 
+1671                  for child in self_node: 
+1672                      for result in self.apply_templates(context, child): 
+1673                          if isinstance(result, basestring): 
+1674                              el = etree.Element("T") 
+1675                              el.text = result 
+1676                          else: 
+1677                              el = result 
+1678                          output_parent.append(el) 
+
1679   
+1680          extensions = { ('testns', 'myext') : MyExt() } 
+1681   
+1682          result = tree.xslt(style, extensions=extensions) 
+1683          self.assertEqual(self._rootstring(result), 
+1684                            _bytes('<A><T>Y</T><T>XYZ</T></A>')) 
+1685   
+1686 -    def test_extension_element_apply_templates_elements_only(self): 
+
1687          tree = self.parse('<a><b>B</b></a>') 
+1688          style = self.parse('''\ 
+1689  <xsl:stylesheet version="1.0" 
+1690      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1691      xmlns:myns="testns" 
+1692      extension-element-prefixes="myns"> 
+1693    <xsl:template match="a"> 
+1694      <A><myns:myext><x>X</x><y>Y</y><z/></myns:myext></A> 
+1695    </xsl:template> 
+1696    <xsl:template match="x"><X/></xsl:template> 
+1697    <xsl:template match="z">XYZ</xsl:template> 
+1698  </xsl:stylesheet>''') 
+1699   
+1700          class MyExt(etree.XSLTExtension): 
+1701              def execute(self, context, self_node, input_node, output_parent): 
+1702                  for child in self_node: 
+1703                      for result in self.apply_templates(context, child, 
+1704                                                         elements_only=True): 
+1705                          assert not isinstance(result, basestring) 
+1706                          output_parent.append(result) 
+
1707   
+1708          extensions = { ('testns', 'myext') : MyExt() } 
+1709   
+1710          result = tree.xslt(style, extensions=extensions) 
+1711          self.assertEqual(self._rootstring(result), 
+1712                            _bytes('<A><X/></A>')) 
+1713   
+1714 -    def test_extension_element_apply_templates_remove_blank_text(self): 
+
1715          tree = self.parse('<a><b>B</b></a>') 
+1716          style = self.parse('''\ 
+1717  <xsl:stylesheet version="1.0" 
+1718      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1719      xmlns:myns="testns" 
+1720      extension-element-prefixes="myns"> 
+1721    <xsl:template match="a"> 
+1722      <A><myns:myext><x>X</x><y>Y</y><z/></myns:myext></A> 
+1723    </xsl:template> 
+1724    <xsl:template match="x"><X/></xsl:template> 
+1725    <xsl:template match="y"><xsl:text>   </xsl:text></xsl:template> 
+1726    <xsl:template match="z">XYZ</xsl:template> 
+1727  </xsl:stylesheet>''') 
+1728   
+1729          class MyExt(etree.XSLTExtension): 
+1730              def execute(self, context, self_node, input_node, output_parent): 
+1731                  for child in self_node: 
+1732                      for result in self.apply_templates(context, child, 
+1733                                                         remove_blank_text=True): 
+1734                          if isinstance(result, basestring): 
+1735                              assert result.strip() 
+1736                              el = etree.Element("T") 
+1737                              el.text = result 
+1738                          else: 
+1739                              el = result 
+1740                          output_parent.append(el) 
+
1741   
+1742          extensions = { ('testns', 'myext') : MyExt() } 
+1743   
+1744          result = tree.xslt(style, extensions=extensions) 
+1745          self.assertEqual(self._rootstring(result), 
+1746                            _bytes('<A><X/><T>XYZ</T></A>')) 
+1747   
+1748 -    def test_extension_element_apply_templates_target_node(self): 
+
1749          tree = self.parse('<a><b>B</b></a>') 
+1750          style = self.parse('''\ 
+1751  <xsl:stylesheet version="1.0" 
+1752      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1753      xmlns:myns="testns" 
+1754      extension-element-prefixes="myns"> 
+1755    <xsl:template match="a"> 
+1756      <A><myns:myext><x>X</x><y>Y</y><z/></myns:myext></A> 
+1757    </xsl:template> 
+1758    <xsl:template match="x" /> 
+1759    <xsl:template match="z">XYZ</xsl:template> 
+1760  </xsl:stylesheet>''') 
+1761   
+1762          class MyExt(etree.XSLTExtension): 
+1763              def execute(self, context, self_node, input_node, output_parent): 
+1764                  for child in self_node: 
+1765                      self.apply_templates(context, child, output_parent) 
+
1766   
+1767          extensions = { ('testns', 'myext') : MyExt() } 
+1768   
+1769          result = tree.xslt(style, extensions=extensions) 
+1770          self.assertEqual(self._rootstring(result), 
+1771                            _bytes('<A>YXYZ</A>')) 
+1772   
+1773 -    def test_extension_element_apply_templates_target_node_doc(self): 
+
1774          tree = self.parse('<a><b>B</b></a>') 
+1775          style = self.parse('''\ 
+1776  <xsl:stylesheet version="1.0" 
+1777      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1778      xmlns:myns="testns" 
+1779      extension-element-prefixes="myns"> 
+1780    <xsl:template match="a"> 
+1781      <myns:myext><x>X</x><y>Y</y><z/></myns:myext> 
+1782    </xsl:template> 
+1783    <xsl:template match="x"><xsl:processing-instruction name="test">TEST</xsl:processing-instruction></xsl:template> 
+1784    <xsl:template match="y"><Y>XYZ</Y></xsl:template> 
+1785    <xsl:template match="z"><xsl:comment>TEST</xsl:comment></xsl:template> 
+1786  </xsl:stylesheet>''') 
+1787   
+1788          class MyExt(etree.XSLTExtension): 
+1789              def execute(self, context, self_node, input_node, output_parent): 
+1790                  for child in self_node: 
+1791                      self.apply_templates(context, child, output_parent) 
+
1792   
+1793          extensions = { ('testns', 'myext') : MyExt() } 
+1794   
+1795          result = tree.xslt(style, extensions=extensions) 
+1796          self.assertEqual(etree.tostring(result), 
+1797                            _bytes('<?test TEST?><Y>XYZ</Y><!--TEST-->')) 
+1798   
+1799 -    def test_extension_element_process_children(self): 
+
1800          tree = self.parse('<a><b>E</b></a>') 
+1801          style = self.parse('''\ 
+1802  <xsl:stylesheet version="1.0" 
+1803      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1804      xmlns:myns="testns" 
+1805      extension-element-prefixes="myns"> 
+1806    <xsl:template match="a"> 
+1807      <xsl:variable name="testvar">yo</xsl:variable> 
+1808      <A> 
+1809        <myns:myext> 
+1810          <xsl:attribute name="attr"> 
+1811            <xsl:value-of select="$testvar" /> 
+1812          </xsl:attribute> 
+1813          <B> 
+1814            <xsl:choose> 
+1815              <xsl:when test="1 = 2"><C/></xsl:when> 
+1816              <xsl:otherwise><D><xsl:value-of select="b/text()" /></D></xsl:otherwise> 
+1817            </xsl:choose> 
+1818          </B> 
+1819        </myns:myext> 
+1820      </A> 
+1821    </xsl:template> 
+1822  </xsl:stylesheet>''') 
+1823   
+1824          class MyExt(etree.XSLTExtension): 
+1825              def execute(self, context, self_node, input_node, output_parent): 
+1826                  el = etree.Element('MY') 
+1827                  self.process_children(context, el) 
+1828                  output_parent.append(el) 
+
1829   
+1830          extensions = { ('testns', 'myext') : MyExt() } 
+1831   
+1832          result = tree.xslt(style, extensions=extensions) 
+1833          self.assertEqual(self._rootstring(result), 
+1834                            _bytes('<A><MYattr="yo"><B><D>E</D></B></MY></A>')) 
+1835   
+1836 -    def test_extension_element_process_children_to_append_only(self): 
+
1837          tree = self.parse('<a/>') 
+1838          style = self.parse('''\ 
+1839  <xsl:stylesheet version="1.0" 
+1840      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1841      xmlns:myns="testns" 
+1842      extension-element-prefixes="myns"> 
+1843    <xsl:template match="a"> 
+1844      <myns:myext> 
+1845        <A/> 
+1846      </myns:myext> 
+1847    </xsl:template> 
+1848  </xsl:stylesheet>''') 
+1849   
+1850          class MyExt(etree.XSLTExtension): 
+1851              def execute(self, context, self_node, input_node, output_parent): 
+1852                  self.process_children(context, output_parent) 
+
1853   
+1854          extensions = { ('testns', 'myext') : MyExt() } 
+1855   
+1856          result = tree.xslt(style, extensions=extensions) 
+1857          self.assertEqual(self._rootstring(result), 
+1858                            _bytes('<A/>')) 
+1859   
+1860 -    def test_extension_element_process_children_to_read_only_raise(self): 
+
1861          tree = self.parse('<a/>') 
+1862          style = self.parse('''\ 
+1863  <xsl:stylesheet version="1.0" 
+1864      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1865      xmlns:myns="testns" 
+1866      extension-element-prefixes="myns"> 
+1867    <xsl:template match="a"> 
+1868      <myns:myext> 
+1869        <A/> 
+1870      </myns:myext> 
+1871    </xsl:template> 
+1872  </xsl:stylesheet>''') 
+1873   
+1874          class MyExt(etree.XSLTExtension): 
+1875              def execute(self, context, self_node, input_node, output_parent): 
+1876                  self.process_children(context, self_node) 
+
1877   
+1878          extensions = { ('testns', 'myext') : MyExt() } 
+1879   
+1880          self.assertRaises(TypeError, tree.xslt, style, extensions=extensions) 
+1881   
+1882 -    def test_extension_element_process_children_with_subextension_element(self): 
+
1883          tree = self.parse('<a/>') 
+1884          style = self.parse('''\ 
+1885  <xsl:stylesheet version="1.0" 
+1886      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1887      xmlns:myns="testns" 
+1888      extension-element-prefixes="myns"> 
+1889    <xsl:template match="a"> 
+1890      <myns:myext> 
+1891        <A><myns:myext><B/></myns:myext></A> 
+1892      </myns:myext> 
+1893    </xsl:template> 
+1894  </xsl:stylesheet>''') 
+1895   
+1896          class MyExt(etree.XSLTExtension): 
+1897              callback_call_counter = 0 
+1898              def execute(self, context, self_node, input_node, output_parent): 
+1899                  self.callback_call_counter += 1 
+1900                  el = etree.Element('MY', n=str(self.callback_call_counter)) 
+1901                  self.process_children(context, el) 
+1902                  output_parent.append(el) 
+
1903   
+1904          extensions = { ('testns', 'myext') : MyExt() } 
+1905   
+1906          result = tree.xslt(style, extensions=extensions) 
+1907          self.assertEqual(self._rootstring(result), 
+1908                            _bytes('<MYn="1"><A><MYn="2"><B/></MY></A></MY>')) 
+1909   
+1910 -    def test_extension_element_raise(self): 
+
1911          tree = self.parse('<a><b>B</b></a>') 
+1912          style = self.parse('''\ 
+1913  <xsl:stylesheet version="1.0" 
+1914      xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
+1915      xmlns:myns="testns" 
+1916      extension-element-prefixes="myns" 
+1917      exclude-result-prefixes="myns"> 
+1918    <xsl:template match="a"> 
+1919      <A><myns:myext>b</myns:myext></A> 
+1920    </xsl:template> 
+1921  </xsl:stylesheet>''') 
+1922   
+1923          class MyError(Exception): 
+1924              pass 
+
1925   
+1926          class MyExt(etree.XSLTExtension): 
+1927              def execute(self, context, self_node, input_node, output_parent): 
+1928                  raise MyError("expected!") 
+1929   
+1930          extensions = { ('testns', 'myext') : MyExt() } 
+1931          self.assertRaises(MyError, tree.xslt, style, extensions=extensions) 
+1932   
+1933      # FIXME: DISABLED - implementation seems to be broken 
+1934      # if someone cares enough about this feature, I take pull requests that fix it. 
+1935 -    def _test_multiple_extension_elements_with_output_parent(self): 
+
1936          tree = self.parse("""\ 
+1937  <text> 
+1938    <par>This is <format>arbitrary</format> text in a paragraph</par> 
+1939  </text>""") 
+1940          style = self.parse("""\ 
+1941  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:my="my" extension-element-prefixes="my" version="1.0"> 
+1942    <xsl:template match="par"> 
+1943      <my:par><xsl:apply-templates /></my:par> 
+1944    </xsl:template> 
+1945    <xsl:template match="format"> 
+1946      <my:format><xsl:apply-templates /></my:format> 
+1947    </xsl:template> 
+1948  </xsl:stylesheet> 
+1949  """) 
+1950          test = self 
+1951          calls = [] 
+1952   
+1953          class ExtMyPar(etree.XSLTExtension): 
+1954              def execute(self, context, self_node, input_node, output_parent): 
+1955                  calls.append('par') 
+1956                  p = etree.Element("p") 
+1957                  p.attrib["style"] = "color:red" 
+1958                  self.process_children(context, p) 
+1959                  output_parent.append(p) 
+
1960   
+1961          class ExtMyFormat(etree.XSLTExtension): 
+1962              def execute(self, context, self_node, input_node, output_parent): 
+1963                  calls.append('format') 
+1964                  content = self.process_children(context) 
+1965                  test.assertEqual(1, len(content)) 
+1966                  test.assertEqual('arbitrary', content[0]) 
+1967                  test.assertEqual('This is ', output_parent.text) 
+1968                  output_parent.text += '*-%s-*' % content[0] 
+1969   
+1970          extensions = {("my", "par"): ExtMyPar(), ("my", "format"): ExtMyFormat()} 
+1971          transform = etree.XSLT(style, extensions=extensions) 
+1972          result = transform(tree) 
+1973          self.assertEqual(['par', 'format'], calls) 
+1974          self.assertEqual( 
+1975              b'<p style="color:red">This is *-arbitrary-* text in a paragraph</p>\n', 
+1976              etree.tostring(result)) 
+1977   
+1978 -    def test_extensions_nsmap(self): 
+
1979          tree = self.parse("""\ 
+1980  <root> 
+1981    <inner xmlns:sha256="http://www.w3.org/2001/04/xmlenc#sha256"> 
+1982      <data>test</data> 
+1983    </inner> 
+1984  </root> 
+1985  """) 
+1986          style = self.parse("""\ 
+1987  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:my="extns" extension-element-prefixes="my" version="1.0"> 
+1988    <xsl:template match="node()|@*"> 
+1989      <xsl:copy> 
+1990        <xsl:apply-templates select="node()|@*"/> 
+1991      </xsl:copy> 
+1992    </xsl:template> 
+1993   
+1994    <xsl:template match="data"> 
+1995      <my:show-nsmap/> 
+1996    </xsl:template> 
+1997  </xsl:stylesheet> 
+1998  """) 
+1999          class MyExt(etree.XSLTExtension): 
+2000              def execute(self, context, self_node, input_node, output_parent): 
+2001                  output_parent.text = str(input_node.nsmap) 
+
2002   
+2003          extensions = {('extns', 'show-nsmap'): MyExt()} 
+2004   
+2005          result = tree.xslt(style, extensions=extensions) 
+2006          self.assertEqual(etree.tostring(result, pretty_print=True), b"""\ 
+2007  <root> 
+2008    <inner xmlns:sha256="http://www.w3.org/2001/04/xmlenc#sha256">{'sha256': 'http://www.w3.org/2001/04/xmlenc#sha256'} 
+2009    </inner> 
+2010  </root> 
+2011  """) 
+2012   
+2013   
+2014   
+2015 -class Py3XSLTTestCase(HelperTestCase): 
+
2016      """XSLT tests for etree under Python 3""" 
+2017   
+2018      pytestmark = skipif('sys.version_info < (3,0)') 
+2019   
+2020 -    def test_xslt_result_bytes(self): 
+
2021          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+2022          style = self.parse('''\ 
+2023  <xsl:stylesheet version="1.0" 
+2024      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+2025    <xsl:template match="*" /> 
+2026    <xsl:template match="/"> 
+2027      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+2028    </xsl:template> 
+2029  </xsl:stylesheet>''') 
+2030   
+2031          st = etree.XSLT(style) 
+2032          res = st(tree) 
+2033          self.assertEqual(_bytes('''\ 
+2034  <?xml version="1.0"?> 
+2035  <foo>B</foo> 
+2036  '''), 
+2037                            bytes(res)) 
+
2038   
+2039 -    def test_xslt_result_bytearray(self): 
+
2040          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+2041          style = self.parse('''\ 
+2042  <xsl:stylesheet version="1.0" 
+2043      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+2044    <xsl:template match="*" /> 
+2045    <xsl:template match="/"> 
+2046      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+2047    </xsl:template> 
+2048  </xsl:stylesheet>''') 
+2049   
+2050          st = etree.XSLT(style) 
+2051          res = st(tree) 
+2052          self.assertEqual(_bytes('''\ 
+2053  <?xml version="1.0"?> 
+2054  <foo>B</foo> 
+2055  '''), 
+2056                            bytearray(res)) 
+
2057   
+2058 -    def test_xslt_result_memoryview(self): 
+
2059          tree = self.parse('<a><b>B</b><c>C</c></a>') 
+2060          style = self.parse('''\ 
+2061  <xsl:stylesheet version="1.0" 
+2062      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
+2063    <xsl:template match="*" /> 
+2064    <xsl:template match="/"> 
+2065      <foo><xsl:value-of select="/a/b/text()" /></foo> 
+2066    </xsl:template> 
+2067  </xsl:stylesheet>''') 
+2068   
+2069          st = etree.XSLT(style) 
+2070          res = st(tree) 
+2071          self.assertEqual(_bytes('''\ 
+2072  <?xml version="1.0"?> 
+2073  <foo>B</foo> 
+2074  '''), 
+2075                            bytes(memoryview(res))) 
+
2076   
+2077   
+2078 -def test_suite(): 
+
2079      suite = unittest.TestSuite() 
+2080      suite.addTests([unittest.makeSuite(ETreeXSLTTestCase)]) 
+2081      suite.addTests([unittest.makeSuite(ETreeEXSLTTestCase)]) 
+2082      suite.addTests([unittest.makeSuite(ETreeXSLTExtFuncTestCase)]) 
+2083      suite.addTests([unittest.makeSuite(ETreeXSLTExtElementTestCase)]) 
+2084      if is_python3: 
+2085          suite.addTests([unittest.makeSuite(Py3XSLTTestCase)]) 
+2086      suite.addTests( 
+2087          [make_doctest('../../../doc/extensions.txt')]) 
+2088      suite.addTests( 
+2089          [make_doctest('../../../doc/xpathxslt.txt')]) 
+2090      return suite 
+
2091   
+2092  if __name__ == '__main__': 
+2093      print('to test use test.py %s' % __file__) 
+2094   
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeEXSLTTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeXSLTExtElementTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeXSLTExtFuncTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               ETreeXSLTTestCase
+
+               object --+        
+                        |        
+   unittest.case.TestCase --+    
+                            |    
+common_imports.HelperTestCase --+
+                                |
+                               Py3XSLTTestCase
+
+>>> import lxml.usedoctest
+>>> # now do your XML doctests ...
+
+ 1  """Doctest module for XML comparison. 
+ 2   
+ 3  Usage:: 
+ 4   
+ 5     >>> import lxml.usedoctest 
+ 6     >>> # now do your XML doctests ... 
+ 7   
+ 8  See `lxml.doctestcompare` 
+ 9  """ 
+10   
+11  from lxml import doctestcompare 
+12   
+13  doctestcompare.temp_install(del_module=__name__) 
+14   
+
+rfc822.Message --+
+                 |
+                Message
+
E
lxml.etree
lxml.html
lxml.isoschematron
lxml.objectify
redirect.html#dotted.name
+object --+    
+         |    
+basestring --+
+             |
+            str
+
+set(['area',
+     'base',
+     'basefont',
+     'br',
+     'col',
+     'frame',
+     'hr',
+     'img',
+...
+
+{'http://purl.org/dc/elements/1.1/': 'dc',
+ 'http://schemas.xmlsoap.org/wsdl/': 'wsdl',
+ 'http://www.w3.org/1999/02/22-rdf-syntax-ns#': 'rdf',
+ 'http://www.w3.org/1999/xhtml': 'html',
+ 'http://www.w3.org/2001/XMLSchema': 'xs',
+ 'http://www.w3.org/2001/XMLSchema-instance': 'xsi',
+ 'http://www.w3.org/XML/1998/namespace': 'xml'}
+
+{'html': <__builtin__.function object>,
+ 'text': <__builtin__.function object>,
+ 'xml': <__builtin__.function object>}
+
+   1  # 
+   2  # ElementTree 
+   3  # $Id: ElementTree.py 3440 2008-07-18 14:45:01Z fredrik $ 
+   4  # 
+   5  # light-weight XML support for Python 2.3 and later. 
+   6  # 
+   7  # history (since 1.2.6): 
+   8  # 2005-11-12 fl   added tostringlist/fromstringlist helpers 
+   9  # 2006-07-05 fl   merged in selected changes from the 1.3 sandbox 
+  10  # 2006-07-05 fl   removed support for 2.1 and earlier 
+  11  # 2007-06-21 fl   added deprecation/future warnings 
+  12  # 2007-08-25 fl   added doctype hook, added parser version attribute etc 
+  13  # 2007-08-26 fl   added new serializer code (better namespace handling, etc) 
+  14  # 2007-08-27 fl   warn for broken /tag searches on tree level 
+  15  # 2007-09-02 fl   added html/text methods to serializer (experimental) 
+  16  # 2007-09-05 fl   added method argument to tostring/tostringlist 
+  17  # 2007-09-06 fl   improved error handling 
+  18  # 2007-09-13 fl   added itertext, iterfind; assorted cleanups 
+  19  # 2007-12-15 fl   added C14N hooks, copy method (experimental) 
+  20  # 
+  21  # Copyright (c) 1999-2008 by Fredrik Lundh.  All rights reserved. 
+  22  # 
+  23  # fredrik@pythonware.com 
+  24  # http://www.pythonware.com 
+  25  # 
+  26  # -------------------------------------------------------------------- 
+  27  # The ElementTree toolkit is 
+  28  # 
+  29  # Copyright (c) 1999-2008 by Fredrik Lundh 
+  30  # 
+  31  # By obtaining, using, and/or copying this software and/or its 
+  32  # associated documentation, you agree that you have read, understood, 
+  33  # and will comply with the following terms and conditions: 
+  34  # 
+  35  # Permission to use, copy, modify, and distribute this software and 
+  36  # its associated documentation for any purpose and without fee is 
+  37  # hereby granted, provided that the above copyright notice appears in 
+  38  # all copies, and that both that copyright notice and this permission 
+  39  # notice appear in supporting documentation, and that the name of 
+  40  # Secret Labs AB or the author not be used in advertising or publicity 
+  41  # pertaining to distribution of the software without specific, written 
+  42  # prior permission. 
+  43  # 
+  44  # SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD 
+  45  # TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- 
+  46  # ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR 
+  47  # BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 
+  48  # DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 
+  49  # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 
+  50  # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+  51  # OF THIS SOFTWARE. 
+  52  # -------------------------------------------------------------------- 
+  53   
+  54  # Licensed to PSF under a Contributor Agreement. 
+  55  # See http://www.python.org/psf/license for licensing details. 
+  56   
+  57  __all__ = [ 
+  58      # public symbols 
+  59      "Comment", 
+  60      "dump", 
+  61      "Element", "ElementTree", 
+  62      "fromstring", "fromstringlist", 
+  63      "iselement", "iterparse", 
+  64      "parse", "ParseError", 
+  65      "PI", "ProcessingInstruction", 
+  66      "QName", 
+  67      "SubElement", 
+  68      "tostring", "tostringlist", 
+  69      "TreeBuilder", 
+  70      "VERSION", 
+  71      "XML", 
+  72      "XMLParser", "XMLTreeBuilder", 
+  73      ] 
+  74   
+  75  VERSION = "1.3.0" 
+  76   
+  77  ## 
+  78  # The <b>Element</b> type is a flexible container object, designed to 
+  79  # store hierarchical data structures in memory. The type can be 
+  80  # described as a cross between a list and a dictionary. 
+  81  # <p> 
+  82  # Each element has a number of properties associated with it: 
+  83  # <ul> 
+  84  # <li>a <i>tag</i>. This is a string identifying what kind of data 
+  85  # this element represents (the element type, in other words).</li> 
+  86  # <li>a number of <i>attributes</i>, stored in a Python dictionary.</li> 
+  87  # <li>a <i>text</i> string.</li> 
+  88  # <li>an optional <i>tail</i> string.</li> 
+  89  # <li>a number of <i>child elements</i>, stored in a Python sequence</li> 
+  90  # </ul> 
+  91  # 
+  92  # To create an element instance, use the {@link #Element} constructor 
+  93  # or the {@link #SubElement} factory function. 
+  94  # <p> 
+  95  # The {@link #ElementTree} class can be used to wrap an element 
+  96  # structure, and convert it from and to XML. 
+  97  ## 
+  98   
+  99  import sys 
+ 100  import re 
+ 101  import warnings 
+ 102   
+ 103   
+ 104 -class _SimpleElementPath(object): 
+
 105      # emulate pre-1.2 find/findtext/findall behaviour 
+ 106 -    def find(self, element, tag, namespaces=None): 
+
 107          for elem in element: 
+ 108              if elem.tag == tag: 
+ 109                  return elem 
+ 110          return None 
+
 111 -    def findtext(self, element, tag, default=None, namespaces=None): 
+
 112          elem = self.find(element, tag) 
+ 113          if elem is None: 
+ 114              return default 
+ 115          return elem.text or "" 
+
 116 -    def iterfind(self, element, tag, namespaces=None): 
+
 117          if tag[:3] == ".//": 
+ 118              for elem in element.iter(tag[3:]): 
+ 119                  yield elem 
+ 120          for elem in element: 
+ 121              if elem.tag == tag: 
+ 122                  yield elem 
+
 123 -    def findall(self, element, tag, namespaces=None): 
+
 124          return list(self.iterfind(element, tag, namespaces)) 
+
 125   
+ 126  try: 
+ 127      from . import ElementPath 
+ 128  except ImportError: 
+ 129      ElementPath = _SimpleElementPath() 
+ 130   
+ 131  ## 
+ 132  # Parser error.  This is a subclass of <b>SyntaxError</b>. 
+ 133  # <p> 
+ 134  # In addition to the exception value, an exception instance contains a 
+ 135  # specific exception code in the <b>code</b> attribute, and the line and 
+ 136  # column of the error in the <b>position</b> attribute. 
+ 137   
+ 138 -class ParseError(SyntaxError): 
+
 139      pass 
+
 140   
+ 141  # -------------------------------------------------------------------- 
+ 142   
+ 143  ## 
+ 144  # Checks if an object appears to be a valid element object. 
+ 145  # 
+ 146  # @param An element instance. 
+ 147  # @return A true value if this is an element object. 
+ 148  # @defreturn flag 
+ 149   
+ 150 -def iselement(element): 
+
 151      # FIXME: not sure about this; might be a better idea to look 
+ 152      # for tag/attrib/text attributes 
+ 153      return isinstance(element, Element) or hasattr(element, "tag") 
+
 154   
+ 155  ## 
+ 156  # Element class.  This class defines the Element interface, and 
+ 157  # provides a reference implementation of this interface. 
+ 158  # <p> 
+ 159  # The element name, attribute names, and attribute values can be 
+ 160  # either ASCII strings (ordinary Python strings containing only 7-bit 
+ 161  # ASCII characters) or Unicode strings. 
+ 162  # 
+ 163  # @param tag The element name. 
+ 164  # @param attrib An optional dictionary, containing element attributes. 
+ 165  # @param **extra Additional attributes, given as keyword arguments. 
+ 166  # @see Element 
+ 167  # @see SubElement 
+ 168  # @see Comment 
+ 169  # @see ProcessingInstruction 
+ 170   
+ 171 -class Element(object): 
+
 172      # <tag attrib>text<child/>...</tag>tail 
+ 173   
+ 174      ## 
+ 175      # (Attribute) Element tag. 
+ 176   
+ 177      tag = None 
+ 178   
+ 179      ## 
+ 180      # (Attribute) Element attribute dictionary.  Where possible, use 
+ 181      # {@link #Element.get}, 
+ 182      # {@link #Element.set}, 
+ 183      # {@link #Element.keys}, and 
+ 184      # {@link #Element.items} to access 
+ 185      # element attributes. 
+ 186   
+ 187      attrib = None 
+ 188   
+ 189      ## 
+ 190      # (Attribute) Text before first subelement.  This is either a 
+ 191      # string or the value None.  Note that if there was no text, this 
+ 192      # attribute may be either None or an empty string, depending on 
+ 193      # the parser. 
+ 194   
+ 195      text = None 
+ 196   
+ 197      ## 
+ 198      # (Attribute) Text after this element's end tag, but before the 
+ 199      # next sibling element's start tag.  This is either a string or 
+ 200      # the value None.  Note that if there was no text, this attribute 
+ 201      # may be either None or an empty string, depending on the parser. 
+ 202   
+ 203      tail = None # text after end tag, if any 
+ 204   
+ 205      # constructor 
+ 206   
+ 207 -    def __init__(self, tag, attrib={}, **extra): 
+
 208          attrib = attrib.copy() 
+ 209          attrib.update(extra) 
+ 210          self.tag = tag 
+ 211          self.attrib = attrib 
+ 212          self._children = [] 
+
 213   
+ 214 -    def __repr__(self): 
+
 215          return "<Element %s at 0x%x>" % (repr(self.tag), id(self)) 
+
 216   
+ 217      ## 
+ 218      # Creates a new element object of the same type as this element. 
+ 219      # 
+ 220      # @param tag Element tag. 
+ 221      # @param attrib Element attributes, given as a dictionary. 
+ 222      # @return A new element instance. 
+ 223   
+ 224 -    def makeelement(self, tag, attrib): 
+
 225          return self.__class__(tag, attrib) 
+
 226   
+ 227      ## 
+ 228      # (Experimental) Copies the current element.  This creates a 
+ 229      # shallow copy; subelements will be shared with the original tree. 
+ 230      # 
+ 231      # @return A new element instance. 
+ 232   
+ 233 -    def copy(self): 
+
 234          elem = self.makeelement(self.tag, self.attrib) 
+ 235          elem.text = self.text 
+ 236          elem.tail = self.tail 
+ 237          elem[:] = self 
+ 238          return elem 
+
 239   
+ 240      ## 
+ 241      # Returns the number of subelements.  Note that this only counts 
+ 242      # full elements; to check if there's any content in an element, you 
+ 243      # have to check both the length and the <b>text</b> attribute. 
+ 244      # 
+ 245      # @return The number of subelements. 
+ 246   
+ 247 -    def __len__(self): 
+
 248          return len(self._children) 
+
 249   
+ 250 -    def __nonzero__(self): 
+
 251          warnings.warn( 
+ 252              "The behavior of this method will change in future versions.  " 
+ 253              "Use specific 'len(elem)' or 'elem is not None' test instead.", 
+ 254              FutureWarning, stacklevel=2 
+ 255              ) 
+ 256          return len(self._children) != 0 # emulate old behaviour, for now 
+
 257   
+ 258      ## 
+ 259      # Returns the given subelement, by index. 
+ 260      # 
+ 261      # @param index What subelement to return. 
+ 262      # @return The given subelement. 
+ 263      # @exception IndexError If the given element does not exist. 
+ 264   
+ 265 -    def __getitem__(self, index): 
+
 266          return self._children[index] 
+
 267   
+ 268      ## 
+ 269      # Replaces the given subelement, by index. 
+ 270      # 
+ 271      # @param index What subelement to replace. 
+ 272      # @param element The new element value. 
+ 273      # @exception IndexError If the given element does not exist. 
+ 274   
+ 275 -    def __setitem__(self, index, element): 
+
 276          # if isinstance(index, slice): 
+ 277          #     for elt in element: 
+ 278          #         assert iselement(elt) 
+ 279          # else: 
+ 280          #     assert iselement(element) 
+ 281          self._children[index] = element 
+
 282   
+ 283      ## 
+ 284      # Deletes the given subelement, by index. 
+ 285      # 
+ 286      # @param index What subelement to delete. 
+ 287      # @exception IndexError If the given element does not exist. 
+ 288   
+ 289 -    def __delitem__(self, index): 
+
 290          del self._children[index] 
+
 291   
+ 292      ## 
+ 293      # Adds a subelement to the end of this element.  In document order, 
+ 294      # the new element will appear after the last existing subelement (or 
+ 295      # directly after the text, if it's the first subelement), but before 
+ 296      # the end tag for this element. 
+ 297      # 
+ 298      # @param element The element to add. 
+ 299   
+ 300 -    def append(self, element): 
+
 301          # assert iselement(element) 
+ 302          self._children.append(element) 
+
 303   
+ 304      ## 
+ 305      # Appends subelements from a sequence. 
+ 306      # 
+ 307      # @param elements A sequence object with zero or more elements. 
+ 308      # @since 1.3 
+ 309   
+ 310 -    def extend(self, elements): 
+
 311          # for element in elements: 
+ 312          #     assert iselement(element) 
+ 313          self._children.extend(elements) 
+
 314   
+ 315      ## 
+ 316      # Inserts a subelement at the given position in this element. 
+ 317      # 
+ 318      # @param index Where to insert the new subelement. 
+ 319   
+ 320 -    def insert(self, index, element): 
+
 321          # assert iselement(element) 
+ 322          self._children.insert(index, element) 
+
 323   
+ 324      ## 
+ 325      # Removes a matching subelement.  Unlike the <b>find</b> methods, 
+ 326      # this method compares elements based on identity, not on tag 
+ 327      # value or contents.  To remove subelements by other means, the 
+ 328      # easiest way is often to use a list comprehension to select what 
+ 329      # elements to keep, and use slice assignment to update the parent 
+ 330      # element. 
+ 331      # 
+ 332      # @param element What element to remove. 
+ 333      # @exception ValueError If a matching element could not be found. 
+ 334   
+ 335 -    def remove(self, element): 
+
 336          # assert iselement(element) 
+ 337          self._children.remove(element) 
+
 338   
+ 339      ## 
+ 340      # (Deprecated) Returns all subelements.  The elements are returned 
+ 341      # in document order. 
+ 342      # 
+ 343      # @return A list of subelements. 
+ 344      # @defreturn list of Element instances 
+ 345   
+ 346 -    def getchildren(self): 
+
 347          warnings.warn( 
+ 348              "This method will be removed in future versions.  " 
+ 349              "Use 'list(elem)' or iteration over elem instead.", 
+ 350              DeprecationWarning, stacklevel=2 
+ 351              ) 
+ 352          return self._children 
+
 353   
+ 354      ## 
+ 355      # Finds the first matching subelement, by tag name or path. 
+ 356      # 
+ 357      # @param path What element to look for. 
+ 358      # @keyparam namespaces Optional namespace prefix map. 
+ 359      # @return The first matching element, or None if no element was found. 
+ 360      # @defreturn Element or None 
+ 361   
+ 362 -    def find(self, path, namespaces=None): 
+
 363          return ElementPath.find(self, path, namespaces) 
+
 364   
+ 365      ## 
+ 366      # Finds text for the first matching subelement, by tag name or path. 
+ 367      # 
+ 368      # @param path What element to look for. 
+ 369      # @param default What to return if the element was not found. 
+ 370      # @keyparam namespaces Optional namespace prefix map. 
+ 371      # @return The text content of the first matching element, or the 
+ 372      #     default value no element was found.  Note that if the element 
+ 373      #     is found, but has no text content, this method returns an 
+ 374      #     empty string. 
+ 375      # @defreturn string 
+ 376   
+ 377 -    def findtext(self, path, default=None, namespaces=None): 
+
 378          return ElementPath.findtext(self, path, default, namespaces) 
+
 379   
+ 380      ## 
+ 381      # Finds all matching subelements, by tag name or path. 
+ 382      # 
+ 383      # @param path What element to look for. 
+ 384      # @keyparam namespaces Optional namespace prefix map. 
+ 385      # @return A list or other sequence containing all matching elements, 
+ 386      #    in document order. 
+ 387      # @defreturn list of Element instances 
+ 388   
+ 389 -    def findall(self, path, namespaces=None): 
+
 390          return ElementPath.findall(self, path, namespaces) 
+
 391   
+ 392      ## 
+ 393      # Finds all matching subelements, by tag name or path. 
+ 394      # 
+ 395      # @param path What element to look for. 
+ 396      # @keyparam namespaces Optional namespace prefix map. 
+ 397      # @return An iterator or sequence containing all matching elements, 
+ 398      #    in document order. 
+ 399      # @defreturn a generated sequence of Element instances 
+ 400   
+ 401 -    def iterfind(self, path, namespaces=None): 
+
 402          return ElementPath.iterfind(self, path, namespaces) 
+
 403   
+ 404      ## 
+ 405      # Resets an element.  This function removes all subelements, clears 
+ 406      # all attributes, and sets the <b>text</b> and <b>tail</b> attributes 
+ 407      # to None. 
+ 408   
+ 409 -    def clear(self): 
+
 410          self.attrib.clear() 
+ 411          self._children = [] 
+ 412          self.text = self.tail = None 
+
 413   
+ 414      ## 
+ 415      # Gets an element attribute.  Equivalent to <b>attrib.get</b>, but 
+ 416      # some implementations may handle this a bit more efficiently. 
+ 417      # 
+ 418      # @param key What attribute to look for. 
+ 419      # @param default What to return if the attribute was not found. 
+ 420      # @return The attribute value, or the default value, if the 
+ 421      #     attribute was not found. 
+ 422      # @defreturn string or None 
+ 423   
+ 424 -    def get(self, key, default=None): 
+
 425          return self.attrib.get(key, default) 
+
 426   
+ 427      ## 
+ 428      # Sets an element attribute.  Equivalent to <b>attrib[key] = value</b>, 
+ 429      # but some implementations may handle this a bit more efficiently. 
+ 430      # 
+ 431      # @param key What attribute to set. 
+ 432      # @param value The attribute value. 
+ 433   
+ 434 -    def set(self, key, value): 
+
 435          self.attrib[key] = value 
+
 436   
+ 437      ## 
+ 438      # Gets a list of attribute names.  The names are returned in an 
+ 439      # arbitrary order (just like for an ordinary Python dictionary). 
+ 440      # Equivalent to <b>attrib.keys()</b>. 
+ 441      # 
+ 442      # @return A list of element attribute names. 
+ 443      # @defreturn list of strings 
+ 444   
+ 445 -    def keys(self): 
+
 446          return self.attrib.keys() 
+
 447   
+ 448      ## 
+ 449      # Gets element attributes, as a sequence.  The attributes are 
+ 450      # returned in an arbitrary order.  Equivalent to <b>attrib.items()</b>. 
+ 451      # 
+ 452      # @return A list of (name, value) tuples for all attributes. 
+ 453      # @defreturn list of (string, string) tuples 
+ 454   
+ 455 -    def items(self): 
+
 456          return self.attrib.items() 
+
 457   
+ 458      ## 
+ 459      # Creates a tree iterator.  The iterator loops over this element 
+ 460      # and all subelements, in document order, and returns all elements 
+ 461      # with a matching tag. 
+ 462      # <p> 
+ 463      # If the tree structure is modified during iteration, new or removed 
+ 464      # elements may or may not be included.  To get a stable set, use the 
+ 465      # list() function on the iterator, and loop over the resulting list. 
+ 466      # 
+ 467      # @param tag What tags to look for (default is to return all elements). 
+ 468      # @return An iterator containing all the matching elements. 
+ 469      # @defreturn iterator 
+ 470   
+ 471 -    def iter(self, tag=None): 
+
 472          if tag == "*": 
+ 473              tag = None 
+ 474          if tag is None or self.tag == tag: 
+ 475              yield self 
+ 476          for e in self._children: 
+ 477              for e in e.iter(tag): 
+ 478                  yield e 
+
 479   
+ 480      # compatibility 
+ 481 -    def getiterator(self, tag=None): 
+
 482          # Change for a DeprecationWarning in 1.4 
+ 483          warnings.warn( 
+ 484              "This method will be removed in future versions.  " 
+ 485              "Use 'elem.iter()' or 'list(elem.iter())' instead.", 
+ 486              PendingDeprecationWarning, stacklevel=2 
+ 487          ) 
+ 488          return list(self.iter(tag)) 
+
 489   
+ 490      ## 
+ 491      # Creates a text iterator.  The iterator loops over this element 
+ 492      # and all subelements, in document order, and returns all inner 
+ 493      # text. 
+ 494      # 
+ 495      # @return An iterator containing all inner text. 
+ 496      # @defreturn iterator 
+ 497   
+ 498 -    def itertext(self): 
+
 499          tag = self.tag 
+ 500          if not isinstance(tag, basestring) and tag is not None: 
+ 501              return 
+ 502          if self.text: 
+ 503              yield self.text 
+ 504          for e in self: 
+ 505              for s in e.itertext(): 
+ 506                  yield s 
+ 507              if e.tail: 
+ 508                  yield e.tail 
+
 509   
+ 510  # compatibility 
+ 511  _Element = _ElementInterface = Element 
+ 512   
+ 513  ## 
+ 514  # Subelement factory.  This function creates an element instance, and 
+ 515  # appends it to an existing element. 
+ 516  # <p> 
+ 517  # The element name, attribute names, and attribute values can be 
+ 518  # either 8-bit ASCII strings or Unicode strings. 
+ 519  # 
+ 520  # @param parent The parent element. 
+ 521  # @param tag The subelement name. 
+ 522  # @param attrib An optional dictionary, containing element attributes. 
+ 523  # @param **extra Additional attributes, given as keyword arguments. 
+ 524  # @return An element instance. 
+ 525  # @defreturn Element 
+ 526   
+ 527 -def SubElement(parent, tag, attrib={}, **extra): 
+
 528      attrib = attrib.copy() 
+ 529      attrib.update(extra) 
+ 530      element = parent.makeelement(tag, attrib) 
+ 531      parent.append(element) 
+ 532      return element 
+
 533   
+ 534  ## 
+ 535  # Comment element factory.  This factory function creates a special 
+ 536  # element that will be serialized as an XML comment by the standard 
+ 537  # serializer. 
+ 538  # <p> 
+ 539  # The comment string can be either an 8-bit ASCII string or a Unicode 
+ 540  # string. 
+ 541  # 
+ 542  # @param text A string containing the comment string. 
+ 543  # @return An element instance, representing a comment. 
+ 544  # @defreturn Element 
+ 545   
+ 546 -def Comment(text=None): 
+
 547      element = Element(Comment) 
+ 548      element.text = text 
+ 549      return element 
+
 550   
+ 551  ## 
+ 552  # PI element factory.  This factory function creates a special element 
+ 553  # that will be serialized as an XML processing instruction by the standard 
+ 554  # serializer. 
+ 555  # 
+ 556  # @param target A string containing the PI target. 
+ 557  # @param text A string containing the PI contents, if any. 
+ 558  # @return An element instance, representing a PI. 
+ 559  # @defreturn Element 
+ 560   
+ 561 -def ProcessingInstruction(target, text=None): 
+
 562      element = Element(ProcessingInstruction) 
+ 563      element.text = target 
+ 564      if text: 
+ 565          element.text = element.text + " " + text 
+ 566      return element 
+
 567   
+ 568  PI = ProcessingInstruction 
+ 569   
+ 570  ## 
+ 571  # QName wrapper.  This can be used to wrap a QName attribute value, in 
+ 572  # order to get proper namespace handling on output. 
+ 573  # 
+ 574  # @param text A string containing the QName value, in the form {uri}local, 
+ 575  #     or, if the tag argument is given, the URI part of a QName. 
+ 576  # @param tag Optional tag.  If given, the first argument is interpreted as 
+ 577  #     a URI, and this argument is interpreted as a local name. 
+ 578  # @return An opaque object, representing the QName. 
+ 579   
+ 580 -class QName(object): 
+
 581 -    def __init__(self, text_or_uri, tag=None): 
+
 582          if tag: 
+ 583              text_or_uri = "{%s}%s" % (text_or_uri, tag) 
+ 584          self.text = text_or_uri 
+
 585 -    def __str__(self): 
+
 586          return self.text 
+
 587 -    def __hash__(self): 
+
 588          return hash(self.text) 
+
 589 -    def __cmp__(self, other): 
+
 590          if isinstance(other, QName): 
+ 591              return cmp(self.text, other.text) 
+ 592          return cmp(self.text, other) 
+
 593   
+ 594  # -------------------------------------------------------------------- 
+ 595   
+ 596  ## 
+ 597  # ElementTree wrapper class.  This class represents an entire element 
+ 598  # hierarchy, and adds some extra support for serialization to and from 
+ 599  # standard XML. 
+ 600  # 
+ 601  # @param element Optional root element. 
+ 602  # @keyparam file Optional file handle or file name.  If given, the 
+ 603  #     tree is initialized with the contents of this XML file. 
+ 604   
+ 605 -class ElementTree(object): 
+
 606   
+ 607 -    def __init__(self, element=None, file=None): 
+
 608          # assert element is None or iselement(element) 
+ 609          self._root = element # first node 
+ 610          if file: 
+ 611              self.parse(file) 
+
 612   
+ 613      ## 
+ 614      # Gets the root element for this tree. 
+ 615      # 
+ 616      # @return An element instance. 
+ 617      # @defreturn Element 
+ 618   
+ 619 -    def getroot(self): 
+
 620          return self._root 
+
 621   
+ 622      ## 
+ 623      # Replaces the root element for this tree.  This discards the 
+ 624      # current contents of the tree, and replaces it with the given 
+ 625      # element.  Use with care. 
+ 626      # 
+ 627      # @param element An element instance. 
+ 628   
+ 629 -    def _setroot(self, element): 
+
 630          # assert iselement(element) 
+ 631          self._root = element 
+
 632   
+ 633      ## 
+ 634      # Loads an external XML document into this element tree. 
+ 635      # 
+ 636      # @param source A file name or file object.  If a file object is 
+ 637      #     given, it only has to implement a <b>read(n)</b> method. 
+ 638      # @keyparam parser An optional parser instance.  If not given, the 
+ 639      #     standard {@link XMLParser} parser is used. 
+ 640      # @return The document root element. 
+ 641      # @defreturn Element 
+ 642      # @exception ParseError If the parser fails to parse the document. 
+ 643   
+ 644 -    def parse(self, source, parser=None): 
+
 645          close_source = False 
+ 646          if not hasattr(source, "read"): 
+ 647              source = open(source, "rb") 
+ 648              close_source = True 
+ 649          try: 
+ 650              if not parser: 
+ 651                  parser = XMLParser(target=TreeBuilder()) 
+ 652              while 1: 
+ 653                  data = source.read(65536) 
+ 654                  if not data: 
+ 655                      break 
+ 656                  parser.feed(data) 
+ 657              self._root = parser.close() 
+ 658              return self._root 
+ 659          finally: 
+ 660              if close_source: 
+ 661                  source.close() 
+
 662   
+ 663      ## 
+ 664      # Creates a tree iterator for the root element.  The iterator loops 
+ 665      # over all elements in this tree, in document order. 
+ 666      # 
+ 667      # @param tag What tags to look for (default is to return all elements) 
+ 668      # @return An iterator. 
+ 669      # @defreturn iterator 
+ 670   
+ 671 -    def iter(self, tag=None): 
+
 672          # assert self._root is not None 
+ 673          return self._root.iter(tag) 
+
 674   
+ 675      # compatibility 
+ 676 -    def getiterator(self, tag=None): 
+
 677          # Change for a DeprecationWarning in 1.4 
+ 678          warnings.warn( 
+ 679              "This method will be removed in future versions.  " 
+ 680              "Use 'tree.iter()' or 'list(tree.iter())' instead.", 
+ 681              PendingDeprecationWarning, stacklevel=2 
+ 682          ) 
+ 683          return list(self.iter(tag)) 
+
 684   
+ 685      ## 
+ 686      # Same as getroot().find(path), starting at the root of the 
+ 687      # tree. 
+ 688      # 
+ 689      # @param path What element to look for. 
+ 690      # @keyparam namespaces Optional namespace prefix map. 
+ 691      # @return The first matching element, or None if no element was found. 
+ 692      # @defreturn Element or None 
+ 693   
+ 694 -    def find(self, path, namespaces=None): 
+
 695          # assert self._root is not None 
+ 696          if path[:1] == "/": 
+ 697              path = "." + path 
+ 698              warnings.warn( 
+ 699                  "This search is broken in 1.3 and earlier, and will be " 
+ 700                  "fixed in a future version.  If you rely on the current " 
+ 701                  "behaviour, change it to %r" % path, 
+ 702                  FutureWarning, stacklevel=2 
+ 703                  ) 
+ 704          return self._root.find(path, namespaces) 
+
 705   
+ 706      ## 
+ 707      # Same as getroot().findtext(path), starting at the root of the tree. 
+ 708      # 
+ 709      # @param path What element to look for. 
+ 710      # @param default What to return if the element was not found. 
+ 711      # @keyparam namespaces Optional namespace prefix map. 
+ 712      # @return The text content of the first matching element, or the 
+ 713      #     default value no element was found.  Note that if the element 
+ 714      #     is found, but has no text content, this method returns an 
+ 715      #     empty string. 
+ 716      # @defreturn string 
+ 717   
+ 718 -    def findtext(self, path, default=None, namespaces=None): 
+
 719          # assert self._root is not None 
+ 720          if path[:1] == "/": 
+ 721              path = "." + path 
+ 722              warnings.warn( 
+ 723                  "This search is broken in 1.3 and earlier, and will be " 
+ 724                  "fixed in a future version.  If you rely on the current " 
+ 725                  "behaviour, change it to %r" % path, 
+ 726                  FutureWarning, stacklevel=2 
+ 727                  ) 
+ 728          return self._root.findtext(path, default, namespaces) 
+
 729   
+ 730      ## 
+ 731      # Same as getroot().findall(path), starting at the root of the tree. 
+ 732      # 
+ 733      # @param path What element to look for. 
+ 734      # @keyparam namespaces Optional namespace prefix map. 
+ 735      # @return A list or iterator containing all matching elements, 
+ 736      #    in document order. 
+ 737      # @defreturn list of Element instances 
+ 738   
+ 739 -    def findall(self, path, namespaces=None): 
+
 740          # assert self._root is not None 
+ 741          if path[:1] == "/": 
+ 742              path = "." + path 
+ 743              warnings.warn( 
+ 744                  "This search is broken in 1.3 and earlier, and will be " 
+ 745                  "fixed in a future version.  If you rely on the current " 
+ 746                  "behaviour, change it to %r" % path, 
+ 747                  FutureWarning, stacklevel=2 
+ 748                  ) 
+ 749          return self._root.findall(path, namespaces) 
+
 750   
+ 751      ## 
+ 752      # Finds all matching subelements, by tag name or path. 
+ 753      # Same as getroot().iterfind(path). 
+ 754      # 
+ 755      # @param path What element to look for. 
+ 756      # @keyparam namespaces Optional namespace prefix map. 
+ 757      # @return An iterator or sequence containing all matching elements, 
+ 758      #    in document order. 
+ 759      # @defreturn a generated sequence of Element instances 
+ 760   
+ 761 -    def iterfind(self, path, namespaces=None): 
+
 762          # assert self._root is not None 
+ 763          if path[:1] == "/": 
+ 764              path = "." + path 
+ 765              warnings.warn( 
+ 766                  "This search is broken in 1.3 and earlier, and will be " 
+ 767                  "fixed in a future version.  If you rely on the current " 
+ 768                  "behaviour, change it to %r" % path, 
+ 769                  FutureWarning, stacklevel=2 
+ 770                  ) 
+ 771          return self._root.iterfind(path, namespaces) 
+
 772   
+ 773      ## 
+ 774      # Writes the element tree to a file, as XML. 
+ 775      # 
+ 776      # @def write(file, **options) 
+ 777      # @param file A file name, or a file object opened for writing. 
+ 778      # @param **options Options, given as keyword arguments. 
+ 779      # @keyparam encoding Optional output encoding (default is US-ASCII). 
+ 780      # @keyparam xml_declaration Controls if an XML declaration should 
+ 781      #     be added to the file.  Use False for never, True for always, 
+ 782      #     None for only if not US-ASCII or UTF-8.  None is default. 
+ 783      # @keyparam default_namespace Sets the default XML namespace (for "xmlns"). 
+ 784      # @keyparam method Optional output method ("xml", "html", "text" or 
+ 785      #     "c14n"; default is "xml"). 
+ 786   
+ 787 -    def write(self, file_or_filename, 
+ 788                # keyword arguments 
+ 789                encoding=None, 
+ 790                xml_declaration=None, 
+ 791                default_namespace=None, 
+ 792                method=None): 
+
 793          # assert self._root is not None 
+ 794          if not method: 
+ 795              method = "xml" 
+ 796          elif method not in _serialize: 
+ 797              # FIXME: raise an ImportError for c14n if ElementC14N is missing? 
+ 798              raise ValueError("unknown method %r" % method) 
+ 799          if hasattr(file_or_filename, "write"): 
+ 800              file = file_or_filename 
+ 801          else: 
+ 802              file = open(file_or_filename, "wb") 
+ 803          write = file.write 
+ 804          if not encoding: 
+ 805              if method == "c14n": 
+ 806                  encoding = "utf-8" 
+ 807              else: 
+ 808                  encoding = "us-ascii" 
+ 809          elif xml_declaration or (xml_declaration is None and 
+ 810                                   encoding not in ("utf-8", "us-ascii")): 
+ 811              if method == "xml": 
+ 812                  write("<?xml version='1.0' encoding='%s'?>\n" % encoding) 
+ 813          if method == "text": 
+ 814              _serialize_text(write, self._root, encoding) 
+ 815          else: 
+ 816              qnames, namespaces = _namespaces( 
+ 817                  self._root, encoding, default_namespace 
+ 818                  ) 
+ 819              serialize = _serialize[method] 
+ 820              serialize(write, self._root, encoding, qnames, namespaces) 
+ 821          if file_or_filename is not file: 
+ 822              file.close() 
+
 823   
+ 824 -    def write_c14n(self, file): 
+
 825          # lxml.etree compatibility.  use output method instead 
+ 826          return self.write(file, method="c14n") 
+
 827   
+ 828  # -------------------------------------------------------------------- 
+ 829  # serialization support 
+ 830   
+ 831 -def _namespaces(elem, encoding, default_namespace=None): 
+
 832      # identify namespaces used in this tree 
+ 833   
+ 834      # maps qnames to *encoded* prefix:local names 
+ 835      qnames = {None: None} 
+ 836   
+ 837      # maps uri:s to prefixes 
+ 838      namespaces = {} 
+ 839      if default_namespace: 
+ 840          namespaces[default_namespace] = "" 
+ 841   
+ 842      def encode(text): 
+ 843          return text.encode(encoding) 
+
 844   
+ 845      def add_qname(qname): 
+ 846          # calculate serialized qname representation 
+ 847          try: 
+ 848              if qname[:1] == "{": 
+ 849                  uri, tag = qname[1:].rsplit("}", 1) 
+ 850                  prefix = namespaces.get(uri) 
+ 851                  if prefix is None: 
+ 852                      prefix = _namespace_map.get(uri) 
+ 853                      if prefix is None: 
+ 854                          prefix = "ns%d" % len(namespaces) 
+ 855                      if prefix != "xml": 
+ 856                          namespaces[uri] = prefix 
+ 857                  if prefix: 
+ 858                      qnames[qname] = encode("%s:%s" % (prefix, tag)) 
+ 859                  else: 
+ 860                      qnames[qname] = encode(tag) # default element 
+ 861              else: 
+ 862                  if default_namespace: 
+ 863                      # FIXME: can this be handled in XML 1.0? 
+ 864                      raise ValueError( 
+ 865                          "cannot use non-qualified names with " 
+ 866                          "default_namespace option" 
+ 867                          ) 
+ 868                  qnames[qname] = encode(qname) 
+ 869          except TypeError: 
+ 870              _raise_serialization_error(qname) 
+ 871   
+ 872      # populate qname and namespaces table 
+ 873      try: 
+ 874          iterate = elem.iter 
+ 875      except AttributeError: 
+ 876          iterate = elem.getiterator # cET compatibility 
+ 877      for elem in iterate(): 
+ 878          tag = elem.tag 
+ 879          if isinstance(tag, QName): 
+ 880              if tag.text not in qnames: 
+ 881                  add_qname(tag.text) 
+ 882          elif isinstance(tag, basestring): 
+ 883              if tag not in qnames: 
+ 884                  add_qname(tag) 
+ 885          elif tag is not None and tag is not Comment and tag is not PI: 
+ 886              _raise_serialization_error(tag) 
+ 887          for key, value in elem.items(): 
+ 888              if isinstance(key, QName): 
+ 889                  key = key.text 
+ 890              if key not in qnames: 
+ 891                  add_qname(key) 
+ 892              if isinstance(value, QName) and value.text not in qnames: 
+ 893                  add_qname(value.text) 
+ 894          text = elem.text 
+ 895          if isinstance(text, QName) and text.text not in qnames: 
+ 896              add_qname(text.text) 
+ 897      return qnames, namespaces 
+ 898   
+ 899 -def _serialize_xml(write, elem, encoding, qnames, namespaces): 
+
 900      tag = elem.tag 
+ 901      text = elem.text 
+ 902      if tag is Comment: 
+ 903          write("<!--%s-->" % _encode(text, encoding)) 
+ 904      elif tag is ProcessingInstruction: 
+ 905          write("<?%s?>" % _encode(text, encoding)) 
+ 906      else: 
+ 907          tag = qnames[tag] 
+ 908          if tag is None: 
+ 909              if text: 
+ 910                  write(_escape_cdata(text, encoding)) 
+ 911              for e in elem: 
+ 912                  _serialize_xml(write, e, encoding, qnames, None) 
+ 913          else: 
+ 914              write("<" + tag) 
+ 915              items = elem.items() 
+ 916              if items or namespaces: 
+ 917                  if namespaces: 
+ 918                      for v, k in sorted(namespaces.items(), 
+ 919                                         key=lambda x: x[1]):  # sort on prefix 
+ 920                          if k: 
+ 921                              k = ":" + k 
+ 922                          write(" xmlns%s=\"%s\"" % ( 
+ 923                              k.encode(encoding), 
+ 924                              _escape_attrib(v, encoding) 
+ 925                              )) 
+ 926                  for k, v in sorted(items):  # lexical order 
+ 927                      if isinstance(k, QName): 
+ 928                          k = k.text 
+ 929                      if isinstance(v, QName): 
+ 930                          v = qnames[v.text] 
+ 931                      else: 
+ 932                          v = _escape_attrib(v, encoding) 
+ 933                      write(" %s=\"%s\"" % (qnames[k], v)) 
+ 934              if text or len(elem): 
+ 935                  write(">") 
+ 936                  if text: 
+ 937                      write(_escape_cdata(text, encoding)) 
+ 938                  for e in elem: 
+ 939                      _serialize_xml(write, e, encoding, qnames, None) 
+ 940                  write("</" + tag + ">") 
+ 941              else: 
+ 942                  write(" />") 
+ 943      if elem.tail: 
+ 944          write(_escape_cdata(elem.tail, encoding)) 
+
 945   
+ 946  HTML_EMPTY = ("area", "base", "basefont", "br", "col", "frame", "hr", 
+ 947                "img", "input", "isindex", "link", "meta", "param") 
+ 948   
+ 949  try: 
+ 950      HTML_EMPTY = set(HTML_EMPTY) 
+ 951  except NameError: 
+ 952      pass 
+ 953   
+ 954 -def _serialize_html(write, elem, encoding, qnames, namespaces): 
+
 955      tag = elem.tag 
+ 956      text = elem.text 
+ 957      if tag is Comment: 
+ 958          write("<!--%s-->" % _escape_cdata(text, encoding)) 
+ 959      elif tag is ProcessingInstruction: 
+ 960          write("<?%s?>" % _escape_cdata(text, encoding)) 
+ 961      else: 
+ 962          tag = qnames[tag] 
+ 963          if tag is None: 
+ 964              if text: 
+ 965                  write(_escape_cdata(text, encoding)) 
+ 966              for e in elem: 
+ 967                  _serialize_html(write, e, encoding, qnames, None) 
+ 968          else: 
+ 969              write("<" + tag) 
+ 970              items = elem.items() 
+ 971              if items or namespaces: 
+ 972                  if namespaces: 
+ 973                      for v, k in sorted(namespaces.items(), 
+ 974                                         key=lambda x: x[1]):  # sort on prefix 
+ 975                          if k: 
+ 976                              k = ":" + k 
+ 977                          write(" xmlns%s=\"%s\"" % ( 
+ 978                              k.encode(encoding), 
+ 979                              _escape_attrib(v, encoding) 
+ 980                              )) 
+ 981                  for k, v in sorted(items):  # lexical order 
+ 982                      if isinstance(k, QName): 
+ 983                          k = k.text 
+ 984                      if isinstance(v, QName): 
+ 985                          v = qnames[v.text] 
+ 986                      else: 
+ 987                          v = _escape_attrib_html(v, encoding) 
+ 988                      # FIXME: handle boolean attributes 
+ 989                      write(" %s=\"%s\"" % (qnames[k], v)) 
+ 990              write(">") 
+ 991              ltag = tag.lower() 
+ 992              if text: 
+ 993                  if ltag == "script" or ltag == "style": 
+ 994                      write(_encode(text, encoding)) 
+ 995                  else: 
+ 996                      write(_escape_cdata(text, encoding)) 
+ 997              for e in elem: 
+ 998                  _serialize_html(write, e, encoding, qnames, None) 
+ 999              if ltag not in HTML_EMPTY: 
+1000                  write("</" + tag + ">") 
+1001      if elem.tail: 
+1002          write(_escape_cdata(elem.tail, encoding)) 
+
1003   
+1004 -def _serialize_text(write, elem, encoding): 
+
1005      for part in elem.itertext(): 
+1006          write(part.encode(encoding)) 
+1007      if elem.tail: 
+1008          write(elem.tail.encode(encoding)) 
+
1009   
+1010  _serialize = { 
+1011      "xml": _serialize_xml, 
+1012      "html": _serialize_html, 
+1013      "text": _serialize_text, 
+1014  # this optional method is imported at the end of the module 
+1015  #   "c14n": _serialize_c14n, 
+1016  } 
+1017   
+1018  ## 
+1019  # Registers a namespace prefix.  The registry is global, and any 
+1020  # existing mapping for either the given prefix or the namespace URI 
+1021  # will be removed. 
+1022  # 
+1023  # @param prefix Namespace prefix. 
+1024  # @param uri Namespace uri.  Tags and attributes in this namespace 
+1025  #     will be serialized with the given prefix, if at all possible. 
+1026  # @exception ValueError If the prefix is reserved, or is otherwise 
+1027  #     invalid. 
+1028   
+1029 -def register_namespace(prefix, uri): 
+
1030      if re.match("ns\d+$", prefix): 
+1031          raise ValueError("Prefix format reserved for internal use") 
+1032      for k, v in _namespace_map.items(): 
+1033          if k == uri or v == prefix: 
+1034              del _namespace_map[k] 
+1035      _namespace_map[uri] = prefix 
+
1036   
+1037  _namespace_map = { 
+1038      # "well-known" namespace prefixes 
+1039      "http://www.w3.org/XML/1998/namespace": "xml", 
+1040      "http://www.w3.org/1999/xhtml": "html", 
+1041      "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf", 
+1042      "http://schemas.xmlsoap.org/wsdl/": "wsdl", 
+1043      # xml schema 
+1044      "http://www.w3.org/2001/XMLSchema": "xs", 
+1045      "http://www.w3.org/2001/XMLSchema-instance": "xsi", 
+1046      # dublin core 
+1047      "http://purl.org/dc/elements/1.1/": "dc", 
+1048  } 
+1049   
+1050 -def _raise_serialization_error(text): 
+
1051      raise TypeError( 
+1052          "cannot serialize %r (type %s)" % (text, type(text).__name__) 
+1053          ) 
+
1054   
+1055 -def _encode(text, encoding): 
+
1056      try: 
+1057          return text.encode(encoding, "xmlcharrefreplace") 
+1058      except (TypeError, AttributeError): 
+1059          _raise_serialization_error(text) 
+
1060   
+1061 -def _escape_cdata(text, encoding): 
+
1062      # escape character data 
+1063      try: 
+1064          # it's worth avoiding do-nothing calls for strings that are 
+1065          # shorter than 500 character, or so.  assume that's, by far, 
+1066          # the most common case in most applications. 
+1067          if "&" in text: 
+1068              text = text.replace("&", "&amp;") 
+1069          if "<" in text: 
+1070              text = text.replace("<", "&lt;") 
+1071          if ">" in text: 
+1072              text = text.replace(">", "&gt;") 
+1073          return text.encode(encoding, "xmlcharrefreplace") 
+1074      except (TypeError, AttributeError): 
+1075          _raise_serialization_error(text) 
+
1076   
+1077 -def _escape_attrib(text, encoding): 
+
1078      # escape attribute value 
+1079      try: 
+1080          if "&" in text: 
+1081              text = text.replace("&", "&amp;") 
+1082          if "<" in text: 
+1083              text = text.replace("<", "&lt;") 
+1084          if ">" in text: 
+1085              text = text.replace(">", "&gt;") 
+1086          if "\"" in text: 
+1087              text = text.replace("\"", "&quot;") 
+1088          if "\n" in text: 
+1089              text = text.replace("\n", "&#10;") 
+1090          return text.encode(encoding, "xmlcharrefreplace") 
+1091      except (TypeError, AttributeError): 
+1092          _raise_serialization_error(text) 
+
1093   
+1094 -def _escape_attrib_html(text, encoding): 
+
1095      # escape attribute value 
+1096      try: 
+1097          if "&" in text: 
+1098              text = text.replace("&", "&amp;") 
+1099          if ">" in text: 
+1100              text = text.replace(">", "&gt;") 
+1101          if "\"" in text: 
+1102              text = text.replace("\"", "&quot;") 
+1103          return text.encode(encoding, "xmlcharrefreplace") 
+1104      except (TypeError, AttributeError): 
+1105          _raise_serialization_error(text) 
+
1106   
+1107  # -------------------------------------------------------------------- 
+1108   
+1109  ## 
+1110  # Generates a string representation of an XML element, including all 
+1111  # subelements. 
+1112  # 
+1113  # @param element An Element instance. 
+1114  # @keyparam encoding Optional output encoding (default is US-ASCII). 
+1115  # @keyparam method Optional output method ("xml", "html", "text" or 
+1116  #     "c14n"; default is "xml"). 
+1117  # @return An encoded string containing the XML data. 
+1118  # @defreturn string 
+1119   
+1120 -def tostring(element, encoding=None, method=None): 
+
1121      class dummy: 
+1122          pass 
+
1123      data = [] 
+1124      file = dummy() 
+1125      file.write = data.append 
+1126      ElementTree(element).write(file, encoding, method=method) 
+1127      return "".join(data) 
+1128   
+1129  ## 
+1130  # Generates a string representation of an XML element, including all 
+1131  # subelements.  The string is returned as a sequence of string fragments. 
+1132  # 
+1133  # @param element An Element instance. 
+1134  # @keyparam encoding Optional output encoding (default is US-ASCII). 
+1135  # @keyparam method Optional output method ("xml", "html", "text" or 
+1136  #     "c14n"; default is "xml"). 
+1137  # @return A sequence object containing the XML data. 
+1138  # @defreturn sequence 
+1139  # @since 1.3 
+1140   
+1141 -def tostringlist(element, encoding=None, method=None): 
+
1142      class dummy: 
+1143          pass 
+
1144      data = [] 
+1145      file = dummy() 
+1146      file.write = data.append 
+1147      ElementTree(element).write(file, encoding, method=method) 
+1148      # FIXME: merge small fragments into larger parts 
+1149      return data 
+1150   
+1151  ## 
+1152  # Writes an element tree or element structure to sys.stdout.  This 
+1153  # function should be used for debugging only. 
+1154  # <p> 
+1155  # The exact output format is implementation dependent.  In this 
+1156  # version, it's written as an ordinary XML file. 
+1157  # 
+1158  # @param elem An element tree or an individual element. 
+1159   
+1160 -def dump(elem): 
+
1161      # debugging 
+1162      if not isinstance(elem, ElementTree): 
+1163          elem = ElementTree(elem) 
+1164      elem.write(sys.stdout) 
+1165      tail = elem.getroot().tail 
+1166      if not tail or tail[-1] != "\n": 
+1167          sys.stdout.write("\n") 
+
1168   
+1169  # -------------------------------------------------------------------- 
+1170  # parsing 
+1171   
+1172  ## 
+1173  # Parses an XML document into an element tree. 
+1174  # 
+1175  # @param source A filename or file object containing XML data. 
+1176  # @param parser An optional parser instance.  If not given, the 
+1177  #     standard {@link XMLParser} parser is used. 
+1178  # @return An ElementTree instance 
+1179   
+1180 -def parse(source, parser=None): 
+
1181      tree = ElementTree() 
+1182      tree.parse(source, parser) 
+1183      return tree 
+
1184   
+1185  ## 
+1186  # Parses an XML document into an element tree incrementally, and reports 
+1187  # what's going on to the user. 
+1188  # 
+1189  # @param source A filename or file object containing XML data. 
+1190  # @param events A list of events to report back.  If omitted, only "end" 
+1191  #     events are reported. 
+1192  # @param parser An optional parser instance.  If not given, the 
+1193  #     standard {@link XMLParser} parser is used. 
+1194  # @return A (event, elem) iterator. 
+1195   
+1196 -def iterparse(source, events=None, parser=None): 
+
1197      close_source = False 
+1198      if not hasattr(source, "read"): 
+1199          source = open(source, "rb") 
+1200          close_source = True 
+1201      try: 
+1202          if not parser: 
+1203              parser = XMLParser(target=TreeBuilder()) 
+1204          return _IterParseIterator(source, events, parser, close_source) 
+1205      except: 
+1206          if close_source: 
+1207              source.close() 
+1208          raise 
+
1209   
+1210 -class _IterParseIterator(object): 
+
1211   
+1212 -    def __init__(self, source, events, parser, close_source=False): 
+
1213          self._file = source 
+1214          self._close_file = close_source 
+1215          self._events = [] 
+1216          self._index = 0 
+1217          self._error = None 
+1218          self.root = self._root = None 
+1219          self._parser = parser 
+1220          # wire up the parser for event reporting 
+1221          parser = self._parser._parser 
+1222          append = self._events.append 
+1223          if events is None: 
+1224              events = ["end"] 
+1225          for event in events: 
+1226              if event == "start": 
+1227                  try: 
+1228                      parser.ordered_attributes = 1 
+1229                      parser.specified_attributes = 1 
+1230                      def handler(tag, attrib_in, event=event, append=append, 
+1231                                  start=self._parser._start_list): 
+1232                          append((event, start(tag, attrib_in))) 
+
1233                      parser.StartElementHandler = handler 
+1234                  except AttributeError: 
+1235                      def handler(tag, attrib_in, event=event, append=append, 
+1236                                  start=self._parser._start): 
+1237                          append((event, start(tag, attrib_in))) 
+
1238                      parser.StartElementHandler = handler 
+1239              elif event == "end": 
+1240                  def handler(tag, event=event, append=append, 
+1241                              end=self._parser._end): 
+1242                      append((event, end(tag))) 
+1243                  parser.EndElementHandler = handler 
+1244              elif event == "start-ns": 
+1245                  def handler(prefix, uri, event=event, append=append): 
+1246                      try: 
+1247                          uri = (uri or "").encode("ascii") 
+1248                      except UnicodeError: 
+1249                          pass 
+1250                      append((event, (prefix or "", uri or ""))) 
+1251                  parser.StartNamespaceDeclHandler = handler 
+1252              elif event == "end-ns": 
+1253                  def handler(prefix, event=event, append=append): 
+1254                      append((event, None)) 
+1255                  parser.EndNamespaceDeclHandler = handler 
+1256              else: 
+1257                  raise ValueError("unknown event %r" % event) 
+1258   
+1259 -    def next(self): 
+
1260          try: 
+1261              while 1: 
+1262                  try: 
+1263                      item = self._events[self._index] 
+1264                      self._index += 1 
+1265                      return item 
+1266                  except IndexError: 
+1267                      pass 
+1268                  if self._error: 
+1269                      e = self._error 
+1270                      self._error = None 
+1271                      raise e 
+1272                  if self._parser is None: 
+1273                      self.root = self._root 
+1274                      break 
+1275                  # load event buffer 
+1276                  del self._events[:] 
+1277                  self._index = 0 
+1278                  data = self._file.read(16384) 
+1279                  if data: 
+1280                      try: 
+1281                          self._parser.feed(data) 
+1282                      except SyntaxError as exc: 
+1283                          self._error = exc 
+1284                  else: 
+1285                      self._root = self._parser.close() 
+1286                      self._parser = None 
+1287          except: 
+1288              if self._close_file: 
+1289                  self._file.close() 
+1290              raise 
+1291          if self._close_file: 
+1292              self._file.close() 
+1293          raise StopIteration 
+
1294   
+1295 -    def __iter__(self): 
+
1296          return self 
+
1297   
+1298  ## 
+1299  # Parses an XML document from a string constant.  This function can 
+1300  # be used to embed "XML literals" in Python code. 
+1301  # 
+1302  # @param source A string containing XML data. 
+1303  # @param parser An optional parser instance.  If not given, the 
+1304  #     standard {@link XMLParser} parser is used. 
+1305  # @return An Element instance. 
+1306  # @defreturn Element 
+1307   
+1308 -def XML(text, parser=None): 
+
1309      if not parser: 
+1310          parser = XMLParser(target=TreeBuilder()) 
+1311      parser.feed(text) 
+1312      return parser.close() 
+
1313   
+1314  ## 
+1315  # Parses an XML document from a string constant, and also returns 
+1316  # a dictionary which maps from element id:s to elements. 
+1317  # 
+1318  # @param source A string containing XML data. 
+1319  # @param parser An optional parser instance.  If not given, the 
+1320  #     standard {@link XMLParser} parser is used. 
+1321  # @return A tuple containing an Element instance and a dictionary. 
+1322  # @defreturn (Element, dictionary) 
+1323   
+1324 -def XMLID(text, parser=None): 
+
1325      if not parser: 
+1326          parser = XMLParser(target=TreeBuilder()) 
+1327      parser.feed(text) 
+1328      tree = parser.close() 
+1329      ids = {} 
+1330      for elem in tree.iter(): 
+1331          id = elem.get("id") 
+1332          if id: 
+1333              ids[id] = elem 
+1334      return tree, ids 
+
1335   
+1336  ## 
+1337  # Parses an XML document from a string constant.  Same as {@link #XML}. 
+1338  # 
+1339  # @def fromstring(text) 
+1340  # @param source A string containing XML data. 
+1341  # @return An Element instance. 
+1342  # @defreturn Element 
+1343   
+1344  fromstring = XML 
+1345   
+1346  ## 
+1347  # Parses an XML document from a sequence of string fragments. 
+1348  # 
+1349  # @param sequence A list or other sequence containing XML data fragments. 
+1350  # @param parser An optional parser instance.  If not given, the 
+1351  #     standard {@link XMLParser} parser is used. 
+1352  # @return An Element instance. 
+1353  # @defreturn Element 
+1354  # @since 1.3 
+1355   
+1356 -def fromstringlist(sequence, parser=None): 
+
1357      if not parser: 
+1358          parser = XMLParser(target=TreeBuilder()) 
+1359      for text in sequence: 
+1360          parser.feed(text) 
+1361      return parser.close() 
+
1362   
+1363  # -------------------------------------------------------------------- 
+1364   
+1365  ## 
+1366  # Generic element structure builder.  This builder converts a sequence 
+1367  # of {@link #TreeBuilder.start}, {@link #TreeBuilder.data}, and {@link 
+1368  # #TreeBuilder.end} method calls to a well-formed element structure. 
+1369  # <p> 
+1370  # You can use this class to build an element structure using a custom XML 
+1371  # parser, or a parser for some other XML-like format. 
+1372  # 
+1373  # @param element_factory Optional element factory.  This factory 
+1374  #    is called to create new Element instances, as necessary. 
+1375   
+1376 -class TreeBuilder(object): 
+
1377   
+1378 -    def __init__(self, element_factory=None): 
+
1379          self._data = [] # data collector 
+1380          self._elem = [] # element stack 
+1381          self._last = None # last element 
+1382          self._tail = None # true if we're after an end tag 
+1383          if element_factory is None: 
+1384              element_factory = Element 
+1385          self._factory = element_factory 
+
1386   
+1387      ## 
+1388      # Flushes the builder buffers, and returns the toplevel document 
+1389      # element. 
+1390      # 
+1391      # @return An Element instance. 
+1392      # @defreturn Element 
+1393   
+1394 -    def close(self): 
+
1395          assert len(self._elem) == 0, "missing end tags" 
+1396          assert self._last is not None, "missing toplevel element" 
+1397          return self._last 
+
1398   
+1399 -    def _flush(self): 
+
1400          if self._data: 
+1401              if self._last is not None: 
+1402                  text = "".join(self._data) 
+1403                  if self._tail: 
+1404                      assert self._last.tail is None, "internal error (tail)" 
+1405                      self._last.tail = text 
+1406                  else: 
+1407                      assert self._last.text is None, "internal error (text)" 
+1408                      self._last.text = text 
+1409              self._data = [] 
+
1410   
+1411      ## 
+1412      # Adds text to the current element. 
+1413      # 
+1414      # @param data A string.  This should be either an 8-bit string 
+1415      #    containing ASCII text, or a Unicode string. 
+1416   
+1417 -    def data(self, data): 
+
1418          self._data.append(data) 
+
1419   
+1420      ## 
+1421      # Opens a new element. 
+1422      # 
+1423      # @param tag The element name. 
+1424      # @param attrib A dictionary containing element attributes. 
+1425      # @return The opened element. 
+1426      # @defreturn Element 
+1427   
+1428 -    def start(self, tag, attrs): 
+
1429          self._flush() 
+1430          self._last = elem = self._factory(tag, attrs) 
+1431          if self._elem: 
+1432              self._elem[-1].append(elem) 
+1433          self._elem.append(elem) 
+1434          self._tail = 0 
+1435          return elem 
+
1436   
+1437      ## 
+1438      # Closes the current element. 
+1439      # 
+1440      # @param tag The element name. 
+1441      # @return The closed element. 
+1442      # @defreturn Element 
+1443   
+1444 -    def end(self, tag): 
+
1445          self._flush() 
+1446          self._last = self._elem.pop() 
+1447          assert self._last.tag == tag,\ 
+1448                 "end tag mismatch (expected %s, got %s)" % ( 
+1449                     self._last.tag, tag) 
+1450          self._tail = 1 
+1451          return self._last 
+
1452   
+1453  _sentinel = ['sentinel'] 
+1454   
+1455  ## 
+1456  # Element structure builder for XML source data, based on the 
+1457  # <b>expat</b> parser. 
+1458  # 
+1459  # @keyparam target Target object.  If omitted, the builder uses an 
+1460  #     instance of the standard {@link #TreeBuilder} class. 
+1461  # @keyparam html Predefine HTML entities.  This flag is not supported 
+1462  #     by the current implementation. 
+1463  # @keyparam encoding Optional encoding.  If given, the value overrides 
+1464  #     the encoding specified in the XML file. 
+1465  # @see #ElementTree 
+1466  # @see #TreeBuilder 
+1467   
+1468 -class XMLParser(object): 
+
1469   
+1470 -    def __init__(self, html=_sentinel, target=None, encoding=None): 
+
1471          if html is not _sentinel: 
+1472              warnings.warnpy3k( 
+1473                  "The html argument of XMLParser() is deprecated", 
+1474                  DeprecationWarning, stacklevel=2) 
+1475          try: 
+1476              from xml.parsers import expat 
+1477          except ImportError: 
+1478              try: 
+1479                  import pyexpat as expat 
+1480              except ImportError: 
+1481                  raise ImportError( 
+1482                      "No module named expat; use SimpleXMLTreeBuilder instead" 
+1483                      ) 
+1484          parser = expat.ParserCreate(encoding, "}") 
+1485          if target is None: 
+1486              target = TreeBuilder() 
+1487          # underscored names are provided for compatibility only 
+1488          self.parser = self._parser = parser 
+1489          self.target = self._target = target 
+1490          self._error = expat.error 
+1491          self._names = {} # name memo cache 
+1492          # callbacks 
+1493          parser.DefaultHandlerExpand = self._default 
+1494          parser.StartElementHandler = self._start 
+1495          parser.EndElementHandler = self._end 
+1496          parser.CharacterDataHandler = self._data 
+1497          # optional callbacks 
+1498          parser.CommentHandler = self._comment 
+1499          parser.ProcessingInstructionHandler = self._pi 
+1500          # let expat do the buffering, if supported 
+1501          try: 
+1502              self._parser.buffer_text = 1 
+1503          except AttributeError: 
+1504              pass 
+1505          # use new-style attribute handling, if supported 
+1506          try: 
+1507              self._parser.ordered_attributes = 1 
+1508              self._parser.specified_attributes = 1 
+1509              parser.StartElementHandler = self._start_list 
+1510          except AttributeError: 
+1511              pass 
+1512          self._doctype = None 
+1513          self.entity = {} 
+1514          try: 
+1515              self.version = "Expat %d.%d.%d" % expat.version_info 
+1516          except AttributeError: 
+1517              pass # unknown 
+
1518   
+1519 -    def _raiseerror(self, value): 
+
1520          err = ParseError(value) 
+1521          err.code = value.code 
+1522          err.position = value.lineno, value.offset 
+1523          raise err 
+
1524   
+1525 -    def _fixtext(self, text): 
+
1526          # convert text string to ascii, if possible 
+1527          try: 
+1528              return text.encode("ascii") 
+1529          except UnicodeError: 
+1530              return text 
+
1531   
+1532 -    def _fixname(self, key): 
+
1533          # expand qname, and convert name string to ascii, if possible 
+1534          try: 
+1535              name = self._names[key] 
+1536          except KeyError: 
+1537              name = key 
+1538              if "}" in name: 
+1539                  name = "{" + name 
+1540              self._names[key] = name = self._fixtext(name) 
+1541          return name 
+
1542   
+1543 -    def _start(self, tag, attrib_in): 
+
1544          fixname = self._fixname 
+1545          fixtext = self._fixtext 
+1546          tag = fixname(tag) 
+1547          attrib = {} 
+1548          for key, value in attrib_in.items(): 
+1549              attrib[fixname(key)] = fixtext(value) 
+1550          return self.target.start(tag, attrib) 
+
1551   
+1552 -    def _start_list(self, tag, attrib_in): 
+
1553          fixname = self._fixname 
+1554          fixtext = self._fixtext 
+1555          tag = fixname(tag) 
+1556          attrib = {} 
+1557          if attrib_in: 
+1558              for i in range(0, len(attrib_in), 2): 
+1559                  attrib[fixname(attrib_in[i])] = fixtext(attrib_in[i+1]) 
+1560          return self.target.start(tag, attrib) 
+
1561   
+1562 -    def _data(self, text): 
+
1563          return self.target.data(self._fixtext(text)) 
+
1564   
+1565 -    def _end(self, tag): 
+
1566          return self.target.end(self._fixname(tag)) 
+
1567   
+1568 -    def _comment(self, data): 
+
1569          try: 
+1570              comment = self.target.comment 
+1571          except AttributeError: 
+1572              pass 
+1573          else: 
+1574              return comment(self._fixtext(data)) 
+
1575   
+1576 -    def _pi(self, target, data): 
+
1577          try: 
+1578              pi = self.target.pi 
+1579          except AttributeError: 
+1580              pass 
+1581          else: 
+1582              return pi(self._fixtext(target), self._fixtext(data)) 
+
1583   
+1584 -    def _default(self, text): 
+
1585          prefix = text[:1] 
+1586          if prefix == "&": 
+1587              # deal with undefined entities 
+1588              try: 
+1589                  self.target.data(self.entity[text[1:-1]]) 
+1590              except KeyError: 
+1591                  from xml.parsers import expat 
+1592                  err = expat.error( 
+1593                      "undefined entity %s: line %d, column %d" % 
+1594                      (text, self._parser.ErrorLineNumber, 
+1595                      self._parser.ErrorColumnNumber) 
+1596                      ) 
+1597                  err.code = 11 # XML_ERROR_UNDEFINED_ENTITY 
+1598                  err.lineno = self._parser.ErrorLineNumber 
+1599                  err.offset = self._parser.ErrorColumnNumber 
+1600                  raise err 
+1601          elif prefix == "<" and text[:9] == "<!DOCTYPE": 
+1602              self._doctype = [] # inside a doctype declaration 
+1603          elif self._doctype is not None: 
+1604              # parse doctype contents 
+1605              if prefix == ">": 
+1606                  self._doctype = None 
+1607                  return 
+1608              text = text.strip() 
+1609              if not text: 
+1610                  return 
+1611              self._doctype.append(text) 
+1612              n = len(self._doctype) 
+1613              if n > 2: 
+1614                  type = self._doctype[1] 
+1615                  if type == "PUBLIC" and n == 4: 
+1616                      name, type, pubid, system = self._doctype 
+1617                  elif type == "SYSTEM" and n == 3: 
+1618                      name, type, system = self._doctype 
+1619                      pubid = None 
+1620                  else: 
+1621                      return 
+1622                  if pubid: 
+1623                      pubid = pubid[1:-1] 
+1624                  if hasattr(self.target, "doctype"): 
+1625                      self.target.doctype(name, pubid, system[1:-1]) 
+1626                  elif self.doctype != self._XMLParser__doctype: 
+1627                      # warn about deprecated call 
+1628                      self._XMLParser__doctype(name, pubid, system[1:-1]) 
+1629                      self.doctype(name, pubid, system[1:-1]) 
+1630                  self._doctype = None 
+
1631   
+1632      ## 
+1633      # (Deprecated) Handles a doctype declaration. 
+1634      # 
+1635      # @param name Doctype name. 
+1636      # @param pubid Public identifier. 
+1637      # @param system System identifier. 
+1638   
+1639 -    def doctype(self, name, pubid, system): 
+
1640          """This method of XMLParser is deprecated.""" 
+1641          warnings.warn( 
+1642              "This method of XMLParser is deprecated.  Define doctype() " 
+1643              "method on the TreeBuilder target.", 
+1644              DeprecationWarning, 
+1645              ) 
+
1646   
+1647      # sentinel, if doctype is redefined in a subclass 
+1648      __doctype = doctype 
+1649   
+1650      ## 
+1651      # Feeds data to the parser. 
+1652      # 
+1653      # @param data Encoded data. 
+1654   
+1655 -    def feed(self, data): 
+
1656          try: 
+1657              self._parser.Parse(data, 0) 
+1658          except self._error, v: 
+1659              self._raiseerror(v) 
+
1660   
+1661      ## 
+1662      # Finishes feeding data to the parser. 
+1663      # 
+1664      # @return An element structure. 
+1665      # @defreturn Element 
+1666   
+1667 -    def close(self): 
+
1668          try: 
+1669              self._parser.Parse("", 1) # end of data 
+1670          except self._error, v: 
+1671              self._raiseerror(v) 
+1672          tree = self.target.close() 
+1673          del self.target, self._parser # get rid of circular references 
+1674          return tree 
+
1675   
+1676  # compatibility 
+1677  XMLTreeBuilder = XMLParser 
+1678   
+1679  # workaround circular import. 
+1680  try: 
+1681      from ElementC14N import _serialize_c14n 
+1682      _serialize["c14n"] = _serialize_c14n 
+1683  except ImportError: 
+1684      pass 
+1685   
+
+object --+
+         |
+        Element
+
+object --+
+         |
+        ElementTree
+
+              object --+                
+                       |                
+exceptions.BaseException --+            
+                           |            
+        exceptions.Exception --+        
+                               |        
+        exceptions.StandardError --+    
+                                   |    
+              exceptions.SyntaxError --+
+                                       |
+                                      ParseError
+
+object --+
+         |
+        QName
+
+object --+
+         |
+        TreeBuilder
+
+object --+
+         |
+        XMLParser
+
+object --+
+         |
+        _IterParseIterator
+
+object --+
+         |
+        _SimpleElementPath
+
-dev
-devel
libxml2-dev
+pip install -r requirements.txt
+
+hg clone git+ssh://git@github.com/lxml/lxml.git lxml
+
+git clone ssh://git@github.com/lxml/lxml.git lxml
+
lxml
+python setup.py build
+
+python setup.py bdist_egg     # requires 'setuptools' or 'distribute'
+
--with-cython
+python setup.py build --with-cython
+
+python setup.py build_ext -i --with-cython
+
+make inplace
+
CFLAGS
+CFLAGS="-O0"  make inplace
+
Python.h
libxml/xmlversion.h
libxml2-dev
libxslt-devel
+python setup.py build --with-xslt-config=/path/to/xslt-config
+
+env XML2_CONFIG=/path/to/xml2-config python build
+
pkg-config
+env XSLT_CONFIG="pkg-config libxslt" python setup.py build
+
+python setup.py build_ext -i  -I /usr/include/libxml2
+
/usr/include/libxml2/libxml/xmlversion.h
src
lxml.etree
+# cd lxml
+# PYTHONPATH=src python
+Python 2.7.2
+Type "help", "copyright", "credits" or "license" for more information.
+>>> from lxml import etree
+>>>
+
make clean
src/lxml/etree.c
+python test.py
+
src
+make test
+
+python selftest.py
+
+python selftest2.py
+
setuptools
distribute
wheel
cd
+python setup.py bdist_wheel
+
dist
+python setup.py build_egg
+
+python setup.py build
+
cd
build/lib.your.platform
strip
.so
+python setup.py bdist_egg
+
dist
setup.py
+python setup.py build --static-deps
+
tar.gz
libs
setup.py
+python setup.py build --static-deps \
+       --libxml2-version=2.9.1 \
+       --libxslt-version=1.1.28 \
+
+sudo python setup.py install
+
build
bdist_egg
bdist_wheel
+STATIC_DEPS=true pip install lxml
+
+STATIC_DEPS=true sudo pip install lxml
+
STATICBUILD
STATIC_DEPS
+python setup.py bdist_wininst --static-deps
+
pkg
apt-get source lxml
dpkg-source -x lxml-[VERSION].dsc
dch -i
dpkg-buildpackage -rfakeroot -us -uc
dpkg-buildpackage
apt-get build-dep lxml
dpkg -i
lxml.etree.adopt_external_document()
adoptExternalDocument()
+# My Cython extension
+
+# import the public functions and classes of lxml.etree
+cimport etreepublic as cetree
+
+# import the lxml.etree module in Python
+cdef object etree
+from lxml import etree
+
+# initialize the access to the C-API of lxml.etree
+cetree.import_lxml__etree()
+
cetree
+# build a tag name from namespace and element name
+py_tag = cetree.namespacedNameFromNsName("http://some/url", "myelement")
+
+from etreepublic cimport ElementBase
+cdef class NewElementClass(ElementBase):
+     def set_value(self, myval):
+         self.set("my_attribute", myval)
+
+etree.set_element_class_lookup(
+     etree.DefaultElementClassLookup(element=NewElementClass))
+
lxml.etree
/* My C extension */
+
+/* common includes */
+#include "Python.h"
+#include "stdio.h"
+#include "string.h"
+#include "stdarg.h"
+#include "libxml/xmlversion.h"
+#include "libxml/encoding.h"
+#include "libxml/hash.h"
+#include "libxml/tree.h"
+#include "libxml/xmlIO.h"
+#include "libxml/xmlsave.h"
+#include "libxml/globals.h"
+#include "libxml/xmlstring.h"
+
+/* lxml.etree specific includes */
+#include "lxml-version.h"
+#include "etree_defs.h"
+#include "etree.h"
+
+/* setup code */
+import_lxml__etree()
+
etree.h
itertext()
ElementInclude
Element.clear()
keep_tail=True
iterparse()
lxml.objectify
__index__()
nsmap
max_depth
target
start_ns()
end_ns()
TreeBuilder
comment_factory
pi_factory
insert_comments
insert_pis
etree.canonicalize()
C14NWriterTarget
c14n2
comment
pi
iterwalk()
start
rnc2rng
source
track
lxml.html.defs
IOError
Element.find*()
None
ElementTree.write_c14n()
ElementTree.write(f, method="c14n")
_XSLTResultTree.write_output()
lxml.sax
lxml.sax.ElementTreeProducer
pkg-config
Element.insert()
iterwalk()
SelectElement.value
SelectElement.value
None
HTMLParser()
huge_tree
PythonElementClassLookup
.find*()
lxml.builder
lxml.html.diff
lxml.html.clean
xmlfile()
async with
await
iterwalk()
skip_subtree()
RelaxNG.from_rnc_string()
base_url
.write_output(file)
<xsl:output>
useChardet
guess_charset=True
etree.fromstring()
xmlfile()
xmlfile.write()
lxml.*.pyx
*.pyx
etree.pyx
ElementTree.write()
doctype
tostring()
xmlfile
path
xmlfile
fromstring()
docstring
ElementTree.write()
fromstring()
lxml.html.submit_form()
xmlfile
xmlfile.element()
xmlfile.element()
XMLSyntaxError
SyntaxError
HTMLParser()
collect_ids
XMLParser()
xmlfile.write()
default_doctype
HTMLParser
.set('attrname')
None
<div attrname></div>
form_values()
disabled
zlib
inline_style
style
file
FormElement.form_values
Resolver.resolve_string()
objectify.FloatElement
.rnc
rnc2rng
TypeError
cleanup_namespaces()
keep_ns_prefixes
cleanup_namespaces()
top_nsmap
Element
cssselect()
lxml.html
staticmethod()
error_finder
lxml.html
classes
class
docinfo
lxml.html.soupparser
process_children()
output_parent
TypeError
data
lxml.html.clean
+
-
xmlfile.element()
TypeError
iterlinks()
CDATA()
htmlfile
xmlfile
lxml.sax.ElementTreeContentHandler
xmlfile(buffered=False)
xf.flush()
lxml.html.document_fromstring
ensure_head_body=True
lxml.html.iterlinks
XMLParser
collect_ids=False
ElementTree.getelementpath(element)
xmlfile()
close=True
xmlfile()
lxml.html.fragment_fromstring()
__slots__
_LogEntry
_Attrib
resolvers
version
set_element_class_lookup()
makeelement()
iterparse
XMLSchema
Schematron
RelaxNG
error_log
tostring(method="html")
.attrib
parser.feed()
PyUnicode_Compare()
PyByteArray_*()
appendChild()
void
appendChildToElement()
fromstringlist()
attrib
attrib
attrib
iterparse()
recover
iterparse()
PythonElementClassLookup
ReferenceError
AssertionError
handle_failures
make_links_absolute()
resolve_base_href()
XMLPullParser
HTMLPullParser
iterparse()
html=True
ElementMaker
repr(XSLTAccessControl)
ValueError
iterparse()
iterparse()
*PullParser
repr(XSLTAccessControl)
ValueError
apply_templates()
process_children()
elements_only
remove_blank_text
lxml.html
lxml.html
UnicodeDecodeError
IOError
handler.startElement()
TypeError
xmlBufLength()
xmlBufUse()
lxml.html.FormElement.fields
lxml.etree._BaseParser
copy.copy(el.attrib)
el.find*()
--with-unicode-strings
etree.xmlfile()
_ObjectifyElementMakerCaller
.iter()
tag
"{*}name"
"{ns}name"
"{}name"
"{*}name"
"{ns}*"
"{}*"
"{*}*"
"name"
"{}name"
"*"
"{*}*"
.getiterator()
.itersiblings()
.iterancestors()
.iterdescendants()
.iterchildren()
.itertext()
strip_attributes()
strip_elements()
strip_tags()
iterparse()
feed()
xpathgrep.py
E-factory
lxml.builder
iterparse()
tag
.find*()
lxml.objectify
lxml.etree
ElementPath
el.find('*')
.find*()
xpathgrep.py
Element.attrib.update()
attrib
ElementBase
.text
.tail
etreepublic.pxd
lxml/includes/
attrib
lxml.etree
_InputDocument, _ResolverRegistry, _ResolverContext, _BaseContext,
+_ExsltRegExp, _IterparseContext, _TempStore, _ExceptionContext,
+__ContentOnlyElement, _AttribIterator, _NamespaceRegistry,
+_ClassNamespaceRegistry, _FunctionNamespaceRegistry,
+_XPathFunctionNamespaceRegistry, _ParserDictionaryContext,
+_FileReaderContext, _ParserContext, _PythonSaxParserTarget,
+_TargetParserContext, _ReadOnlyProxy, _ReadOnlyPIProxy,
+_ReadOnlyEntityProxy, _ReadOnlyElementProxy, _OpaqueNodeWrapper,
+_OpaqueDocumentWrapper, _ModifyContentOnlyProxy,
+_ModifyContentOnlyPIProxy, _ModifyContentOnlyEntityProxy,
+_AppendOnlyElementProxy, _SaxParserContext, _FilelikeWriter,
+_ParserSchemaValidationContext, _XPathContext,
+_XSLTResolverContext, _XSLTContext, _XSLTQuotedStringParam
_InputDocument, _ResolverRegistry, _ExsltRegExp, _ElementUnicodeResult,
+_IterparseContext, _TempStore, _AttribIterator, _ClassNamespaceRegistry,
+_XPathFunctionNamespaceRegistry, _ParserDictionaryContext,
+_FileReaderContext, _PythonSaxParserTarget, _TargetParserContext,
+_ReadOnlyPIProxy, _ReadOnlyEntityProxy, _OpaqueDocumentWrapper,
+_ModifyContentOnlyPIProxy, _ModifyContentOnlyEntityProxy,
+_AppendOnlyElementProxy, _FilelikeWriter, _ParserSchemaValidationContext,
+_XPathContext, _XSLTResolverContext, _XSLTContext, _XSLTQuotedStringParam,
+_XSLTResultTree, _XSLTProcessingInstruction
feed()
element.remove()
lxml.html.tostring()
with_tail
doctype
iterparse()
lxml.objectify.deannotate()
cleanup_namespaces
lxml.objectify
SubElement()
etree.SubElement
lxml.etree
kill_tags
lxml.html.clean
pi.get()
pi.attrib
lxml.get_include()
Resolver.resolve_file()
close_file
lxml.sax
endElementNS()
parse()
iterparse()
"div *:last-child"
<option>
<option>
--download-dir
lxml.objectify
.close()
iterparse()
marque
marquee
XMLID()
parser
base_url
iterparse()
lxml.html.open_in_browser()
repr()
namespaces
lxml.cssselect.CSSSelector()
lxml.etree.register_namespace(prefix, uri)
tostring()
ElementTree.write()
tostring()
el.find*()
PyErrorLog
doctype
output_parent
XSLTExtension.apply_templates()
XSLTExtension.process_children()
__call__
el.find*()
action
attrname
.target
CommentBase
XMLTreeBuilder
lxml.cssselect
x[attr="val"]
x [attr="val"]
iterlinks()
lxml.html
.value
textarea
.close()
.close()
Element.attrib
XHTMLParser
htmlparser.py
lxml.objectify
strip_tags()
strip_elements()
lxml.etree
resolve_entities
SubElement()
lxml.cssselect
lxml.cssselect
lxml.cssselect
lxml.cssselect
value
help(lxml.objectify)
ElementMaker
strip_attributes()
strip_elements()
strip_tags()
huge_tree
XMLSchema()
standalone
tree.docinfo.standalone
standalone=True/False
xsl:attribute
lxml.html.FormElement._name()
TAG
Element.findtext()
XSLT.strparam()
base
lxml.objectify
iter_links
lxml.html
url("link")
io
io
lxml.html.diff.htmldiff
Link:...
lxml.html.diff
lxml.html.parse
namespace
localname
lxml.html.clean.autolink
recover
.close()
recover
.close()
lxml.html.rewrite_links()
smart_strings
lxml.html.rewrite_links()
objectify.enableRecursiveStr()
objectify.enable_recursive_str()
ElementTree
ElementTree.parse()
tools/xpathgrep.py
ElementTree
etree.cleanup_namespaces(el)
lxml.html
iterparse()
html_to_xhtml()
xhtml_to_html()
ElementTree.parse()
el.find("tag[child]")
parser
XHTMLParser
xhtml_parser
strip_cdata
True
CDATA()
moveNodeToDocument()
makeelement()
.cssselect()
ElementTree.find*()
iterparse()
XSLTAccessControl
options
DENY_ALL
DENY_WRITE
XSLTAccessControl
Element.base
docinfo.URL
etree.clearErrorLog()
etree.clear_error_log()
etree.useGlobalPythonLog()
etree.use_global_python_log()
etree.ElementClassLookup.setFallback()
etree.ElementClassLookup.set_fallback()
etree.getDefaultParser()
etree.get_default_parser()
etree.setDefaultParser()
etree.set_default_parser()
etree.setElementClassLookup()
etree.set_element_class_lookup()
parser.setElementClassLookup()
parser.set_element_class_lookup()
xpath_evaluator.registerNamespace()
xpath_evaluator.register_namespace()
xpath_evaluator.registerNamespaces()
xpath_evaluator.register_namespaces()
objectify.setPytypeAttributeTag
objectify.set_pytype_attribute_tag
objectify.setDefaultParser()
objectify.set_default_parser()
fromstring()
lxml.html.soupparser
lxml.html.diff
<br>
iterparse()
lxml.html.ElementSoup
lxml.html.soupparser
xml2-config
xslt-config
--with-xml2-config=/path/to/xml2-config
xml2-config
--with-xslt-config
base_url
lxml.html
method
lxml.html.tostring()
method="xml"
lxml.html.fromstring()
base_url
lxml.pyclasslookup
help()
lxml.html.builder
lxml.htmlbuilder
form.fields.keys()
lxml.html.setmixin
lxml.html._setmixin
--with-xslt-config=/path/to/xslt-config
xslt-config
unicode
encoding
tostring()
tounicode()
XMLSchema()
RelaxNG()
makeparser()
lxml.objectify
getparent()
with_tail
schema
text()
getparent()
XSLT
Entity()
entity.text
&amp;
position
code
element.attrib
lxml.html.clean.Cleaner
host_whitelist
allow_embedded_url(el, url)
allow_element(el)
element[1:-1:2]
base_url
lxml.doctestcompare
NOPARSE_MARKUP
# doctest: +NOPARSE_MARKUP
feed_error_log
iterparse
error_log
fromstringlist()
tostringlist()
iterparse()
html
encoding
hasChild()
annotate()
xsiannotate()
pyannotate()
ET.write()
tostring()
tounicode()
method
iterfind()
findall()
itertext()
feed()
close()
objectify.E
makeSubElement()
context.context_node
context.eval_context
lxml.html.ElementSoup
lxml.doctestcompare
lxml.usedoctest
lxml.html.usedoctest
lxml.cssselect
lxml.html
ElementNamespaceClassLookup
stringify
objectify.PyType()
Entity
resolve_entities
column
line
XPathError
xsiannotate()
lxml.html.clean
--without-threading
parse()
lxml.html
iter_links
<object>
<embed>
lxml.html.defs.special_inline_tags
lxml.doctestcompare
<tag xmlns="...">
DataElement()
XMLSchema()
RelaxNG()
file
make clean
make
+realclean
element.itersiblings()
getiterator()
iter()
lxml.etree.Extension()
ns
lxml.html.tostring
encoding
<>&/"'
element.getiterator()
element.iter()
el.getiterator()
el.iter()
findOrBuildNodeNs()
findOrBuildNodeNsPrefix
gc.collect()
tearDown()
ElementMaker
lxml.builder
namespace
nsmap
docinfo
internalDTD
externalDTD
no_network
ETCompatXMLParser
etree.fromstring()
base_url
HTML()
XML()
Element()
Element.getiterator(tag)
Comment
ProcessingInstruction
Element
objectify.E
Element.attrib.pop()
lxml.pyclasslookup
remove_comments
parse()
objectify
XML()
Element.addnext(el)
Element.addprevious(el)
Element.attrib
clear()
pop()
deannotate()
makeelement
Element.values()
.keys()
.items()
collectAttributes()
DTD
RelaxNG
XMLSchema
lxml.htmlbuilder
ElementMaker
lxml.builder.E
objectify.ObjectifiedElement
update()
ElementInclude
Element.getiterator(tag)
Comment
ProcessingInstruction
xsi:type
iterparse()
element["text"]
profile_run
XSLT.error_log
attrib
nsmap
compact
namespace
iterwalk()
iterparse()
tag
regexp:match
iterparse()
Element.extend()
Element.replace()
initThread()
{namespace}*
logging
Element.getroottree()
last_error
pretty_print
XSLTAccessControl
etree.tounicode()
unicode()
include "xslt.pxi"
/*
initThreadLogging()
initThread()
attrib
tostring()
tostring()
document('')
# etree
+from lxml.etree import Element
+
+# ElementTree
+from elementtree.ElementTree import Element
+
+# ElementTree in the Python 2.5 standard library
+from xml.etree.ElementTree import Element
+
# instead of
+from elementtree import ElementTree
+# use
+from lxml import etree as ElementTree
+
a = Element('a')
+b = SubElement(a, 'b')
+c = Element('c')
+c.append(b)
+
<a><b /></a>
+
<c><b /></c>
+
<a></a>
+
<c><b/></c>
+
getparent()
getnext()
getprevious()
iterparse()
ExpatError
SyntaxError
ParseError
iterparse()
iterparse()
remove_comments
remove_pis
etree.ETCompatXMLParser
etree.XMLParser
TreeBuilder
lxml.etree
start()
nsmap
Element.getiterator()
Element
Comment
ProcessingInstruction
PI.text
.target
.text
pi.text
pi.target + " " + pi.text
QName("{myns}myname")
copy.deepcopy()
copy.copy()
copy.copy()
lxml.cssselect
lxml.cssselect
cssselect
+pip install cssselect
+
lxml.cssselect
CSSSelector
>>> from lxml.cssselect import CSSSelector
+>>> sel = CSSSelector('div.content')
+>>> sel  #doctest: +ELLIPSIS
+<CSSSelector ... for 'div.content'>
+>>> sel.css
+'div.content'
+
>>> sel.path
+"descendant-or-self::div[@class and contains(concat(' ', normalize-space(@class), ' '), ' content ')]"
+
>>> from lxml.etree import fromstring
+>>> h = fromstring('''<div id="outer">
+...   <div id="inner" class="content body">
+...       text
+...   </div></div>''')
+>>> [e.get('id') for e in sel(h)]
+['inner']
+
CSSSelector
cssselect
XPath
>>> from cssselect import GenericTranslator
+>>> from lxml.etree import XPath
+>>> sel = XPath(GenericTranslator().css_to_xpath('div.content'))
+
CSSSelector
translator
'xml'
'xhtml'
'html'
Element
cssselect
>>> h.cssselect('div.content') == sel(h)
+True
+
CSSSelector
XPath
translator
HtmlElement
'html'
namespace-prefix|element
namespace-prefix:element
CSSSelector
namespaces
lxml.etree.ElementBase
>>> from lxml import etree
+
+>>> class honk(etree.ElementBase):
+...    @property
+...    def honking(self):
+...       return self.get('honking') == 'true'
+
honk
honking
__init___
__new__
__init__
__init__
proxy_cache = list(root.iter())
+
proxy_cache = set(root.iter())
+
_init()
__init__()
_init()
_init()
_init()
honk
>>> parser_lookup = etree.ElementDefaultClassLookup(element=honk)
+>>> parser = etree.XMLParser()
+>>> parser.set_element_class_lookup(parser_lookup)
+
Element()
>>> el = etree.Element("root")
+>>> print(isinstance(el, honk))
+False
+
makeelement()
>>> el = parser.makeelement("root")
+>>> print(isinstance(el, honk))
+True
+
Element()
>>> module_level_parser = etree.XMLParser()
+>>> Element = module_level_parser.makeelement
+
XML()
HTML()
>>> element = etree.XML("<test/>")
+>>> print(isinstance(element, honk))
+False
+
+>>> element = etree.XML("<test/>", parser)
+>>> print(isinstance(element, honk))
+True
+
>>> element = etree.fromstring("<test/>", parser)
+>>> print(isinstance(element, honk))
+True
+>>> el = etree.SubElement(element, "subel")
+>>> print(isinstance(el, honk))
+True
+
>>> lookup = etree.ElementDefaultClassLookup()
+>>> parser = etree.XMLParser()
+>>> parser.set_element_class_lookup(lookup)
+
element
comment
pi
>>> el = parser.makeelement("myelement")
+>>> print(isinstance(el, honk))
+False
+
+>>> lookup = etree.ElementDefaultClassLookup(element=honk)
+>>> parser.set_element_class_lookup(lookup)
+
+>>> el = parser.makeelement("myelement")
+>>> print(isinstance(el, honk))
+True
+>>> el.honking
+False
+>>> el = parser.makeelement("myelement", honking='true')
+>>> etree.tostring(el)
+b'<myelement honking="true"/>'
+>>> el.honking
+True
+
+>>> root = etree.fromstring(
+...     '<root honking="true"><!--comment--></root>', parser)
+>>> root.honking
+True
+>>> print(root[0].text)
+comment
+
>>> lookup = etree.ElementNamespaceClassLookup()
+>>> parser = etree.XMLParser()
+>>> parser.set_element_class_lookup(lookup)
+
>>> fallback = etree.ElementDefaultClassLookup(element=honk)
+>>> lookup = etree.ElementNamespaceClassLookup(fallback)
+>>> parser.set_element_class_lookup(lookup)
+
+>>> root = etree.fromstring(
+...     '<root honking="true"><!--comment--></root>', parser)
+>>> root.honking
+True
+>>> print(root[0].text)
+comment
+
>>> id_class_mapping = {'1234' : honk} # maps attribute values to classes
+
+>>> lookup = etree.AttributeBasedElementClassLookup(
+...                                      'id', id_class_mapping)
+>>> parser = etree.XMLParser()
+>>> parser.set_element_class_lookup(lookup)
+
>>> xml = '<a id="123"><b id="1234"/><b id="1234" honking="true"/></a>'
+>>> a = etree.fromstring(xml, parser)
+
+>>> a.honking       # id does not match !
+Traceback (most recent call last):
+AttributeError: 'lxml.etree._Element' object has no attribute 'honking'
+
+>>> a[0].honking
+False
+>>> a[1].honking
+True
+
>>> fallback = etree.ElementNamespaceClassLookup()
+>>> lookup = etree.AttributeBasedElementClassLookup(
+...                       'id', id_class_mapping, fallback)
+>>> parser = etree.XMLParser()
+>>> parser.set_element_class_lookup(lookup)
+
>>> class MyLookup(etree.CustomElementClassLookup):
+...     def lookup(self, node_type, document, namespace, name):
+...         if node_type == 'element':
+...             return honk  # be a bit more selective here ...
+...         else:
+...             return None  # pass on to (default) fallback
+
+>>> parser = etree.XMLParser()
+>>> parser.set_element_class_lookup(MyLookup())
+
+>>> root = etree.fromstring(
+...     '<root honking="true"><!--comment--></root>', parser)
+>>> root.honking
+True
+>>> print(root[0].text)
+comment
+
.lookup()
lxml.etree.ElementBase
PythonElementClassLookup
>>> class MyLookup(etree.PythonElementClassLookup):
+...     def lookup(self, document, element):
+...         return MyElementClass # defined elsewhere
+
+>>> parser = etree.XMLParser()
+>>> parser.set_element_class_lookup(MyLookup())
+
lookup()
AssertionError
tag
text
tail
getchildren()
getparent()
lxml.pyclasslookup
>>> el = honk(honking='true')
+>>> el.tag
+'honk'
+>>> el.honking
+True
+
ElementNamespaceClassLookup
>>> class hale(etree.ElementBase): pass
+>>> class bopp(etree.ElementBase): pass
+
+>>> el = hale( "some ", honk(honking = 'true'), bopp, " text" )
+
+>>> print(etree.tostring(el, encoding='unicode'))
+<hale>some <honk honking="true"/><bopp/> text</hale>
+
get_namespace(uri)
>>> lookup = etree.ElementNamespaceClassLookup()
+>>> parser = etree.XMLParser()
+>>> parser.set_element_class_lookup(lookup)
+
+>>> namespace = lookup.get_namespace('http://hui.de/honk')
+
honk
>>> namespace['honk'] = honk
+
namespace.update(globals())
>>> xml = '<honk xmlns="http://hui.de/honk" honking="true"/>'
+>>> honk_element = etree.XML(xml, parser)
+>>> print(honk_element.honking)
+True
+
>>> honk_element = parser.makeelement('{http://hui.de/honk}honk',
+...                                   honking='true')
+>>> print(honk_element.honking)
+True
+
honk
>>> xml = ('<honk xmlns="http://hui.de/honk" honking="true">'
+...        '<bla/><!--comment-->'
+...        '</honk>')
+>>> honk_element = etree.XML(xml, parser)
+>>> print(honk_element.honking)
+True
+>>> print(honk_element[0].honking)
+Traceback (most recent call last):
+  ...
+AttributeError: 'lxml.etree._Element' object has no attribute 'honking'
+>>> print(honk_element[1].text)
+comment
+
None
>>> class HonkNSElement(etree.ElementBase):
+...    def honk(self):
+...       return "HONK"
+>>> namespace[None] = HonkNSElement  # default Element for namespace
+
+>>> class HonkElement(HonkNSElement):
+...    @property
+...    def honking(self):
+...       return self.get('honking') == 'true'
+>>> namespace['honk'] = HonkElement  # Element for specific tag
+
>>> xml = ('<honk xmlns="http://hui.de/honk" honking="true">'
+...        '<bla/><!--comment-->'
+...        '</honk>')
+>>> honk_element = etree.fromstring(xml, parser)
+
+>>> print(type(honk_element))
+<class 'HonkElement'>
+>>> print(type(honk_element[0]))
+<class 'HonkNSElement'>
+
+>>> print(honk_element.honking)
+True
+>>> print(honk_element.honk())
+HONK
+
+>>> print(honk_element[0].honk())
+HONK
+>>> print(honk_element[0].honking)
+Traceback (most recent call last):
+...
+AttributeError: 'HonkNSElement' object has no attribute 'honking'
+
+>>> print(honk_element[1].text)  # uses fallback for non-elements
+comment
+
None
>>> honk_elements = lookup.get_namespace('http://hui.de/honk')
+
+>>> @honk_elements(None)
+... class HonkNSElement(etree.ElementBase):
+...    def honk(self):
+...       return "HONK"
+
+>>> @honk_elements
+... class honkel(HonkNSElement):
+...    @property
+...    def honking(self):
+...       return self.get('honking') == 'true'
+
+>>> xml = '<honkel xmlns="http://hui.de/honk" honking="true"><bla/><!--comment--></honkel>'
+>>> honk_element = etree.fromstring(xml, parser)
+
+>>> print(type(honk_element))
+<class 'honkel'>
+>>> print(type(honk_element[0]))
+<class 'HonkNSElement'>
+
lxml.html
lxml.html.soupparser
fromstring()
parse()
lxml.html
convert_tree()
fromstring()
parse()
lxml.html.ElementSoup
soupparser
ElementSoup
>>> tag_soup = '''
+... <meta/><head><title>Hello</head><body onload=crash()>Hi all<p>'''
+
fromstring()
>>> from lxml.html.soupparser import fromstring
+>>> root = fromstring(tag_soup)
+
>>> from lxml.etree import tostring
+>>> print(tostring(root, pretty_print=True).strip())
+<html>
+  <meta/>
+  <head>
+    <title>Hello</title>
+  </head>
+  <body onload="crash()">Hi all<p/></body>
+</html>
+
makeelement
parse()
fromstring()
lxml.html
<html>
+  <head>
+    <meta/>
+    <title>Hello</title>
+  </head>
+  <body onload="crash()">Hi all<p/></body>
+</html>
+
>>> tag_soup = '<body>&copy;&euro;&#45;&#245;&#445;<p>'
+>>> body = fromstring(tag_soup).find('.//body')
+>>> body.text
+u'\xa9\u20ac-\xf5\u01bd'
+
>>> tostring(body)
+'<body>&#169;&#8364;-&#245;&#445;<p/></body>'
+
+>>> tostring(body, method="html")
+'<body>&#169;&#8364;-&#245;&#445;<p></p></body>'
+
>>> tostring(body, encoding="utf-8")
+'<body>\xc2\xa9\xe2\x82\xac-\xc3\xb5\xc6\xbd<p/></body>'
+
+>>> tostring(body, method="html", encoding="utf-8")
+'<body>\xc2\xa9\xe2\x82\xac-\xc3\xb5\xc6\xbd<p></p></body>'
+
+>>> tostring(body, encoding='unicode')
+u'<body>\xa9\u20ac-\xf5\u01bd<p/></body>'
+
+>>> tostring(body, method="html", encoding='unicode')
+u'<body>\xa9\u20ac-\xf5\u01bd<p></p></body>'
+
soupparser
<meta>
>>> tag_soup = '''\
+... <meta http-equiv="Content-Type"
+...       content="text/html;charset=utf-8" />
+... <html>
+...   <head>
+...     <title>Hello W\xc3\xb6rld!</title>
+...   </head>
+...   <body>Hi all</body>
+... </html>'''
+
+>>> import lxml.html
+>>> import lxml.html.soupparser
+
+>>> root = lxml.html.fromstring(tag_soup)
+>>> try:
+...     ignore = tostring(root, encoding='unicode')
+... except UnicodeDecodeError:
+...     root = lxml.html.soupparser.fromstring(tag_soup)
+
UnicodeDammit
>>> try:
+...    from bs4 import UnicodeDammit             # BeautifulSoup 4
+...
+...    def decode_html(html_string):
+...        converted = UnicodeDammit(html_string)
+...        if not converted.unicode_markup:
+...            raise UnicodeDecodeError(
+...                "Failed to detect encoding, tried [%s]",
+...                ', '.join(converted.tried_encodings))
+...        # print converted.original_encoding
+...        return converted.unicode_markup
+...
+... except ImportError:
+...    from BeautifulSoup import UnicodeDammit   # BeautifulSoup 3
+...
+...    def decode_html(html_string):
+...        converted = UnicodeDammit(html_string, isHTML=True)
+...        if not converted.unicode:
+...            raise UnicodeDecodeError(
+...                "Failed to detect encoding, tried [%s]",
+...                ', '.join(converted.triedEncodings))
+...        # print converted.originalEncoding
+...        return converted.unicode
+
+>>> root = lxml.html.fromstring(decode_html(tag_soup))
+
<xsl:value-of select="f:myPythonFunction(.//sometag)" />
+
<xsl:template match="*">
+    <my:python-extension>
+        <some-content />
+    </my:python-extension>
+</xsl:template>
+
>>> def hello(context, a):
+...    return "Hello %s" % a
+>>> def ola(context, a):
+...    return "Ola %s" % a
+>>> def loadsofargs(context, *args):
+...    return "Got %d arguments." % len(args)
+
>>> from lxml import etree
+>>> ns = etree.FunctionNamespace(None)
+>>> ns['hello'] = hello
+>>> ns['countargs'] = loadsofargs
+
FunctionNamespace
@ns("countargs")
>>> @ns
+... def hello(context, a):
+...    return "Hello %s" % a
+
>>> root = etree.XML('<a><b>Haegar</b></a>')
+>>> doc = etree.ElementTree(root)
+
>>> print(root.xpath("hello('Dr. Falken')"))
+Hello Dr. Falken
+>>> print(root.xpath('hello(local-name(*))'))
+Hello b
+>>> print(root.xpath('hello(string(b))'))
+Hello Haegar
+>>> print(root.xpath('countargs(., b, ./*)'))
+Got 3 arguments.
+
hello()
string()
>>> ns = etree.FunctionNamespace('http://mydomain.org/myfunctions')
+>>> ns['hello'] = hello
+
+>>> prefixmap = {'f' : 'http://mydomain.org/myfunctions'}
+>>> print(root.xpath('f:hello(local-name(*))', namespaces=prefixmap))
+Hello b
+
>>> ns = etree.FunctionNamespace('http://mydomain.org/myother/functions')
+>>> ns.prefix = 'es'
+>>> ns['hello'] = ola
+
+>>> print(root.xpath('es:hello(local-name(*))'))
+Ola b
+
eval_context
context_node
>>> def print_tag(context, nodes):
+...     print("%s: %s" % (context.context_node.tag, [ n.tag for n in nodes ]))
+
+>>> ns = etree.FunctionNamespace('http://mydomain.org/printtag')
+>>> ns.prefix = "pt"
+>>> ns["print_tag"] = print_tag
+
+>>> ignore = root.xpath("//*[pt:print_tag(.//*)]")
+a: ['b']
+b: []
+
eval_context
>>> def print_context(context):
+...     context.eval_context[context.context_node.tag] = "done"
+...     print(sorted(context.eval_context.items()))
+>>> ns["print_context"] = print_context
+
+>>> ignore = root.xpath("//*[pt:print_context()]")
+[('a', 'done')]
+[('a', 'done'), ('b', 'done')]
+
>>> e = etree.XPathEvaluator(doc)
+>>> print(e('es:hello(local-name(/a))'))
+Ola a
+
+>>> namespaces = {'f' : 'http://mydomain.org/myfunctions'}
+>>> e = etree.XPathEvaluator(doc, namespaces=namespaces)
+>>> print(e('f:hello(local-name(/a))'))
+Hello a
+
+>>> xslt = etree.XSLT(etree.XML('''
+...   <stylesheet version="1.0"
+...          xmlns="http://www.w3.org/1999/XSL/Transform"
+...          xmlns:es="http://mydomain.org/myother/functions">
+...     <output method="text" encoding="ASCII"/>
+...     <template match="/">
+...       <value-of select="es:hello(string(//b))"/>
+...     </template>
+...   </stylesheet>
+... '''))
+>>> print(xslt(doc))
+Ola Haegar
+
>>> f = StringIO('<a xmlns="http://mydomain.org/myfunctions" />')
+>>> ns_doc = etree.parse(f)
+>>> e = etree.XPathEvaluator(ns_doc)
+>>> e('/a')
+[]
+
>>> e.register_namespace('foo', 'http://mydomain.org/myfunctions')
+>>> e('/foo:a')[0].tag
+'{http://mydomain.org/myfunctions}a'
+
>>> e2 = etree.XPathEvaluator(ns_doc)
+>>> e2('/foo:a')
+Traceback (most recent call last):
+...
+lxml.etree.XPathEvalError: Undefined namespace prefix
+
extensions
>>> extensions = {('local-ns', 'local-hello') : hello}
+>>> namespaces = {'l' : 'local-ns'}
+
+>>> e = etree.XPathEvaluator(doc, namespaces=namespaces, extensions=extensions)
+>>> print(e('l:local-hello(string(b))'))
+Hello Haegar
+
Extension
>>> class MyExt:
+...     def function1(self, _, arg):
+...         return '1'+arg
+...     def function2(self, _, arg):
+...         return '2'+arg
+...     def function3(self, _, arg):
+...         return '3'+arg
+
+>>> ext_module = MyExt()
+>>> functions = ('function1', 'function2')
+>>> extensions = etree.Extension( ext_module, functions, ns='local-ns' )
+
+>>> e = etree.XPathEvaluator(doc, namespaces=namespaces, extensions=extensions)
+>>> print(e('l:function1(string(b))'))
+1Haegar
+
Extension
None
ns
None
>>> functions = ('function1', 'function2', 'function3')
+>>> extensions = etree.Extension( ext_module, functions )
+>>> e = etree.XPathEvaluator(doc, extensions=extensions)
+>>> print(e('function1(function2(function3(string(b))))'))
+123Haegar
+
+>>> extensions = etree.Extension( ext_module, functions, ns=None )
+>>> e = etree.XPathEvaluator(doc, extensions=extensions)
+>>> print(e('function1(function2(function3(string(b))))'))
+123Haegar
+
+>>> extensions = etree.Extension(ext_module)
+>>> e = etree.XPathEvaluator(doc, extensions=extensions)
+>>> print(e('function1(function2(function3(string(b))))'))
+123Haegar
+
+>>> functions = {
+...     'function1' : 'function1',
+...     'function2' : 'function2',
+...     'function3' : 'function3'
+...     }
+>>> extensions = etree.Extension(ext_module, functions)
+>>> e = etree.XPathEvaluator(doc, extensions=extensions)
+>>> print(e('function1(function2(function3(string(b))))'))
+123Haegar
+
>>> extensions1 = etree.Extension(ext_module)
+>>> extensions2 = etree.Extension(ext_module, ns='local-ns')
+>>> e = etree.XPathEvaluator(doc, extensions=[extensions1, extensions2],
+...                          namespaces=namespaces)
+>>> print(e('function1(l:function2(function3(string(b))))'))
+123Haegar
+
>>> def returnsFloat(_):
+...    return 1.7
+>>> def returnsInteger(_):
+...    return 1
+>>> def returnsBool(_):
+...    return True
+>>> def returnFirstNode(_, nodes):
+...    return nodes[0]
+
+>>> ns = etree.FunctionNamespace(None)
+>>> ns['float'] = returnsFloat
+>>> ns['int']   = returnsInteger
+>>> ns['bool']  = returnsBool
+>>> ns['first'] = returnFirstNode
+
+>>> e = etree.XPathEvaluator(doc)
+>>> e("float()")
+1.7
+>>> e("int()")
+1.0
+>>> int( e("int()") )
+1
+>>> e("bool()")
+True
+>>> e("count(first(//b))")
+1.0
+
>>> def returnsNodeSet(_):
+...     results1 = etree.Element('results1')
+...     etree.SubElement(results1, 'result').text = "Alpha"
+...     etree.SubElement(results1, 'result').text = "Beta"
+...
+...     results2 = etree.Element('results2')
+...     etree.SubElement(results2, 'result').text = "Gamma"
+...     etree.SubElement(results2, 'result').text = "Delta"
+...
+...     results3 = etree.SubElement(results2, 'subresult')
+...     return [results1, results2, results3]
+
+>>> ns['new-node-set'] = returnsNodeSet
+
+>>> e = etree.XPathEvaluator(doc)
+
+>>> r = e("new-node-set()/result")
+>>> print([ t.text for t in r ])
+['Alpha', 'Beta', 'Gamma', 'Delta']
+
+>>> r = e("new-node-set()")
+>>> print([ t.tag for t in r ])
+['results1', 'results2', 'subresult']
+>>> print([ len(t) for t in r ])
+[2, 3, 0]
+>>> r[0][0].text
+'Alpha'
+
+>>> etree.tostring(r[0])
+b'<results1><result>Alpha</result><result>Beta</result></results1>'
+
+>>> etree.tostring(r[1])
+b'<results2><result>Gamma</result><result>Delta</result><subresult/></results2>'
+
+>>> etree.tostring(r[2])
+b'<subresult/>'
+
>>> print("%s - %s" % (r[1][-1].tag, r[2].tag))
+subresult - subresult
+>>> print(r[1][-1] == r[2])
+False
+>>> print(r[1][-1].getparent().tag)
+results2
+>>> print(r[2].getparent())
+None
+
<xsl:template match="*">
+    <my:python-extension>
+        <some-content />
+    </my:python-extension>
+</xsl:template>
+
>>> class MyExtElement(etree.XSLTExtension):
+...     def execute(self, context, self_node, input_node, output_parent):
+...         print("Hello from XSLT!")
+...         output_parent.text = "I did it!"
+...         # just copy own content input to output
+...         output_parent.extend( list(self_node) )
+
.execute()
extension-element-prefixes
>>> xslt_ext_tree = etree.XML('''
+... <xsl:stylesheet version="1.0"
+...     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+...     xmlns:my="testns"
+...     extension-element-prefixes="my">
+...     <xsl:template match="/">
+...         <foo><my:ext><child>XYZ</child></my:ext></foo>
+...     </xsl:template>
+...     <xsl:template match="child">
+...         <CHILD>--xyz--</CHILD>
+...     </xsl:template>
+... </xsl:stylesheet>''')
+
>>> my_extension = MyExtElement()
+>>> extensions = { ('testns', 'ext') : my_extension }
+>>> transform = etree.XSLT(xslt_ext_tree, extensions = extensions)
+
>>> root = etree.XML('<dummy/>')
+>>> result = transform(root)
+Hello from XSLT!
+>>> str(result)
+'<?xml version="1.0"?>\n<foo>I did it!<child>XYZ</child></foo>\n'
+
.apply_templates()
XSLTExtension
>>> class MyExtElement(etree.XSLTExtension):
+...     def execute(self, context, self_node, input_node, output_parent):
+...         child = self_node[0]
+...         results = self.apply_templates(context, child)
+...         output_parent.append(results[0])
+
+>>> my_extension = MyExtElement()
+>>> extensions = { ('testns', 'ext') : my_extension }
+>>> transform = etree.XSLT(xslt_ext_tree, extensions = extensions)
+
+>>> root = etree.XML('<dummy/>')
+>>> result = transform(root)
+>>> str(result)
+'<?xml version="1.0"?>\n<foo><CHILD>--xyz--</CHILD></foo>\n'
+
.apply_templates()
.append()
.tail
output_parent
.apply_templates()
elements_only=True
.apply_templates()
remove_blank_text=True
execute()
tostring()
ElementTree
>>> from copy import deepcopy
+>>> class MyExtElement(etree.XSLTExtension):
+...     def execute(self, context, self_node, input_node, output_parent):
+...         child = deepcopy(self_node[0])
+...         child.text = "NEW TEXT"
+...         output_parent.append(child)
+
+>>> my_extension = MyExtElement()
+>>> extensions = { ('testns', 'ext') : my_extension }
+>>> transform = etree.XSLT(xslt_ext_tree, extensions = extensions)
+
+>>> root = etree.XML('<dummy/>')
+>>> result = transform(root)
+>>> str(result)
+'<?xml version="1.0"?>\n<foo><child>NEW TEXT</child></foo>\n'
+
lxml.html.html5parser
lxml.html
fromstring()
parse()
document_fromstring()
fragment_fromstring()
fragments_fromstring()
lxml.html
>>> from lxml.html import tostring, html5parser
+>>> tostring(html5parser.fromstring("<table><td>foo"))
+'<table><tbody><tr><td>foo</td></tr></tbody></table>'
+
parse(filename_url_or_file)
.read()
document_fromstring(html, guess_charset=True)
<html>
guess_charset
fragment_fromstring(string, create_parent=False, guess_charset=False)
create_parent
fragment_fromstring(string, create_parent='div')
<div>
create_parent
guess_charset
fragments_fromstring(string, no_leading_text=False, parser=None)
no_leading_text
guess_charset
fromstring(string)
document_fromstring
fragment_fromstring
parser
HTMLParser
XHTMLParser
doc/html
+hg clone git+ssh://git@github.com/lxml/lxml.git lxml
+
+git clone https://github.com/lxml/lxml.git lxml
+
python-lxml
python3-lxml
apt-get
+sudo apt-get install python3-lxml
+
+sudo port install py27-lxml
+
+sudo apt-get install libxml2-dev libxslt-dev python-dev
+
+sudo apt-get build-dep python3-lxml
+
+pip install lxml
+
+sudo pip install lxml
+
+pip install lxml==3.4.2
+
CFLAGS
+CFLAGS="-O0"  pip install lxml
+
pip
libxml2-dev
libxslt-devel
STATIC_DEPS=true
STATIC_DEPS=true pip install lxml
+STATIC_DEPS=true sudo pip install lxml
+
doc/build.txt
--static-deps
pip
STATIC_DEPS
STATICBUILD
+STATIC_DEPS=true pip install lxml
+
STATICBUILD
STATIC_DEPS
setup.py
src
lxml.etree
lxml.objectify
.pyx
import
cimport
_Element
+cdef class _Element:
+    cdef _Document _doc
+    cdef xmlNode* _c_node
+
c_
c_doc
xmlDoc*
c_node
xmlNode*
_c_node
xmlNode
_c_doc
xmlDoc*
+cdef xmlNode* c_node
+cdef _Document doc
+cdef _Element element
+...
+element = _elementFactory(doc, c_node)
+
getparent()
getnext()
getprevious()
doc
+make html
+
doc/mkhtml.py
make
lxml.etree
include
lxml.objectify
PythonElementClassLookup
update-error-constants.py
XSLT
lxml
CSSSelector
doctestcompare.py
lxml.html
parse(filename_url_or_file)
.read()
.geturl()
urllib.urlopen()
base_url
document_fromstring(string)
<html>
fragment_fromstring(string, create_parent=False)
create_parent
fragment_fromstring(string, create_parent='div')
<div>
fragments_fromstring(string)
fromstring(string)
document_fromstring
fragment_fromstring
.drop_tree()
el.getparent().remove(el)
drop_tree
.drop_tag()
.find_class(class_name)
doc.find_class_name('highlight')
<div class="sidebar highlight">
.find_rel_links(rel)
<a rel="{rel}">
doc.find_rel_links('tag')
.get_element_by_id(id, default=None)
id
default
.text_content()
.cssselect(expr)
.xpath(expr)
.label
<label>
label.for_element
.base_url
.classes
.set(key, value=None)
None
<form novalidate></form>
<div custom-attribute></div>
<form
+novalidate=""></form>
lxml.html
lxml.doctestcompare
usedoctest
>>> import lxml.html.usedoctest
+
>>> import lxml.html
+>>> html = lxml.html.fromstring('''\
+...    <html><body onload="" color="white">
+...      <p>Hi  !</p>
+...    </body></html>
+... ''')
+
+>>> print lxml.html.tostring(html)
+<html><body onload="" color="white"><p>Hi !</p></body></html>
+
+>>> print lxml.html.tostring(html)
+<html> <body color="white" onload=""> <p>Hi    !</p> </body> </html>
+
+>>> print lxml.html.tostring(html)
+<html>
+  <body color="white" onload="">
+    <p>Hi !</p>
+  </body>
+</html>
+
lxml.usedoctest
>>> from lxml.html import builder as E
+>>> from lxml.html import usedoctest
+>>> html = E.HTML(
+...   E.HEAD(
+...     E.LINK(rel="stylesheet", href="great.css", type="text/css"),
+...     E.TITLE("Best Page Ever")
+...   ),
+...   E.BODY(
+...     E.H1(E.CLASS("heading"), "Top News"),
+...     E.P("World News only on this page", style="font-size: 200%"),
+...     "Ah, and here's some more text, by the way.",
+...     lxml.html.fromstring("<p>... and this is a parsed fragment ...</p>")
+...   )
+... )
+
+>>> print lxml.html.tostring(html)
+<html>
+  <head>
+    <link href="great.css" rel="stylesheet" type="text/css">
+    <title>Best Page Ever</title>
+  </head>
+  <body>
+    <h1 class="heading">Top News</h1>
+    <p style="font-size: 200%">World News only on this page</p>
+    Ah, and here's some more text, by the way.
+    <p>... and this is a parsed fragment ...</p>
+  </body>
+</html>
+
lxml.html.tostring
lxml.tostring
lxml.tostring(doc)
<script src="..."></script>
<script src="..." />
lxml.html.open_in_browser(lxml_doc)
.iterlinks()
(element, attribute, link, pos)
attribute
<style>
@import
action
archive
background
cite
classid
codebase
data
href
longdesc
profile
src
usemap
dynsrc
lowsrc
style
url(link)
<style>
@import
url()
<base href>
.resolve_base_href()
<base href>
.make_links_absolute(base_href, resolve_base_href=True)
base_href
base_href="http://localhost/foo/bar.html"
baz.html
http://localhost/foo/baz.html
resolve_base_href
<base href>
self.resolve_base_href()
.rewrite_links(link_repl_func, resolve_base_href=True, base_href=None)
base_href
link_repl_func(link)
"#anchor"
"mailto:bob@example.com"
javascript:...
.iterlinks()
iterlinks(html)
make_links_absolute(html, base_href, ...)
rewrite_links(html, link_repl_func, ...)
resolve_base_href(html)
html
iterlinks()
<form>
doc.forms
doc.forms[0]
<select>
<textarea>
.name
.value
<select
+multiple>
.value_options
.multiple
<select multiple>
.type
<input>
.checkable
.checked
.inputs
.fields
form.inputs
form.fields[x]
form.inputs[x].value
form.fields[x] = y
form.inputs[x].value = y
form.inputs[x]
.value
form.fields.clear(); form.fields.update(new_value)
.form_values()
[(name, value), ...]
urllib.urlencode()
.action
action
.method
method
GET
>>> from lxml.html import fromstring, tostring
+>>> form_page = fromstring('''<html><body><form>
+...   Your name: <input type="text" name="name"> <br>
+...   Your phone: <input type="text" name="phone"> <br>
+...   Your favorite pets: <br>
+...   Dogs: <input type="checkbox" name="interest" value="dogs"> <br>
+...   Cats: <input type="checkbox" name="interest" value="cats"> <br>
+...   Llamas: <input type="checkbox" name="interest" value="llamas"> <br>
+...   <input type="submit"></form></body></html>''')
+>>> form = form_page.forms[0]
+>>> form.fields = dict(
+...     name='John Smith',
+...     phone='555-555-3949',
+...     interest=set(['cats', 'llamas']))
+>>> print tostring(form)
+<html>
+  <body>
+    <form>
+    Your name:
+      <input name="name" type="text" value="John Smith">
+      <br>Your phone:
+      <input name="phone" type="text" value="555-555-3949">
+      <br>Your favorite pets:
+      <br>Dogs:
+      <input name="interest" type="checkbox" value="dogs">
+      <br>Cats:
+      <input checked name="interest" type="checkbox" value="cats">
+      <br>Llamas:
+      <input checked name="interest" type="checkbox" value="llamas">
+      <br>
+      <input type="submit">
+    </form>
+  </body>
+</html>
+
lxml.html.submit_form(form_element)
urllib.urlopen()
extra_values
extra_values={'submit':
+'Yes!'}
open_http
open_http(method,
+url, values)
>>> from lxml.html import parse, submit_form
+>>> page = parse('http://tinyurl.com').getroot()
+>>> page.forms[0].fields['url'] = 'http://lxml.de/'
+>>> result = parse(submit_form(page.forms[0])).getroot()
+>>> [a.attrib['href'] for a in result.xpath("//a[@target='_blank']")]
+['http://tinyurl.com/2xae8s', 'http://preview.tinyurl.com/2xae8s']
+
lxml.html.clean
Cleaner
>>> html = '''\
+... <html>
+...  <head>
+...    <script type="text/javascript" src="evil-site"></script>
+...    <link rel="alternate" type="text/rss" src="evil-rss">
+...    <style>
+...      body {background-image: url(javascript:do_evil)};
+...      div {color: expression(evil)};
+...    </style>
+...  </head>
+...  <body onload="evil_function()">
+...    <!-- I am interpreted for EVIL! -->
+...    <a href="javascript:evil_function()">a link</a>
+...    <a href="#" onclick="evil_function()">another link</a>
+...    <p onclick="evil_function()">a paragraph</p>
+...    <div style="display: none">secret EVIL!</div>
+...    <object> of EVIL! </object>
+...    <iframe src="evil-site"></iframe>
+...    <form action="evil-site">
+...      Password: <input type="password" name="password">
+...    </form>
+...    <blink>annoying EVIL!</blink>
+...    <a href="evil-site">spam spam SPAM!</a>
+...    <image src="evil!">
+...  </body>
+... </html>'''
+
clean_html
>>> from lxml.html.clean import clean_html
+>>> print clean_html(html)
+<div><style>/* deleted */</style><body>
+
+   <a href="">a link</a>
+   <a href="#">another link</a>
+   <p>a paragraph</p>
+   <div>secret EVIL!</div>
+    of EVIL!
+
+
+     Password:
+   annoying EVIL!<a href="evil-site">spam spam SPAM!</a>
+   <img src="evil!"></body></div>
+
Cleaner
>>> from lxml.html.clean import Cleaner
+
+>>> cleaner = Cleaner(page_structure=False, links=False)
+>>> print cleaner.clean_html(html)
+<html>
+  <head>
+    <link rel="alternate" src="evil-rss" type="text/rss">
+    <style>/* deleted */</style>
+  </head>
+  <body>
+    <a href="">a link</a>
+    <a href="#">another link</a>
+    <p>a paragraph</p>
+    <div>secret EVIL!</div>
+    of EVIL!
+    Password:
+    annoying EVIL!
+    <a href="evil-site">spam spam SPAM!</a>
+    <img src="evil!">
+  </body>
+</html>
+
+>>> cleaner = Cleaner(style=True, links=True, add_nofollow=True,
+...                   page_structure=False, safe_attrs_only=False)
+
+>>> print cleaner.clean_html(html)
+<html>
+  <head>
+  </head>
+  <body>
+    <a href="">a link</a>
+    <a href="#">another link</a>
+    <p>a paragraph</p>
+    <div>secret EVIL!</div>
+    of EVIL!
+    Password:
+    annoying EVIL!
+    <a href="evil-site" rel="nofollow">spam spam SPAM!</a>
+    <img src="evil!">
+  </body>
+</html>
+
Cleaner(host_whitelist=['www.youtube.com'])
Cleaner
lxml.html.clean
+autolink(doc, ...)
+
+autolink_html(html, ...)
+
http://example.com
<textarea>
<pre>
<code>
avoid_elements=['textarea', ...]
localhost*
example.*
127.0.0.1
avoid_hosts=[list_of_regexes]
nolink
avoid_classes=['code', ...]
autolink_html()
+word_break(doc, max_width=40, ...)
+
+word_break_html(html, ...)
+
&#8203;
<pre>
<textarea>
<code>
avoid_elements=['textarea', ...]
nobreak
avoid_classes=['code', ...]
break_character=u'\u200b'
word_break_html(html)
lxml.html.diff
htmldiff
html_annotate
<ins>
<del>
svn
+blame
<body>
htmldiff
>>> from lxml.html.diff import htmldiff, html_annotate
+>>> doc1 = '''<p>Here is some text.</p>'''
+>>> doc2 = '''<p>Here is <b>a lot</b> of <i>text</i>.</p>'''
+>>> doc3 = '''<p>Here is <b>a little</b> <i>text</i>.</p>'''
+>>> print htmldiff(doc1, doc2)
+<p>Here is <ins><b>a lot</b> of <i>text</i>.</ins> <del>some text.</del> </p>
+>>> print html_annotate([(doc1, 'author1'), (doc2, 'author2'),
+...                      (doc3, 'author3')])
+<p><span title="author1">Here is</span>
+   <b><span title="author2">a</span>
+   <span title="author3">little</span></b>
+   <i><span title="author2">text</span></i>
+   <span title="author2">.</span></p>
+
html_annotate
markup
markup(text,
+version)
def default_markup(text, version):
+    return '<span title="%s">%s</span>' % (
+        cgi.escape(unicode(version), 1), text)
+
>>> import urllib
+>>> from lxml.html import fromstring
+>>> url = 'http://microformats.org/'
+>>> content = urllib.urlopen(url).read()
+>>> doc = fromstring(content)
+>>> doc.make_links_absolute(url)
+
>>> class Card(object):
+...     def __init__(self, **kw):
+...         for name, value in kw:
+...             setattr(self, name, value)
+>>> class Phone(object):
+...     def __init__(self, phone, types=()):
+...         self.phone, self.types = phone, types
+
>>> def get_text(el, class_name):
+...     els = el.find_class(class_name)
+...     if els:
+...         return els[0].text_content()
+...     else:
+...         return ''
+>>> def get_value(el):
+...     return get_text(el, 'value') or el.text_content()
+>>> def get_all_texts(el, class_name):
+...     return [e.text_content() for e in els.find_class(class_name)]
+>>> def parse_addresses(el):
+...     # Ideally this would parse street, etc.
+...     return el.find_class('adr')
+
>>> for el in doc.find_class('hcard'):
+...     card = Card()
+...     card.el = el
+...     card.fn = get_text(el, 'fn')
+...     card.tels = []
+...     for tel_el in card.find_class('tel'):
+...         card.tels.append(Phone(get_value(tel_el),
+...                                get_all_texts(tel_el, 'type')))
+...     card.addresses = parse_addresses(el)
+
objectify
lxml.etree
lxml.objectify
>>> from lxml import etree
+>>> from lxml import objectify
+
lxml.etree
>>> import lxml.usedoctest
+
lxml.objectify
objectify
>>> root = objectify.Element("root")
+>>> b = objectify.SubElement(root, "b")
+>>> print(root.b[0].tag)
+b
+>>> root.index(root.b[0])
+0
+>>> b = objectify.SubElement(root, "b")
+>>> print(root.b[0].tag)
+b
+>>> print(root.b[1].tag)
+b
+>>> root.index(root.b[1])
+1
+
>>> print(root.b.tag)
+b
+>>> root.index(root.b)
+0
+>>> del root.b
+
>>> x1 = objectify.SubElement(root, "x")
+>>> x2 = objectify.SubElement(root, "x")
+>>> x3 = objectify.SubElement(root, "x")
+
+>>> [ el.tag for el in root.x ]
+['x', 'x', 'x']
+
+>>> [ el.tag for el in root.x[1:3] ]
+['x', 'x']
+
+>>> [ el.tag for el in root.x[-1:] ]
+['x']
+
+>>> del root.x[1:2]
+>>> [ el.tag for el in root.x ]
+['x', 'x']
+
iterchildren()
>>> [ el.tag for el in root.iterchildren() ]
+['b', 'x', 'x']
+
+>>> [ el.tag for el in root.iterchildren(tag='b') ]
+['b']
+
+>>> [ el.tag for el in root.b ]
+['b']
+
>>> c = objectify.SubElement(root, "c", myattr="someval")
+>>> print(root.c.get("myattr"))
+someval
+
+>>> root.c.set("c", "oh-oh")
+>>> print(root.c.get("c"))
+oh-oh
+
>>> el = objectify.Element("yet_another_child")
+>>> root.new_child = el
+>>> print(root.new_child.tag)
+new_child
+>>> print(el.tag)
+yet_another_child
+
+>>> root.y = [ objectify.Element("y"), objectify.Element("y") ]
+>>> [ el.tag for el in root.y ]
+['y', 'y']
+
>>> root.y[:] = [ objectify.Element("y") ]
+>>> [ el.tag for el in root.y ]
+['y']
+
>>> child1 = objectify.SubElement(root, "child")
+>>> child2 = objectify.SubElement(root, "child")
+>>> child3 = objectify.SubElement(root, "child")
+
+>>> el = objectify.Element("new_child")
+>>> subel = objectify.SubElement(el, "sub")
+
+>>> root.child = el
+>>> print(root.child.sub.tag)
+sub
+
+>>> root.child[2] = el
+>>> print(root.child[2].sub.tag)
+sub
+
>>> print(root.b.tag)
+b
+>>> root.b.tag = "notB"
+>>> root.b
+Traceback (most recent call last):
+  ...
+AttributeError: no such child: b
+>>> print(root.notB.tag)
+notB
+
lxml.etree
objectify
parse()
fromstring()
>>> fileobject = StringIO('<test/>')
+
+>>> tree = objectify.parse(fileobject)
+>>> print(isinstance(tree.getroot(), objectify.ObjectifiedElement))
+True
+
+>>> root = objectify.fromstring('<test/>')
+>>> print(isinstance(root, objectify.ObjectifiedElement))
+True
+
objectify
Element()
lxml.etree
>>> obj_el = objectify.Element("new")
+>>> print(isinstance(obj_el, objectify.ObjectifiedElement))
+True
+
>>> child = objectify.SubElement(obj_el, "newchild", attr="value")
+
Element()
objectify
>>> subel = objectify.SubElement(obj_el, "sub")
+>>> print(isinstance(subel, objectify.ObjectifiedElement))
+True
+
+>>> independent_el = etree.Element("new")
+>>> print(isinstance(independent_el, objectify.ObjectifiedElement))
+False
+
>>> E = objectify.E
+>>> root = E.root(
+...   E.a(5),
+...   E.b(6.21),
+...   E.c(True),
+...   E.d("how", tell="me")
+... )
+
+>>> print(etree.tostring(root, pretty_print=True))
+<root xmlns:py="http://codespeak.net/lxml/objectify/pytype">
+  <a py:pytype="int">5</a>
+  <b py:pytype="float">6.21</b>
+  <c py:pytype="bool">true</c>
+  <d py:pytype="str" tell="me">how</d>
+</root>
+
>>> ROOT = objectify.E.root
+>>> TITLE = objectify.E.title
+>>> HOWMANY = getattr(objectify.E, "how-many")
+
+>>> root = ROOT(
+...   TITLE("The title"),
+...   HOWMANY(5)
+... )
+
+>>> print(etree.tostring(root, pretty_print=True))
+<root xmlns:py="http://codespeak.net/lxml/objectify/pytype">
+  <title py:pytype="str">The title</title>
+  <how-many py:pytype="int">5</how-many>
+</root>
+
objectify.E
objectify.ElementMaker
annotate
nsmap
>>> myE = objectify.ElementMaker(annotate=False,
+...           namespace="http://my/ns", nsmap={None : "http://my/ns"})
+
+>>> root = myE.root( myE.someint(2) )
+
+>>> print(etree.tostring(root, pretty_print=True))
+<root xmlns="http://my/ns">
+  <someint>2</someint>
+</root>
+
>>> root = objectify.Element("{http://ns/}root")
+>>> b = objectify.SubElement(root, "{http://ns/}b")
+>>> c = objectify.SubElement(root, "{http://other/}c")
+
+>>> print(root.b.tag)
+{http://ns/}b
+
SubElement()
lxml.etree
>>> print(root.b.tag)
+{http://ns/}b
+
+>>> print(root.c)
+Traceback (most recent call last):
+    ...
+AttributeError: no such child: {http://ns/}c
+
getattr()
>>> c = getattr(root, "{http://other/}c")
+>>> print(c.tag)
+{http://other/}c
+
>>> c = root["{http://other/}c"]
+>>> print(c.tag)
+{http://other/}c
+
>>> el = objectify.SubElement(root, "{http://ns/}tag-name")
+>>> print(root["tag-name"].tag)
+{http://ns/}tag-name
+
+>>> new_el = objectify.Element("{http://ns/}new-element")
+>>> el = objectify.SubElement(new_el, "{http://ns/}child")
+>>> el = objectify.SubElement(new_el, "{http://ns/}child")
+>>> el = objectify.SubElement(new_el, "{http://ns/}child")
+
+>>> root["tag-name"] = [ new_el, new_el ]
+>>> print(len(root["tag-name"]))
+2
+>>> print(root["tag-name"].tag)
+{http://ns/}tag-name
+
+>>> print(len(root["tag-name"].child))
+3
+>>> print(root["tag-name"].child.tag)
+{http://ns/}child
+>>> print(root["tag-name"][1].child.tag)
+{http://ns/}child
+
>>> root = objectify.XML("<root><text>TEXT</text></root>")
+
+>>> print(root.text.text)
+Traceback (most recent call last):
+  ...
+AttributeError: 'NoneType' object has no attribute 'text'
+
+>>> print(root["text"].text)
+TEXT
+
>>> f = StringIO('''\
+...   <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+...     <xsd:element name="a" type="AType"/>
+...     <xsd:complexType name="AType">
+...       <xsd:sequence>
+...         <xsd:element name="b" type="xsd:string" />
+...       </xsd:sequence>
+...     </xsd:complexType>
+...   </xsd:schema>
+... ''')
+>>> schema = etree.XMLSchema(file=f)
+
makeparser()
>>> parser = objectify.makeparser(schema = schema)
+
>>> xml = "<a><b>test</b></a>"
+>>> a = objectify.fromstring(xml, parser)
+
+>>> print(a.b)
+test
+
>>> xml = b"<a><b>test</b><c/></a>"
+>>> a = objectify.fromstring(xml, parser)  # doctest: +ELLIPSIS
+Traceback (most recent call last):
+lxml.etree.XMLSyntaxError: Element 'c': This element is not expected...
+
ObjectPath
>>> root = objectify.Element("{http://ns/}root")
+>>> b1 = objectify.SubElement(root, "{http://ns/}b")
+>>> c  = objectify.SubElement(b1,   "{http://ns/}c")
+>>> b2 = objectify.SubElement(root, "{http://ns/}b")
+>>> d  = objectify.SubElement(root, "{http://other/}d")
+
+>>> path = objectify.ObjectPath("root.b.c")
+>>> print(path)
+root.b.c
+>>> path.hasattr(root)
+True
+>>> print(path.find(root).tag)
+{http://ns/}c
+
+>>> find = objectify.ObjectPath("root.b.c")
+>>> print(find(root).tag)
+{http://ns/}c
+
+>>> find = objectify.ObjectPath("root.{http://other/}d")
+>>> print(find(root).tag)
+{http://other/}d
+
+>>> find = objectify.ObjectPath("root.{not}there")
+>>> print(find(root).tag)
+Traceback (most recent call last):
+  ...
+AttributeError: no such child: {not}there
+
+>>> find = objectify.ObjectPath("{not}there")
+>>> print(find(root).tag)
+Traceback (most recent call last):
+  ...
+ValueError: root element does not match: need {not}there, got {http://ns/}root
+
+>>> find = objectify.ObjectPath("root.b[1]")
+>>> print(find(root).tag)
+{http://ns/}b
+
+>>> find = objectify.ObjectPath("root.{http://ns/}b[1]")
+>>> print(find(root).tag)
+{http://ns/}b
+
>>> find = objectify.ObjectPath(['root', 'b', 'c'])
+>>> print(find(root).tag)
+{http://ns/}c
+
+>>> find = objectify.ObjectPath(['root', '{http://ns/}b[1]'])
+>>> print(find(root).tag)
+{http://ns/}b
+
>>> find = objectify.ObjectPath(".b[1]")
+>>> print(find(root).tag)
+{http://ns/}b
+
+>>> find = objectify.ObjectPath(['', 'b[1]'])
+>>> print(find(root).tag)
+{http://ns/}b
+
+>>> find = objectify.ObjectPath(".unknown[1]")
+>>> print(find(root).tag)
+Traceback (most recent call last):
+  ...
+AttributeError: no such child: {http://ns/}unknown
+
+>>> find = objectify.ObjectPath(".{http://other/}unknown[1]")
+>>> print(find(root).tag)
+Traceback (most recent call last):
+  ...
+AttributeError: no such child: {http://other/}unknown
+
>>> find = objectify.ObjectPath(".")
+>>> print(find(root).tag)
+{http://ns/}root
+
>>> root = objectify.Element("{http://ns/}root")
+
+>>> path = objectify.ObjectPath(".some.child.{http://other/}unknown")
+>>> path.hasattr(root)
+False
+>>> path.find(root)
+Traceback (most recent call last):
+  ...
+AttributeError: no such child: {http://ns/}some
+
+>>> path.setattr(root, "my value") # creates children as necessary
+>>> path.hasattr(root)
+True
+>>> print(path.find(root).text)
+my value
+>>> print(root.some.child["{http://other/}unknown"].text)
+my value
+
+>>> print(len( path.find(root) ))
+1
+>>> path.addattr(root, "my new value")
+>>> print(len( path.find(root) ))
+2
+>>> [ el.text for el in path.find(root) ]
+['my value', 'my new value']
+
setattr()
>>> path.setattr(root, ["v1", "v2", "v3"])
+>>> [ el.text for el in path.find(root) ]
+['v1', 'v2', 'v3']
+
>>> path = objectify.ObjectPath(".{non}existing[1]")
+>>> path.setattr(root, "my value")
+Traceback (most recent call last):
+  ...
+TypeError: creating indexed path attributes is not supported
+
objectify
>>> root = objectify.fromstring(
+...             "<root><a>5</a><b>11</b><c>true</c><d>hoi</d></root>")
+>>> root.a + root.b
+16
+>>> root.a += root.b
+>>> print(root.a)
+16
+
+>>> root.a = 2
+>>> print(root.a + 2)
+4
+>>> print(1 + root.a)
+3
+
+>>> print(root.c)
+True
+>>> root.c = False
+>>> if not root.c:
+...     print("false!")
+false!
+
+>>> print(root.d + " test !")
+hoi test !
+>>> root.d = "%s - %s"
+>>> print(root.d % (1234, 12345))
+1234 - 12345
+
len()
>>> root = objectify.fromstring("<root><a>test</a><b>toast</b></root>")
+>>> print(root.a + ' me') # behaves like a string, right?
+test me
+>>> len(root.a) # but there's only one 'a' element!
+1
+>>> [ a.tag for a in root.a ]
+['a']
+>>> print(root.a[0].tag)
+a
+
+>>> print(root.a)
+test
+>>> [ str(a) for a in root.a[:1] ]
+['test']
+
.text
.pyval
>>> root = objectify.fromstring("<root><a>test</a><b>5</b></root>")
+>>> root.a.text
+'test'
+>>> root.a.pyval
+'test'
+
+>>> root.b.text
+'5'
+>>> root.b.pyval
+5
+
>>> root.a.text  = "25"
+Traceback (most recent call last):
+  ...
+TypeError: attribute 'text' of 'StringElement' objects is not writable
+
+>>> root.a.pyval = 25
+Traceback (most recent call last):
+  ...
+TypeError: attribute 'pyval' of 'StringElement' objects is not writable
+
+>>> root.a = 25
+>>> print(root.a)
+25
+>>> print(root.a.pyval)
+25
+
objectify
dump()
>>> root = objectify.fromstring("""
+... <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+...   <a attr1="foo" attr2="bar">1</a>
+...   <a>1.2</a>
+...   <b>1</b>
+...   <b>true</b>
+...   <c>what?</c>
+...   <d xsi:nil="true"/>
+... </root>
+... """)
+
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = 1 [IntElement]
+      * attr1 = 'foo'
+      * attr2 = 'bar'
+    a = 1.2 [FloatElement]
+    b = 1 [IntElement]
+    b = True [BoolElement]
+    c = 'what?' [StringElement]
+    d = None [NoneElement]
+      * xsi:nil = 'true'
+
>>> root = objectify.fromstring("<root><a>5</a></root>")
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = 5 [IntElement]
+
+>>> root.a = 'nice string!'
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = 'nice string!' [StringElement]
+      * py:pytype = 'str'
+
+>>> root.a = True
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = True [BoolElement]
+      * py:pytype = 'bool'
+
+>>> root.a = [1, 2, 3]
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = 1 [IntElement]
+      * py:pytype = 'int'
+    a = 2 [IntElement]
+      * py:pytype = 'int'
+    a = 3 [IntElement]
+      * py:pytype = 'int'
+
+>>> root.a = (1, 2, 3)
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = 1 [IntElement]
+      * py:pytype = 'int'
+    a = 2 [IntElement]
+      * py:pytype = 'int'
+    a = 3 [IntElement]
+      * py:pytype = 'int'
+
>>> objectify.enable_recursive_str()
+
+>>> root = objectify.fromstring("""
+... <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+...   <a attr1="foo" attr2="bar">1</a>
+...   <a>1.2</a>
+...   <b>1</b>
+...   <b>true</b>
+...   <c>what?</c>
+...   <d xsi:nil="true"/>
+... </root>
+... """)
+
+>>> print(str(root))
+root = None [ObjectifiedElement]
+    a = 1 [IntElement]
+      * attr1 = 'foo'
+      * attr2 = 'bar'
+    a = 1.2 [FloatElement]
+    b = 1 [IntElement]
+    b = True [BoolElement]
+    c = 'what?' [StringElement]
+    d = None [NoneElement]
+      * xsi:nil = 'true'
+
>>> objectify.enable_recursive_str(False)
+
objectify.Element()
objectify.DataElement()
ObjectifyElementClassLookup()
tree_class
empty_data_class
tree_class
ObjectifiedElement
empty_data_class
StringElement
lxml.objectify.PYTYPE_ATTRIBUTE
>>> print(objectify.PYTYPE_ATTRIBUTE)
+{http://codespeak.net/lxml/objectify/pytype}pytype
+>>> ns, name = objectify.PYTYPE_ATTRIBUTE[1:].split('}')
+
+>>> root = objectify.fromstring("""\
+... <root xmlns:py='%s'>
+...   <a py:pytype='str'>5</a>
+...   <b py:pytype='int'>5</b>
+...   <c py:pytype='NoneType' />
+... </root>
+... """ % ns)
+
+>>> print(root.a + 10)
+510
+>>> print(root.b + 10)
+15
+>>> print(root.c)
+None
+
set_pytype_attribute_tag(tag)
annotate()
>>> root = objectify.fromstring("<root><a>test</a><b>5</b></root>")
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = 'test' [StringElement]
+    b = 5 [IntElement]
+
+>>> objectify.annotate(root)
+
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = 'test' [StringElement]
+      * py:pytype = 'str'
+    b = 5 [IntElement]
+      * py:pytype = 'int'
+
>>> root = objectify.fromstring('''\
+...    <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+...          xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+...      <d xsi:type="xsd:double">5</d>
+...      <i xsi:type="xsd:int"   >5</i>
+...      <s xsi:type="xsd:string">5</s>
+...    </root>
+...    ''')
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    d = 5.0 [FloatElement]
+      * xsi:type = 'xsd:double'
+    i = 5 [IntElement]
+      * xsi:type = 'xsd:int'
+    s = '5' [StringElement]
+      * xsi:type = 'xsd:string'
+
xsiannotate()
>>> root = objectify.fromstring('''\
+...    <root><a>test</a><b>5</b><c>true</c></root>
+...    ''')
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = 'test' [StringElement]
+    b = 5 [IntElement]
+    c = True [BoolElement]
+
+>>> objectify.xsiannotate(root)
+
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    a = 'test' [StringElement]
+      * xsi:type = 'xsd:string'
+    b = 5 [IntElement]
+      * xsi:type = 'xsd:integer'
+    c = True [BoolElement]
+      * xsi:type = 'xsd:boolean'
+
xsiannotate()
deannotate()
>>> root = objectify.fromstring('''\
+... <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+...       xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+...   <d xsi:type="xsd:double">5</d>
+...   <i xsi:type="xsd:int"   >5</i>
+...   <s xsi:type="xsd:string">5</s>
+... </root>''')
+>>> objectify.annotate(root)
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    d = 5.0 [FloatElement]
+      * py:pytype = 'float'
+      * xsi:type = 'xsd:double'
+    i = 5 [IntElement]
+      * py:pytype = 'int'
+      * xsi:type = 'xsd:int'
+    s = '5' [StringElement]
+      * py:pytype = 'str'
+      * xsi:type = 'xsd:string'
+>>> objectify.deannotate(root)
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    d = 5 [IntElement]
+    i = 5 [IntElement]
+    s = 5 [IntElement]
+
deannotate()
>>> root = objectify.fromstring('''\
+... <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+...       xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+...   <d xsi:type="xsd:double">5</d>
+...   <i xsi:type="xsd:int"   >5</i>
+...   <s xsi:type="xsd:string">5</s>
+...   <n xsi:nil="true"/>
+... </root>''')
+>>> objectify.annotate(root)
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    d = 5.0 [FloatElement]
+      * py:pytype = 'float'
+      * xsi:type = 'xsd:double'
+    i = 5 [IntElement]
+      * py:pytype = 'int'
+      * xsi:type = 'xsd:int'
+    s = '5' [StringElement]
+      * py:pytype = 'str'
+      * xsi:type = 'xsd:string'
+    n = None [NoneElement]
+      * py:pytype = 'NoneType'
+      * xsi:nil = 'true'
+>>> objectify.deannotate(root, xsi_nil=True)
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    d = 5 [IntElement]
+    i = 5 [IntElement]
+    s = 5 [IntElement]
+    n = u'' [StringElement]
+
deannotate()
pytype
cleanup_namespaces=True
lxml.etree.cleanup_namespaces()
DataElement()
>>> root = objectify.Element("root")
+>>> root.x = objectify.DataElement(5, _pytype="int")
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    x = 5 [IntElement]
+      * py:pytype = 'int'
+
+>>> root.x = objectify.DataElement(5, _pytype="str", myattr="someval")
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    x = '5' [StringElement]
+      * myattr = 'someval'
+      * py:pytype = 'str'
+
+>>> root.x = objectify.DataElement(5, _xsi="integer")
+>>> print(objectify.dump(root))
+root = None [ObjectifiedElement]
+    x = 5 [IntElement]
+      * py:pytype = 'int'
+      * xsi:type = 'xsd:integer'
+
DataElement()
>>> root = objectify.Element("root")
+>>> root.s = objectify.DataElement(5, _xsi="string")
+
+>>> objectify.deannotate(root, xsi=False)
+>>> print(etree.tostring(root, pretty_print=True))
+<root xmlns:py="http://codespeak.net/lxml/objectify/pytype" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <s xsi:type="xsd:string">5</s>
+</root>
+
DataElement()
>>> el = objectify.DataElement('5', _xsi='string')
+>>> namespaces = list(el.nsmap.items())
+>>> namespaces.sort()
+>>> for prefix, namespace in namespaces:
+...     print("%s - %s" % (prefix, namespace))
+py - http://codespeak.net/lxml/objectify/pytype
+xsd - http://www.w3.org/2001/XMLSchema
+xsi - http://www.w3.org/2001/XMLSchema-instance
+
+>>> print(el.get("{http://www.w3.org/2001/XMLSchema-instance}type"))
+xsd:string
+
>>> el = objectify.DataElement('5', _xsi='foo:string',
+...          nsmap={'foo': 'http://www.w3.org/2001/XMLSchema'})
+>>> namespaces = list(el.nsmap.items())
+>>> namespaces.sort()
+>>> for prefix, namespace in namespaces:
+...     print("%s - %s" % (prefix, namespace))
+foo - http://www.w3.org/2001/XMLSchema
+py - http://codespeak.net/lxml/objectify/pytype
+xsi - http://www.w3.org/2001/XMLSchema-instance
+
+>>> print(el.get("{http://www.w3.org/2001/XMLSchema-instance}type"))
+foo:string
+
>>> el = objectify.DataElement('5', _xsi='foo:string',
+...          nsmap={'foo': 'http://www.w3.org/2001/XMLSchema',
+...                 'myxsi': 'http://www.w3.org/2001/XMLSchema-instance'})
+>>> namespaces = list(el.nsmap.items())
+>>> namespaces.sort()
+>>> for prefix, namespace in namespaces:
+...     print("%s - %s" % (prefix, namespace))
+foo - http://www.w3.org/2001/XMLSchema
+myxsi - http://www.w3.org/2001/XMLSchema-instance
+py - http://codespeak.net/lxml/objectify/pytype
+
+>>> print(el.get("{http://www.w3.org/2001/XMLSchema-instance}type"))
+foo:string
+
>>> root = objectify.fromstring("""<root xmlns:schema="http://www.w3.org/2001/XMLSchema"/>""")
+>>> print(etree.tostring(root, pretty_print=True))
+<root xmlns:schema="http://www.w3.org/2001/XMLSchema"/>
+
+>>> s = objectify.DataElement("17", _xsi="string")
+>>> print(etree.tostring(s, pretty_print=True))
+<value xmlns:py="http://codespeak.net/lxml/objectify/pytype" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" py:pytype="str" xsi:type="xsd:string">17</value>
+
+>>> root.s = s
+>>> print(etree.tostring(root, pretty_print=True))
+<root xmlns:schema="http://www.w3.org/2001/XMLSchema">
+  <s xmlns:py="http://codespeak.net/lxml/objectify/pytype" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" py:pytype="str" xsi:type="xsd:string">17</s>
+</root>
+
xsiannotate()
>>> objectify.xsiannotate(root)
+>>> print(etree.tostring(root, pretty_print=True))
+<root xmlns:schema="http://www.w3.org/2001/XMLSchema">
+  <s xmlns:py="http://codespeak.net/lxml/objectify/pytype" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" py:pytype="str" xsi:type="schema:string">17</s>
+</root>
+
ObjectifiedDataElement
NumberElement
BoolElement
self._setValueParser(function)
_init()
PyType
>>> class ChristmasDate(objectify.ObjectifiedDataElement):
+...     def call_santa(self):
+...         print("Ho ho ho!")
+
+>>> def checkChristmasDate(date_string):
+...     if not date_string.startswith('24.12.'):
+...         raise ValueError # or TypeError
+
+>>> xmas_type = objectify.PyType('date', checkChristmasDate, ChristmasDate)
+
py:pytype
>>> xmas_type.xmlSchemaTypes = ("date",)
+
xsi:type
date
>>> xmas_type.register()
+
+>>> root = objectify.fromstring(
+...             "<root><a>24.12.2000</a><b>12.24.2000</b></root>")
+>>> root.a.call_santa()
+Ho ho ho!
+>>> root.b.call_santa()
+Traceback (most recent call last):
+  ...
+AttributeError: no such child: call_santa
+
before
after
register()
>>> root = objectify.fromstring('''\
+...    <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+...      <a xsi:type="date">12.24.2000</a>
+...    </root>
+...    ''')
+>>> print(root.a)
+12.24.2000
+>>> root.a.call_santa()
+Ho ho ho!
+
unregister()
>>> root.a.call_santa()
+Ho ho ho!
+>>> xmas_type.unregister()
+>>> root.a.call_santa()
+Traceback (most recent call last):
+  ...
+AttributeError: no such child: call_santa
+
lxml.etree
lxml.objectify
>>> parser = objectify.makeparser(remove_blank_text=True)
+
>>> parser = etree.XMLParser(remove_blank_text=True)
+
+>>> lookup = objectify.ObjectifyElementClassLookup()
+>>> parser.set_element_class_lookup(lookup)
+
objectify.ObjectifiedElement
lxml.etree.ElementBase
objectify
>>> lookup = etree.ElementNamespaceClassLookup(
+...                   objectify.ObjectifyElementClassLookup() )
+>>> parser.set_element_class_lookup(lookup)
+
countchildren()
iterchildren()
getchildren()
lxml.etree
>>> from lxml import etree
+
io
from io import StringIO, BytesIO
+
>>> xml = '<a xmlns="test"><b xmlns="test"/></a>'
+
+>>> root = etree.fromstring(xml)
+>>> etree.tostring(root)
+b'<a xmlns="test"><b xmlns="test"/></a>'
+
parse()
ElementTree
>>> tree = etree.parse(StringIO(xml))
+>>> etree.tostring(tree.getroot())
+b'<a xmlns="test"><b xmlns="test"/></a>'
+
parse()
>>> tree = etree.parse("doc/test.xml")
+
base_url
>>> root = etree.fromstring(xml, base_url="http://where.it/is/from.xml")
+
>>> parser = etree.XMLParser(ns_clean=True)
+>>> tree   = etree.parse(StringIO(xml), parser)
+>>> etree.tostring(tree.getroot())
+b'<a xmlns="test"><b/></a>'
+
error_log
>>> parser = etree.XMLParser()
+>>> print(len(parser.error_log))
+0
+
+>>> tree = etree.XML("<root>\n</b>", parser)  # doctest: +ELLIPSIS
+Traceback (most recent call last):
+  ...
+lxml.etree.XMLSyntaxError: Opening and ending tag mismatch: root line 1 and b, line 2, column 5...
+
+>>> print(len(parser.error_log))
+1
+
+>>> error = parser.error_log[0]
+>>> print(error.message)
+Opening and ending tag mismatch: root line 1 and b
+>>> print(error.line)
+2
+>>> print(error.column)
+5
+
message
domain
type
level
line
column
filename
domain_name
type_name
level_name
filter_*()
recover
>>> broken_html = "<html><head><title>test<body><h1>page title</h3>"
+
+>>> parser = etree.HTMLParser()
+>>> tree   = etree.parse(StringIO(broken_html), parser)
+
+>>> result = etree.tostring(tree.getroot(),
+...                         pretty_print=True, method="html")
+>>> print(result)
+<html>
+  <head>
+    <title>test</title>
+  </head>
+  <body>
+    <h1>page title</h1>
+  </body>
+</html>
+
>>> html = etree.HTML(broken_html)
+>>> result = etree.tostring(html, pretty_print=True, method="html")
+>>> print(result)
+<html>
+  <head>
+    <title>test</title>
+  </head>
+  <body>
+    <h1>page title</h1>
+  </body>
+</html>
+
>>> pub_id  = "-//W3C//DTD XHTML 1.0 Transitional//EN"
+>>> sys_url = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
+>>> doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_url)
+>>> xml_header = '<?xml version="1.0" encoding="ascii"?>'
+>>> xhtml = xml_header + doctype_string + '<html><body></body></html>'
+
+>>> tree = etree.parse(StringIO(xhtml))
+>>> docinfo = tree.docinfo
+>>> print(docinfo.public_id)
+-//W3C//DTD XHTML 1.0 Transitional//EN
+>>> print(docinfo.system_url)
+http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd
+>>> docinfo.doctype == doctype_string
+True
+
+>>> print(docinfo.xml_version)
+1.0
+>>> print(docinfo.encoding)
+ascii
+
+>>> docinfo.system_url = None
+>>> docinfo.public_id = None
+>>> print(etree.tostring(tree))
+<!DOCTYPE html>
+<html><body/></html>
+
>>> class EchoTarget(object):
+...     def start(self, tag, attrib):
+...         print("start %s %r" % (tag, dict(attrib)))
+...     def end(self, tag):
+...         print("end %s" % tag)
+...     def data(self, data):
+...         print("data %r" % data)
+...     def comment(self, text):
+...         print("comment %s" % text)
+...     def close(self):
+...         print("close")
+...         return "closed!"
+
+>>> parser = etree.XMLParser(target = EchoTarget())
+
+>>> result = etree.XML("<element>some<!--comment-->text</element>",
+...                    parser)
+start element {}
+data u'some'
+comment comment
+data u'text'
+end element
+close
+
+>>> print(result)
+closed!
+
.close()
>>> result = etree.XML("<element>some<!--comment-->text</element>",
+...                    parser)
+start element {}
+data u'some'
+comment comment
+data u'text'
+end element
+close
+
+>>> print(result)
+closed!
+
.close()
>>> class CollectorTarget(object):
+...     def __init__(self):
+...         self.events = []
+...     def start(self, tag, attrib):
+...         self.events.append("start %s %r" % (tag, dict(attrib)))
+...     def end(self, tag):
+...         self.events.append("end %s" % tag)
+...     def data(self, data):
+...         self.events.append("data %r" % data)
+...     def comment(self, text):
+...         self.events.append("comment %s" % text)
+...     def close(self):
+...         self.events.append("close")
+...         return "closed!"
+
+>>> parser = etree.XMLParser(target = CollectorTarget())
+
+>>> result = etree.XML("<element>some</error>",
+...                    parser)        # doctest: +ELLIPSIS
+Traceback (most recent call last):
+  ...
+lxml.etree.XMLSyntaxError: Opening and ending tag mismatch...
+
+>>> for event in parser.target.events:
+...     print(event)
+start element {}
+data u'some'
+close
+
.close()
TreeBuilder
>>> parser = etree.XMLParser(target = etree.TreeBuilder())
+
+>>> result = etree.XML("<element>some<!--comment-->text</element>",
+...                    parser)
+
+>>> print(result.tag)
+element
+>>> print(result[0].text)
+comment
+
parse()
XML()
feed()
>>> parser = etree.XMLParser()
+
+>>> for data in ('<?xml versio', 'n="1.0"?', '><roo', 't><a', '/></root>'):
+...     parser.feed(data)
+
close()
>>> root = parser.close()
+
+>>> print(root.tag)
+root
+>>> print(root[0].tag)
+a
+
close()
read()
read()
feed_error_log
error_log
>>> parser = etree.XMLParser(target = EchoTarget())
+
+>>> parser.feed("<eleme")
+>>> parser.feed("nt>some text</elem")
+start element {}
+data u'some text'
+>>> parser.feed("ent>")
+end element
+
+>>> result = parser.close()
+close
+>>> print(result)
+closed!
+
close()
close()
xml.etree.ElementTree
XMLPullParser
.read_events()
>>> parser = etree.XMLPullParser(events=('start', 'end'))
+
+>>> def print_events(parser):
+...     for action, element in parser.read_events():
+...         print('%s: %s' % (action, element.tag))
+
+>>> parser.feed('<root>some text')
+>>> print_events(parser)
+start: root
+>>> print_events(parser)    # well, no more events, as before ...
+
+>>> parser.feed('<child><a />')
+>>> print_events(parser)
+start: child
+start: a
+end: a
+
+>>> parser.feed('</child></roo')
+>>> print_events(parser)
+end: child
+>>> parser.feed('t>')
+>>> print_events(parser)
+end: root
+
XMLPullParser
.close()
>>> root = parser.close()
+>>> etree.tostring(root)
+b'<root>some text<child><a/></child></root>'
+
.read_events()
tag
.read_events()
(event-type, object)
(prefix, namespaceURI)
end-ns
>>> def print_events(events):
+...     for action, obj in events:
+...         if action in ('start', 'end'):
+...             print("%s: %s" % (action, obj.tag))
+...         elif action == 'start-ns':
+...             print("%s: %s" % (action, obj))
+...         else:
+...             print(action)
+
+>>> event_types = ("start", "end", "start-ns", "end-ns")
+>>> parser = etree.XMLPullParser(event_types)
+>>> events = parser.read_events()
+
+>>> parser.feed('<root><element>')
+>>> print_events(events)
+start: root
+start: element
+>>> parser.feed('text</element><element>text</element>')
+>>> print_events(events)
+end: element
+start: element
+end: element
+>>> parser.feed('<empty-element xmlns="http://testns/" />')
+>>> print_events(events)
+start-ns: ('', 'http://testns/')
+start: {http://testns/}empty-element
+end: {http://testns/}empty-element
+end-ns
+>>> parser.feed('</root>')
+>>> print_events(events)
+end: root
+
>>> parser = etree.XMLPullParser()
+>>> events = parser.read_events()
+
+>>> parser.feed('<root><element key="value">text</element>')
+>>> parser.feed('<element><child /></element>')
+>>> for action, elem in events:
+...     print('%s: %d' % (elem.tag, len(elem)))  # processing
+...     elem.clear(keep_tail=True)               # delete children
+element: 0
+child: 0
+element: 1
+>>> parser.feed('<empty-element xmlns="http://testns/" /></root>')
+>>> for action, elem in events:
+...     print('%s: %d' % (elem.tag, len(elem)))  # processing
+...     elem.clear(keep_tail=True)               # delete children
+{http://testns/}empty-element: 0
+root: 3
+
+>>> root = parser.close()
+>>> etree.tostring(root)
+b'<root/>'
+
>>> for event, element in parser.read_events():
+...     # ... do something with the element
+...     element.clear(keep_tail=True)   # clean up children
+...     while element.getprevious() is not None:
+...         del element.getparent()[0]  # clean up preceding siblings
+
while
tag
if
tag
element.iter(tag)
>>> parser = etree.XMLPullParser(tag="element")
+
+>>> parser.feed('<root><element key="value">text</element>')
+>>> parser.feed('<element><child /></element>')
+>>> parser.feed('<empty-element xmlns="http://testns/" /></root>')
+
+>>> for action, elem in parser.read_events():
+...     print("%s: %s" % (action, elem.tag))
+end: element
+end: element
+
+>>> event_types = ("start", "end")
+>>> parser = etree.XMLPullParser(event_types, tag="{http://testns/}*")
+
+>>> parser.feed('<root><element key="value">text</element>')
+>>> parser.feed('<element><child /></element>')
+>>> parser.feed('<empty-element xmlns="http://testns/" /></root>')
+
+>>> for action, elem in parser.read_events():
+...     print("%s: %s" % (action, elem.tag))
+start: {http://testns/}empty-element
+end: {http://testns/}empty-element
+
XMLPullParser
>>> event_types = ("start", "end", "comment", "pi")
+>>> parser = etree.XMLPullParser(event_types)
+
+>>> parser.feed('<?some pi ?><!-- a comment --><root>')
+>>> parser.feed('<element key="value">text</element>')
+>>> parser.feed('<!-- another comment -->')
+>>> parser.feed('<element>text</element>tail')
+>>> parser.feed('<empty-element xmlns="http://testns/" />')
+>>> parser.feed('</root>')
+
+>>> for action, elem in parser.read_events():
+...     if action in ('start', 'end'):
+...         print("%s: %s" % (action, elem.tag))
+...     elif action == 'pi':
+...         print("%s: -%s=%s-" % (action, elem.target, elem.text))
+...     else: # 'comment'
+...         print("%s: -%s-" % (action, elem.text))
+pi: -some=pi -
+comment: - a comment -
+start: root
+start: element
+end: element
+comment: - another comment -
+start: element
+end: element
+start: {http://testns/}empty-element
+end: {http://testns/}empty-element
+end: root
+
+>>> root = parser.close()
+>>> print(root.tag)
+root
+
.start()
.end()
>>> class Target(object):
+...     def start(self, tag, attrib):
+...         print('-> start(%s)' % tag)
+...         return '>>START: %s<<' % tag
+...     def end(self, tag):
+...         print('-> end(%s)' % tag)
+...         return '>>END: %s<<' % tag
+...     def close(self):
+...         print('-> close()')
+...         return "CLOSED!"
+
+>>> event_types = ('start', 'end')
+>>> parser = etree.XMLPullParser(event_types, target=Target())
+
+>>> parser.feed('<root><child1 /><child2 /></root>')
+-> start(root)
+-> start(child1)
+-> end(child1)
+-> start(child2)
+-> end(child2)
+-> end(root)
+
+>>> for action, value in parser.read_events():
+...     print('%s: %s' % (action, value))
+start: >>START: root<<
+start: >>START: child1<<
+end: >>END: child1<<
+start: >>START: child2<<
+end: >>END: child2<<
+end: >>END: root<<
+
+>>> print(parser.close())
+-> close()
+CLOSED!
+
TreeBuilder
start()
.end()
TreeBuilder
>>> class AttributeFilter(etree.TreeBuilder):
+...     def start(self, tag, attrib):
+...         attrib = dict(attrib)
+...         if 'evil' in attrib:
+...             del attrib['evil']
+...         return super(AttributeFilter, self).start(tag, attrib)
+
+>>> parser = etree.XMLPullParser(target=AttributeFilter())
+>>> parser.feed('<root><child1 test="123" /><child2 evil="YES" /></root>')
+
+>>> for action, element in parser.read_events():
+...     print('%s: %s(%r)' % (action, element.tag, element.attrib))
+end: child1({'test': '123'})
+end: child2({})
+end: root({})
+
+>>> root = parser.close()
+
iterparse()
XMLPullParser
>>> xml = '''
+... <root>
+...   <element key='value'>text</element>
+...   <element>text</element>tail
+...   <empty-element xmlns="http://testns/" />
+... </root>
+... '''
+
+>>> context = etree.iterparse(StringIO(xml))
+>>> for action, elem in context:
+...     print("%s: %s" % (action, elem.tag))
+end: element
+end: element
+end: {http://testns/}empty-element
+end: root
+
root
>>> context.root.tag
+'root'
+
events
>>> events = ("start", "end")
+>>> context = etree.iterparse(StringIO(xml), events=events)
+>>> for action, elem in context:
+...     print("%s: %s" % (action, elem.tag))
+start: root
+start: element
+end: element
+start: element
+end: element
+start: {http://testns/}empty-element
+end: {http://testns/}empty-element
+end: root
+
iterparse()
tag
tag
html=True
iterwalk()
iterparse()
iterparse()
>>> f = StringIO(xml)
+>>> context = etree.iterparse(
+...             f, events=("start", "end"), tag="element")
+
+>>> for action, elem in context:
+...     print("%s: %s" % (action, elem.tag))
+start: element
+end: element
+start: element
+end: element
+
+>>> root = context.root
+
iterwalk()
>>> context = etree.iterwalk(
+...             root, events=("start", "end"), tag="element")
+
+>>> for action, elem in context:
+...     print("%s: %s" % (action, elem.tag))
+start: element
+end: element
+start: element
+end: element
+
iterwalk
.skip_subtree()
>>> root = etree.XML('''
+... <root>
+...   <a> <b /> </a>
+...   <c />
+... </root>
+... ''')
+
+>>> context = etree.iterwalk(root, events=("start", "end"))
+
+>>> for action, elem in context:
+...     print("%s: %s" % (action, elem.tag))
+...     if action == 'start' and elem.tag == 'a':
+...         context.skip_subtree()  # ignore <b>
+start: root
+start: a
+end: a
+start: c
+end: c
+end: root
+
.skip_subtree()
start
start-ns
XML()
>>> root = etree.XML( u'<test> \uf8d1 + \uf8d2 </test>' )
+
>>> etree.XML( u'<?xml version="1.0" encoding="ASCII"?>\n' +
+...            u'<test> \uf8d1 + \uf8d2 </test>' )
+Traceback (most recent call last):
+  ...
+ValueError: Unicode strings with encoding declaration are not supported. Please use bytes input or XML fragments without declaration.
+
tostring()
>>> etree.tostring(root)
+b'<test> &#63697; + &#63698; </test>'
+
+>>> etree.tostring(root, encoding='UTF-8', xml_declaration=False)
+b'<test> \xef\xa3\x91 + \xef\xa3\x92 </test>'
+
>>> etree.tostring(root, encoding='unicode')
+u'<test> \uf8d1 + \uf8d2 </test>'
+
+>>> el = etree.Element("test")
+>>> etree.tostring(el, encoding='unicode')
+u'<test/>'
+
+>>> subel = etree.SubElement(el, "subtest")
+>>> etree.tostring(el, encoding='unicode')
+u'<test><subtest/></test>'
+
+>>> tree = etree.ElementTree(el)
+>>> etree.tostring(tree, encoding='unicode')
+u'<test><subtest/></test>'
+
tostring(encoding='unicode')
write()
tostring()
tostring(encoding='unicode')
tostring()
tostring()
(SATR T1)
getchildren()
+lxe: tostring_utf16  (S-TR T1)    7.9958 msec/pass
+cET: tostring_utf16  (S-TR T1)   83.1358 msec/pass
+
+lxe: tostring_utf16  (UATR T1)    8.3222 msec/pass
+cET: tostring_utf16  (UATR T1)   84.4688 msec/pass
+
+lxe: tostring_utf16  (S-TR T2)    8.2297 msec/pass
+cET: tostring_utf16  (S-TR T2)   87.3415 msec/pass
+
+lxe: tostring_utf8   (S-TR T2)    6.5677 msec/pass
+cET: tostring_utf8   (S-TR T2)   76.2064 msec/pass
+
+lxe: tostring_utf8   (U-TR T3)    1.1952 msec/pass
+cET: tostring_utf8   (U-TR T3)   22.0058 msec/pass
+
+lxe: tostring_text_ascii     (S-TR T1)    2.7738 msec/pass
+cET: tostring_text_ascii     (S-TR T1)    4.7629 msec/pass
+
+lxe: tostring_text_ascii     (S-TR T3)    0.8273 msec/pass
+cET: tostring_text_ascii     (S-TR T3)    1.5273 msec/pass
+
+lxe: tostring_text_utf16     (S-TR T1)    2.7659 msec/pass
+cET: tostring_text_utf16     (S-TR T1)   10.5038 msec/pass
+
+lxe: tostring_text_utf16     (U-TR T1)    2.8017 msec/pass
+cET: tostring_text_utf16     (U-TR T1)   10.5207 msec/pass
+
tostring()
+lxe: tostring_text_unicode   (S-TR T1)    2.6896 msec/pass
+cET: tostring_text_unicode   (S-TR T1)    1.0056 msec/pass
+
+lxe: tostring_text_unicode   (U-TR T1)    2.7366 msec/pass
+cET: tostring_text_unicode   (U-TR T1)    1.0154 msec/pass
+
+lxe: tostring_text_unicode   (S-TR T3)    0.7997 msec/pass
+cET: tostring_text_unicode   (S-TR T3)    0.3154 msec/pass
+
+lxe: tostring_text_unicode   (U-TR T4)    0.0048 msec/pass
+cET: tostring_text_unicode   (U-TR T4)    0.0160 msec/pass
+
+lxe: parse_bytesIO   (SAXR T1)   13.0246 msec/pass
+cET: parse_bytesIO   (SAXR T1)    8.2929 msec/pass
+
+lxe: parse_bytesIO   (S-XR T3)    1.3542 msec/pass
+cET: parse_bytesIO   (S-XR T3)    2.4023 msec/pass
+
+lxe: parse_bytesIO   (UAXR T3)    7.5610 msec/pass
+cET: parse_bytesIO   (UAXR T3)   11.2455 msec/pass
+
+xml.etree.ElementTree.parse done in 0.017 seconds
+xml.etree.cElementTree.parse done in 0.007 seconds
+xml.etree.cElementTree.XMLParser.feed(): 6636 nodes read in 0.007 seconds
+lxml.etree.parse done in 0.003 seconds
+drop_whitespace.parse done in 0.003 seconds
+lxml.etree.XMLParser.feed(): 6636 nodes read in 0.004 seconds
+minidom tree read in 0.080 seconds
+
+xml.etree.ElementTree.parse done in 0.038 seconds
+xml.etree.cElementTree.parse done in 0.030 seconds
+xml.etree.cElementTree.XMLParser.feed(): 25317 nodes read in 0.030 seconds
+lxml.etree.parse done in 0.016 seconds
+drop_whitespace.parse done in 0.015 seconds
+lxml.etree.XMLParser.feed(): 25317 nodes read in 0.022 seconds
+minidom tree read in 0.288 seconds
+
+Memory usage: 7284
+xml.etree.ElementTree.parse done in 0.017 seconds
+Memory usage: 9432 (+2148)
+xml.etree.cElementTree.parse done in 0.007 seconds
+Memory usage: 9432 (+2152)
+xml.etree.cElementTree.XMLParser.feed(): 6636 nodes read in 0.007 seconds
+Memory usage: 9448 (+2164)
+lxml.etree.parse done in 0.003 seconds
+Memory usage: 11032 (+3748)
+drop_whitespace.parse done in 0.003 seconds
+Memory usage: 10224 (+2940)
+lxml.etree.XMLParser.feed(): 6636 nodes read in 0.004 seconds
+Memory usage: 11804 (+4520)
+minidom tree read in 0.080 seconds
+Memory usage: 12324 (+5040)
+
+Memory usage: 10420
+xml.etree.ElementTree.parse done in 0.038 seconds
+Memory usage: 20660 (+10240)
+xml.etree.cElementTree.parse done in 0.030 seconds
+Memory usage: 20660 (+10240)
+xml.etree.cElementTree.XMLParser.feed(): 25317 nodes read in 0.030 seconds
+Memory usage: 20844 (+10424)
+lxml.etree.parse done in 0.016 seconds
+Memory usage: 27624 (+17204)
+drop_whitespace.parse done in 0.015 seconds
+Memory usage: 24468 (+14052)
+lxml.etree.XMLParser.feed(): 25317 nodes read in 0.022 seconds
+Memory usage: 29844 (+19424)
+minidom tree read in 0.288 seconds
+Memory usage: 28788 (+18368)
+
iterparse()
+lxe: iterparse_bytesIO   (SAXR T1)   17.9198 msec/pass
+cET: iterparse_bytesIO   (SAXR T1)   14.4982 msec/pass
+
+lxe: iterparse_bytesIO   (UAXR T3)    8.8522 msec/pass
+cET: iterparse_bytesIO   (UAXR T3)   12.9857 msec/pass
+
+lxe: write_utf8_parse_bytesIO   (S-TR T1)   19.8867 msec/pass
+cET: write_utf8_parse_bytesIO   (S-TR T1)   80.7259 msec/pass
+
+lxe: write_utf8_parse_bytesIO   (UATR T2)   23.7896 msec/pass
+cET: write_utf8_parse_bytesIO   (UATR T2)   98.0766 msec/pass
+
+lxe: write_utf8_parse_bytesIO   (S-TR T3)    3.0684 msec/pass
+cET: write_utf8_parse_bytesIO   (S-TR T3)   24.6122 msec/pass
+
+lxe: write_utf8_parse_bytesIO   (SATR T4)    0.3495 msec/pass
+cET: write_utf8_parse_bytesIO   (SATR T4)    1.9610 msec/pass
+
lxml.etree
+lxe:       --     S-     U-     -A     SA     UA
+     T1: 0.0299 0.0343 0.0344 0.0293 0.0345 0.0342
+     T2: 0.0368 0.0423 0.0418 0.0427 0.0474 0.0459
+     T3: 0.0088 0.0084 0.0086 0.0251 0.0258 0.0261
+     T4: 0.0002 0.0002 0.0002 0.0005 0.0006 0.0006
+cET:       --     S-     U-     -A     SA     UA
+     T1: 0.0050 0.0045 0.0093 0.0044 0.0043 0.0043
+     T2: 0.0073 0.0075 0.0074 0.0201 0.0075 0.0074
+     T3: 0.0033 0.0213 0.0032 0.0034 0.0033 0.0035
+     T4: 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
+
list(element)
+lxe: root_list_children        (--TR T1)    0.0038 msec/pass
+cET: root_list_children        (--TR T1)    0.0010 msec/pass
+
+lxe: root_list_children        (--TR T2)    0.0455 msec/pass
+cET: root_list_children        (--TR T2)    0.0050 msec/pass
+
+lxe: first_child               (--TR T2)    0.0424 msec/pass
+cET: first_child               (--TR T2)    0.0384 msec/pass
+
+lxe: last_child                (--TR T1)    0.0477 msec/pass
+cET: last_child                (--TR T1)    0.0467 msec/pass
+
+lxe: middle_child              (--TR T1)    0.0710 msec/pass
+cET: middle_child              (--TR T1)    0.0420 msec/pass
+
+lxe: middle_child              (--TR T2)    1.7393 msec/pass
+cET: middle_child              (--TR T2)    0.0396 msec/pass
+
+lxe: create_elements           (--TC T2)    1.0045 msec/pass
+cET: create_elements           (--TC T2)    0.0753 msec/pass
+
Element.makeelement()
+lxe: makeelement               (--TC T2)    1.0586 msec/pass
+cET: makeelement               (--TC T2)    0.1483 msec/pass
+
+lxe: create_subelements        (--TC T2)    0.8826 msec/pass
+cET: create_subelements        (--TC T2)    0.0827 msec/pass
+
+lxe: append_from_document      (--TR T1,T2)    1.0812 msec/pass
+cET: append_from_document      (--TR T1,T2)    0.1104 msec/pass
+
+lxe: append_from_document      (--TR T3,T4)    0.0155 msec/pass
+cET: append_from_document      (--TR T3,T4)    0.0060 msec/pass
+
+lxe: insert_from_document         (--TR T1,T2)    3.9763 msec/pass
+cET: insert_from_document         (--TR T1,T2)    0.1459 msec/pass
+
+lxe: replace_children_element   (--TC T1)    0.0749 msec/pass
+cET: replace_children_element   (--TC T1)    0.0081 msec/pass
+
+lxe: replace_children           (--TC T1)    0.0052 msec/pass
+cET: replace_children           (--TC T1)    0.0036 msec/pass
+
makeelement()
+lxe: deepcopy_all              (--TR T1)    3.1650 msec/pass
+cET: deepcopy_all              (--TR T1)   53.9973 msec/pass
+
+lxe: deepcopy_all              (-ATR T2)    3.7365 msec/pass
+cET: deepcopy_all              (-ATR T2)   61.6267 msec/pass
+
+lxe: deepcopy_all              (S-TR T3)    0.7913 msec/pass
+cET: deepcopy_all              (S-TR T3)   13.6220 msec/pass
+
.iter()
+lxe: iter_all             (--TR T1)    1.0529 msec/pass
+cET: iter_all             (--TR T1)    0.2635 msec/pass
+
+lxe: iter_islice          (--TR T2)    0.0110 msec/pass
+cET: iter_islice          (--TR T2)    0.0050 msec/pass
+
+lxe: iter_tag             (--TR T2)    0.0079 msec/pass
+cET: iter_tag             (--TR T2)    0.0112 msec/pass
+
+lxe: iter_tag_all         (--TR T2)    0.1822 msec/pass
+cET: iter_tag_all         (--TR T2)    0.5343 msec/pass
+
Element.findall()
+lxe: findall              (--TR T2)    1.7176 msec/pass
+cET: findall              (--TR T2)    0.9973 msec/pass
+
+lxe: findall              (--TR T3)    0.3967 msec/pass
+cET: findall              (--TR T3)    0.2525 msec/pass
+
+lxe: findall_tag          (--TR T2)    0.2258 msec/pass
+cET: findall_tag          (--TR T2)    0.5770 msec/pass
+
+lxe: findall_tag          (--TR T3)    0.1085 msec/pass
+cET: findall_tag          (--TR T3)    0.1919 msec/pass
+
.findall()
element.iter()
xpath()
+lxe: xpath_method         (--TC T1)    0.3982 msec/pass
+lxe: xpath_method         (--TC T2)    7.8895 msec/pass
+lxe: xpath_method         (--TC T3)    0.0477 msec/pass
+lxe: xpath_method         (--TC T4)    0.3982 msec/pass
+
XPath
+lxe: xpath_class          (--TC T1)    0.0713 msec/pass
+lxe: xpath_class          (--TC T2)    1.1325 msec/pass
+lxe: xpath_class          (--TC T3)    0.0215 msec/pass
+lxe: xpath_class          (--TC T4)    0.0722 msec/pass
+
XPathEvaluator
+lxe: xpath_element        (--TR T1)    0.1101 msec/pass
+lxe: xpath_element        (--TR T2)    2.0473 msec/pass
+lxe: xpath_element        (--TR T3)    0.0267 msec/pass
+lxe: xpath_element        (--TR T4)    0.1087 msec/pass
+
+lxe: xpath_class_repeat           (--TC T1   )    0.3884 msec/pass
+lxe: xpath_class_repeat           (--TC T2   )    7.6182 msec/pass
+lxe: xpath_class_repeat           (--TC T3   )    0.0465 msec/pass
+lxe: xpath_class_repeat           (--TC T4   )    0.3877 msec/pass
+
+lxe: find_single                (--TR T2)    0.0184 msec/pass
+cET: find_single                (--TR T2)    0.0052 msec/pass
+
+lxe: iter_single                (--TR T2)    0.0024 msec/pass
+cET: iter_single                (--TR T2)    0.0007 msec/pass
+
+lxe: xpath_single               (--TR T2)    0.0033 msec/pass
+
+lxe: iterfind_two               (--TR T2)    0.0184 msec/pass
+cET: iterfind_two               (--TR T2)    0.0062 msec/pass
+
+lxe: iter_two                   (--TR T2)    0.0029 msec/pass
+cET: iter_two                   (--TR T2)    0.0017 msec/pass
+
+lxe: xpath_two                  (--TR T2)    0.2768 msec/pass
+
findall()
iterparse()
def bench_ET():
+    tree = ElementTree.parse("ot.xml")
+    result = []
+    for v in tree.findall("//v"):
+        text = v.text
+        if 'begat' in text:
+            result.append(text)
+    return len(result)
+
iterparse()
def bench_ET_iterparse():
+    result = []
+    for event, v in ElementTree.iterparse("ot.xml"):
+        if v.tag == 'v':
+            text = v.text
+            if 'begat' in text:
+                result.append(text)
+        v.clear()
+    return len(result)
+
iterparse()
findall()
v.clear()
def bench_lxml_xpath_all():
+    tree = etree.parse("ot.xml")
+    result = tree.xpath("//v[contains(., 'begat')]/text()")
+    return len(result)
+
def bench_lxml_xpath():
+    tree = etree.parse("ot.xml")
+    result = []
+    for v in tree.xpath("//v"):
+        text = v.text
+        if 'begat' in text:
+            result.append(text)
+    return len(result)
+
def bench_lxml_getiterator():
+    tree = etree.parse("ot.xml")
+    result = []
+    for v in tree.getiterator("v"):
+        text = v.text
+        if 'begat' in text:
+            result.append(text)
+    return len(result)
+
getiterator("v")
iterparse()
iterparse()
parse()
iterparse()
iterparse()
+lxe: attribute                  (--TR T1)    4.1828 msec/pass
+lxe: attribute                  (--TR T2)   17.3802 msec/pass
+lxe: attribute                  (--TR T4)    3.8657 msec/pass
+
+lxe: objectpath                 (--TR T1)    0.9289 msec/pass
+lxe: objectpath                 (--TR T2)   13.3109 msec/pass
+lxe: objectpath                 (--TR T4)    0.9289 msec/pass
+
+lxe: attributes_deep            (--TR T1)    6.2900 msec/pass
+lxe: attributes_deep            (--TR T2)   20.4713 msec/pass
+lxe: attributes_deep            (--TR T4)    6.1679 msec/pass
+
+lxe: objectpath_deep            (--TR T1)    1.3049 msec/pass
+lxe: objectpath_deep            (--TR T2)   14.0815 msec/pass
+lxe: objectpath_deep            (--TR T4)    1.3051 msec/pass
+
cache[root] = list(root.iter())
+
del cache[root]
+
+lxe: attribute_cached           (--TR T1)    3.1357 msec/pass
+lxe: attribute_cached           (--TR T2)   15.8911 msec/pass
+lxe: attribute_cached           (--TR T4)    2.9194 msec/pass
+
+lxe: attributes_deep_cached     (--TR T1)    3.8984 msec/pass
+lxe: attributes_deep_cached     (--TR T2)   16.8300 msec/pass
+lxe: attributes_deep_cached     (--TR T4)    3.6936 msec/pass
+
+lxe: objectpath_deep_cached     (--TR T1)    0.7496 msec/pass
+lxe: objectpath_deep_cached     (--TR T2)   12.3763 msec/pass
+lxe: objectpath_deep_cached     (--TR T4)    0.7427 msec/pass
+
weakref.WeakKeyDictionary
objectify.annotate()
no_network
>>> from lxml import etree
+
+>>> class DTDResolver(etree.Resolver):
+...     def resolve(self, url, id, context):
+...         print("Resolving URL '%s'" % url)
+...         return self.resolve_string(
+...             '<!ENTITY myentity "[resolved text: %s]">' % url, context)
+
url
id
resolve_string
resolve_filename
resolve_file
resolve_empty
resolve()
resolve()
resolve_*()
>>> parser = etree.XMLParser(load_dtd=True)
+>>> parser.resolvers.add( DTDResolver() )
+
>>> xml = '<!DOCTYPE doc SYSTEM "MissingDTD.dtd"><doc>&myentity;</doc>'
+>>> tree = etree.parse(StringIO(xml), parser)
+Resolving URL 'MissingDTD.dtd'
+>>> root = tree.getroot()
+>>> print(root.text)
+[resolved text: MissingDTD.dtd]
+
>>> class PrefixResolver(etree.Resolver):
+...     def __init__(self, prefix):
+...         self.prefix = prefix
+...         self.result_xml = '''\
+...              <xsl:stylesheet
+...                     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+...                <test xmlns="testNS">%s-TEST</test>
+...              </xsl:stylesheet>
+...              ''' % prefix
+...     def resolve(self, url, pubid, context):
+...         if url.startswith(self.prefix):
+...             print("Resolved url %s as prefix %s" % (url, self.prefix))
+...             return self.resolve_string(self.result_xml, context)
+
>>> xml_text = """\
+... <xsl:stylesheet version="1.0"
+...    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+...   <xsl:include href="honk:test"/>
+...   <xsl:template match="/">
+...     <test>
+...       <xsl:value-of select="document('hoi:test')/*/*/text()"/>
+...     </test>
+...   </xsl:template>
+... </xsl:stylesheet>
+... """
+
honk:test
xsl:import
xsl:include
hoi:test
document
>>> hoi_parser = etree.XMLParser()
+>>> normal_doc = etree.parse(StringIO(xml_text), hoi_parser)
+
+>>> hoi_parser.resolvers.add( PrefixResolver("hoi") )
+>>> hoi_doc = etree.parse(StringIO(xml_text), hoi_parser)
+
+>>> honk_parser = etree.XMLParser()
+>>> honk_parser.resolvers.add( PrefixResolver("honk") )
+>>> honk_doc = etree.parse(StringIO(xml_text), honk_parser)
+
honk:test
xsl:include
hoi
>>> transform = etree.XSLT(normal_doc)
+Traceback (most recent call last):
+  ...
+lxml.etree.XSLTParseError: Cannot resolve URI honk:test
+
+>>> transform = etree.XSLT(hoi_doc)
+Traceback (most recent call last):
+  ...
+lxml.etree.XSLTParseError: Cannot resolve URI honk:test
+
honk
>>> transform = etree.XSLT(honk_doc)
+Resolved url honk:test as prefix honk
+
hoi
honk
>>> result = transform(normal_doc)
+Traceback (most recent call last):
+  ...
+lxml.etree.XSLTApplyError: Cannot resolve URI hoi:test
+
+>>> result = transform(hoi_doc)
+Traceback (most recent call last):
+  ...
+lxml.etree.XSLTApplyError: Cannot resolve URI hoi:test
+
+>>> result = transform(honk_doc)
+Traceback (most recent call last):
+  ...
+lxml.etree.XSLTApplyError: Cannot resolve URI hoi:test
+
hoi
>>> honk_parser.resolvers.add( PrefixResolver("hoi") )
+>>> result = transform(honk_doc)
+Resolved url hoi:test as prefix hoi
+>>> print(str(result)[:-1])
+<?xml version="1.0"?>
+<test>hoi-TEST</test>
+
hoi
>>> result = transform(normal_doc)
+Resolved url hoi:test as prefix hoi
+>>> print(str(result)[:-1])
+<?xml version="1.0"?>
+<test>hoi-TEST</test>
+
XSLTAccessControl
>>> transform = etree.XSLT(honk_doc)
+Resolved url honk:test as prefix honk
+>>> result = transform(normal_doc)
+Resolved url hoi:test as prefix hoi
+
+>>> ac = etree.XSLTAccessControl(read_network=False)
+>>> transform = etree.XSLT(honk_doc, access_control=ac)
+Resolved url honk:test as prefix honk
+>>> result = transform(normal_doc)
+Traceback (most recent call last):
+  ...
+lxml.etree.XSLTApplyError: xsltLoadDocument: read rights for hoi:test denied
+
xsl:import
read_file=False
write_file=False
read_file
*_network
lxml.sax.ElementTreeContentHandler
>>> import lxml.sax
+>>> handler = lxml.sax.ElementTreeContentHandler()
+
>>> handler.startElementNS((None, 'a'), 'a', {})
+>>> handler.startElementNS((None, 'b'), 'b', {(None, 'foo'): 'bar'})
+>>> handler.characters('Hello world')
+>>> handler.endElementNS((None, 'b'), 'b')
+>>> handler.endElementNS((None, 'a'), 'a')
+
etree
>>> tree = handler.etree
+>>> lxml.etree.tostring(tree.getroot())
+b'<a><b foo="bar">Hello world</b></a>'
+
makeelement
ElementTreeContentHandler
>>> f = StringIO('<a><b>Text</b></a>')
+>>> tree = lxml.etree.parse(f)
+
>>> from xml.sax.handler import ContentHandler
+>>> class MyContentHandler(ContentHandler):
+...     def __init__(self):
+...         self.a_amount = 0
+...         self.b_amount = 0
+...         self.text = None
+...
+...     def startElementNS(self, name, qname, attributes):
+...         uri, localname = name
+...         if localname == 'a':
+...             self.a_amount += 1
+...         if localname == 'b':
+...             self.b_amount += 1
+...
+...     def characters(self, data):
+...         self.text = data
+
>>> handler = MyContentHandler()
+>>> lxml.sax.saxify(tree, handler)
+
>>> handler.a_amount
+1
+>>> handler.b_amount
+1
+>>> handler.text
+'Text'
+
>>> from xml.dom.pulldom import SAX2DOM
+>>> handler = SAX2DOM()
+>>> lxml.sax.saxify(tree, handler)
+
document
>>> dom = handler.document
+>>> print(dom.firstChild.localName)
+a
+
lxml.etree
lxml.etree
>>> from lxml import etree
+
lxml.etree
try:
+  from lxml import etree
+  print("running with lxml.etree")
+except ImportError:
+  try:
+    # Python 2.5
+    import xml.etree.cElementTree as etree
+    print("running with cElementTree on Python 2.5+")
+  except ImportError:
+    try:
+      # Python 2.5
+      import xml.etree.ElementTree as etree
+      print("running with ElementTree on Python 2.5+")
+    except ImportError:
+      try:
+        # normal cElementTree install
+        import cElementTree as etree
+        print("running with cElementTree")
+      except ImportError:
+        try:
+          # normal ElementTree install
+          import elementtree.ElementTree as etree
+          print("running with ElementTree")
+        except ImportError:
+          print("Failed to import ElementTree from any known place")
+
lxml.etree
Element
Element
>>> root = etree.Element("root")
+
tag
>>> print(root.tag)
+root
+
append()
>>> root.append( etree.Element("child1") )
+
SubElement
Element
>>> child2 = etree.SubElement(root, "child2")
+>>> child3 = etree.SubElement(root, "child3")
+
>>> print(etree.tostring(root, pretty_print=True))
+<root>
+  <child1/>
+  <child2/>
+  <child3/>
+</root>
+
>>> child = root[0]
+>>> print(child.tag)
+child1
+
+>>> print(len(root))
+3
+
+>>> root.index(root[1]) # lxml.etree only!
+1
+
+>>> children = list(root)
+
+>>> for child in root:
+...     print(child.tag)
+child1
+child2
+child3
+
+>>> root.insert(0, etree.Element("child0"))
+>>> start = root[:1]
+>>> end   = root[-1:]
+
+>>> print(start[0].tag)
+child0
+>>> print(end[0].tag)
+child3
+
if root:   # this no longer works!
+    print("The root element has children")
+
len(element)
>>> print(etree.iselement(root))  # test if it's some kind of Element
+True
+>>> if len(root):                 # test if it has children
+...     print("The root element has children")
+The root element has children
+
>>> for child in root:
+...     print(child.tag)
+child0
+child1
+child2
+child3
+>>> root[0] = root[-1]  # this moves the element in lxml.etree!
+>>> for child in root:
+...     print(child.tag)
+child3
+child1
+child2
+
>>> l = [0, 1, 2, 3]
+>>> l[0] = l[-1]
+>>> l
+[3, 1, 2, 3]
+
lxml.etree
getparent()
>>> root is root[0].getparent()  # lxml.etree only!
+True
+
lxml.etree
copy
>>> from copy import deepcopy
+
+>>> element = etree.Element("neu")
+>>> element.append( deepcopy(root[1]) )
+
+>>> print(element[0].tag)
+child1
+>>> print([ c.tag for c in root ])
+['child3', 'child1', 'child2']
+
>>> root[0] is root[1].getprevious() # lxml.etree only!
+True
+>>> root[1] is root[0].getnext() # lxml.etree only!
+True
+
>>> root = etree.Element("root", interesting="totally")
+>>> etree.tostring(root)
+b'<root interesting="totally"/>'
+
>>> print(root.get("interesting"))
+totally
+
+>>> print(root.get("hello"))
+None
+>>> root.set("hello", "Huhu")
+>>> print(root.get("hello"))
+Huhu
+
+>>> etree.tostring(root)
+b'<root interesting="totally" hello="Huhu"/>'
+
+>>> sorted(root.keys())
+['hello', 'interesting']
+
+>>> for name, value in sorted(root.items()):
+...     print('%s = %r' % (name, value))
+hello = 'Huhu'
+interesting = 'totally'
+
attrib
>>> attributes = root.attrib
+
+>>> print(attributes["interesting"])
+totally
+>>> print(attributes.get("no-such-attribute"))
+None
+
+>>> attributes["hello"] = "Guten Tag"
+>>> print(attributes["hello"])
+Guten Tag
+>>> print(root.get("hello"))
+Guten Tag
+
attrib
attrib
attrib
>>> d = dict(root.attrib)
+>>> sorted(d.items())
+[('hello', 'Guten Tag'), ('interesting', 'totally')]
+
>>> root = etree.Element("root")
+>>> root.text = "TEXT"
+
+>>> print(root.text)
+TEXT
+
+>>> etree.tostring(root)
+b'<root>TEXT</root>'
+
<html><body>Hello<br/>World</body></html>
+
<br/>
tail
>>> html = etree.Element("html")
+>>> body = etree.SubElement(html, "body")
+>>> body.text = "TEXT"
+
+>>> etree.tostring(html)
+b'<html><body>TEXT</body></html>'
+
+>>> br = etree.SubElement(body, "br")
+>>> etree.tostring(html)
+b'<html><body>TEXT<br/></body></html>'
+
+>>> br.tail = "TAIL"
+>>> etree.tostring(html)
+b'<html><body>TEXT<br/>TAIL</body></html>'
+
.text
.tail
tostring()
with_tail
>>> etree.tostring(br)
+b'<br/>TAIL'
+>>> etree.tostring(br, with_tail=False) # lxml.etree only!
+b'<br/>'
+
text
tail
tostring()
method
>>> etree.tostring(html, method="text")
+b'TEXTTAIL'
+
>>> print(html.xpath("string()")) # lxml.etree only!
+TEXTTAIL
+>>> print(html.xpath("//text()")) # lxml.etree only!
+['TEXT', 'TAIL']
+
>>> build_text_list = etree.XPath("//text()") # lxml.etree only!
+>>> print(build_text_list(html))
+['TEXT', 'TAIL']
+
getparent()
>>> texts = build_text_list(html)
+>>> print(texts[0])
+TEXT
+>>> parent = texts[0].getparent()
+>>> print(parent.tag)
+body
+
+>>> print(texts[1])
+TAIL
+>>> print(texts[1].getparent().tag)
+br
+
>>> print(texts[0].is_text)
+True
+>>> print(texts[1].is_text)
+False
+>>> print(texts[1].is_tail)
+True
+
text()
string()
concat()
>>> stringify = etree.XPath("string()")
+>>> print(stringify(html))
+TEXTTAIL
+>>> print(stringify(html).getparent())
+None
+
>>> root = etree.Element("root")
+>>> etree.SubElement(root, "child").text = "Child 1"
+>>> etree.SubElement(root, "child").text = "Child 2"
+>>> etree.SubElement(root, "another").text = "Child 3"
+
+>>> print(etree.tostring(root, pretty_print=True))
+<root>
+  <child>Child 1</child>
+  <child>Child 2</child>
+  <another>Child 3</another>
+</root>
+
+>>> for element in root.iter():
+...     print("%s - %s" % (element.tag, element.text))
+root - None
+child - Child 1
+child - Child 2
+another - Child 3
+
iter()
>>> for element in root.iter("child"):
+...     print("%s - %s" % (element.tag, element.text))
+child - Child 1
+child - Child 2
+
+>>> for element in root.iter("another", "child"):
+...     print("%s - %s" % (element.tag, element.text))
+child - Child 1
+child - Child 2
+another - Child 3
+
Element
>>> root.append(etree.Entity("#234"))
+>>> root.append(etree.Comment("some comment"))
+
+>>> for element in root.iter():
+...     if isinstance(element.tag, basestring):  # or 'str' in Python 3
+...         print("%s - %s" % (element.tag, element.text))
+...     else:
+...         print("SPECIAL: %s - %s" % (element, element.text))
+root - None
+child - Child 1
+child - Child 2
+another - Child 3
+SPECIAL: &#234; - &#234;
+SPECIAL: <!--some comment--> - some comment
+
+>>> for element in root.iter(tag=etree.Element):
+...     print("%s - %s" % (element.tag, element.text))
+root - None
+child - Child 1
+child - Child 2
+another - Child 3
+
+>>> for element in root.iter(tag=etree.Entity):
+...     print(element.text)
+&#234;
+
"*"
Element
lxml.etree
tostring()
ElementTree.write()
pretty_print
encoding
>>> root = etree.XML('<root><a><b/></a></root>')
+
+>>> etree.tostring(root)
+b'<root><a><b/></a></root>'
+
+>>> print(etree.tostring(root, xml_declaration=True))
+<?xml version='1.0' encoding='ASCII'?>
+<root><a><b/></a></root>
+
+>>> print(etree.tostring(root, encoding='iso-8859-1'))
+<?xml version='1.0' encoding='iso-8859-1'?>
+<root><a><b/></a></root>
+
+>>> print(etree.tostring(root, pretty_print=True))
+<root>
+  <a>
+    <b/>
+  </a>
+</root>
+
method
>>> root = etree.XML(
+...    '<html><head/><body><p>Hello<br/>World</p></body></html>')
+
+>>> etree.tostring(root) # default: method = 'xml'
+b'<html><head/><body><p>Hello<br/>World</p></body></html>'
+
+>>> etree.tostring(root, method='xml') # same as above
+b'<html><head/><body><p>Hello<br/>World</p></body></html>'
+
+>>> etree.tostring(root, method='html')
+b'<html><head></head><body><p>Hello<br>World</p></body></html>'
+
+>>> print(etree.tostring(root, method='html', pretty_print=True))
+<html>
+<head></head>
+<body><p>Hello<br>World</p></body>
+</html>
+
+>>> etree.tostring(root, method='text')
+b'HelloWorld'
+
>>> br = next(root.iter('br'))  # get first result of iteration
+>>> br.tail = u'W\xf6rld'
+
+>>> etree.tostring(root, method='text')  # doctest: +ELLIPSIS
+Traceback (most recent call last):
+  ...
+UnicodeEncodeError: 'ascii' codec can't encode character u'\xf6' ...
+
+>>> etree.tostring(root, method='text', encoding="UTF-8")
+b'HelloW\xc3\xb6rld'
+
'unicode'
>>> etree.tostring(root, encoding='unicode', method='text')
+u'HelloW\xf6rld'
+
ElementTree
>>> root = etree.XML('''\
+... <?xml version="1.0"?>
+... <!DOCTYPE root SYSTEM "test" [ <!ENTITY tasty "parsnips"> ]>
+... <root>
+...   <a>&tasty;</a>
+... </root>
+... ''')
+
+>>> tree = etree.ElementTree(root)
+>>> print(tree.docinfo.xml_version)
+1.0
+>>> print(tree.docinfo.doctype)
+<!DOCTYPE root SYSTEM "test">
+
+>>> tree.docinfo.public_id = '-//W3C//DTD XHTML 1.0 Transitional//EN'
+>>> tree.docinfo.system_url = 'file://local.dtd'
+>>> print(tree.docinfo.doctype)
+<!DOCTYPE root PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "file://local.dtd">
+
ElementTree
parse()
ElementTree
Element
>>> print(etree.tostring(tree))  # lxml 1.3.4 and later
+<!DOCTYPE root PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "file://local.dtd" [
+<!ENTITY tasty "parsnips">
+]>
+<root>
+  <a>parsnips</a>
+</root>
+
>>> print(etree.tostring(tree.getroot()))
+<root>
+  <a>parsnips</a>
+</root>
+
lxml.etree
fromstring()
parse()
fromstring()
>>> some_xml_data = "<root>data</root>"
+
+>>> root = etree.fromstring(some_xml_data)
+>>> print(root.tag)
+root
+>>> etree.tostring(root)
+b'<root>data</root>'
+
XML()
fromstring()
>>> root = etree.XML("<root>data</root>")
+>>> print(root.tag)
+root
+>>> etree.tostring(root)
+b'<root>data</root>'
+
HTML()
>>> root = etree.HTML("<p>data</p>")
+>>> etree.tostring(root)
+b'<html><body><p>data</p></body></html>'
+
parse()
BytesIO
io
StringIO
StringIO
>>> from io import BytesIO
+>>> some_file_or_file_like_object = BytesIO(b"<root>data</root>")
+
+>>> tree = etree.parse(some_file_or_file_like_object)
+
+>>> etree.tostring(tree)
+b'<root>data</root>'
+
parse()
>>> root = tree.getroot()
+>>> print(root.tag)
+root
+>>> etree.tostring(root)
+b'<root>data</root>'
+
parse()
parse()
.read(byte_count)
urllib2
requests
lxml.etree
>>> parser = etree.XMLParser(remove_blank_text=True) # lxml.etree only!
+
>>> root = etree.XML("<root>  <a/>   <b>  </b>     </root>", parser)
+
+>>> etree.tostring(root)
+b'<root><a/><b>  </b></root>'
+
<b>
>>> for element in root.iter("*"):
+...     if element.text is not None and not element.text.strip():
+...         element.text = None
+
+>>> etree.tostring(root)
+b'<root><a/><b/></root>'
+
help(etree.XMLParser)
lxml.etree
read()
urllib
>>> class DataSource:
+...     data = [ b"<roo", b"t><", b"a/", b"><", b"/root>" ]
+...     def read(self, requested_size):
+...         try:
+...             return self.data.pop(0)
+...         except IndexError:
+...             return b''
+
+>>> tree = etree.parse(DataSource())
+
+>>> etree.tostring(tree)
+b'<root><a/></root>'
+
feed(data)
close()
>>> parser = etree.XMLParser()
+
+>>> parser.feed("<roo")
+>>> parser.feed("t><")
+>>> parser.feed("a/")
+>>> parser.feed("><")
+>>> parser.feed("/root>")
+
+>>> root = parser.close()
+
+>>> etree.tostring(root)
+b'<root><a/></root>'
+
feed()
close()
feed()
>>> parser.feed("<root/>")
+>>> root = parser.close()
+>>> etree.tostring(root)
+b'<root/>'
+
lxml.etree
iterparse
iterparse()
>>> some_file_like = BytesIO(b"<root><a>data</a></root>")
+
+>>> for event, element in etree.iterparse(some_file_like):
+...     print("%s, %4s, %s" % (event, element.tag, element.text))
+end,    a, data
+end, root, None
+
iterparse()
events
>>> some_file_like = BytesIO(b"<root><a>data</a></root>")
+
+>>> for event, element in etree.iterparse(some_file_like,
+...                                       events=("start", "end")):
+...     print("%5s, %4s, %s" % (event, element.tag, element.text))
+start, root, None
+start,    a, data
+  end,    a, data
+  end, root, None
+
start
end
.clear()
keep_tail=True
.clear()
>>> some_file_like = BytesIO(
+...     b"<root><a><b>data</b></a><a><b/></a></root>")
+
+>>> for event, element in etree.iterparse(some_file_like):
+...     if element.tag == 'b':
+...         print(element.text)
+...     elif element.tag == 'a':
+...         print("** cleaning up the subtree")
+...         element.clear(keep_tail=True)
+data
+** cleaning up the subtree
+None
+** cleaning up the subtree
+
iterparse()
lxml.etree
>>> xml_file = BytesIO(b'''\
+... <root>
+...   <a><b>ABC</b><c>abc</c></a>
+...   <a><b>MORE DATA</b><c>more data</c></a>
+...   <a><b>XYZ</b><c>xyz</c></a>
+... </root>''')
+
+>>> for _, element in etree.iterparse(xml_file, tag='a'):
+...     print('%s -- %s' % (element.findtext('b'), element[1].text))
+...     element.clear(keep_tail=True)
+ABC -- abc
+MORE DATA -- more data
+XYZ -- xyz
+
lxml.etree
>>> class ParserTarget:
+...     events = []
+...     close_count = 0
+...     def start(self, tag, attrib):
+...         self.events.append(("start", tag, attrib))
+...     def close(self):
+...         events, self.events = self.events, []
+...         self.close_count += 1
+...         return events
+
+>>> parser_target = ParserTarget()
+
+>>> parser = etree.XMLParser(target=parser_target)
+>>> events = etree.fromstring('<root test="true"/>', parser)
+
+>>> print(parser_target.close_count)
+1
+
+>>> for event in events:
+...     print('event: %s - tag: %s' % (event[0], event[1]))
+...     for attr, value in event[2].items():
+...         print(' * %s = %s' % (attr, value))
+event: start - tag: root
+ * test = true
+
.close()
>>> events = etree.fromstring('<root test="true"/>', parser)
+>>> print(parser_target.close_count)
+2
+>>> events = etree.fromstring('<root test="true"/>', parser)
+>>> print(parser_target.close_count)
+3
+>>> events = etree.fromstring('<root test="true"/>', parser)
+>>> print(parser_target.close_count)
+4
+
+>>> for event in events:
+...     print('event: %s - tag: %s' % (event[0], event[1]))
+...     for attr, value in event[2].items():
+...         print(' * %s = %s' % (attr, value))
+event: start - tag: root
+ * test = true
+
>>> xhtml = etree.Element("{http://www.w3.org/1999/xhtml}html")
+>>> body = etree.SubElement(xhtml, "{http://www.w3.org/1999/xhtml}body")
+>>> body.text = "Hello World"
+
+>>> print(etree.tostring(xhtml, pretty_print=True))
+<html:html xmlns:html="http://www.w3.org/1999/xhtml">
+  <html:body>Hello World</html:body>
+</html:html>
+
>>> XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml"
+>>> XHTML = "{%s}" % XHTML_NAMESPACE
+
+>>> NSMAP = {None : XHTML_NAMESPACE} # the default namespace (no prefix)
+
+>>> xhtml = etree.Element(XHTML + "html", nsmap=NSMAP) # lxml only!
+>>> body = etree.SubElement(xhtml, XHTML + "body")
+>>> body.text = "Hello World"
+
+>>> print(etree.tostring(xhtml, pretty_print=True))
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <body>Hello World</body>
+</html>
+
QName
>>> tag = etree.QName('http://www.w3.org/1999/xhtml', 'html')
+>>> print(tag.localname)
+html
+>>> print(tag.namespace)
+http://www.w3.org/1999/xhtml
+>>> print(tag.text)
+{http://www.w3.org/1999/xhtml}html
+
+>>> tag = etree.QName('{http://www.w3.org/1999/xhtml}html')
+>>> print(tag.localname)
+html
+>>> print(tag.namespace)
+http://www.w3.org/1999/xhtml
+
+>>> root = etree.Element('{http://www.w3.org/1999/xhtml}html')
+>>> tag = etree.QName(root)
+>>> print(tag.localname)
+html
+
+>>> tag = etree.QName(root, 'script')
+>>> print(tag.text)
+{http://www.w3.org/1999/xhtml}script
+>>> tag = etree.QName('{http://www.w3.org/1999/xhtml}html', 'script')
+>>> print(tag.text)
+{http://www.w3.org/1999/xhtml}script
+
.nsmap
>>> xhtml.nsmap
+{None: 'http://www.w3.org/1999/xhtml'}
+
>>> root = etree.Element('root', nsmap={'a': 'http://a.b/c'})
+>>> child = etree.SubElement(root, 'child',
+...                          nsmap={'b': 'http://b.c/d'})
+>>> len(root.nsmap)
+1
+>>> len(child.nsmap)
+2
+>>> child.nsmap['a']
+'http://a.b/c'
+>>> child.nsmap['b']
+'http://b.c/d'
+
lxml.etree
>>> body.set(XHTML + "bgcolor", "#CCFFAA")
+
+>>> print(etree.tostring(xhtml, pretty_print=True))
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <body xmlns:html="http://www.w3.org/1999/xhtml" html:bgcolor="#CCFFAA">Hello World</body>
+</html>
+
+>>> print(body.get("bgcolor"))
+None
+>>> body.get(XHTML + "bgcolor")
+'#CCFFAA'
+
>>> find_xhtml_body = etree.ETXPath(      # lxml only !
+...     "//{%s}body" % XHTML_NAMESPACE)
+>>> results = find_xhtml_body(xhtml)
+
+>>> print(results[0].tag)
+{http://www.w3.org/1999/xhtml}body
+
"*"
lxml.etree
>>> for el in xhtml.iter('*'): print(el.tag)   # any element
+{http://www.w3.org/1999/xhtml}html
+{http://www.w3.org/1999/xhtml}body
+>>> for el in xhtml.iter('{http://www.w3.org/1999/xhtml}*'): print(el.tag)
+{http://www.w3.org/1999/xhtml}html
+{http://www.w3.org/1999/xhtml}body
+>>> for el in xhtml.iter('{*}body'): print(el.tag)
+{http://www.w3.org/1999/xhtml}body
+
>>> [ el.tag for el in xhtml.iter('{http://www.w3.org/1999/xhtml}body') ]
+['{http://www.w3.org/1999/xhtml}body']
+>>> [ el.tag for el in xhtml.iter('body') ]
+[]
+>>> [ el.tag for el in xhtml.iter('{}body') ]
+[]
+>>> [ el.tag for el in xhtml.iter('{}*') ]
+[]
+
E-factory
>>> from lxml.builder import E
+
+>>> def CLASS(*args): # class is a reserved word in Python
+...     return {"class":' '.join(args)}
+
+>>> html = page = (
+...   E.html(       # create an Element called "html"
+...     E.head(
+...       E.title("This is a sample document")
+...     ),
+...     E.body(
+...       E.h1("Hello!", CLASS("title")),
+...       E.p("This is a paragraph with ", E.b("bold"), " text in it!"),
+...       E.p("This is another paragraph, with a", "\n      ",
+...         E.a("link", href="http://www.python.org"), "."),
+...       E.p("Here are some reserved characters: <spam&egg>."),
+...       etree.XML("<p>And finally an embedded XHTML fragment.</p>"),
+...     )
+...   )
+... )
+
+>>> print(etree.tostring(page, pretty_print=True))
+<html>
+  <head>
+    <title>This is a sample document</title>
+  </head>
+  <body>
+    <h1 class="title">Hello!</h1>
+    <p>This is a paragraph with <b>bold</b> text in it!</p>
+    <p>This is another paragraph, with a
+      <a href="http://www.python.org">link</a>.</p>
+    <p>Here are some reserved characters: &lt;spam&amp;egg&gt;.</p>
+    <p>And finally an embedded XHTML fragment.</p>
+  </body>
+</html>
+
>>> from lxml.builder import ElementMaker # lxml only !
+
+>>> E = ElementMaker(namespace="http://my.de/fault/namespace",
+...                  nsmap={'p' : "http://my.de/fault/namespace"})
+
+>>> DOC = E.doc
+>>> TITLE = E.title
+>>> SECTION = E.section
+>>> PAR = E.par
+
+>>> my_doc = DOC(
+...   TITLE("The dog and the hog"),
+...   SECTION(
+...     TITLE("The dog"),
+...     PAR("Once upon a time, ..."),
+...     PAR("And then ...")
+...   ),
+...   SECTION(
+...     TITLE("The hog"),
+...     PAR("Sooner or later ...")
+...   )
+... )
+
+>>> print(etree.tostring(my_doc, pretty_print=True))
+<p:doc xmlns:p="http://my.de/fault/namespace">
+  <p:title>The dog and the hog</p:title>
+  <p:section>
+    <p:title>The dog</p:title>
+    <p:par>Once upon a time, ...</p:par>
+    <p:par>And then ...</p:par>
+  </p:section>
+  <p:section>
+    <p:title>The hog</p:title>
+    <p:par>Sooner or later ...</p:par>
+  </p:section>
+</p:doc>
+
lxml.html.builder
{namespace}tag
lxml.etree
iterfind()
findall()
find()
findtext()
.text
>>> root = etree.XML("<root><a x='123'>aText<b/><c/><b/></a></root>")
+
>>> print(root.find("b"))
+None
+>>> print(root.find("a").tag)
+a
+
>>> print(root.find(".//b").tag)
+b
+>>> [ b.tag for b in root.iterfind(".//b") ]
+['b', 'b']
+
>>> print(root.findall(".//a[@x]")[0].tag)
+a
+>>> print(root.findall(".//a[@y]"))
+[]
+
>>> tree = etree.ElementTree(root)
+>>> a = root[0]
+>>> print(tree.getelementpath(a[0]))
+a/b[1]
+>>> print(tree.getelementpath(a[1]))
+a/c
+>>> print(tree.getelementpath(a[2]))
+a/b[2]
+>>> tree.find(tree.getelementpath(a[2])) == a[2]
+True
+
find()
.iter()
>>> print(root.find(".//b").tag)
+b
+>>> print(next(root.iterfind(".//b")).tag)
+b
+>>> print(next(root.iter("b")).tag)
+b
+
.find()
StopIteration
>>> from lxml import etree
+
>>> parser = etree.XMLParser(dtd_validation=True)
+
load_dtd
docinfo
internalDTD
externalDTD
attribute_defaults
>>> schema_root = etree.XML('''\
+...   <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+...     <xsd:element name="a" type="xsd:integer"/>
+...   </xsd:schema>
+... ''')
+>>> schema = etree.XMLSchema(schema_root)
+
+>>> parser = etree.XMLParser(schema = schema)
+>>> root = etree.fromstring("<a>5</a>", parser)
+
>>> root = etree.fromstring("<a>no int</a>", parser)  # doctest: +ELLIPSIS
+Traceback (most recent call last):
+lxml.etree.XMLSyntaxError: Element 'a': 'no int' is not a valid value of the atomic type 'xs:integer'...
+
DTD
DTD
>>> f = StringIO("<!ELEMENT b EMPTY>")
+>>> dtd = etree.DTD(f)
+
>>> root = etree.XML("<b/>")
+>>> print(dtd.validate(root))
+True
+
+>>> root = etree.XML("<b><a/></b>")
+>>> print(dtd.validate(root))
+False
+
>>> print(dtd.error_log.filter_from_errors()[0])
+<string>:1:0:ERROR:VALID:DTD_NOT_EMPTY: Element b was declared EMPTY this one has content
+
external_id
dtd = etree.DTD(external_id = "-//OASIS//DTD DocBook XML V4.2//EN")
+
iterelements
>>> dtd = etree.DTD(StringIO('<!ELEMENT a EMPTY><!ELEMENT b EMPTY>'))
+>>> for el in dtd.iterelements():
+...     print(el.name)
+a
+b
+
elements
>>> dtd = etree.DTD(StringIO('<!ELEMENT a EMPTY><!ELEMENT b EMPTY>'))
+>>> len(dtd.elements())
+2
+
name
type
content
iterattributes()
attributes()
content
left
right
name
name
None
type
occur
left
right
<!ELEMENT a (a|b)+>
>>> dtd = etree.DTD(StringIO('<!ELEMENT a (a|b)+>'))
+>>> content = dtd.elements()[0].content
+>>> content.type, content.occur, content.name
+('or', 'plus', None)
+
+>>> left, right = content.left, content.right
+>>> left.type, left.occur, left.name
+('element', 'once', 'a')
+>>> right.type, right.occur, right.name
+('element', 'once', 'b')
+
name
elemname
type
default
defaultValue
itervalues()
values()
iterentities
entities
+>>> dtd = etree.DTD(StringIO('<!ENTITY hurz "&#x40;">'))
+>>> entity = dtd.entities()[0]
+>>> entity.name, entity.orig, entity.content
+('hurz', '&#x40;', '@')
+
RelaxNG
>>> f = StringIO('''\
+... <element name="a" xmlns="http://relaxng.org/ns/structure/1.0">
+...  <zeroOrMore>
+...     <element name="b">
+...       <text />
+...     </element>
+...  </zeroOrMore>
+... </element>
+... ''')
+>>> relaxng_doc = etree.parse(f)
+>>> relaxng = etree.RelaxNG(relaxng_doc)
+
file
>>> valid = StringIO('<a><b></b></a>')
+>>> doc = etree.parse(valid)
+>>> relaxng.validate(doc)
+True
+
+>>> invalid = StringIO('<a><c></c></a>')
+>>> doc2 = etree.parse(invalid)
+>>> relaxng.validate(doc2)
+False
+
>>> invalid = StringIO('<a><c></c></a>')
+>>> doc2 = etree.parse(invalid)
+>>> if not relaxng(doc2):
+...     print("invalid!")
+invalid!
+
assert_
assertValid
>>> relaxng.assertValid(doc2)
+Traceback (most recent call last):
+  ...
+lxml.etree.DocumentInvalid: Did not expect element c there, line 1
+
+>>> relaxng.assert_(doc2)
+Traceback (most recent call last):
+  ...
+AssertionError: Did not expect element c there, line 1
+
>>> log = relaxng.error_log
+>>> print(log.last_error)
+<string>:1:0:ERROR:RELAXNGV:RELAXNG_ERR_ELEMWRONG: Did not expect element c there
+
>>> error = log.last_error
+>>> print(error.domain_name)
+RELAXNGV
+>>> print(error.type_name)
+RELAXNG_ERR_ELEMWRONG
+
>>> doc.relaxng(relaxng_doc)
+True
+>>> doc2.relaxng(relaxng_doc)
+False
+
>>> f = StringIO('''\
+... <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+... <xsd:element name="a" type="AType"/>
+... <xsd:complexType name="AType">
+...   <xsd:sequence>
+...     <xsd:element name="b" type="xsd:string" />
+...   </xsd:sequence>
+... </xsd:complexType>
+... </xsd:schema>
+... ''')
+>>> xmlschema_doc = etree.parse(f)
+>>> xmlschema = etree.XMLSchema(xmlschema_doc)
+
>>> valid = StringIO('<a><b></b></a>')
+>>> doc = etree.parse(valid)
+>>> xmlschema.validate(doc)
+True
+
+>>> invalid = StringIO('<a><c></c></a>')
+>>> doc2 = etree.parse(invalid)
+>>> xmlschema.validate(doc2)
+False
+
>>> invalid = StringIO('<a><c></c></a>')
+>>> doc2 = etree.parse(invalid)
+>>> if not xmlschema(doc2):
+...     print("invalid!")
+invalid!
+
assert_
assertValid
>>> xmlschema.assertValid(doc2)
+Traceback (most recent call last):
+  ...
+lxml.etree.DocumentInvalid: Element 'c': This element is not expected. Expected is ( b )., line 1
+
+>>> xmlschema.assert_(doc2)
+Traceback (most recent call last):
+  ...
+AssertionError: Element 'c': This element is not expected. Expected is ( b )., line 1
+
>>> log = xmlschema.error_log
+>>> error = log.last_error
+>>> print(error.domain_name)
+SCHEMASV
+>>> print(error.type_name)
+SCHEMAV_ELEMENT_CONTENT
+
+<string>:1:ERROR::SCHEMAV_ELEMENT_CONTENT: Element 'c': This element is not expected. Expected is ( b ).
+
>>> doc.xmlschema(xmlschema_doc)
+True
+>>> doc2.xmlschema(xmlschema_doc)
+False
+
>>> from lxml import isoschematron
+>>> f = StringIO('''\
+... <schema xmlns="http://purl.oclc.org/dsdl/schematron" >
+...   <pattern id="sum_equals_100_percent">
+...     <title>Sum equals 100%.</title>
+...     <rule context="Total">
+...       <assert test="sum(//Percent)=100">Sum is not 100%.</assert>
+...     </rule>
+...   </pattern>
+... </schema>
+... ''')
+
+>>> sct_doc = etree.parse(f)
+>>> schematron = isoschematron.Schematron(sct_doc)
+
>>> valid = StringIO('''\
+... <Total>
+...   <Percent>20</Percent>
+...   <Percent>30</Percent>
+...   <Percent>50</Percent>
+... </Total>
+... ''')
+
+>>> doc = etree.parse(valid)
+>>> schematron.validate(doc)
+True
+
+>>> etree.SubElement(doc.getroot(), "Percent").text = "10"
+
+>>> schematron.validate(doc)
+False
+
>>> is_valid = isoschematron.Schematron(sct_doc)
+
+>>> if not is_valid(doc):
+...     print("invalid!")
+invalid!
+
include
expand
include_params
expand_params
compile_params
phase
compile_params
store_schematron
schematron
store_xslt
validator_xslt
store_report
validation_report
phase
>>> f = StringIO('''\
+... <schema xmlns="http://purl.oclc.org/dsdl/schematron" >
+...   <phase id="phase.sum_check">
+...     <active pattern="sum_equals_100_percent"/>
+...   </phase>
+...   <phase id="phase.entries_check">
+...     <active pattern="all_positive"/>
+...   </phase>
+...   <pattern id="sum_equals_100_percent">
+...     <title>Sum equals 100%.</title>
+...     <rule context="Total">
+...       <assert test="sum(//Percent)=100">Sum is not 100%.</assert>
+...     </rule>
+...   </pattern>
+...   <pattern id="all_positive">
+...     <title>All entries must be positive.</title>
+...     <rule context="Percent">
+...       <assert test="number(.)>0">Number (<value-of select="."/>) not positive</assert>
+...     </rule>
+...   </pattern>
+... </schema>
+... ''')
+
+>>> sct_doc = etree.parse(f)
+>>> schematron = isoschematron.Schematron(sct_doc)
+
+>>> valid = StringIO('''\
+... <Total>
+...   <Percent>20</Percent>
+...   <Percent>30</Percent>
+...   <Percent>50</Percent>
+... </Total>
+... ''')
+
+>>> doc = etree.parse(valid)
+>>> schematron.validate(doc)
+True
+
+>>> invalid_positive = StringIO('''\
+... <Total>
+...   <Percent>0</Percent>
+...   <Percent>50</Percent>
+...   <Percent>50</Percent>
+... </Total>
+... ''')
+
+>>> doc = etree.parse(invalid_positive)
+
+>>> schematron.validate(doc)
+False
+
>>> selective = isoschematron.Schematron(sct_doc, phase="phase.sum_check")
+>>> selective.validate(doc)
+True
+
>>> f = StringIO('''\
+... <schema xmlns="http://www.ascc.net/xml/schematron" >
+...   <pattern name="Sum equals 100%.">
+...     <rule context="Total">
+...       <assert test="sum(//Percent)=100">Sum is not 100%.</assert>
+...     </rule>
+...   </pattern>
+... </schema>
+... ''')
+
+>>> sct_doc = etree.parse(f)
+>>> schematron = etree.Schematron(sct_doc)
+
>>> valid = StringIO('''\
+... <Total>
+...   <Percent>20</Percent>
+...   <Percent>30</Percent>
+...   <Percent>50</Percent>
+... </Total>
+... ''')
+
+>>> doc = etree.parse(valid)
+>>> schematron.validate(doc)
+True
+
+>>> etree.SubElement(doc.getroot(), "Percent").text = "10"
+
+>>> schematron.validate(doc)
+False
+
>>> is_valid = etree.Schematron(sct_doc)
+
+>>> if not is_valid(doc):
+...     print("invalid!")
+invalid!
+
xpath()
XPath
XPathEvaluator
ETXPath
xslt()
>>> from lxml import etree
+
xpath()
XPath
XPathEvaluator
xpath()
xpath()
>>> f = StringIO('<foo><bar></bar></foo>')
+>>> tree = etree.parse(f)
+
+>>> r = tree.xpath('/foo/bar')
+>>> len(r)
+1
+>>> r[0].tag
+'bar'
+
+>>> r = tree.xpath('bar')
+>>> r[0].tag
+'bar'
+
xpath()
>>> root = tree.getroot()
+>>> r = root.xpath('bar')
+>>> r[0].tag
+'bar'
+
+>>> bar = root[0]
+>>> r = bar.xpath('/foo/bar')
+>>> r[0].tag
+'bar'
+
+>>> tree = bar.getroottree()
+>>> r = tree.xpath('/foo/bar')
+>>> r[0].tag
+'bar'
+
xpath()
>>> expr = "//*[local-name() = $name]"
+
+>>> print(root.xpath(expr, name = "foo")[0].tag)
+foo
+
+>>> print(root.xpath(expr, name = "bar")[0].tag)
+bar
+
+>>> print(root.xpath("$text", text = "Hello World!"))
+Hello World!
+
namespaces
>>> f = StringIO('''\
+... <a:foo xmlns:a="http://codespeak.net/ns/test1"
+...        xmlns:b="http://codespeak.net/ns/test2">
+...    <b:bar>Text</b:bar>
+... </a:foo>
+... ''')
+>>> doc = etree.parse(f)
+
+>>> r = doc.xpath('/x:foo/b:bar',
+...               namespaces={'x': 'http://codespeak.net/ns/test1',
+...                           'b': 'http://codespeak.net/ns/test2'})
+>>> len(r)
+1
+>>> r[0].tag
+'{http://codespeak.net/ns/test2}bar'
+>>> r[0].text
+'Text'
+
extensions
(prefix, URI)
getparent()
result.getparent()
//foo/@attribute
foo
text()
//text()
is_text
is_tail
is_attribute
getparent()
string()
concat()
getparent()
smart_strings
>>> root = etree.XML("<root><a>TEXT</a></root>")
+
+>>> find_text = etree.XPath("//text()")
+>>> text = find_text(root)[0]
+>>> print(text)
+TEXT
+>>> print(text.getparent().text)
+TEXT
+
+>>> find_text = etree.XPath("//text()", smart_strings=False)
+>>> text = find_text(root)[0]
+>>> print(text)
+TEXT
+>>> hasattr(text, 'getparent')
+False
+
getpath(element)
>>> a  = etree.Element("a")
+>>> b  = etree.SubElement(a, "b")
+>>> c  = etree.SubElement(a, "c")
+>>> d1 = etree.SubElement(c, "d")
+>>> d2 = etree.SubElement(c, "d")
+
+>>> tree = etree.ElementTree(c)
+>>> print(tree.getpath(d2))
+/c/d[2]
+>>> tree.xpath(tree.getpath(d2)) == [d2]
+True
+
XPath
XPath
>>> root = etree.XML("<root><a><b/></a><b/></root>")
+
+>>> find = etree.XPath("//b")
+>>> print(find(root)[0].tag)
+b
+
xpath()
xpath()
XPath
>>> count_elements = etree.XPath("count(//*[local-name() = $name])")
+
+>>> print(count_elements(root, name = "a"))
+1.0
+>>> print(count_elements(root, name = "b"))
+2.0
+
>>> root = etree.XML("<root xmlns='NS'><a><b/></a><b/></root>")
+
+>>> find = etree.XPath("//n:b", namespaces={'n':'NS'})
+>>> print(find(root)[0].tag)
+{NS}b
+
XPath
>>> regexpNS = "http://exslt.org/regular-expressions"
+>>> find = etree.XPath("//*[re:test(., '^abc$', 'i')]",
+...                    namespaces={'re':regexpNS})
+
+>>> root = etree.XML("<root><a>aB</a><b>aBc</b></root>")
+>>> print(find(root)[0].text)
+aBc
+
regexp
XPathEvaluator
XPathDocumentEvaluator
XPathElementEvaluator
>>> root = etree.XML("<root><a><b/></a><b/></root>")
+>>> xpatheval = etree.XPathEvaluator(root)
+
+>>> print(isinstance(xpatheval, etree.XPathElementEvaluator))
+True
+
+>>> print(xpatheval("//b")[0].tag)
+b
+
ETXPath
find*()
{ns}name
ETXPath
XPath
>>> root = etree.XML("<root xmlns='ns'><a><b/></a><b/></root>")
+
+>>> find = etree.XPath("//p:b", namespaces={'p' : 'ns'})
+>>> print(find(root)[0].tag)
+{ns}b
+
ETXPath
>>> find = etree.ETXPath("//{ns}b")
+>>> print(find(root)[0].tag)
+{ns}b
+
>>> find = etree.XPath("\\")
+Traceback (most recent call last):
+  ...
+lxml.etree.XPathSyntaxError: Invalid expression
+
>>> find = etree.XPath("//*[1.1.1]")
+Traceback (most recent call last):
+  ...
+lxml.etree.XPathSyntaxError: Invalid predicate
+
>>> find = etree.XPath("//ns:a")
+>>> find(root)
+Traceback (most recent call last):
+  ...
+lxml.etree.XPathEvalError: Undefined namespace prefix
+
XPath
xpath()
>>> root = etree.Element("test")
+>>> find = root.xpath("//*[1.1.1]")
+Traceback (most recent call last):
+  ...
+lxml.etree.XPathEvalError: Invalid predicate
+
+>>> find = root.xpath("//ns:a")
+Traceback (most recent call last):
+  ...
+lxml.etree.XPathEvalError: Undefined namespace prefix
+
+>>> find = root.xpath("\\")
+Traceback (most recent call last):
+  ...
+lxml.etree.XPathEvalError: Invalid expression
+
XPathSyntaxError
XPathError
>>> xslt_root = etree.XML('''\
+... <xsl:stylesheet version="1.0"
+...     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+...     <xsl:template match="/">
+...         <foo><xsl:value-of select="/a/b/text()" /></foo>
+...     </xsl:template>
+... </xsl:stylesheet>''')
+>>> transform = etree.XSLT(xslt_root)
+
>>> f = StringIO('<a><b>Text</b></a>')
+>>> doc = etree.parse(f)
+>>> result_tree = transform(doc)
+
>>> root = etree.XML('<a><b>Text</b></a>')
+>>> result = transform(root)
+
+>>> result.getroot().text
+'Text'
+
>>> str(result)
+'<?xml version="1.0"?>\n<foo>Text</foo>\n'
+
xsl:output
UTF-8
unicode()
>>> unicode(result)
+u'<?xml version="1.0"?>\n<foo>Text</foo>\n'
+
>>> xslt_tree = etree.XML('''\
+... <xsl:stylesheet version="1.0"
+...     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+...     <xsl:output encoding="UCS4"/>
+...     <xsl:template match="/">
+...         <foo><xsl:value-of select="/a/b/text()" /></foo>
+...     </xsl:template>
+... </xsl:stylesheet>''')
+>>> transform = etree.XSLT(xslt_tree)
+
+>>> result = transform(doc)
+>>> unicode(result)
+Traceback (most recent call last):
+  ...
+LookupError: unknown encoding: UCS4
+
.write()
ElementTree
.write_output()
<xsl:output>
>>> xslt_root = etree.XML('''\
+... <xsl:stylesheet version="1.0"
+...     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+...     <xsl:output method="text" encoding="utf8" />
+...     <xsl:template match="/">
+...         <foo><xsl:value-of select="/a/b/text()" /></foo>
+...     </xsl:template>
+... </xsl:stylesheet>''')
+>>> transform = etree.XSLT(xslt_root)
+
+>>> result = transform(doc)
+>>> result.write_output("output.txt.gz", compression=9)    # doctest: +SKIP
+
+>>> from io import BytesIO
+>>> out = BytesIO()
+>>> result.write_output(out)
+>>> data = out.getvalue()
+>>> b'Text' in data
+True
+
>>> xslt_tree = etree.XML('''\
+... <xsl:stylesheet version="1.0"
+...     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+...     <xsl:param name="a" />
+...     <xsl:template match="/">
+...         <foo><xsl:value-of select="$a" /></foo>
+...     </xsl:template>
+... </xsl:stylesheet>''')
+>>> transform = etree.XSLT(xslt_tree)
+>>> doc_root = etree.XML('<a><b>Text</b></a>')
+
>>> result = transform(doc_root, a="5")
+>>> str(result)
+'<?xml version="1.0"?>\n<foo>5</foo>\n'
+
>>> result = transform(doc_root, a="/a/b/text()")
+>>> str(result)
+'<?xml version="1.0"?>\n<foo>Text</foo>\n'
+
>>> result = transform(doc_root, a=etree.XPath("/a/b/text()"))
+>>> str(result)
+'<?xml version="1.0"?>\n<foo>Text</foo>\n'
+
>>> result = transform(doc_root, a="'A'")
+>>> str(result)
+'<?xml version="1.0"?>\n<foo>A</foo>\n'
+
.strparam()
>>> plain_string_value = etree.XSLT.strparam(
+...                          """ It's "Monty Python" """)
+>>> result = transform(doc_root, a=plain_string_value)
+>>> str(result)
+'<?xml version="1.0"?>\n<foo> It\'s "Monty Python" </foo>\n'
+
>>> transform = etree.XSLT(etree.XML('''\
+... <xsl:stylesheet version="1.0"
+...     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+...     <xsl:param name="non-python-identifier" />
+...     <xsl:template match="/">
+...         <foo><xsl:value-of select="$non-python-identifier" /></foo>
+...     </xsl:template>
+... </xsl:stylesheet>'''))
+
+>>> result = transform(doc_root, **{'non-python-identifier': '5'})
+>>> str(result)
+'<?xml version="1.0"?>\n<foo>5</foo>\n'
+
XSLT
>>> xslt_root = etree.XML('''\
+... <xsl:stylesheet version="1.0"
+...     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+...     <xsl:template match="/">
+...         <xsl:message terminate="no">STARTING</xsl:message>
+...         <foo><xsl:value-of select="/a/b/text()" /></foo>
+...         <xsl:message terminate="no">DONE</xsl:message>
+...     </xsl:template>
+... </xsl:stylesheet>''')
+>>> transform = etree.XSLT(xslt_root)
+
+>>> doc_root = etree.XML('<a><b>Text</b></a>')
+>>> result = transform(doc_root)
+>>> str(result)
+'<?xml version="1.0"?>\n<foo>Text</foo>\n'
+
+>>> print(transform.error_log)
+<string>:0:0:ERROR:XSLT:ERR_OK: STARTING
+<string>:0:0:ERROR:XSLT:ERR_OK: DONE
+
+>>> for entry in transform.error_log:
+...     print('message from line %s, col %s: %s' % (
+...                entry.line, entry.column, entry.message))
+...     print('domain: %s (%d)' % (entry.domain_name, entry.domain))
+...     print('type: %s (%d)' % (entry.type_name, entry.type))
+...     print('level: %s (%d)' % (entry.level_name, entry.level))
+...     print('filename: %s' % entry.filename)
+message from line 0, col 0: STARTING
+domain: XSLT (22)
+type: ERR_OK (0)
+level: ERROR (2)
+filename: <string>
+message from line 0, col 0: DONE
+domain: XSLT (22)
+type: ERR_OK (0)
+level: ERROR (2)
+filename: <string>
+
libxslt
xslt()
>>> result = doc.xslt(xslt_tree, a="'A'")
+>>> str(result)
+'<?xml version="1.0"?>\n<foo>A</foo>\n'
+
>>> transform = etree.XSLT(xslt_tree)
+>>> result = transform(doc, a="'A'")
+>>> str(result)
+'<?xml version="1.0"?>\n<foo>A</foo>\n'
+
partial()
functools
XPath()
XSLT()
profile_run
>>> result = transform(doc, a="/a/b/text()", profile_run=True)
+>>> profile = result.xslt_profile
+
xslt_profile
<profile>
+  <template rank="1" match="/" name="" mode="" calls="1" time="1" average="1"/>
+</profile>
+
>>> del result.xslt_profile
+
{...}
>>> tag = "{http://www.w3.org/the/namespace}tagname"
+>>> element = etree.Element(tag)
+
.text
.tail
>>> div = html.fragment_fromstring(
+...     "<div><p>a paragraph<br>split in two</p> parts</div>")
+>>> p = div[0]
+>>> br = p[0]
+
+>>> p.text
+'a paragraph'
+>>> br.text
+>>> br.tail
+'split in two'
+>>> p.tail
+' parts'
+
.get()
.set()
>>> root = etree.fromstring(
+...     '<root a="the value" b="of an" c="attribute"/>')
+
+>>> root.get('a')
+'the value'
+
+>>> root.set('a', "THE value")
+>>> root.get('a')
+'THE value'
+
.attrib
>>> d = root.attrib
+
+>>> list(sorted(d.keys()))
+['a', 'b', 'c']
+>>> list(sorted(d.values()))
+['THE value', 'attribute', 'of an']
+
>>> root = etree.fromstring(
+...   "<root> <a><b/><b/></a> <c><d/><e><f/></e><g/></c> </root>")
+
+>>> print([child.tag for child in root])   # children
+['a', 'c']
+
+>>> print([el.tag for el in root.iter()])  # self and descendants
+['root', 'a', 'b', 'b', 'c', 'd', 'e', 'f', 'g']
+
+>>> print([el.tag for el in root.iterdescendants()])
+['a', 'b', 'b', 'c', 'd', 'e', 'f', 'g']
+
+
+>>> def iter_breadth_first(root):
+...     bfs_queue = collections.deque([root])
+...     while bfs_queue:
+...         el = bfs_queue.popleft()  # pop next element
+...         bfs_queue.extend(el)      # append its children
+...         yield el
+
+>>> print([el.tag for el in iter_breadth_first(root)])
+['root', 'a', 'c', 'b', 'b', 'd', 'e', 'g', 'f']
+
>>> root = etree.fromstring(
+...   "<root> <a><b/><b/></a> <c><d/><e><f/></e><g/></c> </root>")
+
+>>> tree_walker = etree.iterwalk(root, events=('start', 'end'))
+
+>>> for (event, element) in tree_walker:
+...     print("%s (%s)" % (element.tag, event))
+root (start)
+a (start)
+b (start)
+b (end)
+b (start)
+b (end)
+a (end)
+c (start)
+d (start)
+d (end)
+e (start)
+f (start)
+f (end)
+e (end)
+g (start)
+g (end)
+c (end)
+root (end)
+
<root>
+  <speech class='dialog'><p>So be it!</p></speech>
+  <p>stuff</p>
+</root>
+
>>> find_paragraphs = etree.XPath("//p")
+>>> paragraphs = find_paragraphs(xml_tree)
+
+>>> print([ p.text for p in paragraphs ])
+['So be it!', 'stuff']
+
>>> find_dialogs = cssselect.CSSSelector("speech.dialog p")
+>>> paragraphs = find_dialogs(xml_tree)
+
+>>> print([ p.text for p in paragraphs ])
+['So be it!']
+
fromstring(xml_data)
parse(filename)
parse(url)
parse(f)
f = open(filename, 'rb')
parse(f)
f.read(size)
parser.feed(xml_chunk)
result = parser.close()
fromstring()
>>> root_element = etree.fromstring(some_xml_data)
+
fromstring()
>>> parser = etree.HTMLParser(remove_comments=True)
+>>> root_element = etree.fromstring(some_html_data, parser)
+
XML()
HTML()
>>> root_element = etree.XML("<root><child/></root>")
+>>> root_element = etree.HTML("<p>some<br>paragraph</p>")
+
parse()
fromstring()
iterparse()
(start/end, element)
parse()
fromstring()
target
iterparse()
feed
entry
entry
author
link
summary
content
>>> from lxml.builder import ElementMaker
+>>> A = ElementMaker(namespace="http://www.w3.org/2005/Atom",
+...                  nsmap={None : "http://www.w3.org/2005/Atom"})
+
>>> atom = A.feed(
+...   A.author( A.name("Stefan Behnel") ),
+...   A.entry(
+...     A.title("News from lxml"),
+...     A.link(href="http://codespeak.net/lxml/"),
+...     A.summary("See what's <b>fun</b> about lxml...",
+...               type="html"),
+...   )
+... )
+
>>> from lxml.etree import tostring
+>>> print( tostring(atom, pretty_print=True) )
+
>>> atom = A.feed(
+...   A.author( A.name("Stefan Behnel") ),
+...   A.entry(
+...     A.title("News from lxml"),
+...     A.link(href="http://codespeak.net/lxml/"),
+...     A.summary("See what's <b>fun</b> about lxml...",
+...               type="html"),
+...   )
+... )
+
<feed xmlns="http://www.w3.org/2005/Atom">
+  <author>
+    <name>Stefan Behnel</name>
+  </author>
+  <entry>
+    <title>News from lxml</title>
+    <link href="http://codespeak.net/lxml/"/>
+    <summary type="html">See what's &lt;b&gt;fun&lt;/b&gt;
+                         about lxml...</summary>
+  </entry>
+</feed>
+
>>> atom = A.feed(
+...   A.author( A.name("Stefan Behnel") ),
+...   A.entry(
+...     A.titel("News from lxml"),
+...     A.link(href="http://codespeak.net/lxml/"),
+...     A.summary("See what's <b>fun</b> about lxml...",
+...               type="html"),
+...   )
+... )
+
<feed xmlns="http://www.w3.org/2005/Atom">
+  <author>
+    <name>Stefan Behnel</name>
+  </author>
+  <entry>
+    <titel>News from lxml</titel>
+    <link href="http://codespeak.net/lxml/"/>
+    <summary type="html">See what's &lt;b&gt;fun&lt;/b&gt;
+                         about lxml...</summary>
+  </entry>
+</feed>
+
# atomgen.py
+
+from lxml import etree
+from lxml.builder import ElementMaker
+
+ATOM_NAMESPACE = "http://www.w3.org/2005/Atom"
+
+A = ElementMaker(namespace=ATOM_NAMESPACE,
+                 nsmap={None : ATOM_NAMESPACE})
+
+feed = A.feed
+entry = A.entry
+title = A.title
+# ... and so on and so forth ...
+
+
+# plus a little validation function: isvalid()
+isvalid = etree.RelaxNG(file="atom.rng")
+
>>> import atomgen as A
+
+>>> atom = A.feed(
+...   A.author( A.name("Stefan Behnel") ),
+...   A.entry(
+...     A.link(href="http://codespeak.net/lxml/"),
+...     A.title("News from lxml"),
+...     A.summary("See what's <b>fun</b> about lxml...",
+...               type="html"),
+...   )
+... )
+
+>>> A.isvalid(atom) # ok, forgot the ID's => invalid XML ...
+False
+
+>>> title = A.titel("News from lxml")
+Traceback (most recent call last):
+  ...
+AttributeError: 'module' object has no attribute 'titel'
+
>>> import lxml.html.builder as h
+
+>>> html_fragment = h.DIV(
+...   "this is some\n",
+...   h.A("HTML", href="http://w3.org/MarkUp/"),
+...   "\ncontent")
+
>>> serialised_html = etree.tostring(html_fragment, method="html")
+
+>>> summary = A.summary(serialised_html, type="html")
+
>>> print(etree.tostring(summary))
+<summary xmlns="http://www.w3.org/2005/Atom" type="html">
+   &lt;div&gt;this is some
+   &lt;a href="http://w3.org/MarkUp/"&gt;HTML&lt;/a&gt;
+   content&lt;/div&gt;
+</summary>
+
>>> from copy import deepcopy
+>>> xhtml_fragment = deepcopy(html_fragment)
+
+>>> from lxml.html import html_to_xhtml
+>>> html_to_xhtml(xhtml_fragment)
+
+>>> summary = A.summary(xhtml_fragment, type="xhtml")
+
>>> print(etree.tostring(summary, pretty_print=True))
+<summary xmlns="http://www.w3.org/2005/Atom" type="xhtml">
+  <html:div xmlns:html="http://www.w3.org/1999/xhtml">this is some
+  <html:a href="http://w3.org/MarkUp/">HTML</html:a>
+  content</html:div>
+</summary>
+
>>> class HonkElement(etree.ElementBase):
+...    @property
+...    def honking(self):
+...       return self.get('honking') == 'true'
+
>>> lookup = etree.ElementDefaultClassLookup(
+...                             element=HonkElement)
+
+>>> parser = etree.XMLParser()
+>>> parser.set_element_class_lookup(lookup)
+
>>> root = etree.XML('<root><honk honking="true"/></root>',
+...                  parser)
+
+>>> root.honking
+False
+>>> root[0].honking
+True
+
ElementDefaultClassLookup()
CustomElementClassLookup()
ElementNamespaceClassLookup()
id
class
AttributeBasedElementClassLookup()
PythonElementClassLookup()
# atom.py
+
+ATOM_NAMESPACE = "http://www.w3.org/2005/Atom"
+_ATOM_NS = "{%s}" % ATOM_NAMESPACE
+
+class FeedElement(etree.ElementBase):
+    @property
+    def entries(self):
+       return self.findall(_ATOM_NS + "entry")
+
title
class FeedElement(etree.ElementBase):
+    # ...
+    @property
+    def title(self):
+        "return the title or None"
+        return self.find("title")
+
>>> from lxml import objectify
+
+>>> feed = objectify.parse("atom-example.xml")
+>>> print(feed.title)
+Example Feed
+
+>>> print([entry.title for entry in feed.entry])
+['Atom-Powered Robots Run Amok']
+
+>>> print(feed.entry[0].title)
+Atom-Powered Robots Run Amok
+
from itertools import chain
+
+class FeedElement(objectify.ObjectifiedElement):
+
+    def addIDs(self):
+        "initialise the IDs of feed and entries"
+
+        for element in chain([self], self.entry):
+            if element.find(_ATOM_NS + "id") is None:
+                id = etree.SubElement(self, _ATOM_NS + "id")
+                id.text = make_guid()
+
# ...
+_atom_lookup = etree.ElementNamespaceClassLookup(
+                  objectify.ObjectifyElementClassLookup())
+
+# map the classes to tag names
+ns = _atom_lookup.get_namespace(ATOM_NAMESPACE)
+ns["feed"]  = FeedElement
+ns["entry"] = EntryElement
+# ... and so on
+# or use ns.update(vars()) with appropriate class names
+
+# create a parser that does some whitespace cleanup
+atom_parser = etree.XMLParser(remove_blank_text=True)
+
+# make it use our Atom classes
+atom_parser.set_element_class_lookup(_atom_lookup)
+
+# and help users in using our parser setup
+def parse(input):
+    return etree.parse(input, atom_parser)
+
>>> import atom
+>>> feed = atom.parse("ep2008/atom-example.xml").getroot()
+
+>>> print(len(feed.entry))
+1
+>>> print([entry.title for entry in feed.entry])
+['Atom-Powered Robots Run Amok']
+
+>>> link_tag = "{%s}link" % atom.ATOM_NAMESPACE
+>>> print([link.get("href") for link in feed.iter(link_tag)])
+['http://example.org/', 'http://example.org/2003/12/13/atom03']
+

Label	Highlighted when...	Links to...
[Parent]	(never highlighted)	the parent of the current package
[Package]	viewing a package	the package containing the current object +
[Module]	viewing a module	the module containing the current object +
[Class]	viewing a class	the class containing the current object
[Trees]	viewing the trees page	the trees page
[Index]	viewing the index page	the index page
[Help]	viewing the help page	the help page

+ Project Contents ...	+ API Documentation Frame +
+ Module Contents ... +

lxml FAQ - Frequently Asked Questions

General Questions

Is there a tutorial?

Where can I find more documentation about lxml?

What standards does lxml implement?

Who uses lxml?

What is the difference between lxml.etree and lxml.objectify?

How can I make my application run faster?

What about that trailing text on serialised Elements?

How can I find out if an Element is a comment or PI?

How can I map an XML tree into a dict of dicts?

Why does lxml sometimes return 'str' values for text in Python 2?

Why do I get XInclude or DTD lookup failures on some systems but not on others?

How do namespaces work in lxml?

Installation

Which version of libxml2 and libxslt should I use or require?

Where are the binary builds?

Why do I get errors about missing UCS4 symbols when installing lxml?

My C compiler crashes on installation

Contributing

Why is lxml not written in Python?

How can I contribute?

Bugs

My application crashes!

My application crashes on MacOS-X!

I think I have found a bug in lxml. What should I do?

How do I know a bug is really in lxml and not in libxml2?

Threading

Can I use threads to concurrently access the lxml API?

Does my program run faster if I use threads?

Would my single-threaded program run faster if I turned off threading?

Why can't I reuse XSLT stylesheets in other threads?

My program crashes when run with mod_python/Pyro/Zope/Plone/...

Parsing and Serialisation

Why doesn't the pretty_print option reformat my XML output?

Why can't lxml parse my XML from unicode strings?

Can lxml parse from file objects opened in unicode/text mode?

What is the difference between str(xslt(doc)) and xslt(doc).write() ?

Why can't I just delete parents or clear the root node in iterparse()?

How do I output null characters in XML text?

Is lxml vulnerable to XML bombs?

How do I use lxml safely as a web-service endpoint?

How can I sort the attributes?

XPath and Document Traversal

What are the findall() and xpath() methods on Element(Tree)?

Why doesn't findall() support full XPath expressions?

How can I find out which namespace prefixes are used in a document?

How can I specify a default namespace for XPath expressions?

APIs specific to lxml.etree

lxml.etree

Other Element APIs

Trees and Documents

Iteration

Error handling on exceptions

Error logging

Serialisation

C14N

Pretty printing

XML declaration

Incremental XML generation

CDATA

XInclude and ElementInclude

Type ABCMeta

__instancecheck__(cls, + instance) +

__new__(mcls, + name, + bases, + namespace) + Static Method +

__subclasscheck__(cls, + subclass) +

Class Hierarchy

Class SelectorError

Class SelectorSyntaxError

Class ExpressionError

Class XPathExpr

__init__(self, + path='', + element='*', + condition='', + star_prefix=False) + (Constructor) +

__repr__(self) + (Representation operator) +

__str__(self) + (Informal representation operator) +

Class AssertionError

__init__(...) + (Constructor) +

__new__(T, + S, + ...) +

API Documentation

Object Documentation

Project Documentation

Why doesn't the `pretty_print` option reformat my XML output?

What are the `findall()` and `xpath()` methods on Element(Tree)?

Why doesn't `findall()` support full XPath expressions?

instancecheck(cls, + instance) +

new(mcls, + name, + bases, + namespace) +
Static Method +

subclasscheck(cls, + subclass) +

init(self, + path=`''`, + element=`''`, + condition=`''`, + star_prefix=False) +
(Constructor)* +

repr(self) +
(Representation operator) +

str(self) +
(Informal representation operator) +

init(...) +
(Constructor) +

new(T, + S, + ...) +

init(self, + typemap=None, + namespace=None, + nsmap=None, + makeelement=None) +
(Constructor) +

getattribute(...) +