Package pyxb :: Package utils :: Module saxdom
[hide private]
[frames] | no frames]

Source Code for Module pyxb.utils.saxdom

  1  # Copyright 2009, Peter A. Bigot 
  2  # 
  3  # Licensed under the Apache License, Version 2.0 (the "License"); you may 
  4  # not use this file except in compliance with the License. You may obtain a 
  5  # copy of the License at: 
  6  # 
  7  #            http://www.apache.org/licenses/LICENSE-2.0 
  8  # 
  9  # Unless required by applicable law or agreed to in writing, software 
 10  # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 
 11  # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
 12  # License for the specific language governing permissions and limitations 
 13  # under the License. 
 14   
 15  """This module contains support for a DOM tree representation from an XML 
 16  document using a SAX parser. 
 17   
 18  This functionality exists because we need a DOM interface to generate the 
 19  binding classses, but the Python C{xml.dom.minidom} package does not support 
 20  location information.  The SAX interface does, so we have a SAX content 
 21  handler which converts the SAX events into a DOM tree. 
 22   
 23  This is not a general-purpose DOM capability; only a small subset of the DOM 
 24  interface is supported, and only for storing the XML information, not for 
 25  converting it back into document format. 
 26  """ 
 27   
 28  import xml.dom 
 29  import saxutils 
 30  import StringIO 
 31  import pyxb.namespace 
 32   
33 -def _DumpDOM (n, depth=0):
34 """Utility function to print a DOM tree.""" 35 36 pfx = ' ' * depth 37 if (xml.dom.Node.ELEMENT_NODE == n.nodeType): 38 print '%sElement[%d] %s %s with %d children' % (pfx, n._indexInParent(), n, pyxb.namespace.ExpandedName(n.name), len(n.childNodes)) 39 ins = pyxb.namespace.resolution.NamespaceContext.GetNodeContext(n).inScopeNamespaces() 40 print '%s%s' % (pfx, ' ; '.join([ '%s=%s' % (_k, _v.uri()) for (_k, _v) in ins.items()])) 41 for (k, v) in n.attributes.items(): 42 print '%s %s=%s' % (pfx, pyxb.namespace.ExpandedName(k), v) 43 for cn in n.childNodes: 44 _DumpDOM(cn, depth+1) 45 elif (xml.dom.Node.TEXT_NODE == n.nodeType): 46 #print '%sText "%s"' % (pfx, n.value) 47 pass 48 elif (xml.dom.Node.DOCUMENT_NODE == n.nodeType): 49 print 'Document node' 50 _DumpDOM(n.firstChild, depth) 51 else: 52 print 'UNRECOGNIZED %s' % (n.nodeType,)
53
54 -class _DOMSAXHandler (saxutils.BaseSAXHandler):
55 """SAX handler class that transforms events into a DOM tree.""" 56
57 - def document (self):
58 """The document that is the root of the generated tree.""" 59 return self.__document
60 __document = None 61
62 - def startDocument (self):
63 super(_DOMSAXHandler, self).startDocument() 64 self.__document = Document(namespace_context=self.namespaceContext())
65
66 - def endDocument (self):
67 content = self.elementState().content() 68 if 0 < len(content): 69 ( content, element_use, maybe_element ) = content[0] 70 self.__document.appendChild(content)
71 #_DumpDOM(content) 72
73 - def startElementNS (self, name, qname, attrs):
74 (this_state, parent_state, ns_ctx, name_en) = super(_DOMSAXHandler, self).startElementNS(name, qname, attrs) 75 this_state.__attributes = NamedNodeMap() 76 for name in attrs.getNames(): 77 attr_en = pyxb.namespace.ExpandedName(name) 78 value = attrs.getValue(name) 79 this_state.__attributes._addItem(Attr(expanded_name=attr_en, namespace_context=ns_ctx, value=value, location=this_state.location()))
80
81 - def endElementNS (self, name, qname):
82 this_state = super(_DOMSAXHandler, self).endElementNS(name, qname) 83 ns_ctx = this_state.namespaceContext() 84 element = Element(namespace_context=ns_ctx, expanded_name=this_state.expandedName(), attributes=this_state.__attributes, location=this_state.location()) 85 for ( content, element_use, maybe_element ) in this_state.content(): 86 if isinstance(content, Node): 87 element.appendChild(content) 88 else: 89 element.appendChild(Text(content, namespace_context=ns_ctx)) 90 parent_state = this_state.parentState() 91 parent_state.addElementContent(element, None)
92 #print '%s %s has %d children' % (element.namespaceURI, element.localName, len(element.childNodes)) 93
94 -def parse (stream, **kw):
95 """Parse a stream containing an XML document and return the DOM tree 96 representing its contents. 97 98 Keywords not described here are passed to L{saxutils.make_parser}. 99 100 @param stream: An object presenting the standard file C{read} interface 101 from which the document can be read. 102 103 @keyword content_handler_constructor: Input is overridden to assign this a 104 value of L{_DOMSAXHandler}. 105 106 @rtype: C{xml.dom.Document} 107 """ 108 109 kw['content_handler_constructor'] = _DOMSAXHandler 110 saxer = saxutils.make_parser(**kw) 111 handler = saxer.getContentHandler() 112 saxer.parse(stream) 113 return handler.document()
114
115 -def parseString (text, **kw):
116 """Parse a string holding an XML document and return the corresponding DOM 117 tree.""" 118 119 return parse(StringIO.StringIO(text), **kw)
120
121 -class Node (xml.dom.Node, pyxb.utils.utility.Locatable_mixin):
122 """Base for the minimal DOM interface required by PyXB."""
123 - def __init__ (self, node_type, **kw):
124 location = kw.pop('location', None) 125 if location is not None: 126 pyxb.utils.utility.Locatable_mixin.__init__(self, location=location) 127 self.__nodeType = node_type 128 self.__parentNode = None 129 self.__childNodes = [] 130 self.__namespaceContext = kw['namespace_context'] 131 self.__value = kw.get('value') 132 self.__attributes = kw.get('attributes') 133 expanded_name = kw.get('expanded_name') 134 if expanded_name is not None: 135 self.__name = expanded_name.uriTuple() 136 self.__namespaceURI = expanded_name.namespaceURI() 137 self.__localName = expanded_name.localName() 138 self.__namespaceContext.setNodeContext(self)
139 140 location = property(lambda _s: _s._location()) 141 142 __name = None 143 name = property(lambda _s: _s.__name)
144 - def _name (self): return self.__name
145 __namespaceURI = None 146 namespaceURI = property(lambda _s: _s.__namespaceURI) 147 __localName = None 148 localName = property(lambda _s: _s.__localName) 149 __value = None 150 value = property(lambda _s: _s.__value) 151
152 - def _indexInParent (self): return self.__indexInParent
153
154 - def __childIfPresent (self, index):
155 if index < len(self.__childNodes): 156 return self.__childNodes[index] 157 return None
158
159 - def appendChild (self, new_child):
160 new_child._setParentNode(self, len(self.__childNodes)) 161 self.__childNodes.append(new_child)
162
163 - def _setParentNode (self, parent_node, index_in_parent):
164 self.__parentNode = parent_node 165 self.__indexInParent = index_in_parent
166
167 - def _setAttributes (self, attributes):
168 assert self.__attributes is None 169 self.__attributes = attributes
170 __attributes = None 171 172 nodeType = property(lambda _s: _s.__nodeType) 173 parentNode = property(lambda _s: _s.__parentNode) 174 firstChild = property(lambda _s: _s.__childIfPresent(0)) 175 childNodes = property(lambda _s: _s.__childNodes) 176 attributes = property(lambda _s: _s.__attributes) 177 178 nextSibling = property(lambda _s: _s.parentNode.__childIfPresent(_s.__indexInParent+1)) 179
180 - def hasAttributeNS (self, ns_uri, local_name):
181 return self.getAttributeNodeNS(ns_uri, local_name) is not None
182
183 - def getAttributeNodeNS (self, ns_uri, local_name):
184 return self.__attributes._getAttr( (ns_uri, local_name) )
185
186 - def getAttributeNS (self, ns_uri, local_name):
187 rv = self.getAttributeNodeNS(ns_uri, local_name) 188 if rv is None: 189 return '' 190 return rv.value
191
192 -class Document (Node):
193 """Add the documentElement interface."""
194 - def __init__ (self, **kw):
195 super(Document, self).__init__(node_type=xml.dom.Node.DOCUMENT_NODE, **kw)
196 197 documentElement = Node.firstChild
198
199 -class Attr (Node):
200 """Add the nodeName and nodeValue interface."""
201 - def __init__ (self, **kw):
202 super(Attr, self).__init__(node_type=xml.dom.Node.ATTRIBUTE_NODE, **kw)
203 nodeName = Node.name 204 nodeValue = Node.value
205
206 -class NamedNodeMap (dict):
207 """Implement that portion of NamedNodeMap required to satisfy PyXB's 208 needs.""" 209 __members = None 210
211 - def __init__ (self):
212 super(NamedNodeMap, self).__init__() 213 self.__members = []
214 215 length = property(lambda _s: len(_s.__members))
216 - def item (self, index):
217 return self.__members[index]
218
219 - def _addItem (self, attr):
220 self[attr.name] = attr.value 221 assert pyxb.namespace.resolution.NamespaceContext.GetNodeContext(attr) is not None 222 self.__members.append(attr)
223
224 - def _getAttr (self, name):
225 for attr in self.__members: 226 if attr.name == name: 227 return attr 228 return None
229
230 -class Element (Node):
231 - def __init__ (self, **kw):
232 super(Element, self).__init__(node_type=xml.dom.Node.ELEMENT_NODE, **kw) 233 assert self.attributes is not None
234 nodeName = Node.localName
235
236 -class _CharacterData (Node):
237 """Abstract base for anything holding text data.""" 238 data = Node.value
239
240 -class Text (_CharacterData):
241 - def __init__ (self, text, **kw):
242 super(Text, self).__init__(value=text, node_type=xml.dom.Node.TEXT_NODE, **kw)
243
244 -class Comment (_CharacterData):
245 - def __init__ (self, text, **kw):
246 super(Text, self).__init__(value=text, node_type=xml.dom.Node.COMMENT_NODE, **kw)
247 248 if '__main__' == __name__: 249 import sys 250 xml_file = '/home/pab/pyxb/dev/examples/tmsxtvd/tmsdatadirect_sample.xml' 251 if 1 < len(sys.argv): 252 xml_file = sys.argv[1] 253 254 doc = parse(file(xml_file)) 255 256 ## Local Variables: 257 ## fill-column:78 258 ## End: 259