| import libxml2mod |
| import types |
| import sys |
| |
| # The root of all libxml2 errors. |
| class libxmlError(Exception): pass |
| |
| # Type of the wrapper class for the C objects wrappers |
| def checkWrapper(obj): |
| try: |
| n = type(_obj).__name__ |
| if n != 'PyCObject' and n != 'PyCapsule': |
| return 1 |
| except: |
| return 0 |
| return 0 |
| |
| # |
| # id() is sometimes negative ... |
| # |
| def pos_id(o): |
| i = id(o) |
| if (i < 0): |
| return (sys.maxsize - i) |
| return i |
| |
| # |
| # Errors raised by the wrappers when some tree handling failed. |
| # |
| class treeError(libxmlError): |
| def __init__(self, msg): |
| self.msg = msg |
| def __str__(self): |
| return self.msg |
| |
| class parserError(libxmlError): |
| def __init__(self, msg): |
| self.msg = msg |
| def __str__(self): |
| return self.msg |
| |
| class uriError(libxmlError): |
| def __init__(self, msg): |
| self.msg = msg |
| def __str__(self): |
| return self.msg |
| |
| class xpathError(libxmlError): |
| def __init__(self, msg): |
| self.msg = msg |
| def __str__(self): |
| return self.msg |
| |
| class ioWrapper: |
| def __init__(self, _obj): |
| self.__io = _obj |
| self._o = None |
| |
| def io_close(self): |
| if self.__io == None: |
| return(-1) |
| self.__io.close() |
| self.__io = None |
| return(0) |
| |
| def io_flush(self): |
| if self.__io == None: |
| return(-1) |
| self.__io.flush() |
| return(0) |
| |
| def io_read(self, len = -1): |
| if self.__io == None: |
| return(-1) |
| try: |
| if len < 0: |
| ret = self.__io.read() |
| else: |
| ret = self.__io.read(len) |
| except Exception: |
| import sys |
| e = sys.exc_info()[1] |
| print("failed to read from Python:", type(e)) |
| print("on IO:", self.__io) |
| self.__io == None |
| return(-1) |
| |
| return(ret) |
| |
| def io_write(self, str, len = -1): |
| if self.__io == None: |
| return(-1) |
| if len < 0: |
| return(self.__io.write(str)) |
| return(self.__io.write(str, len)) |
| |
| class ioReadWrapper(ioWrapper): |
| def __init__(self, _obj, enc = ""): |
| ioWrapper.__init__(self, _obj) |
| self._o = libxml2mod.xmlCreateInputBuffer(self, enc) |
| |
| def __del__(self): |
| print("__del__") |
| self.io_close() |
| if self._o != None: |
| libxml2mod.xmlFreeParserInputBuffer(self._o) |
| self._o = None |
| |
| def close(self): |
| self.io_close() |
| if self._o != None: |
| libxml2mod.xmlFreeParserInputBuffer(self._o) |
| self._o = None |
| |
| class ioWriteWrapper(ioWrapper): |
| def __init__(self, _obj, enc = ""): |
| # print "ioWriteWrapper.__init__", _obj |
| if type(_obj) == type(''): |
| print("write io from a string") |
| self.o = None |
| elif type(_obj).__name__ == 'PyCapsule': |
| file = libxml2mod.outputBufferGetPythonFile(_obj) |
| if file != None: |
| ioWrapper.__init__(self, file) |
| else: |
| ioWrapper.__init__(self, _obj) |
| self._o = _obj |
| # elif type(_obj) == types.InstanceType: |
| # print(("write io from instance of %s" % (_obj.__class__))) |
| # ioWrapper.__init__(self, _obj) |
| # self._o = libxml2mod.xmlCreateOutputBuffer(self, enc) |
| else: |
| file = libxml2mod.outputBufferGetPythonFile(_obj) |
| if file != None: |
| ioWrapper.__init__(self, file) |
| else: |
| ioWrapper.__init__(self, _obj) |
| self._o = _obj |
| |
| def __del__(self): |
| # print "__del__" |
| self.io_close() |
| if self._o != None: |
| libxml2mod.xmlOutputBufferClose(self._o) |
| self._o = None |
| |
| def flush(self): |
| self.io_flush() |
| if self._o != None: |
| libxml2mod.xmlOutputBufferClose(self._o) |
| self._o = None |
| |
| def close(self): |
| self.io_flush() |
| if self._o != None: |
| libxml2mod.xmlOutputBufferClose(self._o) |
| self._o = None |
| |
| # |
| # Example of a class to handle SAX events |
| # |
| class SAXCallback: |
| """Base class for SAX handlers""" |
| def startDocument(self): |
| """called at the start of the document""" |
| pass |
| |
| def endDocument(self): |
| """called at the end of the document""" |
| pass |
| |
| def startElement(self, tag, attrs): |
| """called at the start of every element, tag is the name of |
| the element, attrs is a dictionary of the element's attributes""" |
| pass |
| |
| def endElement(self, tag): |
| """called at the start of every element, tag is the name of |
| the element""" |
| pass |
| |
| def characters(self, data): |
| """called when character data have been read, data is the string |
| containing the data, multiple consecutive characters() callback |
| are possible.""" |
| pass |
| |
| def cdataBlock(self, data): |
| """called when CDATA section have been read, data is the string |
| containing the data, multiple consecutive cdataBlock() callback |
| are possible.""" |
| pass |
| |
| def reference(self, name): |
| """called when an entity reference has been found""" |
| pass |
| |
| def ignorableWhitespace(self, data): |
| """called when potentially ignorable white spaces have been found""" |
| pass |
| |
| def processingInstruction(self, target, data): |
| """called when a PI has been found, target contains the PI name and |
| data is the associated data in the PI""" |
| pass |
| |
| def comment(self, content): |
| """called when a comment has been found, content contains the comment""" |
| pass |
| |
| def externalSubset(self, name, externalID, systemID): |
| """called when a DOCTYPE declaration has been found, name is the |
| DTD name and externalID, systemID are the DTD public and system |
| identifier for that DTd if available""" |
| pass |
| |
| def internalSubset(self, name, externalID, systemID): |
| """called when a DOCTYPE declaration has been found, name is the |
| DTD name and externalID, systemID are the DTD public and system |
| identifier for that DTD if available""" |
| pass |
| |
| def entityDecl(self, name, type, externalID, systemID, content): |
| """called when an ENTITY declaration has been found, name is the |
| entity name and externalID, systemID are the entity public and |
| system identifier for that entity if available, type indicates |
| the entity type, and content reports it's string content""" |
| pass |
| |
| def notationDecl(self, name, externalID, systemID): |
| """called when an NOTATION declaration has been found, name is the |
| notation name and externalID, systemID are the notation public and |
| system identifier for that notation if available""" |
| pass |
| |
| def attributeDecl(self, elem, name, type, defi, defaultValue, nameList): |
| """called when an ATTRIBUTE definition has been found""" |
| pass |
| |
| def elementDecl(self, name, type, content): |
| """called when an ELEMENT definition has been found""" |
| pass |
| |
| def entityDecl(self, name, publicId, systemID, notationName): |
| """called when an unparsed ENTITY declaration has been found, |
| name is the entity name and publicId,, systemID are the entity |
| public and system identifier for that entity if available, |
| and notationName indicate the associated NOTATION""" |
| pass |
| |
| def warning(self, msg): |
| #print msg |
| pass |
| |
| def error(self, msg): |
| raise parserError(msg) |
| |
| def fatalError(self, msg): |
| raise parserError(msg) |
| |
| # |
| # This class is the ancestor of all the Node classes. It provides |
| # the basic functionalities shared by all nodes (and handle |
| # gracefylly the exception), like name, navigation in the tree, |
| # doc reference, content access and serializing to a string or URI |
| # |
| class xmlCore: |
| def __init__(self, _obj=None): |
| if _obj != None: |
| self._o = _obj; |
| return |
| self._o = None |
| |
| def __eq__(self, other): |
| if other == None: |
| return False |
| ret = libxml2mod.compareNodesEqual(self._o, other._o) |
| if ret == None: |
| return False |
| return ret == True |
| def __ne__(self, other): |
| if other == None: |
| return True |
| ret = libxml2mod.compareNodesEqual(self._o, other._o) |
| return not ret |
| def __hash__(self): |
| ret = libxml2mod.nodeHash(self._o) |
| return ret |
| |
| def __str__(self): |
| return self.serialize() |
| def get_parent(self): |
| ret = libxml2mod.parent(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| def get_children(self): |
| ret = libxml2mod.children(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| def get_last(self): |
| ret = libxml2mod.last(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| def get_next(self): |
| ret = libxml2mod.next(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| def get_properties(self): |
| ret = libxml2mod.properties(self._o) |
| if ret == None: |
| return None |
| return xmlAttr(_obj=ret) |
| def get_prev(self): |
| ret = libxml2mod.prev(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| def get_content(self): |
| return libxml2mod.xmlNodeGetContent(self._o) |
| getContent = get_content # why is this duplicate naming needed ? |
| def get_name(self): |
| return libxml2mod.name(self._o) |
| def get_type(self): |
| return libxml2mod.type(self._o) |
| def get_doc(self): |
| ret = libxml2mod.doc(self._o) |
| if ret == None: |
| if self.type in ["document_xml", "document_html"]: |
| return xmlDoc(_obj=self._o) |
| else: |
| return None |
| return xmlDoc(_obj=ret) |
| # |
| # Those are common attributes to nearly all type of nodes |
| # defined as python2 properties |
| # |
| import sys |
| if float(sys.version[0:3]) < 2.2: |
| def __getattr__(self, attr): |
| if attr == "parent": |
| ret = libxml2mod.parent(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| elif attr == "properties": |
| ret = libxml2mod.properties(self._o) |
| if ret == None: |
| return None |
| return xmlAttr(_obj=ret) |
| elif attr == "children": |
| ret = libxml2mod.children(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| elif attr == "last": |
| ret = libxml2mod.last(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| elif attr == "next": |
| ret = libxml2mod.next(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| elif attr == "prev": |
| ret = libxml2mod.prev(self._o) |
| if ret == None: |
| return None |
| return nodeWrap(ret) |
| elif attr == "content": |
| return libxml2mod.xmlNodeGetContent(self._o) |
| elif attr == "name": |
| return libxml2mod.name(self._o) |
| elif attr == "type": |
| return libxml2mod.type(self._o) |
| elif attr == "doc": |
| ret = libxml2mod.doc(self._o) |
| if ret == None: |
| if self.type == "document_xml" or self.type == "document_html": |
| return xmlDoc(_obj=self._o) |
| else: |
| return None |
| return xmlDoc(_obj=ret) |
| raise AttributeError(attr) |
| else: |
| parent = property(get_parent, None, None, "Parent node") |
| children = property(get_children, None, None, "First child node") |
| last = property(get_last, None, None, "Last sibling node") |
| next = property(get_next, None, None, "Next sibling node") |
| prev = property(get_prev, None, None, "Previous sibling node") |
| properties = property(get_properties, None, None, "List of properies") |
| content = property(get_content, None, None, "Content of this node") |
| name = property(get_name, None, None, "Node name") |
| type = property(get_type, None, None, "Node type") |
| doc = property(get_doc, None, None, "The document this node belongs to") |
| |
| # |
| # Serialization routines, the optional arguments have the following |
| # meaning: |
| # encoding: string to ask saving in a specific encoding |
| # indent: if 1 the serializer is asked to indent the output |
| # |
| def serialize(self, encoding = None, format = 0): |
| return libxml2mod.serializeNode(self._o, encoding, format) |
| def saveTo(self, file, encoding = None, format = 0): |
| return libxml2mod.saveNodeTo(self._o, file, encoding, format) |
| |
| # |
| # Canonicalization routines: |
| # |
| # nodes: the node set (tuple or list) to be included in the |
| # canonized image or None if all document nodes should be |
| # included. |
| # exclusive: the exclusive flag (0 - non-exclusive |
| # canonicalization; otherwise - exclusive canonicalization) |
| # prefixes: the list of inclusive namespace prefixes (strings), |
| # or None if there is no inclusive namespaces (only for |
| # exclusive canonicalization, ignored otherwise) |
| # with_comments: include comments in the result (!=0) or not |
| # (==0) |
| def c14nMemory(self, |
| nodes=None, |
| exclusive=0, |
| prefixes=None, |
| with_comments=0): |
| if nodes: |
| nodes = [n._o for n in nodes] |
| return libxml2mod.xmlC14NDocDumpMemory( |
| self.get_doc()._o, |
| nodes, |
| exclusive != 0, |
| prefixes, |
| with_comments != 0) |
| def c14nSaveTo(self, |
| file, |
| nodes=None, |
| exclusive=0, |
| prefixes=None, |
| with_comments=0): |
| if nodes: |
| nodes = [n._o for n in nodes] |
| return libxml2mod.xmlC14NDocSaveTo( |
| self.get_doc()._o, |
| nodes, |
| exclusive != 0, |
| prefixes, |
| with_comments != 0, |
| file) |
| |
| # |
| # Selecting nodes using XPath, a bit slow because the context |
| # is allocated/freed every time but convenient. |
| # |
| def xpathEval(self, expr): |
| doc = self.doc |
| if doc == None: |
| return None |
| ctxt = doc.xpathNewContext() |
| ctxt.setContextNode(self) |
| res = ctxt.xpathEval(expr) |
| ctxt.xpathFreeContext() |
| return res |
| |
| # # |
| # # Selecting nodes using XPath, faster because the context |
| # # is allocated just once per xmlDoc. |
| # # |
| # # Removed: DV memleaks c.f. #126735 |
| # # |
| # def xpathEval2(self, expr): |
| # doc = self.doc |
| # if doc == None: |
| # return None |
| # try: |
| # doc._ctxt.setContextNode(self) |
| # except: |
| # doc._ctxt = doc.xpathNewContext() |
| # doc._ctxt.setContextNode(self) |
| # res = doc._ctxt.xpathEval(expr) |
| # return res |
| def xpathEval2(self, expr): |
| return self.xpathEval(expr) |
| |
| # Remove namespaces |
| def removeNsDef(self, href): |
| """ |
| Remove a namespace definition from a node. If href is None, |
| remove all of the ns definitions on that node. The removed |
| namespaces are returned as a linked list. |
| |
| Note: If any child nodes referred to the removed namespaces, |
| they will be left with dangling links. You should call |
| renconciliateNs() to fix those pointers. |
| |
| Note: This method does not free memory taken by the ns |
| definitions. You will need to free it manually with the |
| freeNsList() method on the returns xmlNs object. |
| """ |
| |
| ret = libxml2mod.xmlNodeRemoveNsDef(self._o, href) |
| if ret is None:return None |
| __tmp = xmlNs(_obj=ret) |
| return __tmp |
| |
| # support for python2 iterators |
| def walk_depth_first(self): |
| return xmlCoreDepthFirstItertor(self) |
| def walk_breadth_first(self): |
| return xmlCoreBreadthFirstItertor(self) |
| __iter__ = walk_depth_first |
| |
| def free(self): |
| try: |
| self.doc._ctxt.xpathFreeContext() |
| except: |
| pass |
| libxml2mod.xmlFreeDoc(self._o) |
| |
| |
| # |
| # implements the depth-first iterator for libxml2 DOM tree |
| # |
| class xmlCoreDepthFirstItertor: |
| def __init__(self, node): |
| self.node = node |
| self.parents = [] |
| def __iter__(self): |
| return self |
| def __next__(self): |
| while 1: |
| if self.node: |
| ret = self.node |
| self.parents.append(self.node) |
| self.node = self.node.children |
| return ret |
| try: |
| parent = self.parents.pop() |
| except IndexError: |
| raise StopIteration |
| self.node = parent.next |
| next = __next__ |
| |
| # |
| # implements the breadth-first iterator for libxml2 DOM tree |
| # |
| class xmlCoreBreadthFirstItertor: |
| def __init__(self, node): |
| self.node = node |
| self.parents = [] |
| def __iter__(self): |
| return self |
| def __next__(self): |
| while 1: |
| if self.node: |
| ret = self.node |
| self.parents.append(self.node) |
| self.node = self.node.next |
| return ret |
| try: |
| parent = self.parents.pop() |
| except IndexError: |
| raise StopIteration |
| self.node = parent.children |
| next = __next__ |
| |
| # |
| # converters to present a nicer view of the XPath returns |
| # |
| def nodeWrap(o): |
| # TODO try to cast to the most appropriate node class |
| name = libxml2mod.type(o) |
| if name == "element" or name == "text": |
| return xmlNode(_obj=o) |
| if name == "attribute": |
| return xmlAttr(_obj=o) |
| if name[0:8] == "document": |
| return xmlDoc(_obj=o) |
| if name == "namespace": |
| return xmlNs(_obj=o) |
| if name == "elem_decl": |
| return xmlElement(_obj=o) |
| if name == "attribute_decl": |
| return xmlAttribute(_obj=o) |
| if name == "entity_decl": |
| return xmlEntity(_obj=o) |
| if name == "dtd": |
| return xmlDtd(_obj=o) |
| return xmlNode(_obj=o) |
| |
| def xpathObjectRet(o): |
| otype = type(o) |
| if otype == type([]): |
| ret = list(map(xpathObjectRet, o)) |
| return ret |
| elif otype == type(()): |
| ret = list(map(xpathObjectRet, o)) |
| return tuple(ret) |
| elif otype == type('') or otype == type(0) or otype == type(0.0): |
| return o |
| else: |
| return nodeWrap(o) |
| |
| # |
| # register an XPath function |
| # |
| def registerXPathFunction(ctxt, name, ns_uri, f): |
| ret = libxml2mod.xmlRegisterXPathFunction(ctxt, name, ns_uri, f) |
| |
| # |
| # For the xmlTextReader parser configuration |
| # |
| PARSER_LOADDTD=1 |
| PARSER_DEFAULTATTRS=2 |
| PARSER_VALIDATE=3 |
| PARSER_SUBST_ENTITIES=4 |
| |
| # |
| # For the error callback severities |
| # |
| PARSER_SEVERITY_VALIDITY_WARNING=1 |
| PARSER_SEVERITY_VALIDITY_ERROR=2 |
| PARSER_SEVERITY_WARNING=3 |
| PARSER_SEVERITY_ERROR=4 |
| |
| # |
| # register the libxml2 error handler |
| # |
| def registerErrorHandler(f, ctx): |
| """Register a Python written function to for error reporting. |
| The function is called back as f(ctx, error). """ |
| import sys |
| if 'libxslt' not in sys.modules: |
| # normal behaviour when libxslt is not imported |
| ret = libxml2mod.xmlRegisterErrorHandler(f,ctx) |
| else: |
| # when libxslt is already imported, one must |
| # use libxst's error handler instead |
| import libxslt |
| ret = libxslt.registerErrorHandler(f,ctx) |
| return ret |
| |
| class parserCtxtCore: |
| |
| def __init__(self, _obj=None): |
| if _obj != None: |
| self._o = _obj; |
| return |
| self._o = None |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlFreeParserCtxt(self._o) |
| self._o = None |
| |
| def setErrorHandler(self,f,arg): |
| """Register an error handler that will be called back as |
| f(arg,msg,severity,reserved). |
| |
| @reserved is currently always None.""" |
| libxml2mod.xmlParserCtxtSetErrorHandler(self._o,f,arg) |
| |
| def getErrorHandler(self): |
| """Return (f,arg) as previously registered with setErrorHandler |
| or (None,None).""" |
| return libxml2mod.xmlParserCtxtGetErrorHandler(self._o) |
| |
| def addLocalCatalog(self, uri): |
| """Register a local catalog with the parser""" |
| return libxml2mod.addLocalCatalog(self._o, uri) |
| |
| |
| class ValidCtxtCore: |
| |
| def __init__(self, *args, **kw): |
| pass |
| |
| def setValidityErrorHandler(self, err_func, warn_func, arg=None): |
| """ |
| Register error and warning handlers for DTD validation. |
| These will be called back as f(msg,arg) |
| """ |
| libxml2mod.xmlSetValidErrors(self._o, err_func, warn_func, arg) |
| |
| |
| class SchemaValidCtxtCore: |
| |
| def __init__(self, *args, **kw): |
| pass |
| |
| def setValidityErrorHandler(self, err_func, warn_func, arg=None): |
| """ |
| Register error and warning handlers for Schema validation. |
| These will be called back as f(msg,arg) |
| """ |
| libxml2mod.xmlSchemaSetValidErrors(self._o, err_func, warn_func, arg) |
| |
| |
| class relaxNgValidCtxtCore: |
| |
| def __init__(self, *args, **kw): |
| pass |
| |
| def setValidityErrorHandler(self, err_func, warn_func, arg=None): |
| """ |
| Register error and warning handlers for RelaxNG validation. |
| These will be called back as f(msg,arg) |
| """ |
| libxml2mod.xmlRelaxNGSetValidErrors(self._o, err_func, warn_func, arg) |
| |
| |
| def _xmlTextReaderErrorFunc(xxx_todo_changeme,msg,severity,locator): |
| """Intermediate callback to wrap the locator""" |
| (f,arg) = xxx_todo_changeme |
| return f(arg,msg,severity,xmlTextReaderLocator(locator)) |
| |
| class xmlTextReaderCore: |
| |
| def __init__(self, _obj=None): |
| self.input = None |
| if _obj != None:self._o = _obj;return |
| self._o = None |
| |
| def __del__(self): |
| if self._o != None: |
| libxml2mod.xmlFreeTextReader(self._o) |
| self._o = None |
| |
| def SetErrorHandler(self,f,arg): |
| """Register an error handler that will be called back as |
| f(arg,msg,severity,locator).""" |
| if f is None: |
| libxml2mod.xmlTextReaderSetErrorHandler(\ |
| self._o,None,None) |
| else: |
| libxml2mod.xmlTextReaderSetErrorHandler(\ |
| self._o,_xmlTextReaderErrorFunc,(f,arg)) |
| |
| def GetErrorHandler(self): |
| """Return (f,arg) as previously registered with setErrorHandler |
| or (None,None).""" |
| f,arg = libxml2mod.xmlTextReaderGetErrorHandler(self._o) |
| if f is None: |
| return None,None |
| else: |
| # assert f is _xmlTextReaderErrorFunc |
| return arg |
| |
| # |
| # The cleanup now goes though a wrapper in libxml.c |
| # |
| def cleanupParser(): |
| libxml2mod.xmlPythonCleanupParser() |
| |
| # |
| # The interface to xmlRegisterInputCallbacks. |
| # Since this API does not allow to pass a data object along with |
| # match/open callbacks, it is necessary to maintain a list of all |
| # Python callbacks. |
| # |
| __input_callbacks = [] |
| def registerInputCallback(func): |
| def findOpenCallback(URI): |
| for cb in reversed(__input_callbacks): |
| o = cb(URI) |
| if o is not None: |
| return o |
| libxml2mod.xmlRegisterInputCallback(findOpenCallback) |
| __input_callbacks.append(func) |
| |
| def popInputCallbacks(): |
| # First pop python-level callbacks, when no more available - start |
| # popping built-in ones. |
| if len(__input_callbacks) > 0: |
| __input_callbacks.pop() |
| if len(__input_callbacks) == 0: |
| libxml2mod.xmlUnregisterInputCallback() |
| |
| # WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING |
| # |
| # Everything before this line comes from libxml.py |
| # Everything after this line is automatically generated |
| # |
| # WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING |
| |
