850 lines
25 KiB
Python
850 lines
25 KiB
Python
"""
|
|
The xml_simple_reader.py script is an xml parser that can parse a line separated xml text.
|
|
|
|
This xml parser will read a line seperated xml text and produce a tree of the xml with a document element. Each element can have an attribute table, childNodes, a class name, parentNode, text and a link to the document element.
|
|
|
|
This example gets an xml tree for the xml file boolean.xml. This example is run in a terminal in the folder which contains boolean.xml and xml_simple_reader.py.
|
|
|
|
|
|
> python
|
|
Python 2.5.1 (r251:54863, Sep 22 2007, 01:43:31)
|
|
[GCC 4.2.1 (SUSE Linux)] on linux2
|
|
Type "help", "copyright", "credits" or "license" for more information.
|
|
>>> fileName = 'boolean.xml'
|
|
>>> file = open(fileName, 'r')
|
|
>>> xmlText = file.read()
|
|
>>> file.close()
|
|
>>> from xml_simple_reader import DocumentNode
|
|
>>> xmlParser = DocumentNode(fileName, xmlText)
|
|
>>> print(xmlParser)
|
|
?xml, {'version': '1.0'}
|
|
ArtOfIllusion, {'xmlns:bf': '//babelfiche/codec', 'version': '2.0', 'fileversion': '3'}
|
|
Scene, {'bf:id': 'theScene'}
|
|
materials, {'bf:elem-type': 'java.lang.Object', 'bf:list': 'collection', 'bf:id': '1', 'bf:type': 'java.util.Vector'}
|
|
..
|
|
many more lines of the xml tree
|
|
..
|
|
|
|
"""
|
|
|
|
|
|
from __future__ import absolute_import
|
|
#Init has to be imported first because it has code to workaround the python bug where relative imports don't work if the module is imported as a main module.
|
|
import __init__
|
|
|
|
from fabmetheus_utilities.geometry.geometry_utilities import evaluate
|
|
from fabmetheus_utilities.geometry.geometry_utilities import matrix
|
|
from fabmetheus_utilities import archive
|
|
from fabmetheus_utilities import euclidean
|
|
from fabmetheus_utilities import xml_simple_writer
|
|
import cStringIO
|
|
|
|
|
|
__author__ = 'Enrique Perez (perez_enrique@yahoo.com)'
|
|
__credits__ = 'Nophead <http://hydraraptor.blogspot.com/>\nArt of Illusion <http://www.artofillusion.org/>'
|
|
__date__ = '$Date: 2008/21/04 $'
|
|
__license__ = 'GNU Affero General Public License http://www.gnu.org/licenses/agpl.html'
|
|
|
|
|
|
globalGetAccessibleAttributeSet = set('getPaths getPreviousVertex getPreviousElementNode getVertexes parentNode'.split())
|
|
|
|
|
|
def createAppendByText(parentNode, xmlText):
|
|
'Create and append the child nodes from the xmlText.'
|
|
monad = OpenMonad(parentNode)
|
|
for character in xmlText:
|
|
monad = monad.getNextMonad(character)
|
|
|
|
def createAppendByTextb(parentNode, xmlText):
|
|
'Create and append the child nodes from the xmlText.'
|
|
monad = OpenMonad(parentNode)
|
|
for character in xmlText:
|
|
monad = monad.getNextMonad(character)
|
|
|
|
def getChildElementsByLocalName(childNodes, localName):
|
|
'Get the childNodes which have the given local name.'
|
|
childElementsByLocalName = []
|
|
for childNode in childNodes:
|
|
if localName.lower() == childNode.getNodeName():
|
|
childElementsByLocalName.append(childNode)
|
|
return childElementsByLocalName
|
|
|
|
def getDocumentNode(fileName):
|
|
'Get the document from the file name.'
|
|
xmlText = getFileText('test.xml')
|
|
return DocumentNode(fileName, xmlText)
|
|
|
|
def getElementsByLocalName(childNodes, localName):
|
|
'Get the descendents which have the given local name.'
|
|
elementsByLocalName = getChildElementsByLocalName(childNodes, localName)
|
|
for childNode in childNodes:
|
|
if childNode.getNodeType() == 1:
|
|
elementsByLocalName += childNode.getElementsByLocalName(localName)
|
|
return elementsByLocalName
|
|
|
|
def getFileText(fileName, printWarning=True, readMode='r'):
|
|
'Get the entire text of a file.'
|
|
try:
|
|
file = open(fileName, readMode)
|
|
fileText = file.read()
|
|
file.close()
|
|
return fileText
|
|
except IOError:
|
|
if printWarning:
|
|
print('The file ' + fileName + ' does not exist.')
|
|
return ''
|
|
|
|
|
|
class CDATASectionMonad:
|
|
'A monad to handle a CDATASection node.'
|
|
def __init__(self, input, parentNode):
|
|
'Initialize.'
|
|
self.input = input
|
|
self.parentNode = parentNode
|
|
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
self.input.write(character)
|
|
if character == '>':
|
|
inputString = self.input.getvalue()
|
|
if inputString.endswith(']]>'):
|
|
textContent = '<%s\n' % inputString
|
|
self.parentNode.childNodes.append(CDATASectionNode(self.parentNode, textContent))
|
|
return OpenMonad(self.parentNode)
|
|
return self
|
|
|
|
|
|
class CDATASectionNode:
|
|
'A CDATASection node.'
|
|
def __init__(self, parentNode, textContent=''):
|
|
'Initialize.'
|
|
self.parentNode = parentNode
|
|
self.textContent = textContent
|
|
|
|
def __repr__(self):
|
|
'Get the string representation of this CDATASection node.'
|
|
return self.textContent
|
|
|
|
def addToIdentifierDictionaries(self):
|
|
'Add the element to the owner document identifier dictionaries.'
|
|
pass
|
|
|
|
def addXML(self, depth, output):
|
|
'Add xml for this CDATASection node.'
|
|
output.write(self.textContent)
|
|
|
|
def appendSelfToParent(self):
|
|
'Append self to the parentNode.'
|
|
self.parentNode.appendChild(self)
|
|
|
|
def copyXMLChildNodes(self, idSuffix, parentNode):
|
|
'Copy the xml childNodes.'
|
|
pass
|
|
|
|
def getAttributes(self):
|
|
'Get the attributes.'
|
|
return {}
|
|
|
|
def getChildNodes(self):
|
|
'Get the empty set.'
|
|
return []
|
|
|
|
def getCopy(self, idSuffix, parentNode):
|
|
'Copy the xml element, set its dictionary and add it to the parentNode.'
|
|
copy = self.getCopyShallow()
|
|
copy.parentNode = parentNode
|
|
copy.appendSelfToParent()
|
|
return copy
|
|
|
|
def getCopyShallow(self, attributes=None):
|
|
'Copy the node and set its parentNode.'
|
|
return CDATASectionNode(self.parentNode, self.textContent)
|
|
|
|
def getNodeName(self):
|
|
'Get the node name.'
|
|
return '#cdata-section'
|
|
|
|
def getNodeType(self):
|
|
'Get the node type.'
|
|
return 4
|
|
|
|
def getOwnerDocument(self):
|
|
'Get the owner document.'
|
|
return self.parentNode.getOwnerDocument()
|
|
|
|
def getTextContent(self):
|
|
'Get the text content.'
|
|
return self.textContent
|
|
|
|
def removeChildNodesFromIDNameParent(self):
|
|
'Remove the childNodes from the id and name dictionaries and the childNodes.'
|
|
pass
|
|
|
|
def removeFromIDNameParent(self):
|
|
'Remove this from the id and name dictionaries and the childNodes of the parentNode.'
|
|
if self.parentNode != None:
|
|
self.parentNode.childNodes.remove(self)
|
|
|
|
def setParentAddToChildNodes(self, parentNode):
|
|
'Set the parentNode and add this to its childNodes.'
|
|
self.parentNode = parentNode
|
|
if self.parentNode != None:
|
|
self.parentNode.childNodes.append(self)
|
|
|
|
attributes = property(getAttributes)
|
|
childNodes = property(getChildNodes)
|
|
nodeName = property(getNodeName)
|
|
nodeType = property(getNodeType)
|
|
ownerDocument = property(getOwnerDocument)
|
|
|
|
|
|
class CommentMonad(CDATASectionMonad):
|
|
'A monad to handle a comment node.'
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
self.input.write(character)
|
|
if character == '>':
|
|
inputString = self.input.getvalue()
|
|
if inputString.endswith('-->'):
|
|
textContent = '<%s\n' % inputString
|
|
self.parentNode.childNodes.append(CommentNode(self.parentNode, textContent))
|
|
return OpenMonad(self.parentNode)
|
|
return self
|
|
|
|
|
|
class CommentNode(CDATASectionNode):
|
|
'A comment node.'
|
|
def getCopyShallow(self, attributes=None):
|
|
'Copy the node and set its parentNode.'
|
|
return CommentNode(self.parentNode, self.textContent)
|
|
|
|
def getNodeName(self):
|
|
'Get the node name.'
|
|
return '#comment'
|
|
|
|
def getNodeType(self):
|
|
'Get the node type.'
|
|
return 8
|
|
|
|
nodeName = property(getNodeName)
|
|
nodeType = property(getNodeType)
|
|
|
|
|
|
class DocumentNode:
|
|
'A class to parse an xml text and store the elements.'
|
|
def __init__(self, fileName, xmlText):
|
|
'Initialize.'
|
|
self.childNodes = []
|
|
self.fileName = fileName
|
|
self.idDictionary = {}
|
|
self.nameDictionary = {}
|
|
self.parentNode = None
|
|
self.tagDictionary = {}
|
|
self.xmlText = xmlText
|
|
createAppendByText(self, xmlText)
|
|
|
|
def __repr__(self):
|
|
'Get the string representation of this xml document.'
|
|
output = cStringIO.StringIO()
|
|
for childNode in self.childNodes:
|
|
childNode.addXML(0, output)
|
|
return output.getvalue()
|
|
|
|
def appendChild(self, elementNode):
|
|
'Append child elementNode to the child nodes.'
|
|
self.childNodes.append(elementNode)
|
|
elementNode.addToIdentifierDictionaries()
|
|
return elementNode
|
|
|
|
def getAttributes(self):
|
|
'Get the attributes.'
|
|
return {}
|
|
|
|
def getCascadeBoolean(self, defaultBoolean, key):
|
|
'Get the cascade boolean.'
|
|
return defaultBoolean
|
|
|
|
def getCascadeFloat(self, defaultFloat, key):
|
|
'Get the cascade float.'
|
|
return defaultFloat
|
|
|
|
def getDocumentElement(self):
|
|
'Get the document element.'
|
|
if len(self.childNodes) == 0:
|
|
return None
|
|
return self.childNodes[-1]
|
|
|
|
def getElementsByLocalName(self, localName):
|
|
'Get the descendents which have the given local name.'
|
|
return getElementsByLocalName(self.childNodes, localName)
|
|
|
|
def getImportNameChain(self, suffix=''):
|
|
'Get the import name chain with the suffix at the end.'
|
|
return suffix
|
|
|
|
def getNodeName(self):
|
|
'Get the node name.'
|
|
return '#document'
|
|
|
|
def getNodeType(self):
|
|
'Get the node type.'
|
|
return 9
|
|
|
|
def getOriginalRoot(self):
|
|
'Get the original reparsed document element.'
|
|
if evaluate.getEvaluatedBoolean(True, self.documentElement, 'getOriginalRoot'):
|
|
return DocumentNode(self.fileName, self.xmlText).documentElement
|
|
return None
|
|
|
|
def getOwnerDocument(self):
|
|
'Get the owner document.'
|
|
return self
|
|
|
|
attributes = property(getAttributes)
|
|
documentElement = property(getDocumentElement)
|
|
nodeName = property(getNodeName)
|
|
nodeType = property(getNodeType)
|
|
ownerDocument = property(getOwnerDocument)
|
|
|
|
|
|
class DocumentTypeMonad(CDATASectionMonad):
|
|
'A monad to handle a document type node.'
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
self.input.write(character)
|
|
if character == '>':
|
|
inputString = self.input.getvalue()
|
|
if inputString.endswith('?>'):
|
|
textContent = '%s\n' % inputString
|
|
self.parentNode.childNodes.append(DocumentTypeNode(self.parentNode, textContent))
|
|
return OpenMonad(self.parentNode)
|
|
return self
|
|
|
|
|
|
class DocumentTypeNode(CDATASectionNode):
|
|
'A document type node.'
|
|
def getCopyShallow(self, attributes=None):
|
|
'Copy the node and set its parentNode.'
|
|
return DocumentTypeNode(self.parentNode, self.textContent)
|
|
|
|
def getNodeName(self):
|
|
'Get the node name.'
|
|
return '#forNowDocumentType'
|
|
|
|
def getNodeType(self):
|
|
'Get the node type.'
|
|
return 10
|
|
|
|
nodeName = property(getNodeName)
|
|
nodeType = property(getNodeType)
|
|
|
|
|
|
class ElementEndMonad:
|
|
'A monad to look for the end of an ElementNode tag.'
|
|
def __init__(self, parentNode):
|
|
'Initialize.'
|
|
self.parentNode = parentNode
|
|
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
if character == '>':
|
|
return TextMonad(self.parentNode)
|
|
return self
|
|
|
|
|
|
class ElementLocalNameMonad:
|
|
'A monad to set the local name of an ElementNode.'
|
|
def __init__(self, character, parentNode):
|
|
'Initialize.'
|
|
self.input = cStringIO.StringIO()
|
|
self.input.write(character)
|
|
self.parentNode = parentNode
|
|
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
if character == '[':
|
|
if (self.input.getvalue() + character).startswith('![CDATA['):
|
|
self.input.write(character)
|
|
return CDATASectionMonad(self.input, self.parentNode)
|
|
if character == '-':
|
|
if (self.input.getvalue() + character).startswith('!--'):
|
|
self.input.write(character)
|
|
return CommentMonad(self.input, self.parentNode)
|
|
if character.isspace():
|
|
self.setLocalName()
|
|
return ElementReadMonad(self.elementNode)
|
|
if character == '/':
|
|
self.setLocalName()
|
|
self.elementNode.appendSelfToParent()
|
|
return ElementEndMonad(self.elementNode.parentNode)
|
|
if character == '>':
|
|
self.setLocalName()
|
|
self.elementNode.appendSelfToParent()
|
|
return TextMonad(self.elementNode)
|
|
self.input.write(character)
|
|
return self
|
|
|
|
def setLocalName(self):
|
|
'Set the class name.'
|
|
self.elementNode = ElementNode(self.parentNode)
|
|
self.elementNode.localName = self.input.getvalue().lower().strip()
|
|
|
|
|
|
class ElementNode:
|
|
'An xml element.'
|
|
def __init__(self, parentNode=None):
|
|
'Initialize.'
|
|
self.attributes = {}
|
|
self.childNodes = []
|
|
self.localName = ''
|
|
self.parentNode = parentNode
|
|
self.xmlObject = None
|
|
|
|
def __repr__(self):
|
|
'Get the string representation of this xml document.'
|
|
return '%s\n%s\n%s' % (self.localName, self.attributes, self.getTextContent())
|
|
|
|
def _getAccessibleAttribute(self, attributeName):
|
|
'Get the accessible attribute.'
|
|
global globalGetAccessibleAttributeSet
|
|
if attributeName in globalGetAccessibleAttributeSet:
|
|
return getattr(self, attributeName, None)
|
|
return None
|
|
|
|
def addSuffixToID(self, idSuffix):
|
|
'Add the suffix to the id.'
|
|
if 'id' in self.attributes:
|
|
self.attributes['id'] += idSuffix
|
|
|
|
def addToIdentifierDictionaries(self):
|
|
'Add the element to the owner document identifier dictionaries.'
|
|
ownerDocument = self.getOwnerDocument()
|
|
importNameChain = self.getImportNameChain()
|
|
idKey = self.getStrippedAttributesValue('id')
|
|
if idKey != None:
|
|
ownerDocument.idDictionary[importNameChain + idKey] = self
|
|
nameKey = self.getStrippedAttributesValue('name')
|
|
if nameKey != None:
|
|
euclidean.addElementToListDictionaryIfNotThere(self, importNameChain + nameKey, ownerDocument.nameDictionary)
|
|
for tagKey in self.getTagKeys():
|
|
euclidean.addElementToListDictionaryIfNotThere(self, tagKey, ownerDocument.tagDictionary)
|
|
|
|
def addXML(self, depth, output):
|
|
'Add xml for this elementNode.'
|
|
innerOutput = cStringIO.StringIO()
|
|
xml_simple_writer.addXMLFromObjects(depth + 1, self.childNodes, innerOutput)
|
|
innerText = innerOutput.getvalue()
|
|
xml_simple_writer.addBeginEndInnerXMLTag(self.attributes, depth, innerText, self.localName, output, self.getTextContent())
|
|
|
|
def appendChild(self, elementNode):
|
|
'Append child elementNode to the child nodes.'
|
|
self.childNodes.append(elementNode)
|
|
elementNode.addToIdentifierDictionaries()
|
|
return elementNode
|
|
|
|
def appendSelfToParent(self):
|
|
'Append self to the parentNode.'
|
|
self.parentNode.appendChild(self)
|
|
|
|
def copyXMLChildNodes(self, idSuffix, parentNode):
|
|
'Copy the xml childNodes.'
|
|
for childNode in self.childNodes:
|
|
childNode.getCopy(idSuffix, parentNode)
|
|
|
|
def getCascadeBoolean(self, defaultBoolean, key):
|
|
'Get the cascade boolean.'
|
|
if key in self.attributes:
|
|
value = evaluate.getEvaluatedBoolean(None, self, key)
|
|
if value != None:
|
|
return value
|
|
return self.parentNode.getCascadeBoolean(defaultBoolean, key)
|
|
|
|
def getCascadeFloat(self, defaultFloat, key):
|
|
'Get the cascade float.'
|
|
if key in self.attributes:
|
|
value = evaluate.getEvaluatedFloat(None, self, key)
|
|
if value != None:
|
|
return value
|
|
return self.parentNode.getCascadeFloat(defaultFloat, key)
|
|
|
|
def getChildElementsByLocalName(self, localName):
|
|
'Get the childNodes which have the given local name.'
|
|
return getChildElementsByLocalName(self.childNodes, localName)
|
|
|
|
def getCopy(self, idSuffix, parentNode):
|
|
'Copy the xml element, set its dictionary and add it to the parentNode.'
|
|
matrix4X4 = matrix.getBranchMatrixSetElementNode(self)
|
|
attributesCopy = self.attributes.copy()
|
|
attributesCopy.update(matrix4X4.getAttributes('matrix.'))
|
|
copy = self.getCopyShallow(attributesCopy)
|
|
copy.setParentAddToChildNodes(parentNode)
|
|
copy.addSuffixToID(idSuffix)
|
|
copy.addToIdentifierDictionaries()
|
|
self.copyXMLChildNodes(idSuffix, copy)
|
|
return copy
|
|
|
|
def getCopyShallow(self, attributes=None):
|
|
'Copy the xml element and set its dictionary and parentNode.'
|
|
if attributes == None: # to evade default initialization bug where a dictionary is initialized to the last dictionary
|
|
attributes = {}
|
|
copyShallow = ElementNode(self.parentNode)
|
|
copyShallow.attributes = attributes
|
|
copyShallow.localName = self.localName
|
|
return copyShallow
|
|
|
|
def getDocumentElement(self):
|
|
'Get the document element.'
|
|
return self.getOwnerDocument().getDocumentElement()
|
|
|
|
def getElementNodeByID(self, idKey):
|
|
'Get the xml element by id.'
|
|
idDictionary = self.getOwnerDocument().idDictionary
|
|
idKey = self.getImportNameChain() + idKey
|
|
if idKey in idDictionary:
|
|
return idDictionary[idKey]
|
|
return None
|
|
|
|
def getElementNodesByName(self, nameKey):
|
|
'Get the xml elements by name.'
|
|
nameDictionary = self.getOwnerDocument().nameDictionary
|
|
nameKey = self.getImportNameChain() + nameKey
|
|
if nameKey in nameDictionary:
|
|
return nameDictionary[nameKey]
|
|
return None
|
|
|
|
def getElementNodesByTag(self, tagKey):
|
|
'Get the xml elements by tag.'
|
|
tagDictionary = self.getOwnerDocument().tagDictionary
|
|
if tagKey in tagDictionary:
|
|
return tagDictionary[tagKey]
|
|
return None
|
|
|
|
def getElementsByLocalName(self, localName):
|
|
'Get the descendents which have the given local name.'
|
|
return getElementsByLocalName(self.childNodes, localName)
|
|
|
|
def getFirstChildByLocalName(self, localName):
|
|
'Get the first childNode which has the given class name.'
|
|
for childNode in self.childNodes:
|
|
if localName.lower() == childNode.getNodeName():
|
|
return childNode
|
|
return None
|
|
|
|
def getIDSuffix(self, elementIndex=None):
|
|
'Get the id suffix from the dictionary.'
|
|
suffix = self.localName
|
|
if 'id' in self.attributes:
|
|
suffix = self.attributes['id']
|
|
if elementIndex == None:
|
|
return '_%s' % suffix
|
|
return '_%s_%s' % (suffix, elementIndex)
|
|
|
|
def getImportNameChain(self, suffix=''):
|
|
'Get the import name chain with the suffix at the end.'
|
|
importName = self.getStrippedAttributesValue('_importName')
|
|
if importName != None:
|
|
suffix = '%s.%s' % (importName, suffix)
|
|
return self.parentNode.getImportNameChain(suffix)
|
|
|
|
def getNodeName(self):
|
|
'Get the node name.'
|
|
return self.localName
|
|
|
|
def getNodeType(self):
|
|
'Get the node type.'
|
|
return 1
|
|
|
|
def getOwnerDocument(self):
|
|
'Get the owner document.'
|
|
return self.parentNode.getOwnerDocument()
|
|
|
|
def getParser(self):
|
|
'Get the parser.'
|
|
return self.getOwnerDocument()
|
|
|
|
def getPaths(self):
|
|
'Get all paths.'
|
|
if self.xmlObject == None:
|
|
return []
|
|
return self.xmlObject.getPaths()
|
|
|
|
def getPreviousElementNode(self):
|
|
'Get previous ElementNode if it exists.'
|
|
if self.parentNode == None:
|
|
return None
|
|
previousElementNodeIndex = self.parentNode.childNodes.index(self) - 1
|
|
if previousElementNodeIndex < 0:
|
|
return None
|
|
return self.parentNode.childNodes[previousElementNodeIndex]
|
|
|
|
def getPreviousVertex(self, defaultVector3=None):
|
|
'Get previous vertex if it exists.'
|
|
if self.parentNode == None:
|
|
return defaultVector3
|
|
if self.parentNode.xmlObject == None:
|
|
return defaultVector3
|
|
if len(self.parentNode.xmlObject.vertexes) < 1:
|
|
return defaultVector3
|
|
return self.parentNode.xmlObject.vertexes[-1]
|
|
|
|
def getStrippedAttributesValue(self, keyString):
|
|
'Get the stripped attribute value if the length is at least one, otherwise return None.'
|
|
if keyString in self.attributes:
|
|
strippedAttributesValue = self.attributes[keyString].strip()
|
|
if len(strippedAttributesValue) > 0:
|
|
return strippedAttributesValue
|
|
return None
|
|
|
|
def getSubChildWithID( self, idReference ):
|
|
'Get the childNode which has the idReference.'
|
|
for childNode in self.childNodes:
|
|
if 'bf:id' in childNode.attributes:
|
|
if childNode.attributes['bf:id'] == idReference:
|
|
return childNode
|
|
subChildWithID = childNode.getSubChildWithID( idReference )
|
|
if subChildWithID != None:
|
|
return subChildWithID
|
|
return None
|
|
|
|
def getTagKeys(self):
|
|
'Get stripped tag keys.'
|
|
if 'tags' not in self.attributes:
|
|
return []
|
|
tagKeys = []
|
|
tagString = self.attributes['tags']
|
|
if tagString.startswith('='):
|
|
tagString = tagString[1 :]
|
|
if tagString.startswith('['):
|
|
tagString = tagString[1 :]
|
|
if tagString.endswith(']'):
|
|
tagString = tagString[: -1]
|
|
for tagWord in tagString.split(','):
|
|
tagKey = tagWord.strip()
|
|
if tagKey != '':
|
|
tagKeys.append(tagKey)
|
|
return tagKeys
|
|
|
|
def getTextContent(self):
|
|
'Get the text from the child nodes.'
|
|
if len(self.childNodes) == 0:
|
|
return ''
|
|
firstNode = self.childNodes[0]
|
|
if firstNode.nodeType == 3:
|
|
return firstNode.textContent
|
|
return ''
|
|
|
|
def getValueByKey( self, key ):
|
|
'Get value by the key.'
|
|
if key in evaluate.globalElementValueDictionary:
|
|
return evaluate.globalElementValueDictionary[key](self)
|
|
if key in self.attributes:
|
|
return evaluate.getEvaluatedLinkValue(self, self.attributes[key])
|
|
return None
|
|
|
|
def getVertexes(self):
|
|
'Get the vertexes.'
|
|
if self.xmlObject == None:
|
|
return []
|
|
return self.xmlObject.getVertexes()
|
|
|
|
def getXMLProcessor(self):
|
|
'Get the xmlProcessor.'
|
|
return self.getDocumentElement().xmlProcessor
|
|
|
|
def linkObject(self, xmlObject):
|
|
'Link self to xmlObject and add xmlObject to archivableObjects.'
|
|
self.xmlObject = xmlObject
|
|
self.xmlObject.elementNode = self
|
|
self.parentNode.xmlObject.archivableObjects.append(self.xmlObject)
|
|
|
|
def printAllVariables(self):
|
|
'Print all variables.'
|
|
print('attributes')
|
|
print(self.attributes)
|
|
print('childNodes')
|
|
print(self.childNodes)
|
|
print('localName')
|
|
print(self.localName)
|
|
print('parentNode')
|
|
print(self.parentNode.getNodeName())
|
|
print('text')
|
|
print(self.getTextContent())
|
|
print('xmlObject')
|
|
print(self.xmlObject)
|
|
print('')
|
|
|
|
def printAllVariablesRoot(self):
|
|
'Print all variables and the document element variables.'
|
|
self.printAllVariables()
|
|
documentElement = self.getDocumentElement()
|
|
if documentElement != None:
|
|
print('')
|
|
print('Root variables:')
|
|
documentElement.printAllVariables()
|
|
|
|
def removeChildNodesFromIDNameParent(self):
|
|
'Remove the childNodes from the id and name dictionaries and the childNodes.'
|
|
childNodesCopy = self.childNodes[:]
|
|
for childNode in childNodesCopy:
|
|
childNode.removeFromIDNameParent()
|
|
|
|
def removeFromIDNameParent(self):
|
|
'Remove this from the id and name dictionaries and the childNodes of the parentNode.'
|
|
self.removeChildNodesFromIDNameParent()
|
|
idKey = self.getStrippedAttributesValue('id')
|
|
if idKey != None:
|
|
idDictionary = self.getOwnerDocument().idDictionary
|
|
idKey = self.getImportNameChain() + idKey
|
|
if idKey in idDictionary:
|
|
del idDictionary[idKey]
|
|
nameKey = self.getStrippedAttributesValue('name')
|
|
if nameKey != None:
|
|
euclidean.removeElementFromListTable(self, self.getImportNameChain() + nameKey, self.getOwnerDocument().nameDictionary)
|
|
for tagKey in self.getTagKeys():
|
|
euclidean.removeElementFromListTable(self, tagKey, self.getOwnerDocument().tagDictionary)
|
|
if self.parentNode != None:
|
|
self.parentNode.childNodes.remove(self)
|
|
|
|
def setParentAddToChildNodes(self, parentNode):
|
|
'Set the parentNode and add this to its childNodes.'
|
|
self.parentNode = parentNode
|
|
if self.parentNode != None:
|
|
self.parentNode.childNodes.append(self)
|
|
|
|
def setTextContent(self, textContent=''):
|
|
'Get the text from the child nodes.'
|
|
if len(self.childNodes) == 0:
|
|
self.childNodes.append(TextNode(self, textContent))
|
|
return
|
|
firstNode = self.childNodes[0]
|
|
if firstNode.nodeType == 3:
|
|
firstNode.textContent = textContent
|
|
self.childNodes.append(TextNode(self, textContent))
|
|
|
|
nodeName = property(getNodeName)
|
|
nodeType = property(getNodeType)
|
|
ownerDocument = property(getOwnerDocument)
|
|
textContent = property(getTextContent)
|
|
|
|
|
|
class ElementReadMonad:
|
|
'A monad to read the attributes of the ElementNode tag.'
|
|
def __init__(self, elementNode):
|
|
'Initialize.'
|
|
self.elementNode = elementNode
|
|
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
if character.isspace():
|
|
return self
|
|
if character == '/':
|
|
self.elementNode.appendSelfToParent()
|
|
return ElementEndMonad(self.elementNode.parentNode)
|
|
if character == '>':
|
|
self.elementNode.appendSelfToParent()
|
|
return TextMonad(self.elementNode)
|
|
return KeyMonad(character, self.elementNode)
|
|
|
|
|
|
class KeyMonad:
|
|
'A monad to set the key of an attribute of an ElementNode.'
|
|
def __init__(self, character, elementNode):
|
|
'Initialize.'
|
|
self.input = cStringIO.StringIO()
|
|
self.input.write(character)
|
|
self.elementNode = elementNode
|
|
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
if character == '=':
|
|
return ValueMonad(self.elementNode, self.input.getvalue().strip())
|
|
self.input.write(character)
|
|
return self
|
|
|
|
|
|
class OpenChooseMonad(ElementEndMonad):
|
|
'A monad to choose the next monad.'
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
if character.isspace():
|
|
return self
|
|
if character == '?':
|
|
input = cStringIO.StringIO()
|
|
input.write('<?')
|
|
return DocumentTypeMonad(input, self.parentNode)
|
|
if character == '/':
|
|
return ElementEndMonad(self.parentNode.parentNode)
|
|
return ElementLocalNameMonad(character, self.parentNode)
|
|
|
|
|
|
class OpenMonad(ElementEndMonad):
|
|
'A monad to handle the open tag character.'
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
if character == '<':
|
|
return OpenChooseMonad(self.parentNode)
|
|
return self
|
|
|
|
|
|
class TextMonad:
|
|
'A monad to handle the open tag character and set the text.'
|
|
def __init__(self, parentNode):
|
|
'Initialize.'
|
|
self.input = cStringIO.StringIO()
|
|
self.parentNode = parentNode
|
|
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
if character == '<':
|
|
inputString = self.input.getvalue().strip()
|
|
if len(inputString) > 0:
|
|
self.parentNode.childNodes.append(TextNode(self.parentNode, inputString))
|
|
return OpenChooseMonad(self.parentNode)
|
|
self.input.write(character)
|
|
return self
|
|
|
|
|
|
class TextNode(CDATASectionNode):
|
|
'A text node.'
|
|
def addXML(self, depth, output):
|
|
'Add xml for this text node.'
|
|
pass
|
|
|
|
def getCopyShallow(self, attributes=None):
|
|
'Copy the node and set its parentNode.'
|
|
return TextNode(self.parentNode, self.textContent)
|
|
|
|
def getNodeName(self):
|
|
'Get the node name.'
|
|
return '#text'
|
|
|
|
def getNodeType(self):
|
|
'Get the node type.'
|
|
return 3
|
|
|
|
nodeName = property(getNodeName)
|
|
nodeType = property(getNodeType)
|
|
|
|
|
|
class ValueMonad:
|
|
'A monad to set the value of an attribute of an ElementNode.'
|
|
def __init__(self, elementNode, key):
|
|
'Initialize.'
|
|
self.elementNode = elementNode
|
|
self.input = cStringIO.StringIO()
|
|
self.key = key
|
|
self.quoteCharacter = None
|
|
|
|
def getNextMonad(self, character):
|
|
'Get the next monad.'
|
|
if self.quoteCharacter == None:
|
|
if character == '"' or character == "'":
|
|
self.quoteCharacter = character
|
|
return self
|
|
if self.quoteCharacter == character:
|
|
self.elementNode.attributes[self.key] = self.input.getvalue()
|
|
return ElementReadMonad(self.elementNode)
|
|
self.input.write(character)
|
|
return self
|
|
|