lxml.etree module

The lxml.etree module implements the extended ElementTree API for XML.

exception lxml.etree.C14NError

Bases: LxmlError

Error during C14N serialisation.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.DTDError

Bases: LxmlError

Base class for DTD errors.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.DTDParseError

Bases: DTDError

Error while parsing a DTD.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.DTDValidateError

Bases: DTDError

Error while validating an XML document with a DTD.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.DocumentInvalid

Bases: LxmlError

Validation error.

Raised by all document validators when their assertValid(tree) method fails.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.Error

Bases: Exception

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.LxmlError

Bases: Error

Main exception base class for lxml. All other exceptions inherit from this one.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.LxmlRegistryError

Bases: LxmlError

Base class of lxml registry errors.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.LxmlSyntaxError

Bases: LxmlError, SyntaxError

Base class for all syntax errors.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

end_lineno: exception end lineno

end_offset: exception end offset

filename: exception filename

lineno: exception lineno

msg: exception msg

offset: exception offset

print_file_and_line: exception print_file_and_line

text: exception text

exception lxml.etree.NamespaceRegistryError

Bases: LxmlRegistryError

Error registering a namespace extension.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.ParseError(message, code, line, column, filename=None)

Bases: LxmlSyntaxError

Syntax error while parsing an XML document.

For compatibility with ElementTree 1.3 and later.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

end_lineno: exception end lineno

end_offset: exception end offset

filename: exception filename

lineno: exception lineno

msg: exception msg

offset: exception offset

property position

print_file_and_line: exception print_file_and_line

text: exception text

exception lxml.etree.ParserError

Bases: LxmlError

Internal lxml parser error.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.RelaxNGError

Bases: LxmlError

Base class for RelaxNG errors.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.RelaxNGParseError

Bases: RelaxNGError

Error while parsing an XML document as RelaxNG.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.RelaxNGValidateError

Bases: RelaxNGError

Error while validating an XML document with a RelaxNG schema.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.SchematronError

Bases: LxmlError

Base class of all Schematron errors.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.SchematronParseError

Bases: SchematronError

Error while parsing an XML document as Schematron schema.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.SchematronValidateError

Bases: SchematronError

Error while validating an XML document with a Schematron schema.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.SerialisationError

Bases: LxmlError

A libxml2 error that occurred during serialisation.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XIncludeError

Bases: LxmlError

Error during XInclude processing.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XMLSchemaError

Bases: LxmlError

Base class of all XML Schema errors

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XMLSchemaParseError

Bases: XMLSchemaError

Error while parsing an XML document as XML Schema.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XMLSchemaValidateError

Bases: XMLSchemaError

Error while validating an XML document with an XML Schema.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XMLSyntaxAssertionError(message, code, line, column, filename=None)

Bases: XMLSyntaxError, AssertionError

An XMLSyntaxError that additionally inherits from AssertionError for ElementTree / backwards compatibility reasons.

This class may get replaced by a plain XMLSyntaxError in a future version.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

end_lineno: exception end lineno

end_offset: exception end offset

filename: exception filename

lineno: exception lineno

msg: exception msg

offset: exception offset

property position

print_file_and_line: exception print_file_and_line

text: exception text

exception lxml.etree.XMLSyntaxError(message, code, line, column, filename=None)

Bases: ParseError

Syntax error while parsing an XML document.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

end_lineno: exception end lineno

end_offset: exception end offset

filename: exception filename

lineno: exception lineno

msg: exception msg

offset: exception offset

property position

print_file_and_line: exception print_file_and_line

text: exception text

exception lxml.etree.XPathError

Bases: LxmlError

Base class of all XPath errors.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XPathEvalError

Bases: XPathError

Error during XPath evaluation.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XPathFunctionError

Bases: XPathEvalError

Internal error looking up an XPath extension function.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XPathResultError

Bases: XPathEvalError

Error handling an XPath result.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XPathSyntaxError

Bases: LxmlSyntaxError, XPathError

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

end_lineno: exception end lineno

end_offset: exception end offset

filename: exception filename

lineno: exception lineno

msg: exception msg

offset: exception offset

print_file_and_line: exception print_file_and_line

text: exception text

exception lxml.etree.XSLTApplyError

Bases: XSLTError

Error running an XSL transformation.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XSLTError

Bases: LxmlError

Base class of all XSLT errors.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XSLTExtensionError

Bases: XSLTError

Error registering an XSLT extension.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XSLTParseError

Bases: XSLTError

Error parsing a stylesheet document.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree.XSLTSaveError

Bases: XSLTError, SerialisationError

Error serialising an XSLT result.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception lxml.etree._TargetParserResult(result)

Bases: Exception

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

class lxml.etree.AncestorsIterator(self, node, tag=None)

Bases: _ElementMatchIterator

Iterates over the ancestors of an element (from parent to parent).

class lxml.etree.AttributeBasedElementClassLookup(self, attribute_name, class_mapping, fallback=None)

Bases: FallbackElementClassLookup

Checks an attribute of an Element and looks up the value in a class dictionary.

Arguments:

attribute name - ‘{ns}name’ style string
class mapping - Python dict mapping attribute values to Element classes
fallback - optional fallback lookup mechanism

A None key in the class mapping will be checked if the attribute is missing.

set_fallback(self, lookup): Sets the fallback scheme for this lookup method.

fallback

class lxml.etree.C14NWriterTarget

Bases: object

Canonicalization writer target for the XMLParser.

Serialises parse events to XML C14N 2.0.

Configuration options:

with_comments: set to true to include comments
strip_text: set to true to strip whitespace before and after text content
rewrite_prefixes: set to true to replace namespace prefixes by “n{number}”
qname_aware_tags: a set of qname aware tag names in which prefixes
should be replaced in text content
qname_aware_attrs: a set of qname aware attribute names in which prefixes
should be replaced in text content
exclude_attrs: a set of attribute names that should not be serialised
exclude_tags: a set of tag names that should not be serialised

_iter_namespaces(ns_stack)

close()

comment(text)

data(data)

end(tag)

pi(target, data)

start(tag, attrs)

start_ns(prefix, uri)

class lxml.etree.CDATA(data)

Bases: object

CDATA factory. This factory creates an opaque data object that can be used to set Element text. The usual way to use it is:

>>> el = Element('content')
>>> el.text = CDATA('a string')

>>> print(el.text)
a string
>>> print(tostring(el, encoding="unicode"))
<content><![CDATA[a string]]></content>

class lxml.etree.CommentBase

Bases: _Comment

All custom Comment classes must inherit from this one.

To create an XML Comment instance, use the Comment() factory.

Subclasses must not override __init__ or __new__ as it is absolutely undefined when these objects will be created or destroyed. All persistent state of Comments must be stored in the underlying XML. If you really need to initialize the object after creation, you can implement an _init(self) method that will be called after object creation.

_init(self): Called after object initialisation. Custom subclasses may override this if they recursively call _init() in the superclasses.

addnext(self, element)

Adds the element as a following sibling directly after this element.

This is normally used to set a processing instruction or comment after the root node of a document. Note that tail text is automatically discarded when adding at the root level.

addprevious(self, element)

Adds the element as a preceding sibling directly before this element.

This is normally used to set a processing instruction or comment before the root node of a document. Note that tail text is automatically discarded when adding at the root level.

append(self, value)

clear(self, keep_tail=False)

Resets an element. This function removes all subelements, clears all attributes and sets the text and tail properties to None.

Pass keep_tail=True to leave the tail text untouched.

cssselect(expr, *, translator)

Run the CSS expression on this element and its children, returning a list of the results.

Equivalent to lxml.cssselect.CSSSelect(expr)(self) – note that pre-compiling the expression can provide a substantial speedup.

extend(self, elements): Extends the current children by the elements in the iterable.

find(self, path, namespaces=None)

Finds the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds text for the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

get(self, key, default=None)

getchildren(self)

Returns all direct children. The elements are returned in document order.

Deprecated: Note that this method has been deprecated as of ElementTree 1.3 and lxml 2.0. New code should use list(element) or simply iterate over elements.

getiterator(self, tag=None, *tags)

Returns a sequence or iterator of all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags, see iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the element.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getnext(self): Returns the following sibling of this element or None.

getparent(self): Returns the parent of this element or None for the root element.

getprevious(self): Returns the preceding sibling of this element or None.

getroottree(self)

Return an ElementTree for the root node of the document that contains this element.

This is the same as following element.getparent() up the tree until it returns None (for the root element) and then build an ElementTree for the last parent that was returned.

index(self, child, start=None, stop=None)

Find the position of the child within the parent.

This method is not part of the original ElementTree API.

insert(self, index, value)

items(self)

iter(self, tag=None, *tags)

Iterate over all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags: pass "{ns}localname" as tag. Either or both of ns and localname can be * for a wildcard; ns can be empty for no namespace. "localname" is equivalent to "{}localname" (i.e. no namespace) but "*" is "{*}*" (any or no namespace), not "{}*".

You can also pass the Element, Comment, ProcessingInstruction and Entity factory functions to look only for the specific element type.

Passing multiple tags (or a sequence of tags) instead of a single tag will let the iterator return all elements matching any of these tags, in document order.

iterancestors(self, tag=None, *tags)

Iterate over the ancestors of this element (from parent to parent).

Can be restricted to find only elements with specific tags, see iter.

iterchildren(self, tag=None, *tags, reversed=False)

Iterate over the children of this element.

As opposed to using normal iteration on this element, the returned elements can be reversed with the ‘reversed’ keyword and restricted to find only elements with specific tags, see iter.

iterdescendants(self, tag=None, *tags)

Iterate over the descendants of this element in document order.

As opposed to el.iter(), this iterator does not yield the element itself. The returned elements can be restricted to find only elements with specific tags, see iter.

iterfind(self, path, namespaces=None)

Iterates over all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

itersiblings(self, tag=None, *tags, preceding=False)

Iterate over the following or preceding siblings of this element.

The direction is determined by the ‘preceding’ keyword which defaults to False, i.e. forward iteration over the following siblings. When True, the iterator yields the preceding siblings in reverse document order, i.e. starting right before the current element and going backwards.

Can be restricted to find only elements with specific tags, see iter.

itertext(self, tag=None, *tags, with_tail=True)

Iterates over the text content of a subtree.

You can pass tag names to restrict text content to specific elements, see iter.

You can set the with_tail keyword argument to False to skip over tail text.

keys(self)

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with the same document.

remove(self, element): Removes a matching subelement. Unlike the find methods, this method compares elements based on identity, not on tag value or contents.

replace(self, old_element, new_element): Replaces a subelement with the element passed as second argument.

set(self, key, value)

values(self)

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): Evaluate an xpath expression using the element as context node.

attrib

base

The base URI of the Element (xml:base or HTML base URL). None if the base URI is unknown.

Note that the value depends on the URL of the document that holds the Element if there is no xml:base attribute on the Element or its ancestors.

Setting this property will set an xml:base attribute on the Element, regardless of the document type (XML or HTML).

nsmap

Namespace prefix->URI mapping known in the context of this Element. This includes all namespace declarations of the parents.

Note that changing the returned dict has no effect on the Element.

prefix: Namespace prefix or None.

sourceline: Original line number as found by the parser or None if unknown.

tag

tail: Text after this element’s end tag, but before the next sibling element’s start tag. This is either a string or the value None, if there was no text.

text

class lxml.etree.CustomElementClassLookup(self, fallback=None)

Bases: FallbackElementClassLookup

Element class lookup based on a subclass method.

You can inherit from this class and override the method:

lookup(self, type, doc, namespace, name)

to lookup the element class for a node. Arguments of the method: * type: one of ‘element’, ‘comment’, ‘PI’, ‘entity’ * doc: document that the node is in * namespace: namespace URI of the node (or None for comments/PIs/entities) * name: name of the element/entity, None for comments, target for PIs

If you return None from this method, the fallback will be called.

lookup(self, type, doc, namespace, name)

set_fallback(self, lookup): Sets the fallback scheme for this lookup method.

fallback

class lxml.etree.DTD(self, file=None, external_id=None)

Bases: _Validator

A DTD validator.

Can load from filesystem directly given a filename or file-like object. Alternatively, pass the keyword parameter external_id to load from a catalog.

_append_log_message(domain, type, level, line, message, filename)

_clear_error_log()

assertValid(self, etree): Raises DocumentInvalid if the document does not comply with the schema.

assert_(self, etree): Raises AssertionError if the document does not comply with the schema.

elements()

entities()

iterelements()

iterentities()

validate(self, etree)

Validate the document using this schema.

Returns true if document is valid, false if not.

error_log: The log of validation errors and warnings.

external_id

name

system_url

class lxml.etree.DocInfo

Bases: object

Document information provided by parser and DTD.

clear(): Removes DOCTYPE and internal subset from the document.

URL: The source URL of the document (or None if unknown).

doctype: Returns a DOCTYPE declaration string for the document.

encoding: Returns the encoding name as declared by the document.

externalDTD: Returns a DTD validator based on the external subset of the document.

internalDTD: Returns a DTD validator based on the internal subset of the document.

public_id

Public ID of the DOCTYPE.

Mutable. May be set to a valid string or None. If a DTD does not exist, setting this variable (even to None) will create one.

root_name: Returns the name of the root node as defined by the DOCTYPE.

standalone: Returns the standalone flag as declared by the document. The possible values are True (standalone='yes'), False (standalone='no' or flag not provided in the declaration), and None (unknown or no declaration found). Note that a normal truth test on this value will always tell if the standalone flag was set to 'yes' or not.

system_url

System ID of the DOCTYPE.

Mutable. May be set to a valid string or None. If a DTD does not exist, setting this variable (even to None) will create one.

xml_version: Returns the XML version as declared by the document.

class lxml.etree.ETCompatXMLParser(self, encoding=None, attribute_defaults=False, dtd_validation=False, load_dtd=False, no_network=True, ns_clean=False, recover=False, schema=None, huge_tree=False, remove_blank_text=False, resolve_entities=True, remove_comments=True, remove_pis=True, strip_cdata=True, target=None, compact=True)

Bases: XMLParser

An XML parser with an ElementTree compatible default setup.

See the XMLParser class for details.

This parser has remove_comments and remove_pis enabled by default and thus ignores comments and processing instructions.

close(self)

Terminates feeding data to this parser. This tells the parser to process any remaining data in the feed buffer, and then returns the root Element of the tree that was parsed.

This method must be called after passing the last chunk of data into the feed() method. It should only be called when using the feed parser interface, all other usage is undefined.

copy(self): Create a new parser with the same configuration.

feed(self, data)

Feeds data to the parser. The argument should be an 8-bit string buffer containing encoded data, although Unicode is supported as long as both string types are not mixed.

This is the main entry point to the consumer interface of a parser. The parser will parse as much of the XML stream as it can on each call. To finish parsing or to reset the parser, call the close() method. Both methods may raise ParseError if errors occur in the input data. If an error is raised, there is no longer a need to call close().

The feed parser interface is independent of the normal parser usage. You can use the same parser as a feed parser and in the parse() function concurrently.

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with this parser.

setElementClassLookup(lookup)

Deprecated: use parser.set_element_class_lookup(lookup) instead.

set_element_class_lookup(self, lookup=None)

Set a lookup scheme for element classes generated from this parser.

Reset it by passing None or nothing.

error_log: The error log of the last parser run.

feed_error_log

The error log of the last (or current) run of the feed parser.

Note that this is local to the feed parser and thus is different from what the error_log property returns.

resolvers: The custom resolver registry of this parser.

target

version: The version of the underlying XML parser.

class lxml.etree.ETXPath(self, path, extensions=None, regexp=True, smart_strings=True)

Bases: XPath

Special XPath class that supports the ElementTree {uri} notation for namespaces.

Note that this class does not accept the namespace keyword argument. All namespaces must be passed as part of the path string. Smart strings will be returned for string results unless you pass smart_strings=False.

evaluate(self, _eval_arg, **_variables)

Evaluate an XPath expression.

Instead of calling this method, you can also call the evaluator object itself.

Variables may be provided as keyword arguments. Note that namespaces are currently not supported for variables.

Deprecated: call the object, not its method.

error_log

path: The literal XPath expression.

class lxml.etree.ElementBase(*children, attrib=None, nsmap=None, **_extra)

Bases: _Element

The public Element class. All custom Element classes must inherit from this one. To create an Element, use the Element() factory.

BIG FAT WARNING: Subclasses must not override __init__ or __new__ as it is absolutely undefined when these objects will be created or destroyed. All persistent state of Elements must be stored in the underlying XML. If you really need to initialize the object after creation, you can implement an _init(self) method that will be called directly after object creation.

Subclasses of this class can be instantiated to create a new Element. By default, the tag name will be the class name and the namespace will be empty. You can modify this with the following class attributes:

TAG - the tag name, possibly containing a namespace in Clark notation
NAMESPACE - the default namespace URI, unless provided as part of the TAG attribute.
HTML - flag if the class is an HTML tag, as opposed to an XML tag. This only applies to un-namespaced tags and defaults to false (i.e. XML).
PARSER - the parser that provides the configuration for the newly created document. Providing an HTML parser here will default to creating an HTML element.

In user code, the latter three are commonly inherited in class hierarchies that implement a common namespace.

_init(self): Called after object initialisation. Custom subclasses may override this if they recursively call _init() in the superclasses.

addnext(self, element)

Adds the element as a following sibling directly after this element.

This is normally used to set a processing instruction or comment after the root node of a document. Note that tail text is automatically discarded when adding at the root level.

addprevious(self, element)

Adds the element as a preceding sibling directly before this element.

This is normally used to set a processing instruction or comment before the root node of a document. Note that tail text is automatically discarded when adding at the root level.

append(self, element): Adds a subelement to the end of this element.

clear(self, keep_tail=False)

Resets an element. This function removes all subelements, clears all attributes and sets the text and tail properties to None.

Pass keep_tail=True to leave the tail text untouched.

cssselect(expr, *, translator)

Run the CSS expression on this element and its children, returning a list of the results.

Equivalent to lxml.cssselect.CSSSelect(expr)(self) – note that pre-compiling the expression can provide a substantial speedup.

extend(self, elements): Extends the current children by the elements in the iterable.

find(self, path, namespaces=None)

Finds the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds text for the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

get(self, key, default=None): Gets an element attribute.

getchildren(self)

Returns all direct children. The elements are returned in document order.

Deprecated: Note that this method has been deprecated as of ElementTree 1.3 and lxml 2.0. New code should use list(element) or simply iterate over elements.

getiterator(self, tag=None, *tags)

Returns a sequence or iterator of all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags, see iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the element.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getnext(self): Returns the following sibling of this element or None.

getparent(self): Returns the parent of this element or None for the root element.

getprevious(self): Returns the preceding sibling of this element or None.

getroottree(self)

Return an ElementTree for the root node of the document that contains this element.

This is the same as following element.getparent() up the tree until it returns None (for the root element) and then build an ElementTree for the last parent that was returned.

index(self, child, start=None, stop=None)

Find the position of the child within the parent.

This method is not part of the original ElementTree API.

insert(self, index, element): Inserts a subelement at the given position in this element

items(self): Gets element attributes, as a sequence. The attributes are returned in an arbitrary order.

iter(self, tag=None, *tags)

Iterate over all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags: pass "{ns}localname" as tag. Either or both of ns and localname can be * for a wildcard; ns can be empty for no namespace. "localname" is equivalent to "{}localname" (i.e. no namespace) but "*" is "{*}*" (any or no namespace), not "{}*".

You can also pass the Element, Comment, ProcessingInstruction and Entity factory functions to look only for the specific element type.

Passing multiple tags (or a sequence of tags) instead of a single tag will let the iterator return all elements matching any of these tags, in document order.

iterancestors(self, tag=None, *tags)

Iterate over the ancestors of this element (from parent to parent).

Can be restricted to find only elements with specific tags, see iter.

iterchildren(self, tag=None, *tags, reversed=False)

Iterate over the children of this element.

As opposed to using normal iteration on this element, the returned elements can be reversed with the ‘reversed’ keyword and restricted to find only elements with specific tags, see iter.

iterdescendants(self, tag=None, *tags)

Iterate over the descendants of this element in document order.

As opposed to el.iter(), this iterator does not yield the element itself. The returned elements can be restricted to find only elements with specific tags, see iter.

iterfind(self, path, namespaces=None)

Iterates over all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

itersiblings(self, tag=None, *tags, preceding=False)

Iterate over the following or preceding siblings of this element.

The direction is determined by the ‘preceding’ keyword which defaults to False, i.e. forward iteration over the following siblings. When True, the iterator yields the preceding siblings in reverse document order, i.e. starting right before the current element and going backwards.

Can be restricted to find only elements with specific tags, see iter.

itertext(self, tag=None, *tags, with_tail=True)

Iterates over the text content of a subtree.

You can pass tag names to restrict text content to specific elements, see iter.

You can set the with_tail keyword argument to False to skip over tail text.

keys(self): Gets a list of attribute names. The names are returned in an arbitrary order (just like for an ordinary Python dictionary).

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with the same document.

remove(self, element): Removes a matching subelement. Unlike the find methods, this method compares elements based on identity, not on tag value or contents.

replace(self, old_element, new_element): Replaces a subelement with the element passed as second argument.

set(self, key, value): Sets an element attribute. In HTML documents (not XML or XHTML), the value None is allowed and creates an attribute without value (just the attribute name).

values(self): Gets element attribute values as a sequence of strings. The attributes are returned in an arbitrary order.

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): Evaluate an xpath expression using the element as context node.

attrib: Element attribute dictionary. Where possible, use get(), set(), keys(), values() and items() to access element attributes.

base

The base URI of the Element (xml:base or HTML base URL). None if the base URI is unknown.

Note that the value depends on the URL of the document that holds the Element if there is no xml:base attribute on the Element or its ancestors.

Setting this property will set an xml:base attribute on the Element, regardless of the document type (XML or HTML).

nsmap

Namespace prefix->URI mapping known in the context of this Element. This includes all namespace declarations of the parents.

Note that changing the returned dict has no effect on the Element.

prefix: Namespace prefix or None.

sourceline: Original line number as found by the parser or None if unknown.

tag: Element tag

tail: Text after this element’s end tag, but before the next sibling element’s start tag. This is either a string or the value None, if there was no text.

text: Text before the first subelement. This is either a string or the value None, if there was no text.

class lxml.etree.ElementChildIterator(self, node, tag=None, reversed=False)

Bases: _ElementMatchIterator

Iterates over the children of an element.

class lxml.etree.ElementClassLookup(self)

Bases: object

Superclass of Element class lookups.

class lxml.etree.ElementDefaultClassLookup(self, element=None, comment=None, pi=None, entity=None)

Bases: ElementClassLookup

Element class lookup scheme that always returns the default Element class.

The keyword arguments element, comment, pi and entity accept the respective Element classes.

comment_class

element_class

entity_class

pi_class

class lxml.etree.ElementDepthFirstIterator(self, node, tag=None, inclusive=True)

Bases: object

Iterates over an element and its sub-elements in document order (depth first pre-order).

Note that this also includes comments, entities and processing instructions. To filter them out, check if the tag property of the returned element is a string (i.e. not None and not a factory function), or pass the Element factory for the tag argument to receive only Elements.

If the optional tag argument is not None, the iterator returns only the elements that match the respective name and namespace.

The optional boolean argument ‘inclusive’ defaults to True and can be set to False to exclude the start element itself.

Note that the behaviour of this iterator is completely undefined if the tree it traverses is modified during iteration.

class lxml.etree.ElementNamespaceClassLookup(self, fallback=None)

Bases: FallbackElementClassLookup

Element class lookup scheme that searches the Element class in the Namespace registry.

Usage:

>>> 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."

get_namespace(self, ns_uri)

Retrieve the namespace object associated with the given URI. Pass None for the empty namespace.

Creates a new namespace object if it does not yet exist.

set_fallback(self, lookup): Sets the fallback scheme for this lookup method.

fallback

class lxml.etree.ElementTextIterator(self, element, tag=None, with_tail=True)

Bases: object

Iterates over the text content of a subtree.

You can pass the tag keyword argument to restrict text content to a specific tag name.

You can set the with_tail keyword argument to False to skip over tail text (e.g. if you know that it’s only whitespace from pretty-printing).

class lxml.etree.EntityBase

Bases: _Entity

All custom Entity classes must inherit from this one.

To create an XML Entity instance, use the Entity() factory.

Subclasses must not override __init__ or __new__ as it is absolutely undefined when these objects will be created or destroyed. All persistent state of Entities must be stored in the underlying XML. If you really need to initialize the object after creation, you can implement an _init(self) method that will be called after object creation.

_init(self): Called after object initialisation. Custom subclasses may override this if they recursively call _init() in the superclasses.

addnext(self, element)

Adds the element as a following sibling directly after this element.

This is normally used to set a processing instruction or comment after the root node of a document. Note that tail text is automatically discarded when adding at the root level.

addprevious(self, element)

Adds the element as a preceding sibling directly before this element.

This is normally used to set a processing instruction or comment before the root node of a document. Note that tail text is automatically discarded when adding at the root level.

append(self, value)

clear(self, keep_tail=False)

Resets an element. This function removes all subelements, clears all attributes and sets the text and tail properties to None.

Pass keep_tail=True to leave the tail text untouched.

cssselect(expr, *, translator)

Run the CSS expression on this element and its children, returning a list of the results.

Equivalent to lxml.cssselect.CSSSelect(expr)(self) – note that pre-compiling the expression can provide a substantial speedup.

extend(self, elements): Extends the current children by the elements in the iterable.

find(self, path, namespaces=None)

Finds the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds text for the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

get(self, key, default=None)

getchildren(self)

Returns all direct children. The elements are returned in document order.

Deprecated: Note that this method has been deprecated as of ElementTree 1.3 and lxml 2.0. New code should use list(element) or simply iterate over elements.

getiterator(self, tag=None, *tags)

Returns a sequence or iterator of all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags, see iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the element.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getnext(self): Returns the following sibling of this element or None.

getparent(self): Returns the parent of this element or None for the root element.

getprevious(self): Returns the preceding sibling of this element or None.

getroottree(self)

Return an ElementTree for the root node of the document that contains this element.

This is the same as following element.getparent() up the tree until it returns None (for the root element) and then build an ElementTree for the last parent that was returned.

index(self, child, start=None, stop=None)

Find the position of the child within the parent.

This method is not part of the original ElementTree API.

insert(self, index, value)

items(self)

iter(self, tag=None, *tags)

Iterate over all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags: pass "{ns}localname" as tag. Either or both of ns and localname can be * for a wildcard; ns can be empty for no namespace. "localname" is equivalent to "{}localname" (i.e. no namespace) but "*" is "{*}*" (any or no namespace), not "{}*".

You can also pass the Element, Comment, ProcessingInstruction and Entity factory functions to look only for the specific element type.

Passing multiple tags (or a sequence of tags) instead of a single tag will let the iterator return all elements matching any of these tags, in document order.

iterancestors(self, tag=None, *tags)

Iterate over the ancestors of this element (from parent to parent).

Can be restricted to find only elements with specific tags, see iter.

iterchildren(self, tag=None, *tags, reversed=False)

Iterate over the children of this element.

As opposed to using normal iteration on this element, the returned elements can be reversed with the ‘reversed’ keyword and restricted to find only elements with specific tags, see iter.

iterdescendants(self, tag=None, *tags)

Iterate over the descendants of this element in document order.

As opposed to el.iter(), this iterator does not yield the element itself. The returned elements can be restricted to find only elements with specific tags, see iter.

iterfind(self, path, namespaces=None)

Iterates over all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

itersiblings(self, tag=None, *tags, preceding=False)

Iterate over the following or preceding siblings of this element.

The direction is determined by the ‘preceding’ keyword which defaults to False, i.e. forward iteration over the following siblings. When True, the iterator yields the preceding siblings in reverse document order, i.e. starting right before the current element and going backwards.

Can be restricted to find only elements with specific tags, see iter.

itertext(self, tag=None, *tags, with_tail=True)

Iterates over the text content of a subtree.

You can pass tag names to restrict text content to specific elements, see iter.

You can set the with_tail keyword argument to False to skip over tail text.

keys(self)

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with the same document.

remove(self, element): Removes a matching subelement. Unlike the find methods, this method compares elements based on identity, not on tag value or contents.

replace(self, old_element, new_element): Replaces a subelement with the element passed as second argument.

set(self, key, value)

values(self)

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): Evaluate an xpath expression using the element as context node.

attrib

base

The base URI of the Element (xml:base or HTML base URL). None if the base URI is unknown.

Note that the value depends on the URL of the document that holds the Element if there is no xml:base attribute on the Element or its ancestors.

Setting this property will set an xml:base attribute on the Element, regardless of the document type (XML or HTML).

name

nsmap

Namespace prefix->URI mapping known in the context of this Element. This includes all namespace declarations of the parents.

Note that changing the returned dict has no effect on the Element.

prefix: Namespace prefix or None.

sourceline: Original line number as found by the parser or None if unknown.

tag

tail: Text after this element’s end tag, but before the next sibling element’s start tag. This is either a string or the value None, if there was no text.

text

class lxml.etree.ErrorDomains

Bases: object

Libxml2 error domains

_getName(default=None, /): Return the value for key if key is in the dictionary, else default.

BUFFER = 29

C14N = 21

CATALOG = 20

CHECK = 24

DATATYPE = 15

DTD = 4

FTP = 9

HTML = 5

HTTP = 10

I18N = 27

IO = 8

MEMORY = 6

MODULE = 26

NAMESPACE = 3

NONE = 0

OUTPUT = 7

PARSER = 1

REGEXP = 14

RELAXNGP = 18

RELAXNGV = 19

SCHEMASP = 16

SCHEMASV = 17

SCHEMATRONV = 28

TREE = 2

URI = 30

VALID = 23

WRITER = 25

XINCLUDE = 11

XPATH = 12

XPOINTER = 13

XSLT = 22

_names = {0: 'NONE', 1: 'PARSER', 2: 'TREE', 3: 'NAMESPACE', 4: 'DTD', 5: 'HTML', 6: 'MEMORY', 7: 'OUTPUT', 8: 'IO', 9: 'FTP', 10: 'HTTP', 11: 'XINCLUDE', 12: 'XPATH', 13: 'XPOINTER', 14: 'REGEXP', 15: 'DATATYPE', 16: 'SCHEMASP', 17: 'SCHEMASV', 18: 'RELAXNGP', 19: 'RELAXNGV', 20: 'CATALOG', 21: 'C14N', 22: 'XSLT', 23: 'VALID', 24: 'CHECK', 25: 'WRITER', 26: 'MODULE', 27: 'I18N', 28: 'SCHEMATRONV', 29: 'BUFFER', 30: 'URI'}

class lxml.etree.ErrorLevels

Bases: object

Libxml2 error levels

_getName(default=None, /): Return the value for key if key is in the dictionary, else default.

ERROR = 2

FATAL = 3

NONE = 0

WARNING = 1

_names = {0: 'NONE', 1: 'WARNING', 2: 'ERROR', 3: 'FATAL'}

class lxml.etree.ErrorTypes

Bases: object

Libxml2 error types

_getName(default=None, /): Return the value for key if key is in the dictionary, else default.

BUF_OVERFLOW = 7000

C14N_CREATE_CTXT = 1950

C14N_CREATE_STACK = 1952

C14N_INVALID_NODE = 1953

C14N_RELATIVE_NAMESPACE = 1955

C14N_REQUIRES_UTF8 = 1951

C14N_UNKNOW_NODE = 1954

CATALOG_ENTRY_BROKEN = 1651

CATALOG_MISSING_ATTR = 1650

CATALOG_NOT_CATALOG = 1653

CATALOG_PREFER_VALUE = 1652

CATALOG_RECURSION = 1654

CHECK_ENTITY_TYPE = 5012

CHECK_FOUND_ATTRIBUTE = 5001

CHECK_FOUND_CDATA = 5003

CHECK_FOUND_COMMENT = 5007

CHECK_FOUND_DOCTYPE = 5008

CHECK_FOUND_ELEMENT = 5000

CHECK_FOUND_ENTITY = 5005

CHECK_FOUND_ENTITYREF = 5004

CHECK_FOUND_FRAGMENT = 5009

CHECK_FOUND_NOTATION = 5010

CHECK_FOUND_PI = 5006

CHECK_FOUND_TEXT = 5002

CHECK_NAME_NOT_NULL = 5037

CHECK_NOT_ATTR = 5023

CHECK_NOT_ATTR_DECL = 5024

CHECK_NOT_DTD = 5022

CHECK_NOT_ELEM_DECL = 5025

CHECK_NOT_ENTITY_DECL = 5026

CHECK_NOT_NCNAME = 5034

CHECK_NOT_NS_DECL = 5027

CHECK_NOT_UTF8 = 5032

CHECK_NO_DICT = 5033

CHECK_NO_DOC = 5014

CHECK_NO_ELEM = 5016

CHECK_NO_HREF = 5028

CHECK_NO_NAME = 5015

CHECK_NO_NEXT = 5020

CHECK_NO_PARENT = 5013

CHECK_NO_PREV = 5018

CHECK_NS_ANCESTOR = 5031

CHECK_NS_SCOPE = 5030

CHECK_OUTSIDE_DICT = 5035

CHECK_UNKNOWN_NODE = 5011

CHECK_WRONG_DOC = 5017

CHECK_WRONG_NAME = 5036

CHECK_WRONG_NEXT = 5021

CHECK_WRONG_PARENT = 5029

CHECK_WRONG_PREV = 5019

DTD_ATTRIBUTE_DEFAULT = 500

DTD_ATTRIBUTE_REDEFINED = 501

DTD_ATTRIBUTE_VALUE = 502

DTD_CONTENT_ERROR = 503

DTD_CONTENT_MODEL = 504

DTD_CONTENT_NOT_DETERMINIST = 505

DTD_DIFFERENT_PREFIX = 506

DTD_DUP_TOKEN = 541

DTD_ELEM_DEFAULT_NAMESPACE = 507

DTD_ELEM_NAMESPACE = 508

DTD_ELEM_REDEFINED = 509

DTD_EMPTY_NOTATION = 510

DTD_ENTITY_TYPE = 511

DTD_ID_FIXED = 512

DTD_ID_REDEFINED = 513

DTD_ID_SUBSET = 514

DTD_INVALID_CHILD = 515

DTD_INVALID_DEFAULT = 516

DTD_LOAD_ERROR = 517

DTD_MISSING_ATTRIBUTE = 518

DTD_MIXED_CORRUPT = 519

DTD_MULTIPLE_ID = 520

DTD_NOTATION_REDEFINED = 526

DTD_NOTATION_VALUE = 527

DTD_NOT_EMPTY = 528

DTD_NOT_PCDATA = 529

DTD_NOT_STANDALONE = 530

DTD_NO_DOC = 521

DTD_NO_DTD = 522

DTD_NO_ELEM_NAME = 523

DTD_NO_PREFIX = 524

DTD_NO_ROOT = 525

DTD_ROOT_NAME = 531

DTD_STANDALONE_DEFAULTED = 538

DTD_STANDALONE_WHITE_SPACE = 532

DTD_UNKNOWN_ATTRIBUTE = 533

DTD_UNKNOWN_ELEM = 534

DTD_UNKNOWN_ENTITY = 535

DTD_UNKNOWN_ID = 536

DTD_UNKNOWN_NOTATION = 537

DTD_XMLID_TYPE = 540

DTD_XMLID_VALUE = 539

ERR_ATTLIST_NOT_FINISHED = 51

ERR_ATTLIST_NOT_STARTED = 50

ERR_ATTRIBUTE_NOT_FINISHED = 40

ERR_ATTRIBUTE_NOT_STARTED = 39

ERR_ATTRIBUTE_REDEFINED = 42

ERR_ATTRIBUTE_WITHOUT_VALUE = 41

ERR_CDATA_NOT_FINISHED = 63

ERR_CHARREF_AT_EOF = 10

ERR_CHARREF_IN_DTD = 13

ERR_CHARREF_IN_EPILOG = 12

ERR_CHARREF_IN_PROLOG = 11

ERR_COMMENT_ABRUPTLY_ENDED = 112

ERR_COMMENT_NOT_FINISHED = 45

ERR_CONDSEC_INVALID = 83

ERR_CONDSEC_INVALID_KEYWORD = 95

ERR_CONDSEC_NOT_FINISHED = 59

ERR_CONDSEC_NOT_STARTED = 58

ERR_DOCTYPE_NOT_FINISHED = 61

ERR_DOCUMENT_EMPTY = 4

ERR_DOCUMENT_END = 5

ERR_DOCUMENT_START = 3

ERR_ELEMCONTENT_NOT_FINISHED = 55

ERR_ELEMCONTENT_NOT_STARTED = 54

ERR_ENCODING_NAME = 79

ERR_ENTITYREF_AT_EOF = 14

ERR_ENTITYREF_IN_DTD = 17

ERR_ENTITYREF_IN_EPILOG = 16

ERR_ENTITYREF_IN_PROLOG = 15

ERR_ENTITYREF_NO_NAME = 22

ERR_ENTITYREF_SEMICOL_MISSING = 23

ERR_ENTITY_BOUNDARY = 90

ERR_ENTITY_CHAR_ERROR = 87

ERR_ENTITY_IS_EXTERNAL = 29

ERR_ENTITY_IS_PARAMETER = 30

ERR_ENTITY_LOOP = 89

ERR_ENTITY_NOT_FINISHED = 37

ERR_ENTITY_NOT_STARTED = 36

ERR_ENTITY_PE_INTERNAL = 88

ERR_ENTITY_PROCESSING = 104

ERR_EQUAL_REQUIRED = 75

ERR_EXTRA_CONTENT = 86

ERR_EXT_ENTITY_STANDALONE = 82

ERR_EXT_SUBSET_NOT_FINISHED = 60

ERR_GT_REQUIRED = 73

ERR_HYPHEN_IN_COMMENT = 80

ERR_INTERNAL_ERROR = 1

ERR_INVALID_CHAR = 9

ERR_INVALID_CHARREF = 8

ERR_INVALID_DEC_CHARREF = 7

ERR_INVALID_ENCODING = 81

ERR_INVALID_HEX_CHARREF = 6

ERR_INVALID_URI = 91

ERR_LITERAL_NOT_FINISHED = 44

ERR_LITERAL_NOT_STARTED = 43

ERR_LTSLASH_REQUIRED = 74

ERR_LT_IN_ATTRIBUTE = 38

ERR_LT_REQUIRED = 72

ERR_MISPLACED_CDATA_END = 62

ERR_MISSING_ENCODING = 101

ERR_MIXED_NOT_FINISHED = 53

ERR_MIXED_NOT_STARTED = 52

ERR_NAME_REQUIRED = 68

ERR_NAME_TOO_LONG = 110

ERR_NMTOKEN_REQUIRED = 67

ERR_NOTATION_NOT_FINISHED = 49

ERR_NOTATION_NOT_STARTED = 48

ERR_NOTATION_PROCESSING = 105

ERR_NOT_STANDALONE = 103

ERR_NOT_WELL_BALANCED = 85

ERR_NO_DTD = 94

ERR_NO_MEMORY = 2

ERR_NS_DECL_ERROR = 35

ERR_OK = 0

ERR_PCDATA_REQUIRED = 69

ERR_PEREF_AT_EOF = 18

ERR_PEREF_IN_EPILOG = 20

ERR_PEREF_IN_INT_SUBSET = 21

ERR_PEREF_IN_PROLOG = 19

ERR_PEREF_NO_NAME = 24

ERR_PEREF_SEMICOL_MISSING = 25

ERR_PI_NOT_FINISHED = 47

ERR_PI_NOT_STARTED = 46

ERR_PUBID_REQUIRED = 71

ERR_RESERVED_XML_NAME = 64

ERR_SEPARATOR_REQUIRED = 66

ERR_SPACE_REQUIRED = 65

ERR_STANDALONE_VALUE = 78

ERR_STRING_NOT_CLOSED = 34

ERR_STRING_NOT_STARTED = 33

ERR_TAG_NAME_MISMATCH = 76

ERR_TAG_NOT_FINISHED = 77

ERR_UNDECLARED_ENTITY = 26

ERR_UNKNOWN_ENCODING = 31

ERR_UNKNOWN_VERSION = 108

ERR_UNPARSED_ENTITY = 28

ERR_UNSUPPORTED_ENCODING = 32

ERR_URI_FRAGMENT = 92

ERR_URI_REQUIRED = 70

ERR_USER_STOP = 111

ERR_VALUE_REQUIRED = 84

ERR_VERSION_MISMATCH = 109

ERR_VERSION_MISSING = 96

ERR_XMLDECL_NOT_FINISHED = 57

ERR_XMLDECL_NOT_STARTED = 56

FTP_ACCNT = 2002

FTP_EPSV_ANSWER = 2001

FTP_PASV_ANSWER = 2000

FTP_URL_SYNTAX = 2003

HTML_STRUCURE_ERROR = 800

HTML_UNKNOWN_TAG = 801

HTTP_UNKNOWN_HOST = 2022

HTTP_URL_SYNTAX = 2020

HTTP_USE_IP = 2021

I18N_CONV_FAILED = 6003

I18N_EXCESS_HANDLER = 6002

I18N_NO_HANDLER = 6001

I18N_NO_NAME = 6000

I18N_NO_OUTPUT = 6004

IO_BUFFER_FULL = 1548

IO_EACCES = 1501

IO_EADDRINUSE = 1554

IO_EAFNOSUPPORT = 1556

IO_EAGAIN = 1502

IO_EALREADY = 1555

IO_EBADF = 1503

IO_EBADMSG = 1504

IO_EBUSY = 1505

IO_ECANCELED = 1506

IO_ECHILD = 1507

IO_ECONNREFUSED = 1552

IO_EDEADLK = 1508

IO_EDOM = 1509

IO_EEXIST = 1510

IO_EFAULT = 1511

IO_EFBIG = 1512

IO_EINPROGRESS = 1513

IO_EINTR = 1514

IO_EINVAL = 1515

IO_EIO = 1516

IO_EISCONN = 1551

IO_EISDIR = 1517

IO_EMFILE = 1518

IO_EMLINK = 1519

IO_EMSGSIZE = 1520

IO_ENAMETOOLONG = 1521

IO_ENCODER = 1544

IO_ENETUNREACH = 1553

IO_ENFILE = 1522

IO_ENODEV = 1523

IO_ENOENT = 1524

IO_ENOEXEC = 1525

IO_ENOLCK = 1526

IO_ENOMEM = 1527

IO_ENOSPC = 1528

IO_ENOSYS = 1529

IO_ENOTDIR = 1530

IO_ENOTEMPTY = 1531

IO_ENOTSOCK = 1550

IO_ENOTSUP = 1532

IO_ENOTTY = 1533

IO_ENXIO = 1534

IO_EPERM = 1535

IO_EPIPE = 1536

IO_ERANGE = 1537

IO_EROFS = 1538

IO_ESPIPE = 1539

IO_ESRCH = 1540

IO_ETIMEDOUT = 1541

IO_EXDEV = 1542

IO_FLUSH = 1545

IO_LOAD_ERROR = 1549

IO_NETWORK_ATTEMPT = 1543

IO_NO_INPUT = 1547

IO_UNKNOWN = 1500

IO_WRITE = 1546

MODULE_CLOSE = 4901

MODULE_OPEN = 4900

NS_ERR_ATTRIBUTE_REDEFINED = 203

NS_ERR_COLON = 205

NS_ERR_EMPTY = 204

NS_ERR_QNAME = 202

NS_ERR_UNDEFINED_NAMESPACE = 201

NS_ERR_XML_NAMESPACE = 200

REGEXP_COMPILE_ERROR = 1450

RNGP_ANYNAME_ATTR_ANCESTOR = 1000

RNGP_ATTRIBUTE_CHILDREN = 1002

RNGP_ATTRIBUTE_CONTENT = 1003

RNGP_ATTRIBUTE_EMPTY = 1004

RNGP_ATTRIBUTE_NOOP = 1005

RNGP_ATTR_CONFLICT = 1001

RNGP_CHOICE_CONTENT = 1006

RNGP_CHOICE_EMPTY = 1007

RNGP_CREATE_FAILURE = 1008

RNGP_DATA_CONTENT = 1009

RNGP_DEFINE_CREATE_FAILED = 1011

RNGP_DEFINE_EMPTY = 1012

RNGP_DEFINE_MISSING = 1013

RNGP_DEFINE_NAME_MISSING = 1014

RNGP_DEF_CHOICE_AND_INTERLEAVE = 1010

RNGP_ELEMENT_CONTENT = 1018

RNGP_ELEMENT_EMPTY = 1017

RNGP_ELEMENT_NAME = 1019

RNGP_ELEMENT_NO_CONTENT = 1020

RNGP_ELEM_CONTENT_EMPTY = 1015

RNGP_ELEM_CONTENT_ERROR = 1016

RNGP_ELEM_TEXT_CONFLICT = 1021

RNGP_EMPTY = 1022

RNGP_EMPTY_CONSTRUCT = 1023

RNGP_EMPTY_CONTENT = 1024

RNGP_EMPTY_NOT_EMPTY = 1025

RNGP_ERROR_TYPE_LIB = 1026

RNGP_EXCEPT_EMPTY = 1027

RNGP_EXCEPT_MISSING = 1028

RNGP_EXCEPT_MULTIPLE = 1029

RNGP_EXCEPT_NO_CONTENT = 1030

RNGP_EXTERNALREF_EMTPY = 1031

RNGP_EXTERNALREF_RECURSE = 1033

RNGP_EXTERNAL_REF_FAILURE = 1032

RNGP_FORBIDDEN_ATTRIBUTE = 1034

RNGP_FOREIGN_ELEMENT = 1035

RNGP_GRAMMAR_CONTENT = 1036

RNGP_GRAMMAR_EMPTY = 1037

RNGP_GRAMMAR_MISSING = 1038

RNGP_GRAMMAR_NO_START = 1039

RNGP_GROUP_ATTR_CONFLICT = 1040

RNGP_HREF_ERROR = 1041

RNGP_INCLUDE_EMPTY = 1042

RNGP_INCLUDE_FAILURE = 1043

RNGP_INCLUDE_RECURSE = 1044

RNGP_INTERLEAVE_ADD = 1045

RNGP_INTERLEAVE_CREATE_FAILED = 1046

RNGP_INTERLEAVE_EMPTY = 1047

RNGP_INTERLEAVE_NO_CONTENT = 1048

RNGP_INVALID_DEFINE_NAME = 1049

RNGP_INVALID_URI = 1050

RNGP_INVALID_VALUE = 1051

RNGP_MISSING_HREF = 1052

RNGP_NAME_MISSING = 1053

RNGP_NEED_COMBINE = 1054

RNGP_NOTALLOWED_NOT_EMPTY = 1055

RNGP_NSNAME_ATTR_ANCESTOR = 1056

RNGP_NSNAME_NO_NS = 1057

RNGP_PARAM_FORBIDDEN = 1058

RNGP_PARAM_NAME_MISSING = 1059

RNGP_PARENTREF_CREATE_FAILED = 1060

RNGP_PARENTREF_NAME_INVALID = 1061

RNGP_PARENTREF_NOT_EMPTY = 1064

RNGP_PARENTREF_NO_NAME = 1062

RNGP_PARENTREF_NO_PARENT = 1063

RNGP_PARSE_ERROR = 1065

RNGP_PAT_ANYNAME_EXCEPT_ANYNAME = 1066

RNGP_PAT_ATTR_ATTR = 1067

RNGP_PAT_ATTR_ELEM = 1068

RNGP_PAT_DATA_EXCEPT_ATTR = 1069

RNGP_PAT_DATA_EXCEPT_ELEM = 1070

RNGP_PAT_DATA_EXCEPT_EMPTY = 1071

RNGP_PAT_DATA_EXCEPT_GROUP = 1072

RNGP_PAT_DATA_EXCEPT_INTERLEAVE = 1073

RNGP_PAT_DATA_EXCEPT_LIST = 1074

RNGP_PAT_DATA_EXCEPT_ONEMORE = 1075

RNGP_PAT_DATA_EXCEPT_REF = 1076

RNGP_PAT_DATA_EXCEPT_TEXT = 1077

RNGP_PAT_LIST_ATTR = 1078

RNGP_PAT_LIST_ELEM = 1079

RNGP_PAT_LIST_INTERLEAVE = 1080

RNGP_PAT_LIST_LIST = 1081

RNGP_PAT_LIST_REF = 1082

RNGP_PAT_LIST_TEXT = 1083

RNGP_PAT_NSNAME_EXCEPT_ANYNAME = 1084

RNGP_PAT_NSNAME_EXCEPT_NSNAME = 1085

RNGP_PAT_ONEMORE_GROUP_ATTR = 1086

RNGP_PAT_ONEMORE_INTERLEAVE_ATTR = 1087

RNGP_PAT_START_ATTR = 1088

RNGP_PAT_START_DATA = 1089

RNGP_PAT_START_EMPTY = 1090

RNGP_PAT_START_GROUP = 1091

RNGP_PAT_START_INTERLEAVE = 1092

RNGP_PAT_START_LIST = 1093

RNGP_PAT_START_ONEMORE = 1094

RNGP_PAT_START_TEXT = 1095

RNGP_PAT_START_VALUE = 1096

RNGP_PREFIX_UNDEFINED = 1097

RNGP_REF_CREATE_FAILED = 1098

RNGP_REF_CYCLE = 1099

RNGP_REF_NAME_INVALID = 1100

RNGP_REF_NOT_EMPTY = 1103

RNGP_REF_NO_DEF = 1101

RNGP_REF_NO_NAME = 1102

RNGP_START_CHOICE_AND_INTERLEAVE = 1104

RNGP_START_CONTENT = 1105

RNGP_START_EMPTY = 1106

RNGP_START_MISSING = 1107

RNGP_TEXT_EXPECTED = 1108

RNGP_TEXT_HAS_CHILD = 1109

RNGP_TYPE_MISSING = 1110

RNGP_TYPE_NOT_FOUND = 1111

RNGP_TYPE_VALUE = 1112

RNGP_UNKNOWN_ATTRIBUTE = 1113

RNGP_UNKNOWN_COMBINE = 1114

RNGP_UNKNOWN_CONSTRUCT = 1115

RNGP_UNKNOWN_TYPE_LIB = 1116

RNGP_URI_FRAGMENT = 1117

RNGP_URI_NOT_ABSOLUTE = 1118

RNGP_VALUE_EMPTY = 1119

RNGP_VALUE_NO_CONTENT = 1120

RNGP_XMLNS_NAME = 1121

RNGP_XML_NS = 1122

SAVE_CHAR_INVALID = 1401

SAVE_NOT_UTF8 = 1400

SAVE_NO_DOCTYPE = 1402

SAVE_UNKNOWN_ENCODING = 1403

SCHEMAP_AG_PROPS_CORRECT = 3087

SCHEMAP_ATTRFORMDEFAULT_VALUE = 1701

SCHEMAP_ATTRGRP_NONAME_NOREF = 1702

SCHEMAP_ATTR_NONAME_NOREF = 1703

SCHEMAP_AU_PROPS_CORRECT = 3089

SCHEMAP_AU_PROPS_CORRECT_2 = 3078

SCHEMAP_A_PROPS_CORRECT_2 = 3079

SCHEMAP_A_PROPS_CORRECT_3 = 3090

SCHEMAP_COMPLEXTYPE_NONAME_NOREF = 1704

SCHEMAP_COS_ALL_LIMITED = 3091

SCHEMAP_COS_CT_EXTENDS_1_1 = 3063

SCHEMAP_COS_CT_EXTENDS_1_2 = 3088

SCHEMAP_COS_CT_EXTENDS_1_3 = 1800

SCHEMAP_COS_ST_DERIVED_OK_2_1 = 3031

SCHEMAP_COS_ST_DERIVED_OK_2_2 = 3032

SCHEMAP_COS_ST_RESTRICTS_1_1 = 3011

SCHEMAP_COS_ST_RESTRICTS_1_2 = 3012

SCHEMAP_COS_ST_RESTRICTS_1_3_1 = 3013

SCHEMAP_COS_ST_RESTRICTS_1_3_2 = 3014

SCHEMAP_COS_ST_RESTRICTS_2_1 = 3015

SCHEMAP_COS_ST_RESTRICTS_2_3_1_1 = 3016

SCHEMAP_COS_ST_RESTRICTS_2_3_1_2 = 3017

SCHEMAP_COS_ST_RESTRICTS_2_3_2_1 = 3018

SCHEMAP_COS_ST_RESTRICTS_2_3_2_2 = 3019

SCHEMAP_COS_ST_RESTRICTS_2_3_2_3 = 3020

SCHEMAP_COS_ST_RESTRICTS_2_3_2_4 = 3021

SCHEMAP_COS_ST_RESTRICTS_2_3_2_5 = 3022

SCHEMAP_COS_ST_RESTRICTS_3_1 = 3023

SCHEMAP_COS_ST_RESTRICTS_3_3_1 = 3024

SCHEMAP_COS_ST_RESTRICTS_3_3_1_2 = 3025

SCHEMAP_COS_ST_RESTRICTS_3_3_2_1 = 3027

SCHEMAP_COS_ST_RESTRICTS_3_3_2_2 = 3026

SCHEMAP_COS_ST_RESTRICTS_3_3_2_3 = 3028

SCHEMAP_COS_ST_RESTRICTS_3_3_2_4 = 3029

SCHEMAP_COS_ST_RESTRICTS_3_3_2_5 = 3030

SCHEMAP_COS_VALID_DEFAULT_1 = 3058

SCHEMAP_COS_VALID_DEFAULT_2_1 = 3059

SCHEMAP_COS_VALID_DEFAULT_2_2_1 = 3060

SCHEMAP_COS_VALID_DEFAULT_2_2_2 = 3061

SCHEMAP_CT_PROPS_CORRECT_1 = 1782

SCHEMAP_CT_PROPS_CORRECT_2 = 1783

SCHEMAP_CT_PROPS_CORRECT_3 = 1784

SCHEMAP_CT_PROPS_CORRECT_4 = 1785

SCHEMAP_CT_PROPS_CORRECT_5 = 1786

SCHEMAP_CVC_SIMPLE_TYPE = 3062

SCHEMAP_C_PROPS_CORRECT = 3080

SCHEMAP_DEF_AND_PREFIX = 1768

SCHEMAP_DERIVATION_OK_RESTRICTION_1 = 1787

SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1 = 1788

SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2 = 1789

SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3 = 3077

SCHEMAP_DERIVATION_OK_RESTRICTION_2_2 = 1790

SCHEMAP_DERIVATION_OK_RESTRICTION_3 = 1791

SCHEMAP_DERIVATION_OK_RESTRICTION_4_1 = 1797

SCHEMAP_DERIVATION_OK_RESTRICTION_4_2 = 1798

SCHEMAP_DERIVATION_OK_RESTRICTION_4_3 = 1799

SCHEMAP_ELEMFORMDEFAULT_VALUE = 1705

SCHEMAP_ELEM_DEFAULT_FIXED = 1755

SCHEMAP_ELEM_NONAME_NOREF = 1706

SCHEMAP_EXTENSION_NO_BASE = 1707

SCHEMAP_E_PROPS_CORRECT_2 = 3045

SCHEMAP_E_PROPS_CORRECT_3 = 3046

SCHEMAP_E_PROPS_CORRECT_4 = 3047

SCHEMAP_E_PROPS_CORRECT_5 = 3048

SCHEMAP_E_PROPS_CORRECT_6 = 3049

SCHEMAP_FACET_NO_VALUE = 1708

SCHEMAP_FAILED_BUILD_IMPORT = 1709

SCHEMAP_FAILED_LOAD = 1757

SCHEMAP_FAILED_PARSE = 1766

SCHEMAP_GROUP_NONAME_NOREF = 1710

SCHEMAP_IMPORT_NAMESPACE_NOT_URI = 1711

SCHEMAP_IMPORT_REDEFINE_NSNAME = 1712

SCHEMAP_IMPORT_SCHEMA_NOT_URI = 1713

SCHEMAP_INCLUDE_SCHEMA_NOT_URI = 1770

SCHEMAP_INCLUDE_SCHEMA_NO_URI = 1771

SCHEMAP_INTERNAL = 3069

SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE = 1793

SCHEMAP_INVALID_ATTR_COMBINATION = 1777

SCHEMAP_INVALID_ATTR_INLINE_COMBINATION = 1778

SCHEMAP_INVALID_ATTR_NAME = 1780

SCHEMAP_INVALID_ATTR_USE = 1774

SCHEMAP_INVALID_BOOLEAN = 1714

SCHEMAP_INVALID_ENUM = 1715

SCHEMAP_INVALID_FACET = 1716

SCHEMAP_INVALID_FACET_VALUE = 1717

SCHEMAP_INVALID_MAXOCCURS = 1718

SCHEMAP_INVALID_MINOCCURS = 1719

SCHEMAP_INVALID_REF_AND_SUBTYPE = 1720

SCHEMAP_INVALID_WHITE_SPACE = 1721

SCHEMAP_MG_PROPS_CORRECT_1 = 3074

SCHEMAP_MG_PROPS_CORRECT_2 = 3075

SCHEMAP_MISSING_SIMPLETYPE_CHILD = 1779

SCHEMAP_NOATTR_NOREF = 1722

SCHEMAP_NOROOT = 1759

SCHEMAP_NOTATION_NO_NAME = 1723

SCHEMAP_NOTHING_TO_PARSE = 1758

SCHEMAP_NOTYPE_NOREF = 1724

SCHEMAP_NOT_DETERMINISTIC = 3070

SCHEMAP_NOT_SCHEMA = 1772

SCHEMAP_NO_XMLNS = 3056

SCHEMAP_NO_XSI = 3057

SCHEMAP_PREFIX_UNDEFINED = 1700

SCHEMAP_P_PROPS_CORRECT_1 = 3042

SCHEMAP_P_PROPS_CORRECT_2_1 = 3043

SCHEMAP_P_PROPS_CORRECT_2_2 = 3044

SCHEMAP_RECURSIVE = 1775

SCHEMAP_REDEFINED_ATTR = 1764

SCHEMAP_REDEFINED_ATTRGROUP = 1763

SCHEMAP_REDEFINED_ELEMENT = 1762

SCHEMAP_REDEFINED_GROUP = 1760

SCHEMAP_REDEFINED_NOTATION = 1765

SCHEMAP_REDEFINED_TYPE = 1761

SCHEMAP_REF_AND_CONTENT = 1781

SCHEMAP_REF_AND_SUBTYPE = 1725

SCHEMAP_REGEXP_INVALID = 1756

SCHEMAP_RESTRICTION_NONAME_NOREF = 1726

SCHEMAP_S4S_ATTR_INVALID_VALUE = 3037

SCHEMAP_S4S_ATTR_MISSING = 3036

SCHEMAP_S4S_ATTR_NOT_ALLOWED = 3035

SCHEMAP_S4S_ELEM_MISSING = 3034

SCHEMAP_S4S_ELEM_NOT_ALLOWED = 3033

SCHEMAP_SIMPLETYPE_NONAME = 1727

SCHEMAP_SRC_ATTRIBUTE_1 = 3051

SCHEMAP_SRC_ATTRIBUTE_2 = 3052

SCHEMAP_SRC_ATTRIBUTE_3_1 = 3053

SCHEMAP_SRC_ATTRIBUTE_3_2 = 3054

SCHEMAP_SRC_ATTRIBUTE_4 = 3055

SCHEMAP_SRC_ATTRIBUTE_GROUP_1 = 3071

SCHEMAP_SRC_ATTRIBUTE_GROUP_2 = 3072

SCHEMAP_SRC_ATTRIBUTE_GROUP_3 = 3073

SCHEMAP_SRC_CT_1 = 3076

SCHEMAP_SRC_ELEMENT_1 = 3038

SCHEMAP_SRC_ELEMENT_2_1 = 3039

SCHEMAP_SRC_ELEMENT_2_2 = 3040

SCHEMAP_SRC_ELEMENT_3 = 3041

SCHEMAP_SRC_IMPORT = 3082

SCHEMAP_SRC_IMPORT_1_1 = 3064

SCHEMAP_SRC_IMPORT_1_2 = 3065

SCHEMAP_SRC_IMPORT_2 = 3066

SCHEMAP_SRC_IMPORT_2_1 = 3067

SCHEMAP_SRC_IMPORT_2_2 = 3068

SCHEMAP_SRC_IMPORT_3_1 = 1795

SCHEMAP_SRC_IMPORT_3_2 = 1796

SCHEMAP_SRC_INCLUDE = 3050

SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE = 3006

SCHEMAP_SRC_REDEFINE = 3081

SCHEMAP_SRC_RESOLVE = 3004

SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE = 3005

SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000

SCHEMAP_SRC_SIMPLE_TYPE_2 = 3001

SCHEMAP_SRC_SIMPLE_TYPE_3 = 3002

SCHEMAP_SRC_SIMPLE_TYPE_4 = 3003

SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES = 3007

SCHEMAP_ST_PROPS_CORRECT_1 = 3008

SCHEMAP_ST_PROPS_CORRECT_2 = 3009

SCHEMAP_ST_PROPS_CORRECT_3 = 3010

SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE = 1776

SCHEMAP_TYPE_AND_SUBTYPE = 1728

SCHEMAP_UNION_NOT_EXPRESSIBLE = 1794

SCHEMAP_UNKNOWN_ALL_CHILD = 1729

SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD = 1730

SCHEMAP_UNKNOWN_ATTRGRP_CHILD = 1732

SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP = 1733

SCHEMAP_UNKNOWN_ATTR_CHILD = 1731

SCHEMAP_UNKNOWN_BASE_TYPE = 1734

SCHEMAP_UNKNOWN_CHOICE_CHILD = 1735

SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD = 1736

SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD = 1737

SCHEMAP_UNKNOWN_ELEM_CHILD = 1738

SCHEMAP_UNKNOWN_EXTENSION_CHILD = 1739

SCHEMAP_UNKNOWN_FACET_CHILD = 1740

SCHEMAP_UNKNOWN_FACET_TYPE = 1741

SCHEMAP_UNKNOWN_GROUP_CHILD = 1742

SCHEMAP_UNKNOWN_IMPORT_CHILD = 1743

SCHEMAP_UNKNOWN_INCLUDE_CHILD = 1769

SCHEMAP_UNKNOWN_LIST_CHILD = 1744

SCHEMAP_UNKNOWN_MEMBER_TYPE = 1773

SCHEMAP_UNKNOWN_NOTATION_CHILD = 1745

SCHEMAP_UNKNOWN_PREFIX = 1767

SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD = 1746

SCHEMAP_UNKNOWN_REF = 1747

SCHEMAP_UNKNOWN_RESTRICTION_CHILD = 1748

SCHEMAP_UNKNOWN_SCHEMAS_CHILD = 1749

SCHEMAP_UNKNOWN_SEQUENCE_CHILD = 1750

SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD = 1751

SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD = 1752

SCHEMAP_UNKNOWN_TYPE = 1753

SCHEMAP_UNKNOWN_UNION_CHILD = 1754

SCHEMAP_WARN_ATTR_POINTLESS_PROH = 3086

SCHEMAP_WARN_ATTR_REDECL_PROH = 3085

SCHEMAP_WARN_SKIP_SCHEMA = 3083

SCHEMAP_WARN_UNLOCATED_SCHEMA = 3084

SCHEMAP_WILDCARD_INVALID_NS_MEMBER = 1792

SCHEMATRONV_ASSERT = 4000

SCHEMATRONV_REPORT = 4001

SCHEMAV_ATTRINVALID = 1821

SCHEMAV_ATTRUNKNOWN = 1820

SCHEMAV_CONSTRUCT = 1817

SCHEMAV_CVC_ATTRIBUTE_1 = 1861

SCHEMAV_CVC_ATTRIBUTE_2 = 1862

SCHEMAV_CVC_ATTRIBUTE_3 = 1863

SCHEMAV_CVC_ATTRIBUTE_4 = 1864

SCHEMAV_CVC_AU = 1874

SCHEMAV_CVC_COMPLEX_TYPE_1 = 1873

SCHEMAV_CVC_COMPLEX_TYPE_2_1 = 1841

SCHEMAV_CVC_COMPLEX_TYPE_2_2 = 1842

SCHEMAV_CVC_COMPLEX_TYPE_2_3 = 1843

SCHEMAV_CVC_COMPLEX_TYPE_2_4 = 1844

SCHEMAV_CVC_COMPLEX_TYPE_3_1 = 1865

SCHEMAV_CVC_COMPLEX_TYPE_3_2_1 = 1866

SCHEMAV_CVC_COMPLEX_TYPE_3_2_2 = 1867

SCHEMAV_CVC_COMPLEX_TYPE_4 = 1868

SCHEMAV_CVC_COMPLEX_TYPE_5_1 = 1869

SCHEMAV_CVC_COMPLEX_TYPE_5_2 = 1870

SCHEMAV_CVC_DATATYPE_VALID_1_2_1 = 1824

SCHEMAV_CVC_DATATYPE_VALID_1_2_2 = 1825

SCHEMAV_CVC_DATATYPE_VALID_1_2_3 = 1826

SCHEMAV_CVC_ELT_1 = 1845

SCHEMAV_CVC_ELT_2 = 1846

SCHEMAV_CVC_ELT_3_1 = 1847

SCHEMAV_CVC_ELT_3_2_1 = 1848

SCHEMAV_CVC_ELT_3_2_2 = 1849

SCHEMAV_CVC_ELT_4_1 = 1850

SCHEMAV_CVC_ELT_4_2 = 1851

SCHEMAV_CVC_ELT_4_3 = 1852

SCHEMAV_CVC_ELT_5_1_1 = 1853

SCHEMAV_CVC_ELT_5_1_2 = 1854

SCHEMAV_CVC_ELT_5_2_1 = 1855

SCHEMAV_CVC_ELT_5_2_2_1 = 1856

SCHEMAV_CVC_ELT_5_2_2_2_1 = 1857

SCHEMAV_CVC_ELT_5_2_2_2_2 = 1858

SCHEMAV_CVC_ELT_6 = 1859

SCHEMAV_CVC_ELT_7 = 1860

SCHEMAV_CVC_ENUMERATION_VALID = 1840

SCHEMAV_CVC_FACET_VALID = 1829

SCHEMAV_CVC_FRACTIONDIGITS_VALID = 1838

SCHEMAV_CVC_IDC = 1877

SCHEMAV_CVC_LENGTH_VALID = 1830

SCHEMAV_CVC_MAXEXCLUSIVE_VALID = 1836

SCHEMAV_CVC_MAXINCLUSIVE_VALID = 1834

SCHEMAV_CVC_MAXLENGTH_VALID = 1832

SCHEMAV_CVC_MINEXCLUSIVE_VALID = 1835

SCHEMAV_CVC_MININCLUSIVE_VALID = 1833

SCHEMAV_CVC_MINLENGTH_VALID = 1831

SCHEMAV_CVC_PATTERN_VALID = 1839

SCHEMAV_CVC_TOTALDIGITS_VALID = 1837

SCHEMAV_CVC_TYPE_1 = 1875

SCHEMAV_CVC_TYPE_2 = 1876

SCHEMAV_CVC_TYPE_3_1_1 = 1827

SCHEMAV_CVC_TYPE_3_1_2 = 1828

SCHEMAV_CVC_WILDCARD = 1878

SCHEMAV_DOCUMENT_ELEMENT_MISSING = 1872

SCHEMAV_ELEMCONT = 1810

SCHEMAV_ELEMENT_CONTENT = 1871

SCHEMAV_EXTRACONTENT = 1813

SCHEMAV_FACET = 1823

SCHEMAV_HAVEDEFAULT = 1811

SCHEMAV_INTERNAL = 1818

SCHEMAV_INVALIDATTR = 1814

SCHEMAV_INVALIDELEM = 1815

SCHEMAV_ISABSTRACT = 1808

SCHEMAV_MISC = 1879

SCHEMAV_MISSING = 1804

SCHEMAV_NOROLLBACK = 1807

SCHEMAV_NOROOT = 1801

SCHEMAV_NOTDETERMINIST = 1816

SCHEMAV_NOTEMPTY = 1809

SCHEMAV_NOTNILLABLE = 1812

SCHEMAV_NOTSIMPLE = 1819

SCHEMAV_NOTTOPLEVEL = 1803

SCHEMAV_NOTYPE = 1806

SCHEMAV_UNDECLAREDELEM = 1802

SCHEMAV_VALUE = 1822

SCHEMAV_WRONGELEM = 1805

TREE_INVALID_DEC = 1301

TREE_INVALID_HEX = 1300

TREE_NOT_UTF8 = 1303

TREE_UNTERMINATED_ENTITY = 1302

WAR_CATALOG_PI = 93

WAR_ENTITY_REDEFINED = 107

WAR_LANG_VALUE = 98

WAR_NS_COLUMN = 106

WAR_NS_URI = 99

WAR_NS_URI_RELATIVE = 100

WAR_SPACE_VALUE = 102

WAR_UNDECLARED_ENTITY = 27

WAR_UNKNOWN_VERSION = 97

XINCLUDE_BUILD_FAILED = 1609

XINCLUDE_DEPRECATED_NS = 1617

XINCLUDE_ENTITY_DEF_MISMATCH = 1602

XINCLUDE_FALLBACKS_IN_INCLUDE = 1615

XINCLUDE_FALLBACK_NOT_IN_INCLUDE = 1616

XINCLUDE_FRAGMENT_ID = 1618

XINCLUDE_HREF_URI = 1605

XINCLUDE_INCLUDE_IN_INCLUDE = 1614

XINCLUDE_INVALID_CHAR = 1608

XINCLUDE_MULTIPLE_ROOT = 1611

XINCLUDE_NO_FALLBACK = 1604

XINCLUDE_NO_HREF = 1603

XINCLUDE_PARSE_VALUE = 1601

XINCLUDE_RECURSION = 1600

XINCLUDE_TEXT_DOCUMENT = 1607

XINCLUDE_TEXT_FRAGMENT = 1606

XINCLUDE_UNKNOWN_ENCODING = 1610

XINCLUDE_XPTR_FAILED = 1612

XINCLUDE_XPTR_RESULT = 1613

XPATH_ENCODING_ERROR = 1220

XPATH_EXPRESSION_OK = 1200

XPATH_EXPR_ERROR = 1207

XPATH_INVALID_ARITY = 1212

XPATH_INVALID_CHAR_ERROR = 1221

XPATH_INVALID_CTXT_POSITION = 1214

XPATH_INVALID_CTXT_SIZE = 1213

XPATH_INVALID_OPERAND = 1210

XPATH_INVALID_PREDICATE_ERROR = 1206

XPATH_INVALID_TYPE = 1211

XPATH_MEMORY_ERROR = 1215

XPATH_NUMBER_ERROR = 1201

XPATH_START_LITERAL_ERROR = 1203

XPATH_UNCLOSED_ERROR = 1208

XPATH_UNDEF_PREFIX_ERROR = 1219

XPATH_UNDEF_VARIABLE_ERROR = 1205

XPATH_UNFINISHED_LITERAL_ERROR = 1202

XPATH_UNKNOWN_FUNC_ERROR = 1209

XPATH_VARIABLE_REF_ERROR = 1204

XPTR_CHILDSEQ_START = 1901

XPTR_EVAL_FAILED = 1902

XPTR_EXTRA_OBJECTS = 1903

XPTR_RESOURCE_ERROR = 1217

XPTR_SUB_RESOURCE_ERROR = 1218

XPTR_SYNTAX_ERROR = 1216

XPTR_UNKNOWN_SCHEME = 1900

_names = {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', 8: 'ERR_INVALID_CHARREF', 9: 'ERR_INVALID_CHAR', 10: 'ERR_CHARREF_AT_EOF', 11: 'ERR_CHARREF_IN_PROLOG', 12: 'ERR_CHARREF_IN_EPILOG', 13: 'ERR_CHARREF_IN_DTD', 14: 'ERR_ENTITYREF_AT_EOF', 15: 'ERR_ENTITYREF_IN_PROLOG', 16: 'ERR_ENTITYREF_IN_EPILOG', 17: 'ERR_ENTITYREF_IN_DTD', 18: 'ERR_PEREF_AT_EOF', 19: 'ERR_PEREF_IN_PROLOG', 20: 'ERR_PEREF_IN_EPILOG', 21: 'ERR_PEREF_IN_INT_SUBSET', 22: 'ERR_ENTITYREF_NO_NAME', 23: 'ERR_ENTITYREF_SEMICOL_MISSING', 24: 'ERR_PEREF_NO_NAME', 25: 'ERR_PEREF_SEMICOL_MISSING', 26: 'ERR_UNDECLARED_ENTITY', 27: 'WAR_UNDECLARED_ENTITY', 28: 'ERR_UNPARSED_ENTITY', 29: 'ERR_ENTITY_IS_EXTERNAL', 30: 'ERR_ENTITY_IS_PARAMETER', 31: 'ERR_UNKNOWN_ENCODING', 32: 'ERR_UNSUPPORTED_ENCODING', 33: 'ERR_STRING_NOT_STARTED', 34: 'ERR_STRING_NOT_CLOSED', 35: 'ERR_NS_DECL_ERROR', 36: 'ERR_ENTITY_NOT_STARTED', 37: 'ERR_ENTITY_NOT_FINISHED', 38: 'ERR_LT_IN_ATTRIBUTE', 39: 'ERR_ATTRIBUTE_NOT_STARTED', 40: 'ERR_ATTRIBUTE_NOT_FINISHED', 41: 'ERR_ATTRIBUTE_WITHOUT_VALUE', 42: 'ERR_ATTRIBUTE_REDEFINED', 43: 'ERR_LITERAL_NOT_STARTED', 44: 'ERR_LITERAL_NOT_FINISHED', 45: 'ERR_COMMENT_NOT_FINISHED', 46: 'ERR_PI_NOT_STARTED', 47: 'ERR_PI_NOT_FINISHED', 48: 'ERR_NOTATION_NOT_STARTED', 49: 'ERR_NOTATION_NOT_FINISHED', 50: 'ERR_ATTLIST_NOT_STARTED', 51: 'ERR_ATTLIST_NOT_FINISHED', 52: 'ERR_MIXED_NOT_STARTED', 53: 'ERR_MIXED_NOT_FINISHED', 54: 'ERR_ELEMCONTENT_NOT_STARTED', 55: 'ERR_ELEMCONTENT_NOT_FINISHED', 56: 'ERR_XMLDECL_NOT_STARTED', 57: 'ERR_XMLDECL_NOT_FINISHED', 58: 'ERR_CONDSEC_NOT_STARTED', 59: 'ERR_CONDSEC_NOT_FINISHED', 60: 'ERR_EXT_SUBSET_NOT_FINISHED', 61: 'ERR_DOCTYPE_NOT_FINISHED', 62: 'ERR_MISPLACED_CDATA_END', 63: 'ERR_CDATA_NOT_FINISHED', 64: 'ERR_RESERVED_XML_NAME', 65: 'ERR_SPACE_REQUIRED', 66: 'ERR_SEPARATOR_REQUIRED', 67: 'ERR_NMTOKEN_REQUIRED', 68: 'ERR_NAME_REQUIRED', 69: 'ERR_PCDATA_REQUIRED', 70: 'ERR_URI_REQUIRED', 71: 'ERR_PUBID_REQUIRED', 72: 'ERR_LT_REQUIRED', 73: 'ERR_GT_REQUIRED', 74: 'ERR_LTSLASH_REQUIRED', 75: 'ERR_EQUAL_REQUIRED', 76: 'ERR_TAG_NAME_MISMATCH', 77: 'ERR_TAG_NOT_FINISHED', 78: 'ERR_STANDALONE_VALUE', 79: 'ERR_ENCODING_NAME', 80: 'ERR_HYPHEN_IN_COMMENT', 81: 'ERR_INVALID_ENCODING', 82: 'ERR_EXT_ENTITY_STANDALONE', 83: 'ERR_CONDSEC_INVALID', 84: 'ERR_VALUE_REQUIRED', 85: 'ERR_NOT_WELL_BALANCED', 86: 'ERR_EXTRA_CONTENT', 87: 'ERR_ENTITY_CHAR_ERROR', 88: 'ERR_ENTITY_PE_INTERNAL', 89: 'ERR_ENTITY_LOOP', 90: 'ERR_ENTITY_BOUNDARY', 91: 'ERR_INVALID_URI', 92: 'ERR_URI_FRAGMENT', 93: 'WAR_CATALOG_PI', 94: 'ERR_NO_DTD', 95: 'ERR_CONDSEC_INVALID_KEYWORD', 96: 'ERR_VERSION_MISSING', 97: 'WAR_UNKNOWN_VERSION', 98: 'WAR_LANG_VALUE', 99: 'WAR_NS_URI', 100: 'WAR_NS_URI_RELATIVE', 101: 'ERR_MISSING_ENCODING', 102: 'WAR_SPACE_VALUE', 103: 'ERR_NOT_STANDALONE', 104: 'ERR_ENTITY_PROCESSING', 105: 'ERR_NOTATION_PROCESSING', 106: 'WAR_NS_COLUMN', 107: 'WAR_ENTITY_REDEFINED', 108: 'ERR_UNKNOWN_VERSION', 109: 'ERR_VERSION_MISMATCH', 110: 'ERR_NAME_TOO_LONG', 111: 'ERR_USER_STOP', 112: 'ERR_COMMENT_ABRUPTLY_ENDED', 200: 'NS_ERR_XML_NAMESPACE', 201: 'NS_ERR_UNDEFINED_NAMESPACE', 202: 'NS_ERR_QNAME', 203: 'NS_ERR_ATTRIBUTE_REDEFINED', 204: 'NS_ERR_EMPTY', 205: 'NS_ERR_COLON', 500: 'DTD_ATTRIBUTE_DEFAULT', 501: 'DTD_ATTRIBUTE_REDEFINED', 502: 'DTD_ATTRIBUTE_VALUE', 503: 'DTD_CONTENT_ERROR', 504: 'DTD_CONTENT_MODEL', 505: 'DTD_CONTENT_NOT_DETERMINIST', 506: 'DTD_DIFFERENT_PREFIX', 507: 'DTD_ELEM_DEFAULT_NAMESPACE', 508: 'DTD_ELEM_NAMESPACE', 509: 'DTD_ELEM_REDEFINED', 510: 'DTD_EMPTY_NOTATION', 511: 'DTD_ENTITY_TYPE', 512: 'DTD_ID_FIXED', 513: 'DTD_ID_REDEFINED', 514: 'DTD_ID_SUBSET', 515: 'DTD_INVALID_CHILD', 516: 'DTD_INVALID_DEFAULT', 517: 'DTD_LOAD_ERROR', 518: 'DTD_MISSING_ATTRIBUTE', 519: 'DTD_MIXED_CORRUPT', 520: 'DTD_MULTIPLE_ID', 521: 'DTD_NO_DOC', 522: 'DTD_NO_DTD', 523: 'DTD_NO_ELEM_NAME', 524: 'DTD_NO_PREFIX', 525: 'DTD_NO_ROOT', 526: 'DTD_NOTATION_REDEFINED', 527: 'DTD_NOTATION_VALUE', 528: 'DTD_NOT_EMPTY', 529: 'DTD_NOT_PCDATA', 530: 'DTD_NOT_STANDALONE', 531: 'DTD_ROOT_NAME', 532: 'DTD_STANDALONE_WHITE_SPACE', 533: 'DTD_UNKNOWN_ATTRIBUTE', 534: 'DTD_UNKNOWN_ELEM', 535: 'DTD_UNKNOWN_ENTITY', 536: 'DTD_UNKNOWN_ID', 537: 'DTD_UNKNOWN_NOTATION', 538: 'DTD_STANDALONE_DEFAULTED', 539: 'DTD_XMLID_VALUE', 540: 'DTD_XMLID_TYPE', 541: 'DTD_DUP_TOKEN', 800: 'HTML_STRUCURE_ERROR', 801: 'HTML_UNKNOWN_TAG', 1000: 'RNGP_ANYNAME_ATTR_ANCESTOR', 1001: 'RNGP_ATTR_CONFLICT', 1002: 'RNGP_ATTRIBUTE_CHILDREN', 1003: 'RNGP_ATTRIBUTE_CONTENT', 1004: 'RNGP_ATTRIBUTE_EMPTY', 1005: 'RNGP_ATTRIBUTE_NOOP', 1006: 'RNGP_CHOICE_CONTENT', 1007: 'RNGP_CHOICE_EMPTY', 1008: 'RNGP_CREATE_FAILURE', 1009: 'RNGP_DATA_CONTENT', 1010: 'RNGP_DEF_CHOICE_AND_INTERLEAVE', 1011: 'RNGP_DEFINE_CREATE_FAILED', 1012: 'RNGP_DEFINE_EMPTY', 1013: 'RNGP_DEFINE_MISSING', 1014: 'RNGP_DEFINE_NAME_MISSING', 1015: 'RNGP_ELEM_CONTENT_EMPTY', 1016: 'RNGP_ELEM_CONTENT_ERROR', 1017: 'RNGP_ELEMENT_EMPTY', 1018: 'RNGP_ELEMENT_CONTENT', 1019: 'RNGP_ELEMENT_NAME', 1020: 'RNGP_ELEMENT_NO_CONTENT', 1021: 'RNGP_ELEM_TEXT_CONFLICT', 1022: 'RNGP_EMPTY', 1023: 'RNGP_EMPTY_CONSTRUCT', 1024: 'RNGP_EMPTY_CONTENT', 1025: 'RNGP_EMPTY_NOT_EMPTY', 1026: 'RNGP_ERROR_TYPE_LIB', 1027: 'RNGP_EXCEPT_EMPTY', 1028: 'RNGP_EXCEPT_MISSING', 1029: 'RNGP_EXCEPT_MULTIPLE', 1030: 'RNGP_EXCEPT_NO_CONTENT', 1031: 'RNGP_EXTERNALREF_EMTPY', 1032: 'RNGP_EXTERNAL_REF_FAILURE', 1033: 'RNGP_EXTERNALREF_RECURSE', 1034: 'RNGP_FORBIDDEN_ATTRIBUTE', 1035: 'RNGP_FOREIGN_ELEMENT', 1036: 'RNGP_GRAMMAR_CONTENT', 1037: 'RNGP_GRAMMAR_EMPTY', 1038: 'RNGP_GRAMMAR_MISSING', 1039: 'RNGP_GRAMMAR_NO_START', 1040: 'RNGP_GROUP_ATTR_CONFLICT', 1041: 'RNGP_HREF_ERROR', 1042: 'RNGP_INCLUDE_EMPTY', 1043: 'RNGP_INCLUDE_FAILURE', 1044: 'RNGP_INCLUDE_RECURSE', 1045: 'RNGP_INTERLEAVE_ADD', 1046: 'RNGP_INTERLEAVE_CREATE_FAILED', 1047: 'RNGP_INTERLEAVE_EMPTY', 1048: 'RNGP_INTERLEAVE_NO_CONTENT', 1049: 'RNGP_INVALID_DEFINE_NAME', 1050: 'RNGP_INVALID_URI', 1051: 'RNGP_INVALID_VALUE', 1052: 'RNGP_MISSING_HREF', 1053: 'RNGP_NAME_MISSING', 1054: 'RNGP_NEED_COMBINE', 1055: 'RNGP_NOTALLOWED_NOT_EMPTY', 1056: 'RNGP_NSNAME_ATTR_ANCESTOR', 1057: 'RNGP_NSNAME_NO_NS', 1058: 'RNGP_PARAM_FORBIDDEN', 1059: 'RNGP_PARAM_NAME_MISSING', 1060: 'RNGP_PARENTREF_CREATE_FAILED', 1061: 'RNGP_PARENTREF_NAME_INVALID', 1062: 'RNGP_PARENTREF_NO_NAME', 1063: 'RNGP_PARENTREF_NO_PARENT', 1064: 'RNGP_PARENTREF_NOT_EMPTY', 1065: 'RNGP_PARSE_ERROR', 1066: 'RNGP_PAT_ANYNAME_EXCEPT_ANYNAME', 1067: 'RNGP_PAT_ATTR_ATTR', 1068: 'RNGP_PAT_ATTR_ELEM', 1069: 'RNGP_PAT_DATA_EXCEPT_ATTR', 1070: 'RNGP_PAT_DATA_EXCEPT_ELEM', 1071: 'RNGP_PAT_DATA_EXCEPT_EMPTY', 1072: 'RNGP_PAT_DATA_EXCEPT_GROUP', 1073: 'RNGP_PAT_DATA_EXCEPT_INTERLEAVE', 1074: 'RNGP_PAT_DATA_EXCEPT_LIST', 1075: 'RNGP_PAT_DATA_EXCEPT_ONEMORE', 1076: 'RNGP_PAT_DATA_EXCEPT_REF', 1077: 'RNGP_PAT_DATA_EXCEPT_TEXT', 1078: 'RNGP_PAT_LIST_ATTR', 1079: 'RNGP_PAT_LIST_ELEM', 1080: 'RNGP_PAT_LIST_INTERLEAVE', 1081: 'RNGP_PAT_LIST_LIST', 1082: 'RNGP_PAT_LIST_REF', 1083: 'RNGP_PAT_LIST_TEXT', 1084: 'RNGP_PAT_NSNAME_EXCEPT_ANYNAME', 1085: 'RNGP_PAT_NSNAME_EXCEPT_NSNAME', 1086: 'RNGP_PAT_ONEMORE_GROUP_ATTR', 1087: 'RNGP_PAT_ONEMORE_INTERLEAVE_ATTR', 1088: 'RNGP_PAT_START_ATTR', 1089: 'RNGP_PAT_START_DATA', 1090: 'RNGP_PAT_START_EMPTY', 1091: 'RNGP_PAT_START_GROUP', 1092: 'RNGP_PAT_START_INTERLEAVE', 1093: 'RNGP_PAT_START_LIST', 1094: 'RNGP_PAT_START_ONEMORE', 1095: 'RNGP_PAT_START_TEXT', 1096: 'RNGP_PAT_START_VALUE', 1097: 'RNGP_PREFIX_UNDEFINED', 1098: 'RNGP_REF_CREATE_FAILED', 1099: 'RNGP_REF_CYCLE', 1100: 'RNGP_REF_NAME_INVALID', 1101: 'RNGP_REF_NO_DEF', 1102: 'RNGP_REF_NO_NAME', 1103: 'RNGP_REF_NOT_EMPTY', 1104: 'RNGP_START_CHOICE_AND_INTERLEAVE', 1105: 'RNGP_START_CONTENT', 1106: 'RNGP_START_EMPTY', 1107: 'RNGP_START_MISSING', 1108: 'RNGP_TEXT_EXPECTED', 1109: 'RNGP_TEXT_HAS_CHILD', 1110: 'RNGP_TYPE_MISSING', 1111: 'RNGP_TYPE_NOT_FOUND', 1112: 'RNGP_TYPE_VALUE', 1113: 'RNGP_UNKNOWN_ATTRIBUTE', 1114: 'RNGP_UNKNOWN_COMBINE', 1115: 'RNGP_UNKNOWN_CONSTRUCT', 1116: 'RNGP_UNKNOWN_TYPE_LIB', 1117: 'RNGP_URI_FRAGMENT', 1118: 'RNGP_URI_NOT_ABSOLUTE', 1119: 'RNGP_VALUE_EMPTY', 1120: 'RNGP_VALUE_NO_CONTENT', 1121: 'RNGP_XMLNS_NAME', 1122: 'RNGP_XML_NS', 1200: 'XPATH_EXPRESSION_OK', 1201: 'XPATH_NUMBER_ERROR', 1202: 'XPATH_UNFINISHED_LITERAL_ERROR', 1203: 'XPATH_START_LITERAL_ERROR', 1204: 'XPATH_VARIABLE_REF_ERROR', 1205: 'XPATH_UNDEF_VARIABLE_ERROR', 1206: 'XPATH_INVALID_PREDICATE_ERROR', 1207: 'XPATH_EXPR_ERROR', 1208: 'XPATH_UNCLOSED_ERROR', 1209: 'XPATH_UNKNOWN_FUNC_ERROR', 1210: 'XPATH_INVALID_OPERAND', 1211: 'XPATH_INVALID_TYPE', 1212: 'XPATH_INVALID_ARITY', 1213: 'XPATH_INVALID_CTXT_SIZE', 1214: 'XPATH_INVALID_CTXT_POSITION', 1215: 'XPATH_MEMORY_ERROR', 1216: 'XPTR_SYNTAX_ERROR', 1217: 'XPTR_RESOURCE_ERROR', 1218: 'XPTR_SUB_RESOURCE_ERROR', 1219: 'XPATH_UNDEF_PREFIX_ERROR', 1220: 'XPATH_ENCODING_ERROR', 1221: 'XPATH_INVALID_CHAR_ERROR', 1300: 'TREE_INVALID_HEX', 1301: 'TREE_INVALID_DEC', 1302: 'TREE_UNTERMINATED_ENTITY', 1303: 'TREE_NOT_UTF8', 1400: 'SAVE_NOT_UTF8', 1401: 'SAVE_CHAR_INVALID', 1402: 'SAVE_NO_DOCTYPE', 1403: 'SAVE_UNKNOWN_ENCODING', 1450: 'REGEXP_COMPILE_ERROR', 1500: 'IO_UNKNOWN', 1501: 'IO_EACCES', 1502: 'IO_EAGAIN', 1503: 'IO_EBADF', 1504: 'IO_EBADMSG', 1505: 'IO_EBUSY', 1506: 'IO_ECANCELED', 1507: 'IO_ECHILD', 1508: 'IO_EDEADLK', 1509: 'IO_EDOM', 1510: 'IO_EEXIST', 1511: 'IO_EFAULT', 1512: 'IO_EFBIG', 1513: 'IO_EINPROGRESS', 1514: 'IO_EINTR', 1515: 'IO_EINVAL', 1516: 'IO_EIO', 1517: 'IO_EISDIR', 1518: 'IO_EMFILE', 1519: 'IO_EMLINK', 1520: 'IO_EMSGSIZE', 1521: 'IO_ENAMETOOLONG', 1522: 'IO_ENFILE', 1523: 'IO_ENODEV', 1524: 'IO_ENOENT', 1525: 'IO_ENOEXEC', 1526: 'IO_ENOLCK', 1527: 'IO_ENOMEM', 1528: 'IO_ENOSPC', 1529: 'IO_ENOSYS', 1530: 'IO_ENOTDIR', 1531: 'IO_ENOTEMPTY', 1532: 'IO_ENOTSUP', 1533: 'IO_ENOTTY', 1534: 'IO_ENXIO', 1535: 'IO_EPERM', 1536: 'IO_EPIPE', 1537: 'IO_ERANGE', 1538: 'IO_EROFS', 1539: 'IO_ESPIPE', 1540: 'IO_ESRCH', 1541: 'IO_ETIMEDOUT', 1542: 'IO_EXDEV', 1543: 'IO_NETWORK_ATTEMPT', 1544: 'IO_ENCODER', 1545: 'IO_FLUSH', 1546: 'IO_WRITE', 1547: 'IO_NO_INPUT', 1548: 'IO_BUFFER_FULL', 1549: 'IO_LOAD_ERROR', 1550: 'IO_ENOTSOCK', 1551: 'IO_EISCONN', 1552: 'IO_ECONNREFUSED', 1553: 'IO_ENETUNREACH', 1554: 'IO_EADDRINUSE', 1555: 'IO_EALREADY', 1556: 'IO_EAFNOSUPPORT', 1600: 'XINCLUDE_RECURSION', 1601: 'XINCLUDE_PARSE_VALUE', 1602: 'XINCLUDE_ENTITY_DEF_MISMATCH', 1603: 'XINCLUDE_NO_HREF', 1604: 'XINCLUDE_NO_FALLBACK', 1605: 'XINCLUDE_HREF_URI', 1606: 'XINCLUDE_TEXT_FRAGMENT', 1607: 'XINCLUDE_TEXT_DOCUMENT', 1608: 'XINCLUDE_INVALID_CHAR', 1609: 'XINCLUDE_BUILD_FAILED', 1610: 'XINCLUDE_UNKNOWN_ENCODING', 1611: 'XINCLUDE_MULTIPLE_ROOT', 1612: 'XINCLUDE_XPTR_FAILED', 1613: 'XINCLUDE_XPTR_RESULT', 1614: 'XINCLUDE_INCLUDE_IN_INCLUDE', 1615: 'XINCLUDE_FALLBACKS_IN_INCLUDE', 1616: 'XINCLUDE_FALLBACK_NOT_IN_INCLUDE', 1617: 'XINCLUDE_DEPRECATED_NS', 1618: 'XINCLUDE_FRAGMENT_ID', 1650: 'CATALOG_MISSING_ATTR', 1651: 'CATALOG_ENTRY_BROKEN', 1652: 'CATALOG_PREFER_VALUE', 1653: 'CATALOG_NOT_CATALOG', 1654: 'CATALOG_RECURSION', 1700: 'SCHEMAP_PREFIX_UNDEFINED', 1701: 'SCHEMAP_ATTRFORMDEFAULT_VALUE', 1702: 'SCHEMAP_ATTRGRP_NONAME_NOREF', 1703: 'SCHEMAP_ATTR_NONAME_NOREF', 1704: 'SCHEMAP_COMPLEXTYPE_NONAME_NOREF', 1705: 'SCHEMAP_ELEMFORMDEFAULT_VALUE', 1706: 'SCHEMAP_ELEM_NONAME_NOREF', 1707: 'SCHEMAP_EXTENSION_NO_BASE', 1708: 'SCHEMAP_FACET_NO_VALUE', 1709: 'SCHEMAP_FAILED_BUILD_IMPORT', 1710: 'SCHEMAP_GROUP_NONAME_NOREF', 1711: 'SCHEMAP_IMPORT_NAMESPACE_NOT_URI', 1712: 'SCHEMAP_IMPORT_REDEFINE_NSNAME', 1713: 'SCHEMAP_IMPORT_SCHEMA_NOT_URI', 1714: 'SCHEMAP_INVALID_BOOLEAN', 1715: 'SCHEMAP_INVALID_ENUM', 1716: 'SCHEMAP_INVALID_FACET', 1717: 'SCHEMAP_INVALID_FACET_VALUE', 1718: 'SCHEMAP_INVALID_MAXOCCURS', 1719: 'SCHEMAP_INVALID_MINOCCURS', 1720: 'SCHEMAP_INVALID_REF_AND_SUBTYPE', 1721: 'SCHEMAP_INVALID_WHITE_SPACE', 1722: 'SCHEMAP_NOATTR_NOREF', 1723: 'SCHEMAP_NOTATION_NO_NAME', 1724: 'SCHEMAP_NOTYPE_NOREF', 1725: 'SCHEMAP_REF_AND_SUBTYPE', 1726: 'SCHEMAP_RESTRICTION_NONAME_NOREF', 1727: 'SCHEMAP_SIMPLETYPE_NONAME', 1728: 'SCHEMAP_TYPE_AND_SUBTYPE', 1729: 'SCHEMAP_UNKNOWN_ALL_CHILD', 1730: 'SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD', 1731: 'SCHEMAP_UNKNOWN_ATTR_CHILD', 1732: 'SCHEMAP_UNKNOWN_ATTRGRP_CHILD', 1733: 'SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP', 1734: 'SCHEMAP_UNKNOWN_BASE_TYPE', 1735: 'SCHEMAP_UNKNOWN_CHOICE_CHILD', 1736: 'SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD', 1737: 'SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD', 1738: 'SCHEMAP_UNKNOWN_ELEM_CHILD', 1739: 'SCHEMAP_UNKNOWN_EXTENSION_CHILD', 1740: 'SCHEMAP_UNKNOWN_FACET_CHILD', 1741: 'SCHEMAP_UNKNOWN_FACET_TYPE', 1742: 'SCHEMAP_UNKNOWN_GROUP_CHILD', 1743: 'SCHEMAP_UNKNOWN_IMPORT_CHILD', 1744: 'SCHEMAP_UNKNOWN_LIST_CHILD', 1745: 'SCHEMAP_UNKNOWN_NOTATION_CHILD', 1746: 'SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD', 1747: 'SCHEMAP_UNKNOWN_REF', 1748: 'SCHEMAP_UNKNOWN_RESTRICTION_CHILD', 1749: 'SCHEMAP_UNKNOWN_SCHEMAS_CHILD', 1750: 'SCHEMAP_UNKNOWN_SEQUENCE_CHILD', 1751: 'SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD', 1752: 'SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD', 1753: 'SCHEMAP_UNKNOWN_TYPE', 1754: 'SCHEMAP_UNKNOWN_UNION_CHILD', 1755: 'SCHEMAP_ELEM_DEFAULT_FIXED', 1756: 'SCHEMAP_REGEXP_INVALID', 1757: 'SCHEMAP_FAILED_LOAD', 1758: 'SCHEMAP_NOTHING_TO_PARSE', 1759: 'SCHEMAP_NOROOT', 1760: 'SCHEMAP_REDEFINED_GROUP', 1761: 'SCHEMAP_REDEFINED_TYPE', 1762: 'SCHEMAP_REDEFINED_ELEMENT', 1763: 'SCHEMAP_REDEFINED_ATTRGROUP', 1764: 'SCHEMAP_REDEFINED_ATTR', 1765: 'SCHEMAP_REDEFINED_NOTATION', 1766: 'SCHEMAP_FAILED_PARSE', 1767: 'SCHEMAP_UNKNOWN_PREFIX', 1768: 'SCHEMAP_DEF_AND_PREFIX', 1769: 'SCHEMAP_UNKNOWN_INCLUDE_CHILD', 1770: 'SCHEMAP_INCLUDE_SCHEMA_NOT_URI', 1771: 'SCHEMAP_INCLUDE_SCHEMA_NO_URI', 1772: 'SCHEMAP_NOT_SCHEMA', 1773: 'SCHEMAP_UNKNOWN_MEMBER_TYPE', 1774: 'SCHEMAP_INVALID_ATTR_USE', 1775: 'SCHEMAP_RECURSIVE', 1776: 'SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE', 1777: 'SCHEMAP_INVALID_ATTR_COMBINATION', 1778: 'SCHEMAP_INVALID_ATTR_INLINE_COMBINATION', 1779: 'SCHEMAP_MISSING_SIMPLETYPE_CHILD', 1780: 'SCHEMAP_INVALID_ATTR_NAME', 1781: 'SCHEMAP_REF_AND_CONTENT', 1782: 'SCHEMAP_CT_PROPS_CORRECT_1', 1783: 'SCHEMAP_CT_PROPS_CORRECT_2', 1784: 'SCHEMAP_CT_PROPS_CORRECT_3', 1785: 'SCHEMAP_CT_PROPS_CORRECT_4', 1786: 'SCHEMAP_CT_PROPS_CORRECT_5', 1787: 'SCHEMAP_DERIVATION_OK_RESTRICTION_1', 1788: 'SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1', 1789: 'SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2', 1790: 'SCHEMAP_DERIVATION_OK_RESTRICTION_2_2', 1791: 'SCHEMAP_DERIVATION_OK_RESTRICTION_3', 1792: 'SCHEMAP_WILDCARD_INVALID_NS_MEMBER', 1793: 'SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE', 1794: 'SCHEMAP_UNION_NOT_EXPRESSIBLE', 1795: 'SCHEMAP_SRC_IMPORT_3_1', 1796: 'SCHEMAP_SRC_IMPORT_3_2', 1797: 'SCHEMAP_DERIVATION_OK_RESTRICTION_4_1', 1798: 'SCHEMAP_DERIVATION_OK_RESTRICTION_4_2', 1799: 'SCHEMAP_DERIVATION_OK_RESTRICTION_4_3', 1800: 'SCHEMAP_COS_CT_EXTENDS_1_3', 1801: 'SCHEMAV_NOROOT', 1802: 'SCHEMAV_UNDECLAREDELEM', 1803: 'SCHEMAV_NOTTOPLEVEL', 1804: 'SCHEMAV_MISSING', 1805: 'SCHEMAV_WRONGELEM', 1806: 'SCHEMAV_NOTYPE', 1807: 'SCHEMAV_NOROLLBACK', 1808: 'SCHEMAV_ISABSTRACT', 1809: 'SCHEMAV_NOTEMPTY', 1810: 'SCHEMAV_ELEMCONT', 1811: 'SCHEMAV_HAVEDEFAULT', 1812: 'SCHEMAV_NOTNILLABLE', 1813: 'SCHEMAV_EXTRACONTENT', 1814: 'SCHEMAV_INVALIDATTR', 1815: 'SCHEMAV_INVALIDELEM', 1816: 'SCHEMAV_NOTDETERMINIST', 1817: 'SCHEMAV_CONSTRUCT', 1818: 'SCHEMAV_INTERNAL', 1819: 'SCHEMAV_NOTSIMPLE', 1820: 'SCHEMAV_ATTRUNKNOWN', 1821: 'SCHEMAV_ATTRINVALID', 1822: 'SCHEMAV_VALUE', 1823: 'SCHEMAV_FACET', 1824: 'SCHEMAV_CVC_DATATYPE_VALID_1_2_1', 1825: 'SCHEMAV_CVC_DATATYPE_VALID_1_2_2', 1826: 'SCHEMAV_CVC_DATATYPE_VALID_1_2_3', 1827: 'SCHEMAV_CVC_TYPE_3_1_1', 1828: 'SCHEMAV_CVC_TYPE_3_1_2', 1829: 'SCHEMAV_CVC_FACET_VALID', 1830: 'SCHEMAV_CVC_LENGTH_VALID', 1831: 'SCHEMAV_CVC_MINLENGTH_VALID', 1832: 'SCHEMAV_CVC_MAXLENGTH_VALID', 1833: 'SCHEMAV_CVC_MININCLUSIVE_VALID', 1834: 'SCHEMAV_CVC_MAXINCLUSIVE_VALID', 1835: 'SCHEMAV_CVC_MINEXCLUSIVE_VALID', 1836: 'SCHEMAV_CVC_MAXEXCLUSIVE_VALID', 1837: 'SCHEMAV_CVC_TOTALDIGITS_VALID', 1838: 'SCHEMAV_CVC_FRACTIONDIGITS_VALID', 1839: 'SCHEMAV_CVC_PATTERN_VALID', 1840: 'SCHEMAV_CVC_ENUMERATION_VALID', 1841: 'SCHEMAV_CVC_COMPLEX_TYPE_2_1', 1842: 'SCHEMAV_CVC_COMPLEX_TYPE_2_2', 1843: 'SCHEMAV_CVC_COMPLEX_TYPE_2_3', 1844: 'SCHEMAV_CVC_COMPLEX_TYPE_2_4', 1845: 'SCHEMAV_CVC_ELT_1', 1846: 'SCHEMAV_CVC_ELT_2', 1847: 'SCHEMAV_CVC_ELT_3_1', 1848: 'SCHEMAV_CVC_ELT_3_2_1', 1849: 'SCHEMAV_CVC_ELT_3_2_2', 1850: 'SCHEMAV_CVC_ELT_4_1', 1851: 'SCHEMAV_CVC_ELT_4_2', 1852: 'SCHEMAV_CVC_ELT_4_3', 1853: 'SCHEMAV_CVC_ELT_5_1_1', 1854: 'SCHEMAV_CVC_ELT_5_1_2', 1855: 'SCHEMAV_CVC_ELT_5_2_1', 1856: 'SCHEMAV_CVC_ELT_5_2_2_1', 1857: 'SCHEMAV_CVC_ELT_5_2_2_2_1', 1858: 'SCHEMAV_CVC_ELT_5_2_2_2_2', 1859: 'SCHEMAV_CVC_ELT_6', 1860: 'SCHEMAV_CVC_ELT_7', 1861: 'SCHEMAV_CVC_ATTRIBUTE_1', 1862: 'SCHEMAV_CVC_ATTRIBUTE_2', 1863: 'SCHEMAV_CVC_ATTRIBUTE_3', 1864: 'SCHEMAV_CVC_ATTRIBUTE_4', 1865: 'SCHEMAV_CVC_COMPLEX_TYPE_3_1', 1866: 'SCHEMAV_CVC_COMPLEX_TYPE_3_2_1', 1867: 'SCHEMAV_CVC_COMPLEX_TYPE_3_2_2', 1868: 'SCHEMAV_CVC_COMPLEX_TYPE_4', 1869: 'SCHEMAV_CVC_COMPLEX_TYPE_5_1', 1870: 'SCHEMAV_CVC_COMPLEX_TYPE_5_2', 1871: 'SCHEMAV_ELEMENT_CONTENT', 1872: 'SCHEMAV_DOCUMENT_ELEMENT_MISSING', 1873: 'SCHEMAV_CVC_COMPLEX_TYPE_1', 1874: 'SCHEMAV_CVC_AU', 1875: 'SCHEMAV_CVC_TYPE_1', 1876: 'SCHEMAV_CVC_TYPE_2', 1877: 'SCHEMAV_CVC_IDC', 1878: 'SCHEMAV_CVC_WILDCARD', 1879: 'SCHEMAV_MISC', 1900: 'XPTR_UNKNOWN_SCHEME', 1901: 'XPTR_CHILDSEQ_START', 1902: 'XPTR_EVAL_FAILED', 1903: 'XPTR_EXTRA_OBJECTS', 1950: 'C14N_CREATE_CTXT', 1951: 'C14N_REQUIRES_UTF8', 1952: 'C14N_CREATE_STACK', 1953: 'C14N_INVALID_NODE', 1954: 'C14N_UNKNOW_NODE', 1955: 'C14N_RELATIVE_NAMESPACE', 2000: 'FTP_PASV_ANSWER', 2001: 'FTP_EPSV_ANSWER', 2002: 'FTP_ACCNT', 2003: 'FTP_URL_SYNTAX', 2020: 'HTTP_URL_SYNTAX', 2021: 'HTTP_USE_IP', 2022: 'HTTP_UNKNOWN_HOST', 3000: 'SCHEMAP_SRC_SIMPLE_TYPE_1', 3001: 'SCHEMAP_SRC_SIMPLE_TYPE_2', 3002: 'SCHEMAP_SRC_SIMPLE_TYPE_3', 3003: 'SCHEMAP_SRC_SIMPLE_TYPE_4', 3004: 'SCHEMAP_SRC_RESOLVE', 3005: 'SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE', 3006: 'SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE', 3007: 'SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES', 3008: 'SCHEMAP_ST_PROPS_CORRECT_1', 3009: 'SCHEMAP_ST_PROPS_CORRECT_2', 3010: 'SCHEMAP_ST_PROPS_CORRECT_3', 3011: 'SCHEMAP_COS_ST_RESTRICTS_1_1', 3012: 'SCHEMAP_COS_ST_RESTRICTS_1_2', 3013: 'SCHEMAP_COS_ST_RESTRICTS_1_3_1', 3014: 'SCHEMAP_COS_ST_RESTRICTS_1_3_2', 3015: 'SCHEMAP_COS_ST_RESTRICTS_2_1', 3016: 'SCHEMAP_COS_ST_RESTRICTS_2_3_1_1', 3017: 'SCHEMAP_COS_ST_RESTRICTS_2_3_1_2', 3018: 'SCHEMAP_COS_ST_RESTRICTS_2_3_2_1', 3019: 'SCHEMAP_COS_ST_RESTRICTS_2_3_2_2', 3020: 'SCHEMAP_COS_ST_RESTRICTS_2_3_2_3', 3021: 'SCHEMAP_COS_ST_RESTRICTS_2_3_2_4', 3022: 'SCHEMAP_COS_ST_RESTRICTS_2_3_2_5', 3023: 'SCHEMAP_COS_ST_RESTRICTS_3_1', 3024: 'SCHEMAP_COS_ST_RESTRICTS_3_3_1', 3025: 'SCHEMAP_COS_ST_RESTRICTS_3_3_1_2', 3026: 'SCHEMAP_COS_ST_RESTRICTS_3_3_2_2', 3027: 'SCHEMAP_COS_ST_RESTRICTS_3_3_2_1', 3028: 'SCHEMAP_COS_ST_RESTRICTS_3_3_2_3', 3029: 'SCHEMAP_COS_ST_RESTRICTS_3_3_2_4', 3030: 'SCHEMAP_COS_ST_RESTRICTS_3_3_2_5', 3031: 'SCHEMAP_COS_ST_DERIVED_OK_2_1', 3032: 'SCHEMAP_COS_ST_DERIVED_OK_2_2', 3033: 'SCHEMAP_S4S_ELEM_NOT_ALLOWED', 3034: 'SCHEMAP_S4S_ELEM_MISSING', 3035: 'SCHEMAP_S4S_ATTR_NOT_ALLOWED', 3036: 'SCHEMAP_S4S_ATTR_MISSING', 3037: 'SCHEMAP_S4S_ATTR_INVALID_VALUE', 3038: 'SCHEMAP_SRC_ELEMENT_1', 3039: 'SCHEMAP_SRC_ELEMENT_2_1', 3040: 'SCHEMAP_SRC_ELEMENT_2_2', 3041: 'SCHEMAP_SRC_ELEMENT_3', 3042: 'SCHEMAP_P_PROPS_CORRECT_1', 3043: 'SCHEMAP_P_PROPS_CORRECT_2_1', 3044: 'SCHEMAP_P_PROPS_CORRECT_2_2', 3045: 'SCHEMAP_E_PROPS_CORRECT_2', 3046: 'SCHEMAP_E_PROPS_CORRECT_3', 3047: 'SCHEMAP_E_PROPS_CORRECT_4', 3048: 'SCHEMAP_E_PROPS_CORRECT_5', 3049: 'SCHEMAP_E_PROPS_CORRECT_6', 3050: 'SCHEMAP_SRC_INCLUDE', 3051: 'SCHEMAP_SRC_ATTRIBUTE_1', 3052: 'SCHEMAP_SRC_ATTRIBUTE_2', 3053: 'SCHEMAP_SRC_ATTRIBUTE_3_1', 3054: 'SCHEMAP_SRC_ATTRIBUTE_3_2', 3055: 'SCHEMAP_SRC_ATTRIBUTE_4', 3056: 'SCHEMAP_NO_XMLNS', 3057: 'SCHEMAP_NO_XSI', 3058: 'SCHEMAP_COS_VALID_DEFAULT_1', 3059: 'SCHEMAP_COS_VALID_DEFAULT_2_1', 3060: 'SCHEMAP_COS_VALID_DEFAULT_2_2_1', 3061: 'SCHEMAP_COS_VALID_DEFAULT_2_2_2', 3062: 'SCHEMAP_CVC_SIMPLE_TYPE', 3063: 'SCHEMAP_COS_CT_EXTENDS_1_1', 3064: 'SCHEMAP_SRC_IMPORT_1_1', 3065: 'SCHEMAP_SRC_IMPORT_1_2', 3066: 'SCHEMAP_SRC_IMPORT_2', 3067: 'SCHEMAP_SRC_IMPORT_2_1', 3068: 'SCHEMAP_SRC_IMPORT_2_2', 3069: 'SCHEMAP_INTERNAL', 3070: 'SCHEMAP_NOT_DETERMINISTIC', 3071: 'SCHEMAP_SRC_ATTRIBUTE_GROUP_1', 3072: 'SCHEMAP_SRC_ATTRIBUTE_GROUP_2', 3073: 'SCHEMAP_SRC_ATTRIBUTE_GROUP_3', 3074: 'SCHEMAP_MG_PROPS_CORRECT_1', 3075: 'SCHEMAP_MG_PROPS_CORRECT_2', 3076: 'SCHEMAP_SRC_CT_1', 3077: 'SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3', 3078: 'SCHEMAP_AU_PROPS_CORRECT_2', 3079: 'SCHEMAP_A_PROPS_CORRECT_2', 3080: 'SCHEMAP_C_PROPS_CORRECT', 3081: 'SCHEMAP_SRC_REDEFINE', 3082: 'SCHEMAP_SRC_IMPORT', 3083: 'SCHEMAP_WARN_SKIP_SCHEMA', 3084: 'SCHEMAP_WARN_UNLOCATED_SCHEMA', 3085: 'SCHEMAP_WARN_ATTR_REDECL_PROH', 3086: 'SCHEMAP_WARN_ATTR_POINTLESS_PROH', 3087: 'SCHEMAP_AG_PROPS_CORRECT', 3088: 'SCHEMAP_COS_CT_EXTENDS_1_2', 3089: 'SCHEMAP_AU_PROPS_CORRECT', 3090: 'SCHEMAP_A_PROPS_CORRECT_3', 3091: 'SCHEMAP_COS_ALL_LIMITED', 4000: 'SCHEMATRONV_ASSERT', 4001: 'SCHEMATRONV_REPORT', 4900: 'MODULE_OPEN', 4901: 'MODULE_CLOSE', 5000: 'CHECK_FOUND_ELEMENT', 5001: 'CHECK_FOUND_ATTRIBUTE', 5002: 'CHECK_FOUND_TEXT', 5003: 'CHECK_FOUND_CDATA', 5004: 'CHECK_FOUND_ENTITYREF', 5005: 'CHECK_FOUND_ENTITY', 5006: 'CHECK_FOUND_PI', 5007: 'CHECK_FOUND_COMMENT', 5008: 'CHECK_FOUND_DOCTYPE', 5009: 'CHECK_FOUND_FRAGMENT', 5010: 'CHECK_FOUND_NOTATION', 5011: 'CHECK_UNKNOWN_NODE', 5012: 'CHECK_ENTITY_TYPE', 5013: 'CHECK_NO_PARENT', 5014: 'CHECK_NO_DOC', 5015: 'CHECK_NO_NAME', 5016: 'CHECK_NO_ELEM', 5017: 'CHECK_WRONG_DOC', 5018: 'CHECK_NO_PREV', 5019: 'CHECK_WRONG_PREV', 5020: 'CHECK_NO_NEXT', 5021: 'CHECK_WRONG_NEXT', 5022: 'CHECK_NOT_DTD', 5023: 'CHECK_NOT_ATTR', 5024: 'CHECK_NOT_ATTR_DECL', 5025: 'CHECK_NOT_ELEM_DECL', 5026: 'CHECK_NOT_ENTITY_DECL', 5027: 'CHECK_NOT_NS_DECL', 5028: 'CHECK_NO_HREF', 5029: 'CHECK_WRONG_PARENT', 5030: 'CHECK_NS_SCOPE', 5031: 'CHECK_NS_ANCESTOR', 5032: 'CHECK_NOT_UTF8', 5033: 'CHECK_NO_DICT', 5034: 'CHECK_NOT_NCNAME', 5035: 'CHECK_OUTSIDE_DICT', 5036: 'CHECK_WRONG_NAME', 5037: 'CHECK_NAME_NOT_NULL', 6000: 'I18N_NO_NAME', 6001: 'I18N_NO_HANDLER', 6002: 'I18N_EXCESS_HANDLER', 6003: 'I18N_CONV_FAILED', 6004: 'I18N_NO_OUTPUT', 7000: 'BUF_OVERFLOW'}

class lxml.etree.FallbackElementClassLookup(self, fallback=None)

Bases: ElementClassLookup

Superclass of Element class lookups with additional fallback.

set_fallback(self, lookup): Sets the fallback scheme for this lookup method.

fallback

class lxml.etree.HTMLParser(self, encoding=None, remove_blank_text=False, remove_comments=False, remove_pis=False, strip_cdata=True, no_network=True, target=None, schema: XMLSchema = None, recover=True, compact=True, collect_ids=True, huge_tree=False)

Bases: _FeedParser

The HTML parser.

This parser allows reading HTML into a normal XML tree. By default, it can read broken (non well-formed) HTML, depending on the capabilities of libxml2. Use the ‘recover’ option to switch this off.

Available boolean keyword arguments:

recover - try hard to parse through broken HTML (default: True)
no_network - prevent network access for related files (default: True)
remove_blank_text - discard empty text nodes that are ignorable (i.e. not actual text content)
remove_comments - discard comments
remove_pis - discard processing instructions
strip_cdata - replace CDATA sections by normal text content (default: True)
compact - save memory for short text content (default: True)
default_doctype - add a default doctype even if it is not found in the HTML (default: True)
collect_ids - use a hash table of XML IDs for fast access (default: True)
huge_tree - disable security restrictions and support very deep trees
and very long text content (only affects libxml2 2.7+)

Other keyword arguments:

encoding - override the document encoding
target - a parser target object that will receive the parse events
schema - an XMLSchema to validate against

Note that you should avoid sharing parsers between threads for performance reasons.

close(self)

Terminates feeding data to this parser. This tells the parser to process any remaining data in the feed buffer, and then returns the root Element of the tree that was parsed.

This method must be called after passing the last chunk of data into the feed() method. It should only be called when using the feed parser interface, all other usage is undefined.

copy(self): Create a new parser with the same configuration.

feed(self, data)

Feeds data to the parser. The argument should be an 8-bit string buffer containing encoded data, although Unicode is supported as long as both string types are not mixed.

This is the main entry point to the consumer interface of a parser. The parser will parse as much of the XML stream as it can on each call. To finish parsing or to reset the parser, call the close() method. Both methods may raise ParseError if errors occur in the input data. If an error is raised, there is no longer a need to call close().

The feed parser interface is independent of the normal parser usage. You can use the same parser as a feed parser and in the parse() function concurrently.

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with this parser.

setElementClassLookup(lookup)

Deprecated: use parser.set_element_class_lookup(lookup) instead.

set_element_class_lookup(self, lookup=None)

Set a lookup scheme for element classes generated from this parser.

Reset it by passing None or nothing.

error_log: The error log of the last parser run.

feed_error_log

The error log of the last (or current) run of the feed parser.

Note that this is local to the feed parser and thus is different from what the error_log property returns.

resolvers: The custom resolver registry of this parser.

target

version: The version of the underlying XML parser.

class lxml.etree.HTMLPullParser(self, events=None, *, tag=None, base_url=None, **kwargs)

Bases: HTMLParser

HTML parser that collects parse events in an iterator.

The collected events are the same as for iterparse(), but the parser itself is non-blocking in the sense that it receives data chunks incrementally through its .feed() method, instead of reading them directly from a file(-like) object all by itself.

By default, it collects Element end events. To change that, pass any subset of the available events into the events argument: 'start', 'end', 'start-ns', 'end-ns', 'comment', 'pi'.

To support loading external dependencies relative to the input source, you can pass the base_url.

close(self)

Terminates feeding data to this parser. This tells the parser to process any remaining data in the feed buffer, and then returns the root Element of the tree that was parsed.

This method must be called after passing the last chunk of data into the feed() method. It should only be called when using the feed parser interface, all other usage is undefined.

copy(self): Create a new parser with the same configuration.

feed(self, data)

Feeds data to the parser. The argument should be an 8-bit string buffer containing encoded data, although Unicode is supported as long as both string types are not mixed.

This is the main entry point to the consumer interface of a parser. The parser will parse as much of the XML stream as it can on each call. To finish parsing or to reset the parser, call the close() method. Both methods may raise ParseError if errors occur in the input data. If an error is raised, there is no longer a need to call close().

The feed parser interface is independent of the normal parser usage. You can use the same parser as a feed parser and in the parse() function concurrently.

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with this parser.

read_events()

setElementClassLookup(lookup)

Deprecated: use parser.set_element_class_lookup(lookup) instead.

set_element_class_lookup(self, lookup=None)

Set a lookup scheme for element classes generated from this parser.

Reset it by passing None or nothing.

error_log: The error log of the last parser run.

feed_error_log

The error log of the last (or current) run of the feed parser.

Note that this is local to the feed parser and thus is different from what the error_log property returns.

resolvers: The custom resolver registry of this parser.

target

version: The version of the underlying XML parser.

class lxml.etree.PIBase

Bases: _ProcessingInstruction

All custom Processing Instruction classes must inherit from this one.

To create an XML ProcessingInstruction instance, use the PI() factory.

Subclasses must not override __init__ or __new__ as it is absolutely undefined when these objects will be created or destroyed. All persistent state of PIs must be stored in the underlying XML. If you really need to initialize the object after creation, you can implement an _init(self) method that will be called after object creation.

_init(self): Called after object initialisation. Custom subclasses may override this if they recursively call _init() in the superclasses.

addnext(self, element)

Adds the element as a following sibling directly after this element.

This is normally used to set a processing instruction or comment after the root node of a document. Note that tail text is automatically discarded when adding at the root level.

addprevious(self, element)

Adds the element as a preceding sibling directly before this element.

This is normally used to set a processing instruction or comment before the root node of a document. Note that tail text is automatically discarded when adding at the root level.

append(self, value)

clear(self, keep_tail=False)

Resets an element. This function removes all subelements, clears all attributes and sets the text and tail properties to None.

Pass keep_tail=True to leave the tail text untouched.

cssselect(expr, *, translator)

Run the CSS expression on this element and its children, returning a list of the results.

Equivalent to lxml.cssselect.CSSSelect(expr)(self) – note that pre-compiling the expression can provide a substantial speedup.

extend(self, elements): Extends the current children by the elements in the iterable.

find(self, path, namespaces=None)

Finds the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds text for the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

get(self, key, default=None)

Try to parse pseudo-attributes from the text content of the processing instruction, search for one with the given key as name and return its associated value.

Note that this is only a convenience method for the most common case that all text content is structured in attribute-like name-value pairs with properly quoted values. It is not guaranteed to work for all possible text content.

getchildren(self)

Returns all direct children. The elements are returned in document order.

Deprecated: Note that this method has been deprecated as of ElementTree 1.3 and lxml 2.0. New code should use list(element) or simply iterate over elements.

getiterator(self, tag=None, *tags)

Returns a sequence or iterator of all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags, see iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the element.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getnext(self): Returns the following sibling of this element or None.

getparent(self): Returns the parent of this element or None for the root element.

getprevious(self): Returns the preceding sibling of this element or None.

getroottree(self)

Return an ElementTree for the root node of the document that contains this element.

This is the same as following element.getparent() up the tree until it returns None (for the root element) and then build an ElementTree for the last parent that was returned.

index(self, child, start=None, stop=None)

Find the position of the child within the parent.

This method is not part of the original ElementTree API.

insert(self, index, value)

items(self)

iter(self, tag=None, *tags)

Iterate over all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags: pass "{ns}localname" as tag. Either or both of ns and localname can be * for a wildcard; ns can be empty for no namespace. "localname" is equivalent to "{}localname" (i.e. no namespace) but "*" is "{*}*" (any or no namespace), not "{}*".

You can also pass the Element, Comment, ProcessingInstruction and Entity factory functions to look only for the specific element type.

Passing multiple tags (or a sequence of tags) instead of a single tag will let the iterator return all elements matching any of these tags, in document order.

iterancestors(self, tag=None, *tags)

Iterate over the ancestors of this element (from parent to parent).

Can be restricted to find only elements with specific tags, see iter.

iterchildren(self, tag=None, *tags, reversed=False)

Iterate over the children of this element.

As opposed to using normal iteration on this element, the returned elements can be reversed with the ‘reversed’ keyword and restricted to find only elements with specific tags, see iter.

iterdescendants(self, tag=None, *tags)

Iterate over the descendants of this element in document order.

As opposed to el.iter(), this iterator does not yield the element itself. The returned elements can be restricted to find only elements with specific tags, see iter.

iterfind(self, path, namespaces=None)

Iterates over all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

itersiblings(self, tag=None, *tags, preceding=False)

Iterate over the following or preceding siblings of this element.

The direction is determined by the ‘preceding’ keyword which defaults to False, i.e. forward iteration over the following siblings. When True, the iterator yields the preceding siblings in reverse document order, i.e. starting right before the current element and going backwards.

Can be restricted to find only elements with specific tags, see iter.

itertext(self, tag=None, *tags, with_tail=True)

Iterates over the text content of a subtree.

You can pass tag names to restrict text content to specific elements, see iter.

You can set the with_tail keyword argument to False to skip over tail text.

keys(self)

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with the same document.

remove(self, element): Removes a matching subelement. Unlike the find methods, this method compares elements based on identity, not on tag value or contents.

replace(self, old_element, new_element): Replaces a subelement with the element passed as second argument.

set(self, key, value)

values(self)

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): Evaluate an xpath expression using the element as context node.

attrib: Returns a dict containing all pseudo-attributes that can be parsed from the text content of this processing instruction. Note that modifying the dict currently has no effect on the XML node, although this is not guaranteed to stay this way.

base

The base URI of the Element (xml:base or HTML base URL). None if the base URI is unknown.

Note that the value depends on the URL of the document that holds the Element if there is no xml:base attribute on the Element or its ancestors.

Setting this property will set an xml:base attribute on the Element, regardless of the document type (XML or HTML).

nsmap

Namespace prefix->URI mapping known in the context of this Element. This includes all namespace declarations of the parents.

Note that changing the returned dict has no effect on the Element.

prefix: Namespace prefix or None.

sourceline: Original line number as found by the parser or None if unknown.

tag

tail: Text after this element’s end tag, but before the next sibling element’s start tag. This is either a string or the value None, if there was no text.

target

text

class lxml.etree.ParserBasedElementClassLookup(self, fallback=None)

Bases: FallbackElementClassLookup

Element class lookup based on the XML parser.

set_fallback(self, lookup): Sets the fallback scheme for this lookup method.

fallback

class lxml.etree.PyErrorLog(self, logger_name=None, logger=None)

Bases: _BaseErrorLog

A global error log that connects to the Python stdlib logging package.

The constructor accepts an optional logger name or a readily instantiated logger instance.

If you want to change the mapping between libxml2’s ErrorLevels and Python logging levels, you can modify the level_map dictionary from a subclass.

The default mapping is:

ErrorLevels.WARNING = logging.WARNING
ErrorLevels.ERROR   = logging.ERROR
ErrorLevels.FATAL   = logging.CRITICAL

You can also override the method receive() that takes a LogEntry object and calls self.log(log_entry, format_string, arg1, arg2, ...) with appropriate data.

copy(): Dummy method that returns an empty error log.

log(self, log_entry, message, *args)

Called by the .receive() method to log a _LogEntry instance to the Python logging system. This handles the error level mapping.

In the default implementation, the message argument receives a complete log line, and there are no further args. To change the message format, it is best to override the .receive() method instead of this one.

receive(self, log_entry)

Receive a _LogEntry instance from the logging system. Calls the .log() method with appropriate parameters:

self.log(log_entry, repr(log_entry))

You can override this method to provide your own log output format.

last_error

level_map

class lxml.etree.PythonElementClassLookup(self, fallback=None)

Bases: FallbackElementClassLookup

Element class lookup based on a subclass method.

This class lookup scheme allows access to the entire XML tree in read-only mode. To use it, re-implement the lookup(self, doc, root) method in a subclass:

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

If you return None from this method, the fallback will be called.

The first argument is the opaque document instance that contains the Element. The second argument is a lightweight Element proxy implementation that is only valid during the lookup. Do not try to keep a reference to it. Once the lookup is done, the proxy will be invalid.

Also, you cannot wrap such a read-only Element in an ElementTree, and you must take care not to keep a reference to them outside of the lookup() method.

Note that the API of the Element objects is not complete. It is purely read-only and does not support all features of the normal lxml.etree API (such as XPath, extended slicing or some iteration methods).

See https://lxml.de/element_classes.html

lookup(self, doc, element): Override this method to implement your own lookup scheme.

set_fallback(self, lookup): Sets the fallback scheme for this lookup method.

fallback

class lxml.etree.QName(text_or_uri_or_element, tag=None)

Bases: object

QName wrapper for qualified XML names.

Pass a tag name by itself or a namespace URI and a tag name to create a qualified name. Alternatively, pass an Element to extract its tag name. None as first argument is ignored in order to allow for generic 2-argument usage.

The text property holds the qualified name in {namespace}tagname notation. The namespace and localname properties hold the respective parts of the tag name.

You can pass QName objects wherever a tag name is expected. Also, setting Element text from a QName will resolve the namespace prefix on assignment and set a qualified text value. This is helpful in XML languages like SOAP or XML-Schema that use prefixed tag names in their text content.

localname

namespace

text

class lxml.etree.RelaxNG(self, etree=None, file=None)

Bases: _Validator

Turn a document into a Relax NG validator.

Either pass a schema as Element or ElementTree, or pass a file or filename through the file keyword argument.

_append_log_message(domain, type, level, line, message, filename)

_clear_error_log()

assertValid(self, etree): Raises DocumentInvalid if the document does not comply with the schema.

assert_(self, etree): Raises AssertionError if the document does not comply with the schema.

classmethod from_rnc_string(src, base_url)

Parse a RelaxNG schema in compact syntax from a text string

Requires the rnc2rng package to be installed.

Passing the source URL or file path of the source as ‘base_url’ will enable resolving resource references relative to the source.

validate(self, etree)

Validate the document using this schema.

Returns true if document is valid, false if not.

error_log: The log of validation errors and warnings.

class lxml.etree.RelaxNGErrorTypes

Bases: object

Libxml2 RelaxNG error types

_getName(default=None, /): Return the value for key if key is in the dictionary, else default.

RELAXNG_ERR_ATTREXTRANS = 20

RELAXNG_ERR_ATTRNAME = 14

RELAXNG_ERR_ATTRNONS = 16

RELAXNG_ERR_ATTRVALID = 24

RELAXNG_ERR_ATTRWRONGNS = 18

RELAXNG_ERR_CONTENTVALID = 25

RELAXNG_ERR_DATAELEM = 28

RELAXNG_ERR_DATATYPE = 31

RELAXNG_ERR_DUPID = 4

RELAXNG_ERR_ELEMEXTRANS = 19

RELAXNG_ERR_ELEMNAME = 13

RELAXNG_ERR_ELEMNONS = 15

RELAXNG_ERR_ELEMNOTEMPTY = 21

RELAXNG_ERR_ELEMWRONG = 38

RELAXNG_ERR_ELEMWRONGNS = 17

RELAXNG_ERR_EXTRACONTENT = 26

RELAXNG_ERR_EXTRADATA = 35

RELAXNG_ERR_INTEREXTRA = 12

RELAXNG_ERR_INTERNAL = 37

RELAXNG_ERR_INTERNODATA = 10

RELAXNG_ERR_INTERSEQ = 11

RELAXNG_ERR_INVALIDATTR = 27

RELAXNG_ERR_LACKDATA = 36

RELAXNG_ERR_LIST = 33

RELAXNG_ERR_LISTELEM = 30

RELAXNG_ERR_LISTEMPTY = 9

RELAXNG_ERR_LISTEXTRA = 8

RELAXNG_ERR_MEMORY = 1

RELAXNG_ERR_NODEFINE = 7

RELAXNG_ERR_NOELEM = 22

RELAXNG_ERR_NOGRAMMAR = 34

RELAXNG_ERR_NOSTATE = 6

RELAXNG_ERR_NOTELEM = 23

RELAXNG_ERR_TEXTWRONG = 39

RELAXNG_ERR_TYPE = 2

RELAXNG_ERR_TYPECMP = 5

RELAXNG_ERR_TYPEVAL = 3

RELAXNG_ERR_VALELEM = 29

RELAXNG_ERR_VALUE = 32

RELAXNG_OK = 0

_names = {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', 8: 'RELAXNG_ERR_LISTEXTRA', 9: 'RELAXNG_ERR_LISTEMPTY', 10: 'RELAXNG_ERR_INTERNODATA', 11: 'RELAXNG_ERR_INTERSEQ', 12: 'RELAXNG_ERR_INTEREXTRA', 13: 'RELAXNG_ERR_ELEMNAME', 14: 'RELAXNG_ERR_ATTRNAME', 15: 'RELAXNG_ERR_ELEMNONS', 16: 'RELAXNG_ERR_ATTRNONS', 17: 'RELAXNG_ERR_ELEMWRONGNS', 18: 'RELAXNG_ERR_ATTRWRONGNS', 19: 'RELAXNG_ERR_ELEMEXTRANS', 20: 'RELAXNG_ERR_ATTREXTRANS', 21: 'RELAXNG_ERR_ELEMNOTEMPTY', 22: 'RELAXNG_ERR_NOELEM', 23: 'RELAXNG_ERR_NOTELEM', 24: 'RELAXNG_ERR_ATTRVALID', 25: 'RELAXNG_ERR_CONTENTVALID', 26: 'RELAXNG_ERR_EXTRACONTENT', 27: 'RELAXNG_ERR_INVALIDATTR', 28: 'RELAXNG_ERR_DATAELEM', 29: 'RELAXNG_ERR_VALELEM', 30: 'RELAXNG_ERR_LISTELEM', 31: 'RELAXNG_ERR_DATATYPE', 32: 'RELAXNG_ERR_VALUE', 33: 'RELAXNG_ERR_LIST', 34: 'RELAXNG_ERR_NOGRAMMAR', 35: 'RELAXNG_ERR_EXTRADATA', 36: 'RELAXNG_ERR_LACKDATA', 37: 'RELAXNG_ERR_INTERNAL', 38: 'RELAXNG_ERR_ELEMWRONG', 39: 'RELAXNG_ERR_TEXTWRONG'}

class lxml.etree.Resolver

Bases: object

This is the base class of all resolvers.

resolve(self, system_url, public_id, context)

Override this method to resolve an external source by system_url and public_id. The third argument is an opaque context object.

Return the result of one of the resolve_*() methods.

resolve_empty(self, context)

Return an empty input document.

Pass context as parameter.

resolve_file(self, f, context, base_url=None, close=True)

Return an open file-like object as input document.

Pass open file and context as parameters. You can pass the base URL or filename of the file through the base_url keyword argument. If the close flag is True (the default), the file will be closed after reading.

Note that using .resolve_filename() is more efficient, especially in threaded environments.

resolve_filename(self, filename, context)

Return the name of a parsable file as input document.

Pass filename and context as parameters. You can also pass a URL with an HTTP, FTP or file target.

resolve_string(self, string, context, base_url=None)

Return a parsable string as input document.

Pass data string and context as parameters. You can pass the source URL or filename through the base_url keyword argument.

class lxml.etree.Schematron(self, etree=None, file=None)

Bases: _Validator

A Schematron validator.

Pass a root Element or an ElementTree to turn it into a validator. Alternatively, pass a filename as keyword argument ‘file’ to parse from the file system.

Schematron is a less well known, but very powerful schema language. The main idea is to use the capabilities of XPath to put restrictions on the structure and the content of XML documents. Here is a simple example:

>>> schematron = Schematron(XML('''
... <schema xmlns="http://www.ascc.net/xml/schematron" >
...   <pattern name="id is the only permitted 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

Schematron was added to libxml2 in version 2.6.21. Before version 2.6.32, however, Schematron lacked support for error reporting other than to stderr. This version is therefore required to retrieve validation warnings and errors in lxml.

_append_log_message(domain, type, level, line, message, filename)

_clear_error_log()

assertValid(self, etree): Raises DocumentInvalid if the document does not comply with the schema.

assert_(self, etree): Raises AssertionError if the document does not comply with the schema.

validate(self, etree)

Validate the document using this schema.

Returns true if document is valid, false if not.

error_log: The log of validation errors and warnings.

class lxml.etree.SiblingsIterator(self, node, tag=None, preceding=False)

Bases: _ElementMatchIterator

Iterates over the siblings of an element.

You can pass the boolean keyword preceding to specify the direction.

class lxml.etree.TreeBuilder

Bases: _SaxParserTarget

TreeBuilder(self, element_factory=None, parser=None,: comment_factory=None, pi_factory=None, insert_comments=True, insert_pis=True)

Parser target that builds a tree from parse event callbacks.

The factory arguments can be used to influence the creation of elements, comments and processing instructions.

By default, comments and processing instructions are inserted into the tree, but they can be ignored by passing the respective flags.

The final tree is returned by the close() method.

close(self): Flushes the builder buffers, and returns the toplevel document element. Raises XMLSyntaxError on inconsistencies.

comment(self, comment): Creates a comment using the factory, appends it (unless disabled) and returns it.

data(self, data): Adds text to the current element. The value should be either an 8-bit string containing ASCII text, or a Unicode string.

end(self, tag): Closes the current element.

pi(self, target, data=None): Creates a processing instruction using the factory, appends it (unless disabled) and returns it.

start(self, tag, attrs, nsmap=None): Opens a new element.

class lxml.etree.XInclude(self)

Bases: object

XInclude processor.

Create an instance and call it on an Element to run XInclude processing.

error_log

class lxml.etree.XMLParser(self, encoding=None, attribute_defaults=False, dtd_validation=False, load_dtd=False, no_network=True, ns_clean=False, recover=False, schema: XMLSchema = None, huge_tree=False, remove_blank_text=False, resolve_entities=True, remove_comments=False, remove_pis=False, strip_cdata=True, collect_ids=True, target=None, compact=True)

Bases: _FeedParser

The XML parser.

Parsers can be supplied as additional argument to various parse functions of the lxml API. A default parser is always available and can be replaced by a call to the global function ‘set_default_parser’. New parsers can be created at any time without a major run-time overhead.

The keyword arguments in the constructor are mainly based on the libxml2 parser configuration. A DTD will also be loaded if DTD validation or attribute default values are requested (unless you additionally provide an XMLSchema from which the default attributes can be read).

Available boolean keyword arguments:

attribute_defaults - inject default attributes from DTD or XMLSchema
dtd_validation - validate against a DTD referenced by the document
load_dtd - use DTD for parsing
no_network - prevent network access for related files (default: True)
ns_clean - clean up redundant namespace declarations
recover - try hard to parse through broken XML
remove_blank_text - discard blank text nodes that appear ignorable
remove_comments - discard comments
remove_pis - discard processing instructions
strip_cdata - replace CDATA sections by normal text content (default: True)
compact - save memory for short text content (default: True)
collect_ids - use a hash table of XML IDs for fast access (default: True, always True with DTD validation)
resolve_entities - replace entities by their text value (default: True)
huge_tree - disable security restrictions and support very deep trees
and very long text content (only affects libxml2 2.7+)

Other keyword arguments:

encoding - override the document encoding
target - a parser target object that will receive the parse events
schema - an XMLSchema to validate against

Note that you should avoid sharing parsers between threads. While this is not harmful, it is more efficient to use separate parsers. This does not apply to the default parser.

close(self)

Terminates feeding data to this parser. This tells the parser to process any remaining data in the feed buffer, and then returns the root Element of the tree that was parsed.

This method must be called after passing the last chunk of data into the feed() method. It should only be called when using the feed parser interface, all other usage is undefined.

copy(self): Create a new parser with the same configuration.

feed(self, data)

Feeds data to the parser. The argument should be an 8-bit string buffer containing encoded data, although Unicode is supported as long as both string types are not mixed.

This is the main entry point to the consumer interface of a parser. The parser will parse as much of the XML stream as it can on each call. To finish parsing or to reset the parser, call the close() method. Both methods may raise ParseError if errors occur in the input data. If an error is raised, there is no longer a need to call close().

The feed parser interface is independent of the normal parser usage. You can use the same parser as a feed parser and in the parse() function concurrently.

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with this parser.

setElementClassLookup(lookup)

Deprecated: use parser.set_element_class_lookup(lookup) instead.

set_element_class_lookup(self, lookup=None)

Set a lookup scheme for element classes generated from this parser.

Reset it by passing None or nothing.

error_log: The error log of the last parser run.

feed_error_log

The error log of the last (or current) run of the feed parser.

Note that this is local to the feed parser and thus is different from what the error_log property returns.

resolvers: The custom resolver registry of this parser.

target

version: The version of the underlying XML parser.

class lxml.etree.XMLPullParser(self, events=None, *, tag=None, **kwargs)

Bases: XMLParser

XML parser that collects parse events in an iterator.

The collected events are the same as for iterparse(), but the parser itself is non-blocking in the sense that it receives data chunks incrementally through its .feed() method, instead of reading them directly from a file(-like) object all by itself.

By default, it collects Element end events. To change that, pass any subset of the available events into the events argument: 'start', 'end', 'start-ns', 'end-ns', 'comment', 'pi'.

To support loading external dependencies relative to the input source, you can pass the base_url.

close(self)

Terminates feeding data to this parser. This tells the parser to process any remaining data in the feed buffer, and then returns the root Element of the tree that was parsed.

This method must be called after passing the last chunk of data into the feed() method. It should only be called when using the feed parser interface, all other usage is undefined.

copy(self): Create a new parser with the same configuration.

feed(self, data)

Feeds data to the parser. The argument should be an 8-bit string buffer containing encoded data, although Unicode is supported as long as both string types are not mixed.

This is the main entry point to the consumer interface of a parser. The parser will parse as much of the XML stream as it can on each call. To finish parsing or to reset the parser, call the close() method. Both methods may raise ParseError if errors occur in the input data. If an error is raised, there is no longer a need to call close().

The feed parser interface is independent of the normal parser usage. You can use the same parser as a feed parser and in the parse() function concurrently.

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with this parser.

read_events()

setElementClassLookup(lookup)

Deprecated: use parser.set_element_class_lookup(lookup) instead.

set_element_class_lookup(self, lookup=None)

Set a lookup scheme for element classes generated from this parser.

Reset it by passing None or nothing.

error_log: The error log of the last parser run.

feed_error_log

The error log of the last (or current) run of the feed parser.

Note that this is local to the feed parser and thus is different from what the error_log property returns.

resolvers: The custom resolver registry of this parser.

target

version: The version of the underlying XML parser.

class lxml.etree.XMLSchema(self, etree=None, file=None)

Bases: _Validator

Turn a document into an XML Schema validator.

Either pass a schema as Element or ElementTree, or pass a file or filename through the file keyword argument.

Passing the attribute_defaults boolean option will make the schema insert default/fixed attributes into validated documents.

_append_log_message(domain, type, level, line, message, filename)

_clear_error_log()

assertValid(self, etree): Raises DocumentInvalid if the document does not comply with the schema.

assert_(self, etree): Raises AssertionError if the document does not comply with the schema.

validate(self, etree)

Validate the document using this schema.

Returns true if document is valid, false if not.

error_log: The log of validation errors and warnings.

lxml.etree.XMLTreeBuilder: alias of ETCompatXMLParser

class lxml.etree.XPath(self, path, namespaces=None, extensions=None, regexp=True, smart_strings=True)

Bases: _XPathEvaluatorBase

A compiled XPath expression that can be called on Elements and ElementTrees.

Besides the XPath expression, you can pass prefix-namespace mappings and extension functions to the constructor through the keyword arguments namespaces and extensions. EXSLT regular expression support can be disabled with the ‘regexp’ boolean keyword (defaults to True). Smart strings will be returned for string results unless you pass smart_strings=False.

evaluate(self, _eval_arg, **_variables)

Evaluate an XPath expression.

Instead of calling this method, you can also call the evaluator object itself.

Variables may be provided as keyword arguments. Note that namespaces are currently not supported for variables.

Deprecated: call the object, not its method.

error_log

path: The literal XPath expression.

class lxml.etree.XPathDocumentEvaluator(self, etree, namespaces=None, extensions=None, regexp=True, smart_strings=True)

Bases: XPathElementEvaluator

Create an XPath evaluator for an ElementTree.

Additional namespace declarations can be passed with the ‘namespace’ keyword argument. EXSLT regular expression support can be disabled with the ‘regexp’ boolean keyword (defaults to True). Smart strings will be returned for string results unless you pass smart_strings=False.

evaluate(self, _eval_arg, **_variables)

Evaluate an XPath expression.

Instead of calling this method, you can also call the evaluator object itself.

Variables may be provided as keyword arguments. Note that namespaces are currently not supported for variables.

Deprecated: call the object, not its method.

register_namespace(prefix, uri): Register a namespace with the XPath context.

register_namespaces(namespaces): Register a prefix -> uri dict.

error_log

class lxml.etree.XPathElementEvaluator(self, element, namespaces=None, extensions=None, regexp=True, smart_strings=True)

Bases: _XPathEvaluatorBase

Create an XPath evaluator for an element.

Absolute XPath expressions (starting with ‘/’) will be evaluated against the ElementTree as returned by getroottree().

Additional namespace declarations can be passed with the ‘namespace’ keyword argument. EXSLT regular expression support can be disabled with the ‘regexp’ boolean keyword (defaults to True). Smart strings will be returned for string results unless you pass smart_strings=False.

evaluate(self, _eval_arg, **_variables)

Evaluate an XPath expression.

Instead of calling this method, you can also call the evaluator object itself.

Variables may be provided as keyword arguments. Note that namespaces are currently not supported for variables.

Deprecated: call the object, not its method.

register_namespace(prefix, uri): Register a namespace with the XPath context.

register_namespaces(namespaces): Register a prefix -> uri dict.

error_log

class lxml.etree.XSLT(self, xslt_input, extensions=None, regexp=True, access_control=None)

Bases: object

Turn an XSL document into an XSLT object.

Calling this object on a tree or Element will execute the XSLT:

transform = etree.XSLT(xsl_tree)
result = transform(xml_tree)

Keyword arguments of the constructor:

extensions: a dict mapping (namespace, name) pairs to extension functions or extension elements
regexp: enable exslt regular expression support in XPath (default: True)
access_control: access restrictions for network or file system (see XSLTAccessControl)

Keyword arguments of the XSLT call:

profile_run: enable XSLT profiling and make the profile available as XML document in result.xslt_profile (default: False)

Other keyword arguments of the call are passed to the stylesheet as parameters.

apply(self, _input, profile_run=False, **kw)

Deprecated: call the object, not this method.

static set_global_max_depth(max_depth)

The maximum traversal depth that the stylesheet engine will allow. This does not only count the template recursion depth but also takes the number of variables/parameters into account. The required setting for a run depends on both the stylesheet and the input data.

Example:

XSLT.set_global_max_depth(5000)

Note that this is currently a global, module-wide setting because libxslt does not support it at a per-stylesheet level.

static strparam(strval)

Mark an XSLT string parameter that requires quote escaping before passing it into the transformation. Use it like this:

result = transform(doc, some_strval = XSLT.strparam(
    '''it's "Monty Python's" ...'''))

Escaped string parameters can be reused without restriction.

tostring(self, result_tree)

Save result doc to string based on stylesheet output method.

Deprecated: use str(result_tree) instead.

error_log: The log of errors and warnings of an XSLT execution.

class lxml.etree.XSLTAccessControl(self, read_file=True, write_file=True, create_dir=True, read_network=True, write_network=True)

Bases: object

Access control for XSLT: reading/writing files, directories and network I/O. Access to a type of resource is granted or denied by passing any of the following boolean keyword arguments. All of them default to True to allow access.

read_file
write_file
create_dir
read_network
write_network

For convenience, there is also a class member DENY_ALL that provides an XSLTAccessControl instance that is readily configured to deny everything, and a DENY_WRITE member that denies all write access but allows read access.

See XSLT.

DENY_ALL = XSLTAccessControl(create_dir=False, read_file=False, read_network=False, write_file=False, write_network=False)

DENY_WRITE = XSLTAccessControl(create_dir=False, read_file=True, read_network=True, write_file=False, write_network=False)

options: The access control configuration as a map of options.

class lxml.etree.XSLTExtension

Bases: object

Base class of an XSLT extension element.

apply_templates(self, context, node, output_parent=None, elements_only=False, remove_blank_text=False)

Call this method to retrieve the result of applying templates to an element.

The return value is a list of elements or text strings that were generated by the XSLT processor. If you pass elements_only=True, strings will be discarded from the result list. The option remove_blank_text=True will only discard strings that consist entirely of whitespace (e.g. formatting). These options do not apply to Elements, only to bare string results.

If you pass an Element as output_parent parameter, the result will instead be appended to the element (including attributes etc.) and the return value will be None. This is a safe way to generate content into the output document directly, without having to take care of special values like text or attributes. Note that the string discarding options will be ignored in this case.

execute(self, context, self_node, input_node, output_parent)

Execute this extension element.

Subclasses must override this method. They may append elements to the output_parent element here, or set its text content. To this end, the input_node provides read-only access to the current node in the input document, and the self_node points to the extension element in the stylesheet.

Note that the output_parent parameter may be None if there is no parent element in the current context (e.g. no content was added to the output tree yet).

process_children(self, context, output_parent=None, elements_only=False, remove_blank_text=False)

Call this method to process the XSLT content of the extension element itself.

The return value is a list of elements or text strings that were generated by the XSLT processor. If you pass elements_only=True, strings will be discarded from the result list. The option remove_blank_text=True will only discard strings that consist entirely of whitespace (e.g. formatting). These options do not apply to Elements, only to bare string results.

If you pass an Element as output_parent parameter, the result will instead be appended to the element (including attributes etc.) and the return value will be None. This is a safe way to generate content into the output document directly, without having to take care of special values like text or attributes. Note that the string discarding options will be ignored in this case.

class lxml.etree._Attrib

Bases: object

A dict-like proxy for the Element.attrib property.

clear()

get(key, default)

has_key(key)

items()

iteritems()

iterkeys()

itervalues()

keys()

pop(key, *default)

update(sequence_or_dict)

values()

class lxml.etree._BaseErrorLog

Bases: object

copy()

receive(entry)

last_error

class lxml.etree._Comment

Bases: __ContentOnlyElement

_init(self): Called after object initialisation. Custom subclasses may override this if they recursively call _init() in the superclasses.

addnext(self, element)

Adds the element as a following sibling directly after this element.

This is normally used to set a processing instruction or comment after the root node of a document. Note that tail text is automatically discarded when adding at the root level.

addprevious(self, element)

Adds the element as a preceding sibling directly before this element.

This is normally used to set a processing instruction or comment before the root node of a document. Note that tail text is automatically discarded when adding at the root level.

append(self, value)

clear(self, keep_tail=False)

Resets an element. This function removes all subelements, clears all attributes and sets the text and tail properties to None.

Pass keep_tail=True to leave the tail text untouched.

cssselect(expr, *, translator)

Run the CSS expression on this element and its children, returning a list of the results.

Equivalent to lxml.cssselect.CSSSelect(expr)(self) – note that pre-compiling the expression can provide a substantial speedup.

extend(self, elements): Extends the current children by the elements in the iterable.

find(self, path, namespaces=None)

Finds the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds text for the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

get(self, key, default=None)

getchildren(self)

Returns all direct children. The elements are returned in document order.

Deprecated: Note that this method has been deprecated as of ElementTree 1.3 and lxml 2.0. New code should use list(element) or simply iterate over elements.

getiterator(self, tag=None, *tags)

Returns a sequence or iterator of all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags, see iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the element.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getnext(self): Returns the following sibling of this element or None.

getparent(self): Returns the parent of this element or None for the root element.

getprevious(self): Returns the preceding sibling of this element or None.

getroottree(self)

Return an ElementTree for the root node of the document that contains this element.

This is the same as following element.getparent() up the tree until it returns None (for the root element) and then build an ElementTree for the last parent that was returned.

index(self, child, start=None, stop=None)

Find the position of the child within the parent.

This method is not part of the original ElementTree API.

insert(self, index, value)

items(self)

iter(self, tag=None, *tags)

Iterate over all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags: pass "{ns}localname" as tag. Either or both of ns and localname can be * for a wildcard; ns can be empty for no namespace. "localname" is equivalent to "{}localname" (i.e. no namespace) but "*" is "{*}*" (any or no namespace), not "{}*".

You can also pass the Element, Comment, ProcessingInstruction and Entity factory functions to look only for the specific element type.

Passing multiple tags (or a sequence of tags) instead of a single tag will let the iterator return all elements matching any of these tags, in document order.

iterancestors(self, tag=None, *tags)

Iterate over the ancestors of this element (from parent to parent).

Can be restricted to find only elements with specific tags, see iter.

iterchildren(self, tag=None, *tags, reversed=False)

Iterate over the children of this element.

As opposed to using normal iteration on this element, the returned elements can be reversed with the ‘reversed’ keyword and restricted to find only elements with specific tags, see iter.

iterdescendants(self, tag=None, *tags)

Iterate over the descendants of this element in document order.

As opposed to el.iter(), this iterator does not yield the element itself. The returned elements can be restricted to find only elements with specific tags, see iter.

iterfind(self, path, namespaces=None)

Iterates over all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

itersiblings(self, tag=None, *tags, preceding=False)

Iterate over the following or preceding siblings of this element.

The direction is determined by the ‘preceding’ keyword which defaults to False, i.e. forward iteration over the following siblings. When True, the iterator yields the preceding siblings in reverse document order, i.e. starting right before the current element and going backwards.

Can be restricted to find only elements with specific tags, see iter.

itertext(self, tag=None, *tags, with_tail=True)

Iterates over the text content of a subtree.

You can pass tag names to restrict text content to specific elements, see iter.

You can set the with_tail keyword argument to False to skip over tail text.

keys(self)

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with the same document.

remove(self, element): Removes a matching subelement. Unlike the find methods, this method compares elements based on identity, not on tag value or contents.

replace(self, old_element, new_element): Replaces a subelement with the element passed as second argument.

set(self, key, value)

values(self)

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): Evaluate an xpath expression using the element as context node.

attrib

base

The base URI of the Element (xml:base or HTML base URL). None if the base URI is unknown.

Note that the value depends on the URL of the document that holds the Element if there is no xml:base attribute on the Element or its ancestors.

Setting this property will set an xml:base attribute on the Element, regardless of the document type (XML or HTML).

nsmap

Namespace prefix->URI mapping known in the context of this Element. This includes all namespace declarations of the parents.

Note that changing the returned dict has no effect on the Element.

prefix: Namespace prefix or None.

sourceline: Original line number as found by the parser or None if unknown.

tag

tail: Text after this element’s end tag, but before the next sibling element’s start tag. This is either a string or the value None, if there was no text.

text

class lxml.etree._Document

Bases: object

Internal base class to reference a libxml document.

When instances of this class are garbage collected, the libxml document is cleaned up.

class lxml.etree._DomainErrorLog

Bases: _ErrorLog

clear()

copy(): Creates a shallow copy of this error log and the list of entries.

filter_domains(domains): Filter the errors by the given domains and return a new error log containing the matches.

filter_from_errors(self): Convenience method to get all error messages or worse.

filter_from_fatals(self): Convenience method to get all fatal error messages.

filter_from_level(self, level): Return a log with all messages of the requested level of worse.

filter_from_warnings(self): Convenience method to get all warnings or worse.

filter_levels(self, levels): Filter the errors by the given error levels and return a new error log containing the matches.

filter_types(self, types): Filter the errors by the given types and return a new error log containing the matches.

receive(entry)

last_error

class lxml.etree._Element

Bases: object

Element class.

References a document object and a libxml node.

By pointing to a Document instance, a reference is kept to _Document as long as there is some pointer to a node in it.

_init(self): Called after object initialisation. Custom subclasses may override this if they recursively call _init() in the superclasses.

addnext(self, element)

Adds the element as a following sibling directly after this element.

This is normally used to set a processing instruction or comment after the root node of a document. Note that tail text is automatically discarded when adding at the root level.

addprevious(self, element)

Adds the element as a preceding sibling directly before this element.

This is normally used to set a processing instruction or comment before the root node of a document. Note that tail text is automatically discarded when adding at the root level.

append(self, element): Adds a subelement to the end of this element.

clear(self, keep_tail=False)

Resets an element. This function removes all subelements, clears all attributes and sets the text and tail properties to None.

Pass keep_tail=True to leave the tail text untouched.

cssselect(expr, *, translator)

Run the CSS expression on this element and its children, returning a list of the results.

Equivalent to lxml.cssselect.CSSSelect(expr)(self) – note that pre-compiling the expression can provide a substantial speedup.

extend(self, elements): Extends the current children by the elements in the iterable.

find(self, path, namespaces=None)

Finds the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds text for the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

get(self, key, default=None): Gets an element attribute.

getchildren(self)

Returns all direct children. The elements are returned in document order.

Deprecated: Note that this method has been deprecated as of ElementTree 1.3 and lxml 2.0. New code should use list(element) or simply iterate over elements.

getiterator(self, tag=None, *tags)

Returns a sequence or iterator of all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags, see iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the element.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getnext(self): Returns the following sibling of this element or None.

getparent(self): Returns the parent of this element or None for the root element.

getprevious(self): Returns the preceding sibling of this element or None.

getroottree(self)

Return an ElementTree for the root node of the document that contains this element.

This is the same as following element.getparent() up the tree until it returns None (for the root element) and then build an ElementTree for the last parent that was returned.

index(self, child, start=None, stop=None)

Find the position of the child within the parent.

This method is not part of the original ElementTree API.

insert(self, index, element): Inserts a subelement at the given position in this element

items(self): Gets element attributes, as a sequence. The attributes are returned in an arbitrary order.

iter(self, tag=None, *tags)

Iterate over all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags: pass "{ns}localname" as tag. Either or both of ns and localname can be * for a wildcard; ns can be empty for no namespace. "localname" is equivalent to "{}localname" (i.e. no namespace) but "*" is "{*}*" (any or no namespace), not "{}*".

You can also pass the Element, Comment, ProcessingInstruction and Entity factory functions to look only for the specific element type.

Passing multiple tags (or a sequence of tags) instead of a single tag will let the iterator return all elements matching any of these tags, in document order.

iterancestors(self, tag=None, *tags)

Iterate over the ancestors of this element (from parent to parent).

Can be restricted to find only elements with specific tags, see iter.

iterchildren(self, tag=None, *tags, reversed=False)

Iterate over the children of this element.

As opposed to using normal iteration on this element, the returned elements can be reversed with the ‘reversed’ keyword and restricted to find only elements with specific tags, see iter.

iterdescendants(self, tag=None, *tags)

Iterate over the descendants of this element in document order.

As opposed to el.iter(), this iterator does not yield the element itself. The returned elements can be restricted to find only elements with specific tags, see iter.

iterfind(self, path, namespaces=None)

Iterates over all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

itersiblings(self, tag=None, *tags, preceding=False)

Iterate over the following or preceding siblings of this element.

The direction is determined by the ‘preceding’ keyword which defaults to False, i.e. forward iteration over the following siblings. When True, the iterator yields the preceding siblings in reverse document order, i.e. starting right before the current element and going backwards.

Can be restricted to find only elements with specific tags, see iter.

itertext(self, tag=None, *tags, with_tail=True)

Iterates over the text content of a subtree.

You can pass tag names to restrict text content to specific elements, see iter.

You can set the with_tail keyword argument to False to skip over tail text.

keys(self): Gets a list of attribute names. The names are returned in an arbitrary order (just like for an ordinary Python dictionary).

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with the same document.

remove(self, element): Removes a matching subelement. Unlike the find methods, this method compares elements based on identity, not on tag value or contents.

replace(self, old_element, new_element): Replaces a subelement with the element passed as second argument.

set(self, key, value): Sets an element attribute. In HTML documents (not XML or XHTML), the value None is allowed and creates an attribute without value (just the attribute name).

values(self): Gets element attribute values as a sequence of strings. The attributes are returned in an arbitrary order.

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): Evaluate an xpath expression using the element as context node.

attrib: Element attribute dictionary. Where possible, use get(), set(), keys(), values() and items() to access element attributes.

base

The base URI of the Element (xml:base or HTML base URL). None if the base URI is unknown.

Note that the value depends on the URL of the document that holds the Element if there is no xml:base attribute on the Element or its ancestors.

Setting this property will set an xml:base attribute on the Element, regardless of the document type (XML or HTML).

nsmap

Namespace prefix->URI mapping known in the context of this Element. This includes all namespace declarations of the parents.

Note that changing the returned dict has no effect on the Element.

prefix: Namespace prefix or None.

sourceline: Original line number as found by the parser or None if unknown.

tag: Element tag

tail: Text after this element’s end tag, but before the next sibling element’s start tag. This is either a string or the value None, if there was no text.

text: Text before the first subelement. This is either a string or the value None, if there was no text.

class lxml.etree._ElementIterator

Bases: _ElementTagMatcher

Dead but public. :)

class lxml.etree._ElementMatchIterator: Bases: object

class lxml.etree._ElementStringResult

Bases: bytes

capitalize() → copy of B: Return a copy of B with only its first character capitalized (ASCII) and the rest lower-cased.

center(width, fillchar=b' ', /)

Return a centered string of length width.

Padding is done using the specified fill character.

count(sub[, start[, end]]) → int: Return the number of non-overlapping occurrences of subsection sub in bytes B[start:end]. Optional arguments start and end are interpreted as in slice notation.

decode(encoding='utf-8', errors='strict')

Decode the bytes using the codec registered for encoding.

encoding: The encoding with which to decode the bytes.
errors: The error handling scheme to use for the handling of decoding errors. The default is ‘strict’ meaning that decoding errors raise a UnicodeDecodeError. Other possible values are ‘ignore’ and ‘replace’ as well as any other name registered with codecs.register_error that can handle UnicodeDecodeErrors.

endswith(suffix[, start[, end]]) → bool: Return True if B ends with the specified suffix, False otherwise. With optional start, test B beginning at that position. With optional end, stop comparing B at that position. suffix can also be a tuple of bytes to try.

expandtabs(tabsize=8)

Return a copy where all tab characters are expanded using spaces.

If tabsize is not given, a tab size of 8 characters is assumed.

find(sub[, start[, end]]) → int

Return the lowest index in B where subsection sub is found, such that sub is contained within B[start,end]. Optional arguments start and end are interpreted as in slice notation.

Return -1 on failure.

fromhex()

Create a bytes object from a string of hexadecimal numbers.

Spaces between two numbers are accepted. Example: bytes.fromhex(‘B9 01EF’) -> b’\xb9\x01\xef’.

getparent()

hex()

Create a string of hexadecimal numbers from a bytes object.

sep
An optional single character or byte to separate hex bytes.

bytes_per_sep
How many bytes between separators. Positive values count from the right, negative values count from the left.

Example: >>> value = b’xb9x01xef’ >>> value.hex() ‘b901ef’ >>> value.hex(‘:’) ‘b9:01:ef’ >>> value.hex(‘:’, 2) ‘b9:01ef’ >>> value.hex(‘:’, -2) ‘b901:ef’

index(sub[, start[, end]]) → int

Return the lowest index in B where subsection sub is found, such that sub is contained within B[start,end]. Optional arguments start and end are interpreted as in slice notation.

Raises ValueError when the subsection is not found.

isalnum() → bool: Return True if all characters in B are alphanumeric and there is at least one character in B, False otherwise.

isalpha() → bool: Return True if all characters in B are alphabetic and there is at least one character in B, False otherwise.

isascii() → bool: Return True if B is empty or all characters in B are ASCII, False otherwise.

isdigit() → bool: Return True if all characters in B are digits and there is at least one character in B, False otherwise.

islower() → bool: Return True if all cased characters in B are lowercase and there is at least one cased character in B, False otherwise.

isspace() → bool: Return True if all characters in B are whitespace and there is at least one character in B, False otherwise.

istitle() → bool: Return True if B is a titlecased string and there is at least one character in B, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise.

isupper() → bool: Return True if all cased characters in B are uppercase and there is at least one cased character in B, False otherwise.

join(iterable_of_bytes, /)

Concatenate any number of bytes objects.

The bytes whose method is called is inserted in between each pair.

The result is returned as a new bytes object.

Example: b’.’.join([b’ab’, b’pq’, b’rs’]) -> b’ab.pq.rs’.

ljust(width, fillchar=b' ', /)

Return a left-justified string of length width.

Padding is done using the specified fill character.

lower() → copy of B: Return a copy of B with all ASCII characters converted to lowercase.

lstrip(bytes=None, /)

Strip leading bytes contained in the argument.

If the argument is omitted or None, strip leading ASCII whitespace.

static maketrans(frm, to, /)

Return a translation table useable for the bytes or bytearray translate method.

The returned table will be one where each byte in frm is mapped to the byte at the same position in to.

The bytes objects frm and to must be of the same length.

partition(sep, /)

Partition the bytes into three parts using the given separator.

This will search for the separator sep in the bytes. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.

If the separator is not found, returns a 3-tuple containing the original bytes object and two empty bytes objects.

removeprefix(prefix, /)

Return a bytes object with the given prefix string removed if present.

If the bytes starts with the prefix string, return bytes[len(prefix):]. Otherwise, return a copy of the original bytes.

removesuffix(suffix, /)

Return a bytes object with the given suffix string removed if present.

If the bytes ends with the suffix string and that suffix is not empty, return bytes[:-len(prefix)]. Otherwise, return a copy of the original bytes.

replace(old, new, count=-1, /)

Return a copy with all occurrences of substring old replaced by new.

count
Maximum number of occurrences to replace. -1 (the default value) means replace all occurrences.

If the optional argument count is given, only the first count occurrences are replaced.

rfind(sub[, start[, end]]) → int

Return the highest index in B where subsection sub is found, such that sub is contained within B[start,end]. Optional arguments start and end are interpreted as in slice notation.

Return -1 on failure.

rindex(sub[, start[, end]]) → int

Return the highest index in B where subsection sub is found, such that sub is contained within B[start,end]. Optional arguments start and end are interpreted as in slice notation.

Raise ValueError when the subsection is not found.

rjust(width, fillchar=b' ', /)

Return a right-justified string of length width.

Padding is done using the specified fill character.

rpartition(sep, /)

Partition the bytes into three parts using the given separator.

This will search for the separator sep in the bytes, starting at the end. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.

If the separator is not found, returns a 3-tuple containing two empty bytes objects and the original bytes object.

rsplit(sep=None, maxsplit=-1)

Return a list of the sections in the bytes, using sep as the delimiter.

sep
The delimiter according which to split the bytes. None (the default value) means split on ASCII whitespace characters (space, tab, return, newline, formfeed, vertical tab).

maxsplit
Maximum number of splits to do. -1 (the default value) means no limit.

Splitting is done starting at the end of the bytes and working to the front.

rstrip(bytes=None, /)

Strip trailing bytes contained in the argument.

If the argument is omitted or None, strip trailing ASCII whitespace.

split(sep=None, maxsplit=-1)

Return a list of the sections in the bytes, using sep as the delimiter.

sep: The delimiter according which to split the bytes. None (the default value) means split on ASCII whitespace characters (space, tab, return, newline, formfeed, vertical tab).
maxsplit: Maximum number of splits to do. -1 (the default value) means no limit.

splitlines(keepends=False)

Return a list of the lines in the bytes, breaking at line boundaries.

Line breaks are not included in the resulting list unless keepends is given and true.

startswith(prefix[, start[, end]]) → bool: Return True if B starts with the specified prefix, False otherwise. With optional start, test B beginning at that position. With optional end, stop comparing B at that position. prefix can also be a tuple of bytes to try.

strip(bytes=None, /)

Strip leading and trailing bytes contained in the argument.

If the argument is omitted or None, strip leading and trailing ASCII whitespace.

swapcase() → copy of B: Return a copy of B with uppercase ASCII characters converted to lowercase ASCII and vice versa.

title() → copy of B: Return a titlecased version of B, i.e. ASCII words start with uppercase characters, all remaining cased characters have lowercase.

translate(table, /, delete=b'')

Return a copy with each character mapped by the given translation table.

table
Translation table, which must be a bytes object of length 256.

All characters occurring in the optional argument delete are removed. The remaining characters are mapped through the given translation table.

upper() → copy of B: Return a copy of B with all ASCII characters converted to uppercase.

zfill(width, /)

Pad a numeric string with zeros on the left, to fill a field of the given width.

The original string is never truncated.

class lxml.etree._ElementTagMatcher

Bases: object

Dead but public. :)

class lxml.etree._ElementTree

Bases: object

_setroot(self, root): Relocate the ElementTree to a new root node.

find(self, path, namespaces=None)

Finds the first toplevel element with given tag. Same as tree.getroot().find(path).

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all elements matching the ElementPath expression. Same as getroot().findall(path).

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds the text for the first element matching the ElementPath expression. Same as getroot().findtext(path)

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

getelementpath(self, element)

Returns a structural, absolute ElementPath expression to find the element. This path can be used in the .find() method to look up the element, provided that the elements along the path and their list of immediate children were not modified in between.

ElementPath has the advantage over an XPath expression (as returned by the .getpath() method) that it does not require additional prefix declarations. It is always self-contained.

getiterator(self, *tags, tag=None)

Returns a sequence or iterator of all elements in document order (depth first pre-order), starting with the root element.

Can be restricted to find only elements with specific tags, see _Element.iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the tree.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getpath(self, element)

Returns a structural, absolute XPath expression to find the element.

For namespaced elements, the expression uses prefixes from the document, which therefore need to be provided in order to make any use of the expression in XPath.

Also see the method getelementpath(self, element), which returns a self-contained ElementPath expression.

getroot(self): Gets the root element for this tree.

iter(self, tag=None, *tags)

Creates an iterator for the root element. The iterator loops over all elements in this tree, in document order. Note that siblings of the root element (comments or processing instructions) are not returned by the iterator.

Can be restricted to find only elements with specific tags, see _Element.iter.

iterfind(self, path, namespaces=None)

Iterates over all elements matching the ElementPath expression. Same as getroot().iterfind(path).

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

parse(self, source, parser=None, base_url=None): Updates self with the content of source and returns its root.

relaxng(self, relaxng)

Validate this document using other document.

The relaxng argument is a tree that should contain a Relax NG schema.

Returns True or False, depending on whether validation succeeded.

Note: if you are going to apply the same Relax NG schema against multiple documents, it is more efficient to use the RelaxNG class directly.

write(file, *, encoding, method, pretty_print, xml_declaration, with_tail, standalone, doctype, compression, exclusive, inclusive_ns_prefixes, with_comments, strip_text, docstring)

write(self, file, encoding=None, method=”xml”,: pretty_print=False, xml_declaration=None, with_tail=True, standalone=None, doctype=None, compression=0, exclusive=False, inclusive_ns_prefixes=None, with_comments=True, strip_text=False)

Write the tree to a filename, file or file-like object.

Defaults to ASCII encoding and writing a declaration as needed.

The keyword argument ‘method’ selects the output method: ‘xml’, ‘html’, ‘text’ or ‘c14n’. Default is ‘xml’.

With method="c14n" (C14N version 1), the options exclusive, with_comments and inclusive_ns_prefixes request exclusive C14N, include comments, and list the inclusive prefixes respectively.

With method="c14n2" (C14N version 2), the with_comments and strip_text options control the output of comments and text space according to C14N 2.0.

Passing a boolean value to the standalone option will output an XML declaration with the corresponding standalone flag.

The doctype option allows passing in a plain string that will be serialised before the XML tree. Note that passing in non well-formed content here will make the XML output non well-formed. Also, an existing doctype in the document tree will not be removed when serialising an ElementTree instance.

The compression option enables GZip compression level 1-9.

The inclusive_ns_prefixes should be a list of namespace strings (i.e. [‘xs’, ‘xsi’]) that will be promoted to the top-level element during exclusive C14N serialisation. This parameter is ignored if exclusive mode=False.

If exclusive=True and no list is provided, a namespace will only be rendered if it is used by the immediate parent or one of its attributes and its prefix and values have not already been rendered by an ancestor of the namespace node’s parent element.

write_c14n(file, *, exclusive, with_comments, compression, inclusive_ns_prefixes)

write_c14n(self, file, exclusive=False, with_comments=True,: compression=0, inclusive_ns_prefixes=None)

C14N write of document. Always writes UTF-8.

The compression option enables GZip compression level 1-9.

The inclusive_ns_prefixes should be a list of namespace strings (i.e. [‘xs’, ‘xsi’]) that will be promoted to the top-level element during exclusive C14N serialisation. This parameter is ignored if exclusive mode=False.

If exclusive=True and no list is provided, a namespace will only be rendered if it is used by the immediate parent or one of its attributes and its prefix and values have not already been rendered by an ancestor of the namespace node’s parent element.

NOTE: This method is deprecated as of lxml 4.4 and will be removed in a future release. Use .write(f, method="c14n") instead.

xinclude(self)

Process the XInclude nodes in this document and include the referenced XML fragments.

There is support for loading files through the file system, HTTP and FTP.

Note that XInclude does not support custom resolvers in Python space due to restrictions of libxml2 <= 2.6.29.

xmlschema(self, xmlschema)

Validate this document using other document.

The xmlschema argument is a tree that should contain an XML Schema.

Returns True or False, depending on whether validation succeeded.

Note: If you are going to apply the same XML Schema against multiple documents, it is more efficient to use the XMLSchema class directly.

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables)

XPath evaluate in context of document.

namespaces is an optional dictionary with prefix to namespace URI mappings, used by XPath. extensions defines additional extension functions.

Returns a list (nodeset), or bool, float or string.

In case of a list result, return Element for element nodes, string for text and attribute values.

Note: if you are going to apply multiple XPath expressions against the same document, it is more efficient to use XPathEvaluator directly.

xslt(self, _xslt, extensions=None, access_control=None, **_kw)

Transform this document using other document.

xslt is a tree that should be XSLT keyword parameters are XSLT transformation parameters.

Returns the transformed tree.

Note: if you are going to apply the same XSLT stylesheet against multiple documents, it is more efficient to use the XSLT class directly.

docinfo: Information about the document provided by parser and DTD.

parser: The parser that was used to parse the document in this ElementTree.

class lxml.etree._ElementUnicodeResult

Bases: str

capitalize()

Return a capitalized version of the string.

More specifically, make the first character have upper case and the rest lower case.

casefold(): Return a version of the string suitable for caseless comparisons.

center(width, fillchar=' ', /)

Return a centered string of length width.

Padding is done using the specified fill character (default is a space).

count(sub[, start[, end]]) → int: Return the number of non-overlapping occurrences of substring sub in string S[start:end]. Optional arguments start and end are interpreted as in slice notation.

encode(encoding='utf-8', errors='strict')

Encode the string using the codec registered for encoding.

encoding: The encoding in which to encode the string.
errors: The error handling scheme to use for encoding errors. The default is ‘strict’ meaning that encoding errors raise a UnicodeEncodeError. Other possible values are ‘ignore’, ‘replace’ and ‘xmlcharrefreplace’ as well as any other name registered with codecs.register_error that can handle UnicodeEncodeErrors.

endswith(suffix[, start[, end]]) → bool: Return True if S ends with the specified suffix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. suffix can also be a tuple of strings to try.

expandtabs(tabsize=8)

Return a copy where all tab characters are expanded using spaces.

If tabsize is not given, a tab size of 8 characters is assumed.

find(sub[, start[, end]]) → int

Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.

Return -1 on failure.

format(*args, **kwargs) → str: Return a formatted version of S, using substitutions from args and kwargs. The substitutions are identified by braces (‘{’ and ‘}’).

format_map(mapping) → str: Return a formatted version of S, using substitutions from mapping. The substitutions are identified by braces (‘{’ and ‘}’).

getparent()

index(sub[, start[, end]]) → int

Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.

Raises ValueError when the substring is not found.

isalnum()

Return True if the string is an alpha-numeric string, False otherwise.

A string is alpha-numeric if all characters in the string are alpha-numeric and there is at least one character in the string.

isalpha()

Return True if the string is an alphabetic string, False otherwise.

A string is alphabetic if all characters in the string are alphabetic and there is at least one character in the string.

isascii()

Return True if all characters in the string are ASCII, False otherwise.

ASCII characters have code points in the range U+0000-U+007F. Empty string is ASCII too.

isdecimal()

Return True if the string is a decimal string, False otherwise.

A string is a decimal string if all characters in the string are decimal and there is at least one character in the string.

isdigit()

Return True if the string is a digit string, False otherwise.

A string is a digit string if all characters in the string are digits and there is at least one character in the string.

isidentifier()

Return True if the string is a valid Python identifier, False otherwise.

Call keyword.iskeyword(s) to test whether string s is a reserved identifier, such as “def” or “class”.

islower()

Return True if the string is a lowercase string, False otherwise.

A string is lowercase if all cased characters in the string are lowercase and there is at least one cased character in the string.

isnumeric()

Return True if the string is a numeric string, False otherwise.

A string is numeric if all characters in the string are numeric and there is at least one character in the string.

isprintable()

Return True if the string is printable, False otherwise.

A string is printable if all of its characters are considered printable in repr() or if it is empty.

isspace()

Return True if the string is a whitespace string, False otherwise.

A string is whitespace if all characters in the string are whitespace and there is at least one character in the string.

istitle()

Return True if the string is a title-cased string, False otherwise.

In a title-cased string, upper- and title-case characters may only follow uncased characters and lowercase characters only cased ones.

isupper()

Return True if the string is an uppercase string, False otherwise.

A string is uppercase if all cased characters in the string are uppercase and there is at least one cased character in the string.

join(iterable, /)

Concatenate any number of strings.

The string whose method is called is inserted in between each given string. The result is returned as a new string.

Example: ‘.’.join([‘ab’, ‘pq’, ‘rs’]) -> ‘ab.pq.rs’

ljust(width, fillchar=' ', /)

Return a left-justified string of length width.

Padding is done using the specified fill character (default is a space).

lower(): Return a copy of the string converted to lowercase.

lstrip(chars=None, /)

Return a copy of the string with leading whitespace removed.

If chars is given and not None, remove characters in chars instead.

static maketrans()

Return a translation table usable for str.translate().

If there is only one argument, it must be a dictionary mapping Unicode ordinals (integers) or characters to Unicode ordinals, strings or None. Character keys will be then converted to ordinals. If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y. If there is a third argument, it must be a string, whose characters will be mapped to None in the result.

partition(sep, /)

Partition the string into three parts using the given separator.

This will search for the separator in the string. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.

If the separator is not found, returns a 3-tuple containing the original string and two empty strings.

removeprefix(prefix, /)

Return a str with the given prefix string removed if present.

If the string starts with the prefix string, return string[len(prefix):]. Otherwise, return a copy of the original string.

removesuffix(suffix, /)

Return a str with the given suffix string removed if present.

If the string ends with the suffix string and that suffix is not empty, return string[:-len(suffix)]. Otherwise, return a copy of the original string.

replace(old, new, count=-1, /)

Return a copy with all occurrences of substring old replaced by new.

count
Maximum number of occurrences to replace. -1 (the default value) means replace all occurrences.

If the optional argument count is given, only the first count occurrences are replaced.

rfind(sub[, start[, end]]) → int

Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.

Return -1 on failure.

rindex(sub[, start[, end]]) → int

Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.

Raises ValueError when the substring is not found.

rjust(width, fillchar=' ', /)

Return a right-justified string of length width.

Padding is done using the specified fill character (default is a space).

rpartition(sep, /)

Partition the string into three parts using the given separator.

This will search for the separator in the string, starting at the end. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.

If the separator is not found, returns a 3-tuple containing two empty strings and the original string.

rsplit(sep=None, maxsplit=-1)

Return a list of the substrings in the string, using sep as the separator string.

sep
The separator used to split the string.

When set to None (the default value), will split on any whitespace character (including \n \r \t \f and spaces) and will discard empty strings from the result.

maxsplit
Maximum number of splits (starting from the left). -1 (the default value) means no limit.

Splitting starts at the end of the string and works to the front.

rstrip(chars=None, /)

Return a copy of the string with trailing whitespace removed.

If chars is given and not None, remove characters in chars instead.

split(sep=None, maxsplit=-1)

Return a list of the substrings in the string, using sep as the separator string.

sep
The separator used to split the string.

When set to None (the default value), will split on any whitespace character (including \n \r \t \f and spaces) and will discard empty strings from the result.

maxsplit
Maximum number of splits (starting from the left). -1 (the default value) means no limit.

Note, str.split() is mainly useful for data that has been intentionally delimited. With natural text that includes punctuation, consider using the regular expression module.

splitlines(keepends=False)

Return a list of the lines in the string, breaking at line boundaries.

Line breaks are not included in the resulting list unless keepends is given and true.

startswith(prefix[, start[, end]]) → bool: Return True if S starts with the specified prefix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. prefix can also be a tuple of strings to try.

strip(chars=None, /)

Return a copy of the string with leading and trailing whitespace removed.

If chars is given and not None, remove characters in chars instead.

swapcase(): Convert uppercase characters to lowercase and lowercase characters to uppercase.

title()

Return a version of the string where each word is titlecased.

More specifically, words start with uppercased characters and all remaining cased characters have lower case.

translate(table, /)

Replace each character in the string using the given translation table.

table
Translation table, which must be a mapping of Unicode ordinals to Unicode ordinals, strings, or None.

The table must implement lookup/indexing via __getitem__, for instance a dictionary or list. If this operation raises LookupError, the character is left untouched. Characters mapped to None are deleted.

upper(): Return a copy of the string converted to uppercase.

zfill(width, /)

Pad a numeric string with zeros on the left, to fill a field of the given width.

The string is never truncated.

attrname

is_attribute

is_tail

is_text

class lxml.etree._Entity

Bases: __ContentOnlyElement

_init(self): Called after object initialisation. Custom subclasses may override this if they recursively call _init() in the superclasses.

addnext(self, element)

Adds the element as a following sibling directly after this element.

This is normally used to set a processing instruction or comment after the root node of a document. Note that tail text is automatically discarded when adding at the root level.

addprevious(self, element)

Adds the element as a preceding sibling directly before this element.

This is normally used to set a processing instruction or comment before the root node of a document. Note that tail text is automatically discarded when adding at the root level.

append(self, value)

clear(self, keep_tail=False)

Resets an element. This function removes all subelements, clears all attributes and sets the text and tail properties to None.

Pass keep_tail=True to leave the tail text untouched.

cssselect(expr, *, translator)

Run the CSS expression on this element and its children, returning a list of the results.

Equivalent to lxml.cssselect.CSSSelect(expr)(self) – note that pre-compiling the expression can provide a substantial speedup.

extend(self, elements): Extends the current children by the elements in the iterable.

find(self, path, namespaces=None)

Finds the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds text for the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

get(self, key, default=None)

getchildren(self)

Returns all direct children. The elements are returned in document order.

Deprecated: Note that this method has been deprecated as of ElementTree 1.3 and lxml 2.0. New code should use list(element) or simply iterate over elements.

getiterator(self, tag=None, *tags)

Returns a sequence or iterator of all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags, see iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the element.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getnext(self): Returns the following sibling of this element or None.

getparent(self): Returns the parent of this element or None for the root element.

getprevious(self): Returns the preceding sibling of this element or None.

getroottree(self)

Return an ElementTree for the root node of the document that contains this element.

This is the same as following element.getparent() up the tree until it returns None (for the root element) and then build an ElementTree for the last parent that was returned.

index(self, child, start=None, stop=None)

Find the position of the child within the parent.

This method is not part of the original ElementTree API.

insert(self, index, value)

items(self)

iter(self, tag=None, *tags)

Iterate over all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags: pass "{ns}localname" as tag. Either or both of ns and localname can be * for a wildcard; ns can be empty for no namespace. "localname" is equivalent to "{}localname" (i.e. no namespace) but "*" is "{*}*" (any or no namespace), not "{}*".

You can also pass the Element, Comment, ProcessingInstruction and Entity factory functions to look only for the specific element type.

Passing multiple tags (or a sequence of tags) instead of a single tag will let the iterator return all elements matching any of these tags, in document order.

iterancestors(self, tag=None, *tags)

Iterate over the ancestors of this element (from parent to parent).

Can be restricted to find only elements with specific tags, see iter.

iterchildren(self, tag=None, *tags, reversed=False)

Iterate over the children of this element.

As opposed to using normal iteration on this element, the returned elements can be reversed with the ‘reversed’ keyword and restricted to find only elements with specific tags, see iter.

iterdescendants(self, tag=None, *tags)

Iterate over the descendants of this element in document order.

As opposed to el.iter(), this iterator does not yield the element itself. The returned elements can be restricted to find only elements with specific tags, see iter.

iterfind(self, path, namespaces=None)

Iterates over all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

itersiblings(self, tag=None, *tags, preceding=False)

Iterate over the following or preceding siblings of this element.

The direction is determined by the ‘preceding’ keyword which defaults to False, i.e. forward iteration over the following siblings. When True, the iterator yields the preceding siblings in reverse document order, i.e. starting right before the current element and going backwards.

Can be restricted to find only elements with specific tags, see iter.

itertext(self, tag=None, *tags, with_tail=True)

Iterates over the text content of a subtree.

You can pass tag names to restrict text content to specific elements, see iter.

You can set the with_tail keyword argument to False to skip over tail text.

keys(self)

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with the same document.

remove(self, element): Removes a matching subelement. Unlike the find methods, this method compares elements based on identity, not on tag value or contents.

replace(self, old_element, new_element): Replaces a subelement with the element passed as second argument.

set(self, key, value)

values(self)

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): Evaluate an xpath expression using the element as context node.

attrib

base

The base URI of the Element (xml:base or HTML base URL). None if the base URI is unknown.

Note that the value depends on the URL of the document that holds the Element if there is no xml:base attribute on the Element or its ancestors.

Setting this property will set an xml:base attribute on the Element, regardless of the document type (XML or HTML).

name

nsmap

Namespace prefix->URI mapping known in the context of this Element. This includes all namespace declarations of the parents.

Note that changing the returned dict has no effect on the Element.

prefix: Namespace prefix or None.

sourceline: Original line number as found by the parser or None if unknown.

tag

tail: Text after this element’s end tag, but before the next sibling element’s start tag. This is either a string or the value None, if there was no text.

text

class lxml.etree._ErrorLog

Bases: _ListErrorLog

clear()

copy(): Creates a shallow copy of this error log and the list of entries.

filter_domains(domains): Filter the errors by the given domains and return a new error log containing the matches.

filter_from_errors(self): Convenience method to get all error messages or worse.

filter_from_fatals(self): Convenience method to get all fatal error messages.

filter_from_level(self, level): Return a log with all messages of the requested level of worse.

filter_from_warnings(self): Convenience method to get all warnings or worse.

filter_levels(self, levels): Filter the errors by the given error levels and return a new error log containing the matches.

filter_types(self, types): Filter the errors by the given types and return a new error log containing the matches.

receive(entry)

last_error

class lxml.etree._FeedParser

Bases: _BaseParser

close(self)

Terminates feeding data to this parser. This tells the parser to process any remaining data in the feed buffer, and then returns the root Element of the tree that was parsed.

This method must be called after passing the last chunk of data into the feed() method. It should only be called when using the feed parser interface, all other usage is undefined.

copy(self): Create a new parser with the same configuration.

feed(self, data)

Feeds data to the parser. The argument should be an 8-bit string buffer containing encoded data, although Unicode is supported as long as both string types are not mixed.

This is the main entry point to the consumer interface of a parser. The parser will parse as much of the XML stream as it can on each call. To finish parsing or to reset the parser, call the close() method. Both methods may raise ParseError if errors occur in the input data. If an error is raised, there is no longer a need to call close().

The feed parser interface is independent of the normal parser usage. You can use the same parser as a feed parser and in the parse() function concurrently.

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with this parser.

setElementClassLookup(lookup)

Deprecated: use parser.set_element_class_lookup(lookup) instead.

set_element_class_lookup(self, lookup=None)

Set a lookup scheme for element classes generated from this parser.

Reset it by passing None or nothing.

error_log: The error log of the last parser run.

feed_error_log

The error log of the last (or current) run of the feed parser.

Note that this is local to the feed parser and thus is different from what the error_log property returns.

resolvers: The custom resolver registry of this parser.

target

version: The version of the underlying XML parser.

class lxml.etree._IDDict

Bases: object

IDDict(self, etree) A dictionary-like proxy class that mapps ID attributes to elements.

The dictionary must be instantiated with the root element of a parsed XML document, otherwise the behaviour is undefined. Elements and XML trees that were created or modified ‘by hand’ are not supported.

copy()

get(id_name)

has_key(id_name)

items()

iteritems()

iterkeys()

itervalues()

keys()

values()

class lxml.etree._ListErrorLog

Bases: _BaseErrorLog

Immutable base version of a list based error log.

copy(): Creates a shallow copy of this error log. Reuses the list of entries.

filter_domains(domains): Filter the errors by the given domains and return a new error log containing the matches.

filter_from_errors(self): Convenience method to get all error messages or worse.

filter_from_fatals(self): Convenience method to get all fatal error messages.

filter_from_level(self, level): Return a log with all messages of the requested level of worse.

filter_from_warnings(self): Convenience method to get all warnings or worse.

filter_levels(self, levels): Filter the errors by the given error levels and return a new error log containing the matches.

filter_types(self, types): Filter the errors by the given types and return a new error log containing the matches.

receive(entry)

last_error

class lxml.etree._LogEntry

Bases: object

A log message entry from an error log.

Attributes:

message: the message text
domain: the domain ID (see lxml.etree.ErrorDomains)
type: the message type ID (see lxml.etree.ErrorTypes)
level: the log level ID (see lxml.etree.ErrorLevels)
line: the line at which the message originated (if applicable)
column: the character column at which the message originated (if applicable)
filename: the name of the file in which the message originated (if applicable)
path: the location in which the error was found (if available)

column

domain

domain_name: The name of the error domain. See lxml.etree.ErrorDomains

filename: The file path where the report originated, if any.

level

level_name: The name of the error level. See lxml.etree.ErrorLevels

line

message: The log message string.

path: The XPath for the node where the error was detected.

type

type_name: The name of the error type. See lxml.etree.ErrorTypes

class lxml.etree._ProcessingInstruction

Bases: __ContentOnlyElement

_init(self): Called after object initialisation. Custom subclasses may override this if they recursively call _init() in the superclasses.

addnext(self, element)

Adds the element as a following sibling directly after this element.

This is normally used to set a processing instruction or comment after the root node of a document. Note that tail text is automatically discarded when adding at the root level.

addprevious(self, element)

Adds the element as a preceding sibling directly before this element.

This is normally used to set a processing instruction or comment before the root node of a document. Note that tail text is automatically discarded when adding at the root level.

append(self, value)

clear(self, keep_tail=False)

Resets an element. This function removes all subelements, clears all attributes and sets the text and tail properties to None.

Pass keep_tail=True to leave the tail text untouched.

cssselect(expr, *, translator)

Run the CSS expression on this element and its children, returning a list of the results.

Equivalent to lxml.cssselect.CSSSelect(expr)(self) – note that pre-compiling the expression can provide a substantial speedup.

extend(self, elements): Extends the current children by the elements in the iterable.

find(self, path, namespaces=None)

Finds the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds text for the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

get(self, key, default=None)

Try to parse pseudo-attributes from the text content of the processing instruction, search for one with the given key as name and return its associated value.

Note that this is only a convenience method for the most common case that all text content is structured in attribute-like name-value pairs with properly quoted values. It is not guaranteed to work for all possible text content.

getchildren(self)

Returns all direct children. The elements are returned in document order.

Deprecated: Note that this method has been deprecated as of ElementTree 1.3 and lxml 2.0. New code should use list(element) or simply iterate over elements.

getiterator(self, tag=None, *tags)

Returns a sequence or iterator of all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags, see iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the element.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getnext(self): Returns the following sibling of this element or None.

getparent(self): Returns the parent of this element or None for the root element.

getprevious(self): Returns the preceding sibling of this element or None.

getroottree(self)

Return an ElementTree for the root node of the document that contains this element.

This is the same as following element.getparent() up the tree until it returns None (for the root element) and then build an ElementTree for the last parent that was returned.

index(self, child, start=None, stop=None)

Find the position of the child within the parent.

This method is not part of the original ElementTree API.

insert(self, index, value)

items(self)

iter(self, tag=None, *tags)

Iterate over all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags: pass "{ns}localname" as tag. Either or both of ns and localname can be * for a wildcard; ns can be empty for no namespace. "localname" is equivalent to "{}localname" (i.e. no namespace) but "*" is "{*}*" (any or no namespace), not "{}*".

You can also pass the Element, Comment, ProcessingInstruction and Entity factory functions to look only for the specific element type.

Passing multiple tags (or a sequence of tags) instead of a single tag will let the iterator return all elements matching any of these tags, in document order.

iterancestors(self, tag=None, *tags)

Iterate over the ancestors of this element (from parent to parent).

Can be restricted to find only elements with specific tags, see iter.

iterchildren(self, tag=None, *tags, reversed=False)

Iterate over the children of this element.

As opposed to using normal iteration on this element, the returned elements can be reversed with the ‘reversed’ keyword and restricted to find only elements with specific tags, see iter.

iterdescendants(self, tag=None, *tags)

Iterate over the descendants of this element in document order.

As opposed to el.iter(), this iterator does not yield the element itself. The returned elements can be restricted to find only elements with specific tags, see iter.

iterfind(self, path, namespaces=None)

Iterates over all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

itersiblings(self, tag=None, *tags, preceding=False)

Iterate over the following or preceding siblings of this element.

The direction is determined by the ‘preceding’ keyword which defaults to False, i.e. forward iteration over the following siblings. When True, the iterator yields the preceding siblings in reverse document order, i.e. starting right before the current element and going backwards.

Can be restricted to find only elements with specific tags, see iter.

itertext(self, tag=None, *tags, with_tail=True)

Iterates over the text content of a subtree.

You can pass tag names to restrict text content to specific elements, see iter.

You can set the with_tail keyword argument to False to skip over tail text.

keys(self)

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with the same document.

remove(self, element): Removes a matching subelement. Unlike the find methods, this method compares elements based on identity, not on tag value or contents.

replace(self, old_element, new_element): Replaces a subelement with the element passed as second argument.

set(self, key, value)

values(self)

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): Evaluate an xpath expression using the element as context node.

attrib: Returns a dict containing all pseudo-attributes that can be parsed from the text content of this processing instruction. Note that modifying the dict currently has no effect on the XML node, although this is not guaranteed to stay this way.

base

The base URI of the Element (xml:base or HTML base URL). None if the base URI is unknown.

Note that the value depends on the URL of the document that holds the Element if there is no xml:base attribute on the Element or its ancestors.

Setting this property will set an xml:base attribute on the Element, regardless of the document type (XML or HTML).

nsmap

Namespace prefix->URI mapping known in the context of this Element. This includes all namespace declarations of the parents.

Note that changing the returned dict has no effect on the Element.

prefix: Namespace prefix or None.

sourceline: Original line number as found by the parser or None if unknown.

tag

tail: Text after this element’s end tag, but before the next sibling element’s start tag. This is either a string or the value None, if there was no text.

target

text

class lxml.etree._RotatingErrorLog

Bases: _ErrorLog

clear()

copy(): Creates a shallow copy of this error log and the list of entries.

filter_domains(domains): Filter the errors by the given domains and return a new error log containing the matches.

filter_from_errors(self): Convenience method to get all error messages or worse.

filter_from_fatals(self): Convenience method to get all fatal error messages.

filter_from_level(self, level): Return a log with all messages of the requested level of worse.

filter_from_warnings(self): Convenience method to get all warnings or worse.

filter_levels(self, levels): Filter the errors by the given error levels and return a new error log containing the matches.

filter_types(self, types): Filter the errors by the given types and return a new error log containing the matches.

receive(entry)

last_error

class lxml.etree._SaxParserTarget: Bases: object

class lxml.etree._Validator

Bases: object

Base class for XML validators.

_append_log_message(domain, type, level, line, message, filename)

_clear_error_log()

assertValid(self, etree): Raises DocumentInvalid if the document does not comply with the schema.

assert_(self, etree): Raises AssertionError if the document does not comply with the schema.

validate(self, etree)

Validate the document using this schema.

Returns true if document is valid, false if not.

error_log: The log of validation errors and warnings.

class lxml.etree._XPathEvaluatorBase

Bases: object

evaluate(self, _eval_arg, **_variables)

Evaluate an XPath expression.

Instead of calling this method, you can also call the evaluator object itself.

Variables may be provided as keyword arguments. Note that namespaces are currently not supported for variables.

Deprecated: call the object, not its method.

error_log

class lxml.etree._XSLTProcessingInstruction

Bases: PIBase

_init(self): Called after object initialisation. Custom subclasses may override this if they recursively call _init() in the superclasses.

addnext(self, element)

Adds the element as a following sibling directly after this element.

This is normally used to set a processing instruction or comment after the root node of a document. Note that tail text is automatically discarded when adding at the root level.

addprevious(self, element)

Adds the element as a preceding sibling directly before this element.

This is normally used to set a processing instruction or comment before the root node of a document. Note that tail text is automatically discarded when adding at the root level.

append(self, value)

clear(self, keep_tail=False)

Resets an element. This function removes all subelements, clears all attributes and sets the text and tail properties to None.

Pass keep_tail=True to leave the tail text untouched.

cssselect(expr, *, translator)

Run the CSS expression on this element and its children, returning a list of the results.

Equivalent to lxml.cssselect.CSSSelect(expr)(self) – note that pre-compiling the expression can provide a substantial speedup.

extend(self, elements): Extends the current children by the elements in the iterable.

find(self, path, namespaces=None)

Finds the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds text for the first matching subelement, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

get(self, key, default=None)

Try to parse pseudo-attributes from the text content of the processing instruction, search for one with the given key as name and return its associated value.

Note that this is only a convenience method for the most common case that all text content is structured in attribute-like name-value pairs with properly quoted values. It is not guaranteed to work for all possible text content.

getchildren(self)

Returns all direct children. The elements are returned in document order.

Deprecated: Note that this method has been deprecated as of ElementTree 1.3 and lxml 2.0. New code should use list(element) or simply iterate over elements.

getiterator(self, tag=None, *tags)

Returns a sequence or iterator of all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags, see iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the element.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getnext(self): Returns the following sibling of this element or None.

getparent(self): Returns the parent of this element or None for the root element.

getprevious(self): Returns the preceding sibling of this element or None.

getroottree(self)

Return an ElementTree for the root node of the document that contains this element.

This is the same as following element.getparent() up the tree until it returns None (for the root element) and then build an ElementTree for the last parent that was returned.

index(self, child, start=None, stop=None)

Find the position of the child within the parent.

This method is not part of the original ElementTree API.

insert(self, index, value)

items(self)

iter(self, tag=None, *tags)

Iterate over all elements in the subtree in document order (depth first pre-order), starting with this element.

Can be restricted to find only elements with specific tags: pass "{ns}localname" as tag. Either or both of ns and localname can be * for a wildcard; ns can be empty for no namespace. "localname" is equivalent to "{}localname" (i.e. no namespace) but "*" is "{*}*" (any or no namespace), not "{}*".

You can also pass the Element, Comment, ProcessingInstruction and Entity factory functions to look only for the specific element type.

Passing multiple tags (or a sequence of tags) instead of a single tag will let the iterator return all elements matching any of these tags, in document order.

iterancestors(self, tag=None, *tags)

Iterate over the ancestors of this element (from parent to parent).

Can be restricted to find only elements with specific tags, see iter.

iterchildren(self, tag=None, *tags, reversed=False)

Iterate over the children of this element.

As opposed to using normal iteration on this element, the returned elements can be reversed with the ‘reversed’ keyword and restricted to find only elements with specific tags, see iter.

iterdescendants(self, tag=None, *tags)

Iterate over the descendants of this element in document order.

As opposed to el.iter(), this iterator does not yield the element itself. The returned elements can be restricted to find only elements with specific tags, see iter.

iterfind(self, path, namespaces=None)

Iterates over all matching subelements, by tag name or path.

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

itersiblings(self, tag=None, *tags, preceding=False)

Iterate over the following or preceding siblings of this element.

The direction is determined by the ‘preceding’ keyword which defaults to False, i.e. forward iteration over the following siblings. When True, the iterator yields the preceding siblings in reverse document order, i.e. starting right before the current element and going backwards.

Can be restricted to find only elements with specific tags, see iter.

itertext(self, tag=None, *tags, with_tail=True)

Iterates over the text content of a subtree.

You can pass tag names to restrict text content to specific elements, see iter.

You can set the with_tail keyword argument to False to skip over tail text.

keys(self)

makeelement(self, _tag, attrib=None, nsmap=None, **_extra): Creates a new element associated with the same document.

parseXSL(self, parser=None)

Try to parse the stylesheet referenced by this PI and return an ElementTree for it. If the stylesheet is embedded in the same document (referenced via xml:id), find and return an ElementTree for the stylesheet Element.

The optional parser keyword argument can be passed to specify the parser used to read from external stylesheet URLs.

remove(self, element): Removes a matching subelement. Unlike the find methods, this method compares elements based on identity, not on tag value or contents.

replace(self, old_element, new_element): Replaces a subelement with the element passed as second argument.

set(self, key, value): Supports setting the ‘href’ pseudo-attribute in the text of the processing instruction.

values(self)

xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): Evaluate an xpath expression using the element as context node.

attrib: Returns a dict containing all pseudo-attributes that can be parsed from the text content of this processing instruction. Note that modifying the dict currently has no effect on the XML node, although this is not guaranteed to stay this way.

base

The base URI of the Element (xml:base or HTML base URL). None if the base URI is unknown.

Note that the value depends on the URL of the document that holds the Element if there is no xml:base attribute on the Element or its ancestors.

Setting this property will set an xml:base attribute on the Element, regardless of the document type (XML or HTML).

nsmap

Namespace prefix->URI mapping known in the context of this Element. This includes all namespace declarations of the parents.

Note that changing the returned dict has no effect on the Element.

prefix: Namespace prefix or None.

sourceline: Original line number as found by the parser or None if unknown.

tag

tail: Text after this element’s end tag, but before the next sibling element’s start tag. This is either a string or the value None, if there was no text.

target

text

class lxml.etree._XSLTResultTree

Bases: _ElementTree

The result of an XSLT evaluation.

Use str() or bytes() (or unicode() in Python 2.x) to serialise to a string, and the .write_output() method to write serialise to a file.

_setroot(self, root): Relocate the ElementTree to a new root node.

find(self, path, namespaces=None)

Finds the first toplevel element with given tag. Same as tree.getroot().find(path).

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findall(self, path, namespaces=None)

Finds all elements matching the ElementPath expression. Same as getroot().findall(path).

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

findtext(self, path, default=None, namespaces=None)

Finds the text for the first element matching the ElementPath expression. Same as getroot().findtext(path)

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

getelementpath(self, element)

Returns a structural, absolute ElementPath expression to find the element. This path can be used in the .find() method to look up the element, provided that the elements along the path and their list of immediate children were not modified in between.

ElementPath has the advantage over an XPath expression (as returned by the .getpath() method) that it does not require additional prefix declarations. It is always self-contained.

getiterator(self, *tags, tag=None)

Returns a sequence or iterator of all elements in document order (depth first pre-order), starting with the root element.

Can be restricted to find only elements with specific tags, see _Element.iter.

Deprecated: Note that this method is deprecated as of ElementTree 1.3 and lxml 2.0. It returns an iterator in lxml, which diverges from the original ElementTree behaviour. If you want an efficient iterator, use the tree.iter() method instead. You should only use this method in new code if you require backwards compatibility with older versions of lxml or ElementTree.

getpath(self, element)

Returns a structural, absolute XPath expression to find the element.

For namespaced elements, the expression uses prefixes from the document, which therefore need to be provided in order to make any use of the expression in XPath.

Also see the method getelementpath(self, element), which returns a self-contained ElementPath expression.

getroot(self): Gets the root element for this tree.

iter(self, tag=None, *tags)

Creates an iterator for the root element. The iterator loops over all elements in this tree, in document order. Note that siblings of the root element (comments or processing instructions) are not returned by the iterator.

Can be restricted to find only elements with specific tags, see _Element.iter.

iterfind(self, path, namespaces=None)

Iterates over all elements matching the ElementPath expression. Same as getroot().iterfind(path).

The optional namespaces argument accepts a prefix-to-namespace mapping that allows the usage of XPath prefixes in the path expression.

parse(self, source, parser=None, base_url=None): Updates self with the content of source and returns its root.

relaxng(self, relaxng)

Validate this document using other document.

The relaxng argument is a tree that should contain a Relax NG schema.

Returns True or False, depending on whether validation succeeded.

Note: if you are going to apply the same Relax NG schema against multiple documents, it is more efficient to use the RelaxNG class directly.

write(file, *, encoding, method, pretty_print, xml_declaration, with_tail, standalone, doctype, compression, exclusive, inclusive_ns_prefixes, with_comments, strip_text, docstring)

write(self, file, encoding=None, method=”xml”,: pretty_print=False, xml_declaration=None, with_tail=True, standalone=None, doctype=None, compression=0, exclusive=False, inclusive_ns_prefixes=None, with_comments=True, strip_text=False)