Annotation of embedaddon/libxml2/python/libxml.py, revision 1.1.1.1
1.1 misho 1: import libxml2mod
2: import types
3: import sys
4:
5: # The root of all libxml2 errors.
6: class libxmlError(Exception): pass
7:
8: #
9: # id() is sometimes negative ...
10: #
11: def pos_id(o):
12: i = id(o)
13: if (i < 0):
14: return (sys.maxint - i)
15: return i
16:
17: #
18: # Errors raised by the wrappers when some tree handling failed.
19: #
20: class treeError(libxmlError):
21: def __init__(self, msg):
22: self.msg = msg
23: def __str__(self):
24: return self.msg
25:
26: class parserError(libxmlError):
27: def __init__(self, msg):
28: self.msg = msg
29: def __str__(self):
30: return self.msg
31:
32: class uriError(libxmlError):
33: def __init__(self, msg):
34: self.msg = msg
35: def __str__(self):
36: return self.msg
37:
38: class xpathError(libxmlError):
39: def __init__(self, msg):
40: self.msg = msg
41: def __str__(self):
42: return self.msg
43:
44: class ioWrapper:
45: def __init__(self, _obj):
46: self.__io = _obj
47: self._o = None
48:
49: def io_close(self):
50: if self.__io == None:
51: return(-1)
52: self.__io.close()
53: self.__io = None
54: return(0)
55:
56: def io_flush(self):
57: if self.__io == None:
58: return(-1)
59: self.__io.flush()
60: return(0)
61:
62: def io_read(self, len = -1):
63: if self.__io == None:
64: return(-1)
65: if len < 0:
66: return(self.__io.read())
67: return(self.__io.read(len))
68:
69: def io_write(self, str, len = -1):
70: if self.__io == None:
71: return(-1)
72: if len < 0:
73: return(self.__io.write(str))
74: return(self.__io.write(str, len))
75:
76: class ioReadWrapper(ioWrapper):
77: def __init__(self, _obj, enc = ""):
78: ioWrapper.__init__(self, _obj)
79: self._o = libxml2mod.xmlCreateInputBuffer(self, enc)
80:
81: def __del__(self):
82: print "__del__"
83: self.io_close()
84: if self._o != None:
85: libxml2mod.xmlFreeParserInputBuffer(self._o)
86: self._o = None
87:
88: def close(self):
89: self.io_close()
90: if self._o != None:
91: libxml2mod.xmlFreeParserInputBuffer(self._o)
92: self._o = None
93:
94: class ioWriteWrapper(ioWrapper):
95: def __init__(self, _obj, enc = ""):
96: # print "ioWriteWrapper.__init__", _obj
97: if type(_obj) == type(''):
98: print "write io from a string"
99: self.o = None
100: elif type(_obj) == types.InstanceType:
101: print "write io from instance of %s" % (_obj.__class__)
102: ioWrapper.__init__(self, _obj)
103: self._o = libxml2mod.xmlCreateOutputBuffer(self, enc)
104: else:
105: file = libxml2mod.outputBufferGetPythonFile(_obj)
106: if file != None:
107: ioWrapper.__init__(self, file)
108: else:
109: ioWrapper.__init__(self, _obj)
110: self._o = _obj
111:
112: def __del__(self):
113: # print "__del__"
114: self.io_close()
115: if self._o != None:
116: libxml2mod.xmlOutputBufferClose(self._o)
117: self._o = None
118:
119: def flush(self):
120: self.io_flush()
121: if self._o != None:
122: libxml2mod.xmlOutputBufferClose(self._o)
123: self._o = None
124:
125: def close(self):
126: self.io_flush()
127: if self._o != None:
128: libxml2mod.xmlOutputBufferClose(self._o)
129: self._o = None
130:
131: #
132: # Example of a class to handle SAX events
133: #
134: class SAXCallback:
135: """Base class for SAX handlers"""
136: def startDocument(self):
137: """called at the start of the document"""
138: pass
139:
140: def endDocument(self):
141: """called at the end of the document"""
142: pass
143:
144: def startElement(self, tag, attrs):
145: """called at the start of every element, tag is the name of
146: the element, attrs is a dictionary of the element's attributes"""
147: pass
148:
149: def endElement(self, tag):
150: """called at the start of every element, tag is the name of
151: the element"""
152: pass
153:
154: def characters(self, data):
155: """called when character data have been read, data is the string
156: containing the data, multiple consecutive characters() callback
157: are possible."""
158: pass
159:
160: def cdataBlock(self, data):
161: """called when CDATA section have been read, data is the string
162: containing the data, multiple consecutive cdataBlock() callback
163: are possible."""
164: pass
165:
166: def reference(self, name):
167: """called when an entity reference has been found"""
168: pass
169:
170: def ignorableWhitespace(self, data):
171: """called when potentially ignorable white spaces have been found"""
172: pass
173:
174: def processingInstruction(self, target, data):
175: """called when a PI has been found, target contains the PI name and
176: data is the associated data in the PI"""
177: pass
178:
179: def comment(self, content):
180: """called when a comment has been found, content contains the comment"""
181: pass
182:
183: def externalSubset(self, name, externalID, systemID):
184: """called when a DOCTYPE declaration has been found, name is the
185: DTD name and externalID, systemID are the DTD public and system
186: identifier for that DTd if available"""
187: pass
188:
189: def internalSubset(self, name, externalID, systemID):
190: """called when a DOCTYPE declaration has been found, name is the
191: DTD name and externalID, systemID are the DTD public and system
192: identifier for that DTD if available"""
193: pass
194:
195: def entityDecl(self, name, type, externalID, systemID, content):
196: """called when an ENTITY declaration has been found, name is the
197: entity name and externalID, systemID are the entity public and
198: system identifier for that entity if available, type indicates
199: the entity type, and content reports it's string content"""
200: pass
201:
202: def notationDecl(self, name, externalID, systemID):
203: """called when an NOTATION declaration has been found, name is the
204: notation name and externalID, systemID are the notation public and
205: system identifier for that notation if available"""
206: pass
207:
208: def attributeDecl(self, elem, name, type, defi, defaultValue, nameList):
209: """called when an ATTRIBUTE definition has been found"""
210: pass
211:
212: def elementDecl(self, name, type, content):
213: """called when an ELEMENT definition has been found"""
214: pass
215:
216: def entityDecl(self, name, publicId, systemID, notationName):
217: """called when an unparsed ENTITY declaration has been found,
218: name is the entity name and publicId,, systemID are the entity
219: public and system identifier for that entity if available,
220: and notationName indicate the associated NOTATION"""
221: pass
222:
223: def warning(self, msg):
224: #print msg
225: pass
226:
227: def error(self, msg):
228: raise parserError(msg)
229:
230: def fatalError(self, msg):
231: raise parserError(msg)
232:
233: #
234: # This class is the ancestor of all the Node classes. It provides
235: # the basic functionalities shared by all nodes (and handle
236: # gracefylly the exception), like name, navigation in the tree,
237: # doc reference, content access and serializing to a string or URI
238: #
239: class xmlCore:
240: def __init__(self, _obj=None):
241: if _obj != None:
242: self._o = _obj;
243: return
244: self._o = None
245:
246: def __eq__(self, other):
247: if other == None:
248: return False
249: ret = libxml2mod.compareNodesEqual(self._o, other._o)
250: if ret == None:
251: return False
252: return ret == True
253: def __ne__(self, other):
254: if other == None:
255: return True
256: ret = libxml2mod.compareNodesEqual(self._o, other._o)
257: return not ret
258: def __hash__(self):
259: ret = libxml2mod.nodeHash(self._o)
260: return ret
261:
262: def __str__(self):
263: return self.serialize()
264: def get_parent(self):
265: ret = libxml2mod.parent(self._o)
266: if ret == None:
267: return None
268: return xmlNode(_obj=ret)
269: def get_children(self):
270: ret = libxml2mod.children(self._o)
271: if ret == None:
272: return None
273: return xmlNode(_obj=ret)
274: def get_last(self):
275: ret = libxml2mod.last(self._o)
276: if ret == None:
277: return None
278: return xmlNode(_obj=ret)
279: def get_next(self):
280: ret = libxml2mod.next(self._o)
281: if ret == None:
282: return None
283: return xmlNode(_obj=ret)
284: def get_properties(self):
285: ret = libxml2mod.properties(self._o)
286: if ret == None:
287: return None
288: return xmlAttr(_obj=ret)
289: def get_prev(self):
290: ret = libxml2mod.prev(self._o)
291: if ret == None:
292: return None
293: return xmlNode(_obj=ret)
294: def get_content(self):
295: return libxml2mod.xmlNodeGetContent(self._o)
296: getContent = get_content # why is this duplicate naming needed ?
297: def get_name(self):
298: return libxml2mod.name(self._o)
299: def get_type(self):
300: return libxml2mod.type(self._o)
301: def get_doc(self):
302: ret = libxml2mod.doc(self._o)
303: if ret == None:
304: if self.type in ["document_xml", "document_html"]:
305: return xmlDoc(_obj=self._o)
306: else:
307: return None
308: return xmlDoc(_obj=ret)
309: #
310: # Those are common attributes to nearly all type of nodes
311: # defined as python2 properties
312: #
313: import sys
314: if float(sys.version[0:3]) < 2.2:
315: def __getattr__(self, attr):
316: if attr == "parent":
317: ret = libxml2mod.parent(self._o)
318: if ret == None:
319: return None
320: return xmlNode(_obj=ret)
321: elif attr == "properties":
322: ret = libxml2mod.properties(self._o)
323: if ret == None:
324: return None
325: return xmlAttr(_obj=ret)
326: elif attr == "children":
327: ret = libxml2mod.children(self._o)
328: if ret == None:
329: return None
330: return xmlNode(_obj=ret)
331: elif attr == "last":
332: ret = libxml2mod.last(self._o)
333: if ret == None:
334: return None
335: return xmlNode(_obj=ret)
336: elif attr == "next":
337: ret = libxml2mod.next(self._o)
338: if ret == None:
339: return None
340: return xmlNode(_obj=ret)
341: elif attr == "prev":
342: ret = libxml2mod.prev(self._o)
343: if ret == None:
344: return None
345: return xmlNode(_obj=ret)
346: elif attr == "content":
347: return libxml2mod.xmlNodeGetContent(self._o)
348: elif attr == "name":
349: return libxml2mod.name(self._o)
350: elif attr == "type":
351: return libxml2mod.type(self._o)
352: elif attr == "doc":
353: ret = libxml2mod.doc(self._o)
354: if ret == None:
355: if self.type == "document_xml" or self.type == "document_html":
356: return xmlDoc(_obj=self._o)
357: else:
358: return None
359: return xmlDoc(_obj=ret)
360: raise AttributeError,attr
361: else:
362: parent = property(get_parent, None, None, "Parent node")
363: children = property(get_children, None, None, "First child node")
364: last = property(get_last, None, None, "Last sibling node")
365: next = property(get_next, None, None, "Next sibling node")
366: prev = property(get_prev, None, None, "Previous sibling node")
367: properties = property(get_properties, None, None, "List of properies")
368: content = property(get_content, None, None, "Content of this node")
369: name = property(get_name, None, None, "Node name")
370: type = property(get_type, None, None, "Node type")
371: doc = property(get_doc, None, None, "The document this node belongs to")
372:
373: #
374: # Serialization routines, the optional arguments have the following
375: # meaning:
376: # encoding: string to ask saving in a specific encoding
377: # indent: if 1 the serializer is asked to indent the output
378: #
379: def serialize(self, encoding = None, format = 0):
380: return libxml2mod.serializeNode(self._o, encoding, format)
381: def saveTo(self, file, encoding = None, format = 0):
382: return libxml2mod.saveNodeTo(self._o, file, encoding, format)
383:
384: #
385: # Canonicalization routines:
386: #
387: # nodes: the node set (tuple or list) to be included in the
388: # canonized image or None if all document nodes should be
389: # included.
390: # exclusive: the exclusive flag (0 - non-exclusive
391: # canonicalization; otherwise - exclusive canonicalization)
392: # prefixes: the list of inclusive namespace prefixes (strings),
393: # or None if there is no inclusive namespaces (only for
394: # exclusive canonicalization, ignored otherwise)
395: # with_comments: include comments in the result (!=0) or not
396: # (==0)
397: def c14nMemory(self,
398: nodes=None,
399: exclusive=0,
400: prefixes=None,
401: with_comments=0):
402: if nodes:
403: nodes = map(lambda n: n._o, nodes)
404: return libxml2mod.xmlC14NDocDumpMemory(
405: self.get_doc()._o,
406: nodes,
407: exclusive != 0,
408: prefixes,
409: with_comments != 0)
410: def c14nSaveTo(self,
411: file,
412: nodes=None,
413: exclusive=0,
414: prefixes=None,
415: with_comments=0):
416: if nodes:
417: nodes = map(lambda n: n._o, nodes)
418: return libxml2mod.xmlC14NDocSaveTo(
419: self.get_doc()._o,
420: nodes,
421: exclusive != 0,
422: prefixes,
423: with_comments != 0,
424: file)
425:
426: #
427: # Selecting nodes using XPath, a bit slow because the context
428: # is allocated/freed every time but convenient.
429: #
430: def xpathEval(self, expr):
431: doc = self.doc
432: if doc == None:
433: return None
434: ctxt = doc.xpathNewContext()
435: ctxt.setContextNode(self)
436: res = ctxt.xpathEval(expr)
437: ctxt.xpathFreeContext()
438: return res
439:
440: # #
441: # # Selecting nodes using XPath, faster because the context
442: # # is allocated just once per xmlDoc.
443: # #
444: # # Removed: DV memleaks c.f. #126735
445: # #
446: # def xpathEval2(self, expr):
447: # doc = self.doc
448: # if doc == None:
449: # return None
450: # try:
451: # doc._ctxt.setContextNode(self)
452: # except:
453: # doc._ctxt = doc.xpathNewContext()
454: # doc._ctxt.setContextNode(self)
455: # res = doc._ctxt.xpathEval(expr)
456: # return res
457: def xpathEval2(self, expr):
458: return self.xpathEval(expr)
459:
460: # Remove namespaces
461: def removeNsDef(self, href):
462: """
463: Remove a namespace definition from a node. If href is None,
464: remove all of the ns definitions on that node. The removed
465: namespaces are returned as a linked list.
466:
467: Note: If any child nodes referred to the removed namespaces,
468: they will be left with dangling links. You should call
469: renconciliateNs() to fix those pointers.
470:
471: Note: This method does not free memory taken by the ns
472: definitions. You will need to free it manually with the
473: freeNsList() method on the returns xmlNs object.
474: """
475:
476: ret = libxml2mod.xmlNodeRemoveNsDef(self._o, href)
477: if ret is None:return None
478: __tmp = xmlNs(_obj=ret)
479: return __tmp
480:
481: # support for python2 iterators
482: def walk_depth_first(self):
483: return xmlCoreDepthFirstItertor(self)
484: def walk_breadth_first(self):
485: return xmlCoreBreadthFirstItertor(self)
486: __iter__ = walk_depth_first
487:
488: def free(self):
489: try:
490: self.doc._ctxt.xpathFreeContext()
491: except:
492: pass
493: libxml2mod.xmlFreeDoc(self._o)
494:
495:
496: #
497: # implements the depth-first iterator for libxml2 DOM tree
498: #
499: class xmlCoreDepthFirstItertor:
500: def __init__(self, node):
501: self.node = node
502: self.parents = []
503: def __iter__(self):
504: return self
505: def next(self):
506: while 1:
507: if self.node:
508: ret = self.node
509: self.parents.append(self.node)
510: self.node = self.node.children
511: return ret
512: try:
513: parent = self.parents.pop()
514: except IndexError:
515: raise StopIteration
516: self.node = parent.next
517:
518: #
519: # implements the breadth-first iterator for libxml2 DOM tree
520: #
521: class xmlCoreBreadthFirstItertor:
522: def __init__(self, node):
523: self.node = node
524: self.parents = []
525: def __iter__(self):
526: return self
527: def next(self):
528: while 1:
529: if self.node:
530: ret = self.node
531: self.parents.append(self.node)
532: self.node = self.node.next
533: return ret
534: try:
535: parent = self.parents.pop()
536: except IndexError:
537: raise StopIteration
538: self.node = parent.children
539:
540: #
541: # converters to present a nicer view of the XPath returns
542: #
543: def nodeWrap(o):
544: # TODO try to cast to the most appropriate node class
545: name = libxml2mod.type(o)
546: if name == "element" or name == "text":
547: return xmlNode(_obj=o)
548: if name == "attribute":
549: return xmlAttr(_obj=o)
550: if name[0:8] == "document":
551: return xmlDoc(_obj=o)
552: if name == "namespace":
553: return xmlNs(_obj=o)
554: if name == "elem_decl":
555: return xmlElement(_obj=o)
556: if name == "attribute_decl":
557: return xmlAttribute(_obj=o)
558: if name == "entity_decl":
559: return xmlEntity(_obj=o)
560: if name == "dtd":
561: return xmlDtd(_obj=o)
562: return xmlNode(_obj=o)
563:
564: def xpathObjectRet(o):
565: otype = type(o)
566: if otype == type([]):
567: ret = map(xpathObjectRet, o)
568: return ret
569: elif otype == type(()):
570: ret = map(xpathObjectRet, o)
571: return tuple(ret)
572: elif otype == type('') or otype == type(0) or otype == type(0.0):
573: return o
574: else:
575: return nodeWrap(o)
576:
577: #
578: # register an XPath function
579: #
580: def registerXPathFunction(ctxt, name, ns_uri, f):
581: ret = libxml2mod.xmlRegisterXPathFunction(ctxt, name, ns_uri, f)
582:
583: #
584: # For the xmlTextReader parser configuration
585: #
586: PARSER_LOADDTD=1
587: PARSER_DEFAULTATTRS=2
588: PARSER_VALIDATE=3
589: PARSER_SUBST_ENTITIES=4
590:
591: #
592: # For the error callback severities
593: #
594: PARSER_SEVERITY_VALIDITY_WARNING=1
595: PARSER_SEVERITY_VALIDITY_ERROR=2
596: PARSER_SEVERITY_WARNING=3
597: PARSER_SEVERITY_ERROR=4
598:
599: #
600: # register the libxml2 error handler
601: #
602: def registerErrorHandler(f, ctx):
603: """Register a Python written function to for error reporting.
604: The function is called back as f(ctx, error). """
605: import sys
606: if not sys.modules.has_key('libxslt'):
607: # normal behaviour when libxslt is not imported
608: ret = libxml2mod.xmlRegisterErrorHandler(f,ctx)
609: else:
610: # when libxslt is already imported, one must
611: # use libxst's error handler instead
612: import libxslt
613: ret = libxslt.registerErrorHandler(f,ctx)
614: return ret
615:
616: class parserCtxtCore:
617:
618: def __init__(self, _obj=None):
619: if _obj != None:
620: self._o = _obj;
621: return
622: self._o = None
623:
624: def __del__(self):
625: if self._o != None:
626: libxml2mod.xmlFreeParserCtxt(self._o)
627: self._o = None
628:
629: def setErrorHandler(self,f,arg):
630: """Register an error handler that will be called back as
631: f(arg,msg,severity,reserved).
632:
633: @reserved is currently always None."""
634: libxml2mod.xmlParserCtxtSetErrorHandler(self._o,f,arg)
635:
636: def getErrorHandler(self):
637: """Return (f,arg) as previously registered with setErrorHandler
638: or (None,None)."""
639: return libxml2mod.xmlParserCtxtGetErrorHandler(self._o)
640:
641: def addLocalCatalog(self, uri):
642: """Register a local catalog with the parser"""
643: return libxml2mod.addLocalCatalog(self._o, uri)
644:
645:
646: class ValidCtxtCore:
647:
648: def __init__(self, *args, **kw):
649: pass
650:
651: def setValidityErrorHandler(self, err_func, warn_func, arg=None):
652: """
653: Register error and warning handlers for DTD validation.
654: These will be called back as f(msg,arg)
655: """
656: libxml2mod.xmlSetValidErrors(self._o, err_func, warn_func, arg)
657:
658:
659: class SchemaValidCtxtCore:
660:
661: def __init__(self, *args, **kw):
662: pass
663:
664: def setValidityErrorHandler(self, err_func, warn_func, arg=None):
665: """
666: Register error and warning handlers for Schema validation.
667: These will be called back as f(msg,arg)
668: """
669: libxml2mod.xmlSchemaSetValidErrors(self._o, err_func, warn_func, arg)
670:
671:
672: class relaxNgValidCtxtCore:
673:
674: def __init__(self, *args, **kw):
675: pass
676:
677: def setValidityErrorHandler(self, err_func, warn_func, arg=None):
678: """
679: Register error and warning handlers for RelaxNG validation.
680: These will be called back as f(msg,arg)
681: """
682: libxml2mod.xmlRelaxNGSetValidErrors(self._o, err_func, warn_func, arg)
683:
684:
685: def _xmlTextReaderErrorFunc((f,arg),msg,severity,locator):
686: """Intermediate callback to wrap the locator"""
687: return f(arg,msg,severity,xmlTextReaderLocator(locator))
688:
689: class xmlTextReaderCore:
690:
691: def __init__(self, _obj=None):
692: self.input = None
693: if _obj != None:self._o = _obj;return
694: self._o = None
695:
696: def __del__(self):
697: if self._o != None:
698: libxml2mod.xmlFreeTextReader(self._o)
699: self._o = None
700:
701: def SetErrorHandler(self,f,arg):
702: """Register an error handler that will be called back as
703: f(arg,msg,severity,locator)."""
704: if f is None:
705: libxml2mod.xmlTextReaderSetErrorHandler(\
706: self._o,None,None)
707: else:
708: libxml2mod.xmlTextReaderSetErrorHandler(\
709: self._o,_xmlTextReaderErrorFunc,(f,arg))
710:
711: def GetErrorHandler(self):
712: """Return (f,arg) as previously registered with setErrorHandler
713: or (None,None)."""
714: f,arg = libxml2mod.xmlTextReaderGetErrorHandler(self._o)
715: if f is None:
716: return None,None
717: else:
718: # assert f is _xmlTextReaderErrorFunc
719: return arg
720:
721: #
722: # The cleanup now goes though a wrappe in libxml.c
723: #
724: def cleanupParser():
725: libxml2mod.xmlPythonCleanupParser()
726:
727: # WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
728: #
729: # Everything before this line comes from libxml.py
730: # Everything after this line is automatically generated
731: #
732: # WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
733:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to libxml.py CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / python