77d04ceab8
Updated build script to create win32/linux/macos versions. Fixed the defaults to they work with PLA. Fixed the temperature plugin default "ON" problem. Removed all profiles except for PLA.
849 lines
25 KiB
Python
849 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
|
|
|