# Name: xmlmarshaller.py
# Purpose:
#
-# Author: John Spurling
+# Authors: John Spurling, Joel Hare, Jeff Norton, Alan Mullendore
#
# Created: 7/28/04
# CVS-ID: $Id$
# Copyright: (c) 2004-2005 ActiveGrid, Inc.
# License: wxWindows License
#----------------------------------------------------------------------------
-import __builtin__
import sys
from types import *
+from activegrid.util.lang import *
+import logging
+ifDefPy()
import xml.sax
import xml.sax.handler
-from xml.sax import saxutils
-
-import objutils
+import xml.sax.saxutils
+import datetime
+endIfDef()
+import activegrid.util.utillang as utillang
+import activegrid.util.objutils as objutils
+import activegrid.util.sysutils as sysutils
+import activegrid.util.aglogging as aglogging
MODULE_PATH = "__main__"
-### ToDO remove maxOccurs "unbounded" resolves to -1 hacks after bug 177 is fixed
+## ToDO remove maxOccurs "unbounded" resolves to -1 hacks after bug 177 is fixed
+##unboundedVal = 2147483647 # value used for maxOccurs == "unbounded"
"""
-
-More documentation later, but here are some special Python attributes
-that McLane recognizes:
+Special attributes that we recognize:
name: __xmlname__
type: string
name: __xmlattributes__
type: tuple or list
-description: the name(s) of the Python string attribute(s) to be
+description: the name(s) of the Lang string attribute(s) to be
marshalled as xml attributes instead of nested xml elements. currently
-these can only be strings since there's not a way to get the type
+these can only be strings since there"s not a way to get the type
information back when unmarshalling.
name: __xmlexclude__
type: tuple or list
-description: the name(s) of the python attribute(s) to skip when
+description: the name(s) of the lang attribute(s) to skip when
marshalling.
name: __xmlrename__
type: dict
-description: describes an alternate Python <-> XML name mapping.
+description: describes an alternate Lang <-> XML name mapping.
Normally the name mapping is the identity function. __xmlrename__
-overrides that. The keys are the Python names, the values are their
+overrides that. The keys are the Lang names, the values are their
associated XML names.
name: __xmlflattensequence__
type: dict, tuple, or list
-description: the name(s) of the Python sequence attribute(s) whose
+description: the name(s) of the Lang sequence attribute(s) whose
items are to be marshalled as a series of xml elements (with an
optional keyword argument that specifies the element name to use) as
opposed to containing them in a separate sequence element, e.g.:
myseq = (1, 2)
<!-- normal way of marshalling -->
<myseq>
- <item objtype='int'>1</item>
- <item objtype='int'>2</item>
+ <item objtype="int">1</item>
+ <item objtype="int">2</item>
</myseq>
-<!-- with __xmlflattensequence__ set to {'myseq': 'squish'} -->
-<squish objtype='int'>1</squish>
-<squish objtype='int'>2</squish>
+<!-- with __xmlflattensequence__ set to {"myseq": "squish"} -->
+<squish objtype="int">1</squish>
+<squish objtype="int">2</squish>
name: __xmlnamespaces__
type: dict
name: __xmlattrnamespaces__
type: dict
-description: a dict assigning the Python object's attributes to the namespaces
+description: a dict assigning the Lang object"s attributes to the namespaces
defined in __xmlnamespaces__. Each item in the dict should consist of a
prefix,attributeList combination where the key is the prefix and the value is
-a list of the Python attribute names. e.g.:
+a list of the Lang attribute names. e.g.:
__xmlattrnamespaces__ = { "ag":["firstName", "lastName", "addressLine1", "city"] }
__xmlattrgroups__ = {"name": ["firstName", "lastName"], "address": ["addressLine1", "city", "state", "zip"]}
+name: __xmlcdatacontent__
+type: string
+description: value is the name of a string attribute that should be assigned CDATA content from the
+source document and that should be marshalled as CDATA.
+
+__xmlcdatacontent__ = "messyContent"
+
"""
+global xmlMarshallerLogger
+xmlMarshallerLogger = logging.getLogger("activegrid.util.xmlmarshaller.marshal")
+# INFO : low-level info
+# DEBUG : debugging info
+
################################################################################
#
# module exceptions
return "%s is not supported for marshalling." % str(self.typename)
class XMLAttributeIsNotStringType(Error):
- """Exception raised when an object's attribute is specified to be
+ """Exception raised when an object"s attribute is specified to be
marshalled as an XML attribute of the enclosing object instead of
a nested element.
"""
self.typename = typename
def __str__(self):
return """%s was set to be marshalled as an XML attribute
- instead of a nested element, but the object's type is %s, not
+ instead of a nested element, but the object"s type is %s, not
string.""" % (self.attrname, self.typename)
+class MarshallerException(Exception):
+ pass
+
+class UnmarshallerException(Exception):
+ pass
+
################################################################################
#
# constants and such
#
################################################################################
-XMLNS = 'xmlns'
-XMLNS_PREFIX = XMLNS + ':'
+XMLNS = "xmlns"
+XMLNS_PREFIX = XMLNS + ":"
XMLNS_PREFIX_LENGTH = len(XMLNS_PREFIX)
+DEFAULT_NAMESPACE_KEY = "__DEFAULTNS__"
+TYPE_QNAME = "QName"
+XMLSCHEMA_XSD_URL = "http://www.w3.org/2001/XMLSchema"
+AG_URL = "http://www.activegrid.com/ag.xsd"
-BASETYPE_ELEMENT_NAME = 'item'
+BASETYPE_ELEMENT_NAME = "item"
+DICT_ITEM_NAME = "qqDictItem"
+DICT_ITEM_KEY_NAME = "key"
+DICT_ITEM_VALUE_NAME = "value"
-# This list doesn't seem to be used.
+# This list doesn"t seem to be used.
# Internal documentation or useless? You make the call!
-MEMBERS_TO_SKIP = ('__module__', '__doc__', '__xmlname__', '__xmlattributes__',
- '__xmlexclude__', '__xmlflattensequence__', '__xmlnamespaces__',
- '__xmldefaultnamespace__', '__xmlattrnamespaces__',
- '__xmlattrgroups__')
+##MEMBERS_TO_SKIP = ("__module__", "__doc__", "__xmlname__", "__xmlattributes__",
+## "__xmlexclude__", "__xmlflattensequence__", "__xmlnamespaces__",
+## "__xmldefaultnamespace__", "__xmlattrnamespaces__",
+## "__xmlattrgroups__")
################################################################################
#
#
################################################################################
-def _objectfactory(objname, objargs=None, xsname=None):
- '''dynamically create an object based on the objname and return
- it. look it up in the BASETYPE_ELEMENT_MAP first.
- '''
- # split the objname into the typename and module path,
- # importing the module if need be.
+def setattrignorecase(object, name, value):
+## print "[setattrignorecase] name = %s, value = %s" % (name, value)
+ if (name not in object.__dict__):
+ namelow = name.lower()
+ for attr in object.__dict__:
+ if attr.lower() == namelow:
+ object.__dict__[attr] = value
+ return
+ object.__dict__[name] = value
+
+def getComplexType(obj):
+ if (hasattr(obj, "_instancexsdcomplextype")):
+ return obj._instancexsdcomplextype
+ if (hasattr(obj, "__xsdcomplextype__")):
+ return obj.__xsdcomplextype__
+ return None
+
+def _objectfactory(objtype, objargs=None, objclass=None):
+ "dynamically create an object based on the objtype and return it."
if not isinstance(objargs, list):
objargs = [objargs]
-
- if (xsname):
- try:
- objname = knownGlobalTypes[xsname]
- except KeyError:
- pass
-
-## print "[objectfactory] creating an object of type %s and value %s, xsname=%s" % (objname, objargs, xsname)
- objtype = objname.split('.')[-1]
- pathlist = objname.split('.')
- modulename = '.'.join(pathlist[0:-1])
-
-## print "[objectfactory] object [%s] %s(%r)" % (objname, objtype, objargs)
- if objname == 'bool':
- return not objargs[0].lower() == 'false'
- elif objname == 'str': # don't strip strings - blanks are significant !!!
- if len(objargs) > 0:
- return saxutils.unescape(objargs[0]).encode()
- else:
- return ''
- elif objname == 'unicode': # don't strip strings - blanks are significant !!!
- if len(objargs) > 0:
- return saxutils.unescape(objargs[0]).encode()
+ if (objclass != None):
+ obj = None
+ if (len(objargs) > 0):
+ if (hasattr(objclass, "__xmlcdatacontent__")):
+ obj = objclass()
+ contentAttr = obj.__xmlcdatacontent__
+ obj.__dict__[contentAttr] = str(objargs[0])
+ else:
+ obj = objclass(*objargs)
else:
- return ''
- elif objtype in ('float', 'int', 'str', 'long'):
- objargs = [x.strip() for x in objargs]
+ obj = objclass()
+ if ((obj != None) and (hasattr(obj, 'postUnmarshal'))):
+ obj.postUnmarshal()
+ return obj
+ return objutils.newInstance(objtype, objargs)
- try:
- if __builtin__.__dict__.has_key(objname):
- module = __builtin__
- else:
- if modulename:
- module = __import__(modulename)
- for name in pathlist[1:-1]:
- module = module.__dict__[name]
- if objargs:
- return module.__dict__[objtype](*objargs)
- else:
- if objtype == 'None':
- return None
- return module.__dict__[objtype]()
- except KeyError:
- raise KeyError("Could not find class %s" % objname)
+class GenericXMLObject(object):
+ def __init__(self, content=None):
+ if content != None:
+ self._content = content
+ self.__xmlcontent__ = '_content'
+
+ def __str__(self):
+ return "GenericXMLObject(%s)" % objutils.toDiffableString(self.__dict__)
+ def setXMLAttributes(self, xmlName, attrs=None, children=None, nsMap=None, defaultNS=None):
+ if xmlName != None:
+ i = xmlName.rfind(':')
+ if i < 0:
+ self.__xmlname__ = xmlName
+ if defaultNS != None:
+ self.__xmldefaultnamespace__ = str(defaultNS)
+ else:
+ self.__xmlname__ = xmlName[i+1:]
+ prefix = xmlName[:i]
+ if nsMap.has_key(prefix):
+ self.__xmldefaultnamespace__ = str(nsMap[prefix])
+ if attrs != None:
+ for attrname, attr in attrs.items():
+ attrname = str(attrname)
+ if attrname == XMLNS or attrname.startswith(XMLNS_PREFIX):
+ pass
+ elif attrname == "objtype":
+ pass
+ else:
+ if not hasattr(self, '__xmlattributes__'):
+ self.__xmlattributes__ = []
+ i = attrname.rfind(':')
+ if i >= 0:
+ prefix = attrname[:i]
+ attrname = attrname[i+1:]
+ if not hasattr(self, '__xmlattrnamespaces__'):
+ self.__xmlattrnamespaces__ = {}
+ if self.__xmlattrnamespaces__.has_key(prefix):
+ alist = self.__xmlattrnamespaces__[prefix]
+ else:
+ alist = []
+ alist.append(attrname)
+ self.__xmlattrnamespaces__[prefix] = alist
+ self.__xmlattributes__.append(attrname)
+ if hasattr(self, '__xmlattributes__'):
+ self.__xmlattributes__.sort()
+ if children != None and len(children) > 0:
+ childList = []
+ flattenList = {}
+ for childname, child in children:
+ childstr = str(childname)
+ if childstr in childList:
+ if not flattenList.has_key(childstr):
+ flattenList[childstr] = (childstr,)
+ else:
+ childList.append(childstr)
+ if len(flattenList) > 0:
+ self.__xmlflattensequence__ = flattenList
+
+ def initialize(self, arg1=None):
+ pass
+
+
class Element:
- def __init__(self, name, attrs=None):
+ def __init__(self, name, attrs=None, xsname=None):
self.name = name
self.attrs = attrs
- self.content = ''
+ self.content = ""
self.children = []
+ self.objclass = None
+ self.xsname = xsname
+ self.objtype = None
+
def getobjtype(self):
- if self.attrs.has_key('objtype'):
- return self.attrs.getValue('objtype')
+# objtype = self.attrs.get("objtype")
+ objtype = self.objtype
+ if (objtype == None):
+ if (len(self.children) > 0):
+ objtype = "dict"
+ else:
+ objtype = "str"
+ return objtype
+
+class NsElement(object):
+ def __init__(self):
+ self.nsMap = {}
+ self.targetNS = None
+ self.defaultNS = None
+ self.prefix = None
+
+ def __str__(self):
+ if self.prefix == None:
+ strVal = 'prefix = None; '
+ else:
+ strVal = 'prefix = "%s"; ' % (self.prefix)
+ if self.targetNS == None:
+ strVal += 'targetNS = None; '
+ else:
+ strVal += 'targetNS = "%s"; ' % (self.targetNS)
+ if self.defaultNS == None:
+ strVal += 'defaultNS = None; '
+ else:
+ strVal += 'defaultNS = "%s"; ' % (self.defaultNS)
+ if len(self.nsMap) == 0:
+ strVal += 'nsMap = None; '
else:
- return 'str'
- def toString(self):
- print " name = ", self.name, "; attrs = ", self.attrs, "number of children = ", len(self.children)
- i = -1
- for child in self.children:
- i = i + 1
- childClass = child.__class__.__name__
- print " Child ", i, " class: ",childClass
+ strVal += 'nsMap = {'
+ for ik, iv in self.nsMap.iteritems():
+ strVal += '%s=%s; ' % (ik,iv)
+ strVal += '}'
+ return strVal
+
+ def setKnownTypes(self, masterKnownTypes, masterKnownNamespaces, parentNSE):
+ # if we're a nested element, extend our parent element's mapping
+ if parentNSE != None:
+ self.knownTypes = parentNSE.knownTypes.copy()
+ # but if we have a different default namespace, replace the parent's default mappings
+ if (self.defaultNS != None) and (parentNSE.defaultNS != self.defaultNS):
+ newKT = self.knownTypes.copy()
+ for tag in newKT:
+ if tag.find(':') < 0:
+ del self.knownTypes[tag]
+ newMap = parentNSE.nsMap.copy()
+ if self.nsMap != {}:
+ for k, v in self.nsMap.iteritems():
+ newMap[k] = v
+ self.nsMap = newMap
+ else:
+ self.knownTypes = {}
+ reversedKNS = {}
+ # TODO: instead of starting with the knownNamespaces, start with the "xmlms" mappings
+ # for this element. Then we'd only process the namespaces and tags we need to.
+ # But for now, this works.
+ for long, short in masterKnownNamespaces.iteritems():
+ reversedKNS[short] = long
+ mapLongs = self.nsMap.values()
+ for tag, mapClass in masterKnownTypes.iteritems():
+ i = tag.rfind(':')
+ if i >= 0: # e.g. "wsdl:description"
+ knownTagShort = tag[:i] # "wsdl"
+ knownTagName = tag[i+1:] # "description"
+ knownTagLong = reversedKNS[knownTagShort] # e.g. "http://schemas.xmlsoap.org/wsdl"
+ if (knownTagLong in mapLongs):
+ for mShort, mLong in self.nsMap.iteritems():
+ if mLong == knownTagLong:
+ actualShort = mShort # e.g. "ws"
+ actualTag = '%s:%s' % (actualShort, knownTagName)
+ self.knownTypes[actualTag] = mapClass
+ break
+ if self.defaultNS == knownTagLong:
+ self.knownTypes[knownTagName] = mapClass
+ else: # e.g. "ItemSearchRequest"
+ self.knownTypes[tag] = mapClass
+ def expandQName(self, eName, attrName, attrValue):
+ bigValue = attrValue
+ i = attrValue.rfind(':')
+ if (i < 0):
+ if self.defaultNS != None:
+ bigValue = '%s:%s' % (self.defaultNS, attrValue)
+ else:
+ attrNS = attrValue[:i]
+ attrNCName = attrValue[i+1:]
+ for shortNs, longNs in self.nsMap.iteritems():
+ if shortNs == attrNS:
+ bigValue = '%s:%s' % (longNs, attrNCName)
+ break
+ return bigValue
class XMLObjectFactory(xml.sax.ContentHandler):
- def __init__(self):
+ def __init__(self, knownTypes=None, knownNamespaces=None, xmlSource=None, createGenerics=False):
self.rootelement = None
+ if xmlSource == None:
+ self.xmlSource = "unknown"
+ else:
+ self.xmlSource = xmlSource
+ self.createGenerics = createGenerics
+ self.skipper = False
self.elementstack = []
+ self.nsstack = []
+ self.collectContent = None
+ if (knownNamespaces == None):
+ self.knownNamespaces = {}
+ else:
+ self.knownNamespaces = knownNamespaces
+ self.reversedNamespaces = {}
+ for longns, shortns in self.knownNamespaces.iteritems():
+ self.reversedNamespaces[shortns] = longns
+ self.knownTypes = {}
+ if (knownTypes != None):
+ for tag, cls in knownTypes.iteritems():
+ i = tag.rfind(':')
+ if i >= 0:
+ shortns = tag[:i]
+ tag = tag[i+1:]
+ if not self.reversedNamespaces.has_key(shortns):
+ errorString = 'Error unmarshalling XML document from source "%s": knownTypes specifies an unmapped short namespace "%s" for element "%s"' % (self.xmlSource, shortns, tag)
+ raise UnmarshallerException(errorString)
+ longns = self.reversedNamespaces[shortns]
+ tag = '%s:%s' % (longns, tag)
+ self.knownTypes[tag] = cls
+ #printKnownTypes(self.knownTypes, 'Unmarshaller.XMLObjectFactory.__init__')
xml.sax.handler.ContentHandler.__init__(self)
- def toString(self):
- print "-----XMLObjectFactory Dump-------------------------------"
- if (self.rootelement == None):
- print "rootelement is None"
- else:
- print "rootelement is an object"
- i = -1
- print "length of elementstack is: ", len(self.elementstack)
- for e in self.elementstack:
- i = i + 1
- print "elementstack[", i, "]: "
- e.toString()
- print "-----end XMLObjectFactory--------------------------------"
+ def appendElementStack(self, newElement, newNS):
+ self.elementstack.append(newElement)
+ if (len(self.nsstack) > 0):
+ oldNS = self.nsstack[-1]
+ if newNS.defaultNS == None:
+ newNS.defaultNS = oldNS.defaultNS
+ if newNS.targetNS == None:
+ newNS.targetNS = oldNS.targetNS
+ if len(newNS.nsMap) == 0:
+ newNS.nsMap = oldNS.nsMap
+ elif len(oldNS.nsMap) > 0:
+ map = oldNS.nsMap.copy()
+ map.update(newNS.nsMap)
+ newNS.nsMap = map
+ self.nsstack.append(newNS)
+ return newNS
+
+ def popElementStack(self):
+ element = self.elementstack.pop()
+ nse = self.nsstack.pop()
+ return element, nse
## ContentHandler methods
def startElement(self, name, attrs):
-## print "startElement for name: ", name
- if name.find(':') > -1: # Strip namespace prefixes for now until actually looking them up in xsd
- name = name[name.index(':') + 1:]
-## for attrname in attrs.getNames():
-## print "%s: %s" % (attrname, attrs.getValue(attrname))
- element = Element(name, attrs.copy())
- self.elementstack.append(element)
-## print self.elementstack
+## print '[startElement] <%s>' % (name)
+ if name == 'xs:annotation' or name == 'xsd:annotation': # should use namespace mapping here
+ self.skipper = True
+ self.appendElementStack(Element(name, attrs.copy()), NsElement())
+ if self.skipper:
+ return
+ if self.collectContent != None:
+ strVal = '<%s' % (name)
+ for aKey, aVal in attrs.items():
+ strVal += (' %s="%s"' % (aKey, aVal))
+ strVal += '>'
+ self.collectContent.content += strVal
+ xsname = name
+ i = name.rfind(':')
+ if i >= 0:
+ nsname = name[:i]
+ name = name[i+1:]
+ else:
+ nsname = None
+ element = Element(name, attrs.copy(), xsname=xsname)
+ # if the element has namespace attributes, process them and add them to our stack
+ nse = NsElement()
+ objtype = None
+ for k in attrs.getNames():
+ if k.startswith('xmlns'):
+ longNs = attrs[k]
+ eLongNs = longNs + '/'
+ if str(eLongNs) in asDict(self.knownNamespaces):
+ longNs = eLongNs
+ if k == 'xmlns':
+ nse.defaultNS = longNs
+ else:
+ shortNs = k[6:]
+ nse.nsMap[shortNs] = longNs
+ elif k == 'targetNamespace':
+ nse.targetNS = attrs.getValue(k)
+ elif k == 'objtype':
+ objtype = attrs.getValue(k)
+ nse = self.appendElementStack(element, nse)
+ if nsname != None:
+ if nse.nsMap.has_key(nsname):
+ longname = '%s:%s' % (nse.nsMap[nsname], name)
+## elif objtype == None:
+## errorString = 'Error unmarshalling XML document from source "%s": tag "%s" at line "%d", column "%d" has an undefined namespace' % (self.xmlSource, xsname, self._locator.getLineNumber(), self._locator.getColumnNumber())
+## raise UnmarshallerException(errorString)
+ elif self.reversedNamespaces.has_key(nsname):
+ longname = '%s:%s' % (self.reversedNamespaces[nsname], name)
+ else:
+ longname = xsname
+ elif nse.defaultNS != None:
+ longname = '%s:%s' % (nse.defaultNS, name)
+ else:
+ longname = name
+ element.objtype = objtype
+ element.objclass = self.knownTypes.get(longname)
+ if element.objclass == None and len(self.knownNamespaces) == 0:
+ # handles common case where tags are unqualified and knownTypes are too, but there's a defaultNS
+ element.objclass = self.knownTypes.get(name)
+ if (hasattr(element.objclass, "__xmlcontent__")):
+ self.collectContent = element
def characters(self, content):
-## print "got content: %s" % content
- if content:
- self.elementstack[-1].content += content
+## print '[characters] "%s" (%s)' % (content, type(content))
+ if (content != None):
+ if self.collectContent != None:
+ self.collectContent.content += content
+ else:
+ self.elementstack[-1].content += content
def endElement(self, name):
-## print "[endElement] name of element we're at the end of: %s" % name
+## print "[endElement] </%s>" % name
xsname = name
- if name.find(':') > -1: # Strip namespace prefixes for now until actually looking them up in xsd
- name = name[name.index(':') + 1:]
+ i = name.rfind(':')
+ if i >= 0: # Strip namespace prefixes for now until actually looking them up in xsd
+ name = name[i+1:]
+ if self.skipper:
+ if xsname == "xs:annotation" or xsname == "xsd:annotation": # here too
+ self.skipper = False
+ self.popElementStack()
+ return
+ if self.collectContent != None:
+ if xsname != self.collectContent.xsname:
+ self.collectContent.content += ('</%s>' % (xsname))
+ self.popElementStack()
+ return
+ else:
+ self.collectContent = None
oldChildren = self.elementstack[-1].children
- element = self.elementstack.pop()
+ element, nse = self.popElementStack()
if ((len(self.elementstack) > 1) and (self.elementstack[-1].getobjtype() == "None")):
parentElement = self.elementstack[-2]
-## print "[endElement] %s: found parent with objtype==None: using its grandparent" % name
elif (len(self.elementstack) > 0):
parentElement = self.elementstack[-1]
objtype = element.getobjtype()
-## print "element objtype is: ", objtype
if (objtype == "None"):
-## print "[endElement] %s: skipping a (objtype==None) end tag" % name
return
constructorarglist = []
- if element.content:
+ if (len(element.content) > 0):
strippedElementContent = element.content.strip()
- if strippedElementContent:
+ if (len(strippedElementContent) > 0):
constructorarglist.append(element.content)
-## print "[endElement] calling objectfactory"
- obj = _objectfactory(objtype, constructorarglist, xsname)
- complexType = None
- if hasattr(obj, '__xsdcomplextype__'):
- complexType = getattr(obj, '__xsdcomplextype__')
- if (hasattr(obj, '__xmlname__') and getattr(obj, '__xmlname__') == "sequence"):
-## print "[endElement] sequence found"
-## self.toString()
+ # If the element requires an object, but none is known, use the GenericXMLObject class
+ if ((element.objclass == None) and (element.attrs.get("objtype") == None) and ((len(element.attrs) > 0) or (len(element.children) > 0))):
+ if self.createGenerics:
+ element.objclass = GenericXMLObject
+ obj = _objectfactory(objtype, constructorarglist, element.objclass)
+ if element.objclass == GenericXMLObject:
+ obj.setXMLAttributes(str(xsname), element.attrs, element.children, nse.nsMap, nse.defaultNS)
+ complexType = getComplexType(obj)
+ if (obj != None):
+ if (hasattr(obj, "__xmlname__") and getattr(obj, "__xmlname__") == "sequence"):
self.elementstack[-1].children = oldChildren
-## self.toString()
-## print "done moving sequence stuff; returning"
return
- if len(self.elementstack) > 0:
-## print "[endElement] appending child with name: ", name, "; objtype: ", objtype
- parentElement.children.append((name, obj))
-## print "parentElement now has ", len(parentElement.children), " children"
- else:
- self.rootelement = obj
- if element.attrs and not isinstance(obj, list):
-## print "[endElement] %s: element has attrs and the obj is not a list" % name
+ if (len(element.attrs) > 0) and not isinstance(obj, list):
for attrname, attr in element.attrs.items():
if attrname == XMLNS or attrname.startswith(XMLNS_PREFIX):
if attrname.startswith(XMLNS_PREFIX):
ns = attrname[XMLNS_PREFIX_LENGTH:]
else:
ns = ""
- if not hasattr(obj, '__xmlnamespaces__'):
- obj.__xmlnamespaces__ = {ns:attr}
- elif ns not in obj.__xmlnamespaces__:
- if (hasattr(obj.__class__, '__xmlnamespaces__')
- and obj.__xmlnamespaces__ is obj.__class__.__xmlnamespaces__):
+ if complexType != None or element.objclass == GenericXMLObject:
+ if not hasattr(obj, "__xmlnamespaces__"):
+ obj.__xmlnamespaces__ = {ns:attr}
+ elif ns not in obj.__xmlnamespaces__:
+ if (hasattr(obj.__class__, "__xmlnamespaces__")
+ and (obj.__xmlnamespaces__ is obj.__class__.__xmlnamespaces__)):
obj.__xmlnamespaces__ = dict(obj.__xmlnamespaces__)
- obj.__xmlnamespaces__[ns] = attr
- elif not attrname == 'objtype':
- if attrname.find(':') > -1: # Strip namespace prefixes for now until actually looking them up in xsd
- attrname = attrname[attrname.index(':') + 1:]
- if complexType:
+ obj.__xmlnamespaces__[ns] = attr
+ elif not attrname == "objtype":
+ if attrname.find(":") > -1: # Strip namespace prefixes for now until actually looking them up in xsd
+ attrname = attrname[attrname.find(":") + 1:]
+ if (complexType != None):
xsdElement = complexType.findElement(attrname)
- if xsdElement:
+ if (xsdElement != None):
type = xsdElement.type
- if type:
- type = xsdToPythonType(type)
+ if (type != None):
+ if (type == TYPE_QNAME):
+ attr = nse.expandQName(name, attrname, attr)
+ type = xsdToLangType(type)
### ToDO remove maxOccurs hack after bug 177 is fixed
if attrname == "maxOccurs" and attr == "unbounded":
attr = "-1"
- attr = _objectfactory(type, attr)
- objutils.setattrignorecase(obj, _toAttrName(obj, attrname), attr)
+ try:
+ attr = _objectfactory(type, attr)
+ except Exception, exceptData:
+ errorString = 'Error unmarshalling attribute "%s" at line %d, column %d in XML document from source "%s": %s' % (attrname, self._locator.getLineNumber(), self._locator.getColumnNumber(), self.xmlSource, str(exceptData))
+ raise UnmarshallerException(errorString)
+ try:
+ setattrignorecase(obj, _toAttrName(obj, attrname), attr)
+ except AttributeError:
+ errorString = 'Error setting value of attribute "%s" at line %d, column %d in XML document from source "%s": object type of XML element "%s" is not specified or known' % (attrname, self._locator.getLineNumber(), self._locator.getColumnNumber(), self.xmlSource, name)
+ raise UnmarshallerException(errorString)
## obj.__dict__[_toAttrName(obj, attrname)] = attr
# stuff any child attributes meant to be in a sequence via the __xmlflattensequence__
flattenDict = {}
- if hasattr(obj, '__xmlflattensequence__'):
-## print "[endElement] %s: obj has __xmlflattensequence__" % name
- if (isinstance(obj.__xmlflattensequence__,dict)):
-## print "[endElement] dict with obj.__xmlflattensequence__.items: ", obj.__xmlflattensequence__.items()
- for sequencename, xmlnametuple in obj.__xmlflattensequence__.items():
- for xmlname in xmlnametuple:
-## print "[endElement]: adding flattenDict[%s] = %s" % (xmlname, sequencename)
- flattenDict[xmlname] = sequencename
- # handle __xmlflattensequence__ list/tuple (i.e. no element rename)
- elif (isinstance(obj.__xmlflattensequence__,list) or isinstance(obj.__xmlflattensequence__,tuple)):
- for sequencename in obj.__xmlflattensequence__:
- flattenDict[sequencename] = sequencename
+ if hasattr(obj, "__xmlflattensequence__"):
+ flatten = obj.__xmlflattensequence__
+ if (isinstance(flatten, dict)):
+ for sequencename, xmlnametuple in flatten.items():
+ if (xmlnametuple == None):
+ flattenDict[sequencename] = sequencename
+ elif (not isinstance(xmlnametuple, (tuple, list))):
+ flattenDict[str(xmlnametuple)] = sequencename
+ else:
+ for xmlname in xmlnametuple:
+ flattenDict[xmlname] = sequencename
else:
- raise "Invalid type for __xmlflattensequence___ : it must be a dict, list, or tuple"
+ raise Exception("Invalid type for __xmlflattensequence___ : it must be a dict")
- # reattach an object's attributes to it
+ # reattach an object"s attributes to it
for childname, child in element.children:
-## print "[endElement] childname is: ", childname, "; child is: ", child
- if flattenDict.has_key(childname):
+ if (childname in flattenDict):
sequencename = _toAttrName(obj, flattenDict[childname])
-## print "[endElement] sequencename is: ", sequencename
- try:
-## print "[endElement] obj.__dict__ is: ", obj.__dict__
- sequencevalue = obj.__dict__[sequencename]
- except (AttributeError, KeyError):
- sequencevalue = None
- if sequencevalue == None:
- sequencevalue = []
- obj.__dict__[sequencename] = sequencevalue
+ if (not hasattr(obj, sequencename)):
+ obj.__dict__[sequencename] = []
+ sequencevalue = getattr(obj, sequencename)
+ if (sequencevalue == None):
+ obj.__dict__[sequencename] = []
+ sequencevalue = getattr(obj, sequencename)
sequencevalue.append(child)
- elif isinstance(obj, list):
-## print "appended childname = ", childname
+ elif (objtype == "list"):
obj.append(child)
+ elif isinstance(obj, dict):
+ if (childname == DICT_ITEM_NAME):
+ obj[child[DICT_ITEM_KEY_NAME]] = child[DICT_ITEM_VALUE_NAME]
+ else:
+ obj[childname] = child
else:
-## print "childname = %s, obj = %s, child = %s" % (childname, repr(obj), repr(child))
- objutils.setattrignorecase(obj, _toAttrName(obj, childname), child)
- obj.__dict__[_toAttrName(obj, childname)] = child
+ # don't replace a good attribute value with a bad one
+ childAttrName = _toAttrName(obj, childname)
+ if (not hasattr(obj, childAttrName)) or (getattr(obj, childAttrName) == None) or (getattr(obj, childAttrName) == []) or (not isinstance(child, GenericXMLObject)):
+ try:
+ setattrignorecase(obj, childAttrName, child)
+ except AttributeError:
+ raise MarshallerException("Error unmarshalling child element \"%s\" of XML element \"%s\": object type not specified or known" % (childname, name))
- if complexType:
+ if (complexType != None):
for element in complexType.elements:
if element.default:
elementName = _toAttrName(obj, element.name)
if ((elementName not in obj.__dict__) or (obj.__dict__[elementName] == None)):
- pythonType = xsdToPythonType(element.type)
- defaultValue = _objectfactory(pythonType, element.default)
+ langType = xsdToLangType(element.type)
+ defaultValue = _objectfactory(langType, element.default)
obj.__dict__[elementName] = defaultValue
+ ifDefPy()
+ if (isinstance(obj, list)):
+ if ((element.attrs.has_key("mutable")) and (element.attrs.getValue("mutable") == "false")):
+ obj = tuple(obj)
+ endIfDef()
+
+ if (len(self.elementstack) > 0):
+## print "[endElement] appending child with name: ", name, "; objtype: ", objtype
+ parentElement.children.append((name, obj))
+ else:
+ self.rootelement = obj
+
def getRootObject(self):
return self.rootelement
break
## if (name.startswith("__") and not name.endswith("__")):
## name = "_%s%s" % (obj.__class__.__name__, name)
- return name
+ return str(name)
+
+def printKnownTypes(kt, where):
+ print 'KnownTypes from %s' % (where)
+ for tag, cls in kt.iteritems():
+ print '%s => %s' % (tag, str(cls))
-__typeMappingXsdToPython = {
+__typeMappingXsdToLang = {
"string": "str",
"char": "str",
"varchar": "str",
- "date": "str", # ToDO Need to work out how to create python date types
+ "date": "str", # ToDO Need to work out how to create lang date types
"boolean": "bool",
"decimal": "float", # ToDO Does python have a better fixed point type?
"int": "int",
+ "integer":"int",
"long": "long",
"float": "float",
"bool": "bool",
"datetime": "str", # see above (date)
"time": "str", # see above (date)
"double": "float",
+ "QName" : "str",
+ "blob" : "str", # ag:blob
+ "currency" : "str", # ag:currency
}
-def xsdToPythonType(xsdType):
- try:
- return __typeMappingXsdToPython[xsdType]
- except KeyError:
+def xsdToLangType(xsdType):
+ if xsdType.startswith(XMLSCHEMA_XSD_URL):
+ xsdType = xsdType[len(XMLSCHEMA_XSD_URL)+1:]
+ elif xsdType.startswith(AG_URL):
+ xsdType = xsdType[len(AG_URL)+1:]
+ langType = __typeMappingXsdToLang.get(xsdType)
+ if (langType == None):
raise Exception("Unknown xsd type %s" % xsdType)
+ return langType
+
+def langToXsdType(langType):
+ if langType in asDict(__typeMappingXsdToLang):
+ return '%s:%s' % (XMLSCHEMA_XSD_URL, langType)
+ return langType
-def _getXmlValue(pythonValue):
- if (isinstance(pythonValue, bool)):
- return str(pythonValue).lower()
- elif (isinstance(pythonValue, unicode)):
- return pythonValue.encode()
+def _getXmlValue(langValue):
+ if (isinstance(langValue, bool)):
+ return str(langValue).lower()
+ elif (isinstance(langValue, unicode)):
+ return langValue.encode()
else:
- return str(pythonValue)
+ return str(langValue)
-def unmarshal(xmlstr, knownTypes=None):
- global knownGlobalTypes
- if (knownTypes == None):
- knownGlobalTypes = {}
- else:
- knownGlobalTypes = knownTypes
- objectfactory = XMLObjectFactory()
- xml.sax.parseString(xmlstr, objectfactory)
+def unmarshal(xmlstr, knownTypes=None, knownNamespaces=None, xmlSource=None, createGenerics=False):
+ objectfactory = XMLObjectFactory(knownTypes, knownNamespaces, xmlSource, createGenerics)
+ # on Linux, pyXML's sax.parseString fails when passed unicode
+ if (not sysutils.isWindows()):
+ xmlstr = str(xmlstr)
+ try:
+ xml.sax.parseString(xmlstr, objectfactory)
+ except xml.sax.SAXParseException, errorData:
+ if xmlSource == None:
+ xmlSource = 'unknown'
+ errorString = 'SAXParseException ("%s") detected at line %d, column %d in XML document from source "%s" ' % (errorData.getMessage(), errorData.getLineNumber(), errorData.getColumnNumber(), xmlSource)
+ raise UnmarshallerException(errorString)
return objectfactory.getRootObject()
+def marshal(obj, elementName=None, prettyPrint=False, marshalType=True, indent=0, knownTypes=None, knownNamespaces=None, encoding=-1):
+ worker = XMLMarshalWorker(prettyPrint=prettyPrint, marshalType=marshalType, knownTypes=knownTypes, knownNamespaces=knownNamespaces)
+ if obj != None and hasattr(obj, '__xmldeepexclude__'):
+ worker.xmldeepexclude = obj.__xmldeepexclude__
+ xmlstr = "".join(worker._marshal(obj, elementName, indent=indent))
+ aglogging.info(xmlMarshallerLogger, "marshal produced string of type %s", type(xmlstr))
+ if (encoding == None):
+ return xmlstr
+ if (not isinstance(encoding, basestring)):
+ encoding = sys.getdefaultencoding()
+ if (not isinstance(xmlstr, unicode)):
+ xmlstr = xmlstr.decode()
+ xmlstr = u'<?xml version="1.0" encoding="%s"?>\n%s' % (encoding, xmlstr)
+ return xmlstr.encode(encoding)
-def marshal(obj, elementName=None, prettyPrint=False, indent=0, knownTypes=None, withEncoding=True, encoding=None):
- xmlstr = ''.join(_marshal(obj, elementName, prettyPrint=prettyPrint, indent=indent, knownTypes=knownTypes))
- if withEncoding:
- if encoding is None:
- return '<?xml version="1.0" encoding="%s"?>\n%s' % (sys.getdefaultencoding(), xmlstr)
+class XMLMarshalWorker(object):
+ def __init__(self, marshalType=True, prettyPrint=False, knownTypes=None, knownNamespaces=None):
+ if knownTypes == None:
+ self.knownTypes = {}
else:
- return '<?xml version="1.0" encoding="%s"?>\n%s' % (encoding, xmlstr.encode(encoding))
- else:
- return xmlstr
+ self.knownTypes = knownTypes
+ if knownNamespaces == None:
+ self.knownNamespaces = {}
+ else:
+ self.knownNamespaces = knownNamespaces
+ self.prettyPrint = prettyPrint
+ self.marshalType = marshalType
+ self.xmldeepexclude = []
+ self.nsstack = []
-def _marshal(obj, elementName=None, nameSpacePrefix='', nameSpaces=None, prettyPrint=False, indent=0, knownTypes=None):
- if prettyPrint or indent:
- prefix = ' '*indent
- newline = '\n'
- increment = 4
- else:
- prefix = ''
- newline = ''
- increment = 0
-
- ## Determine the XML element name. If it isn't specified in the
- ## parameter list, look for it in the __xmlname__ Python
- ## attribute, else use the default generic BASETYPE_ELEMENT_NAME.
- if not nameSpaces: nameSpaces = {} # Need to do this since if the {} is a default parameter it gets shared by all calls into the function
- nameSpaceAttrs = ''
- if knownTypes == None:
- knownTypes = {}
- if hasattr(obj, '__xmlnamespaces__'):
- for nameSpaceKey, nameSpaceUrl in getattr(obj, '__xmlnamespaces__').items():
- if nameSpaceUrl in nameSpaces:
- nameSpaceKey = nameSpaces[nameSpaceUrl]
- else:
-## # TODO: Wait to do this until there is shared state for use when going through the object graph
-## origNameSpaceKey = nameSpaceKey # Make sure there is no key collision, ie: same key referencing two different URL's
-## i = 1
-## while nameSpaceKey in nameSpaces.values():
-## nameSpaceKey = origNameSpaceKey + str(i)
-## i += 1
- nameSpaces[nameSpaceUrl] = nameSpaceKey
- if nameSpaceKey == '':
- nameSpaceAttrs += ' xmlns="%s" ' % (nameSpaceUrl)
- else:
- nameSpaceAttrs += ' xmlns:%s="%s" ' % (nameSpaceKey, nameSpaceUrl)
- nameSpaceAttrs = nameSpaceAttrs.rstrip()
- if hasattr(obj, '__xmldefaultnamespace__'):
- nameSpacePrefix = getattr(obj, '__xmldefaultnamespace__') + ':'
- if not elementName:
- if hasattr(obj, '__xmlname__'):
- elementName = nameSpacePrefix + obj.__xmlname__
+ def getNSPrefix(self):
+ if len(self.nsstack) > 0:
+ return self.nsstack[-1].prefix
+ return ''
+
+ def isKnownType(self, elementName):
+ tagLongNs = None
+ nse = self.nsstack[-1]
+ i = elementName.rfind(':')
+ if i > 0:
+ prefix = elementName[:i]
+ name = elementName[i+1:]
else:
- elementName = nameSpacePrefix + BASETYPE_ELEMENT_NAME
- else:
- elementName = nameSpacePrefix + elementName
- if hasattr(obj, '__xmlsequencer__'):
- elementAdd = obj.__xmlsequencer__
- else:
- elementAdd = None
-
-## print "marshal: entered with elementName: ", elementName
- members_to_skip = []
- ## Add more members_to_skip based on ones the user has selected
- ## via the __xmlexclude__ attribute.
- if hasattr(obj, '__xmlexclude__'):
-## print "marshal: found __xmlexclude__"
- members_to_skip += list(obj.__xmlexclude__)
- # Marshal the attributes that are selected to be XML attributes.
- objattrs = ''
- className = obj.__class__.__name__
- classNamePrefix = "_" + className
- if hasattr(obj, '__xmlattributes__'):
-## print "marshal: found __xmlattributes__"
- xmlattributes = obj.__xmlattributes__
- members_to_skip += xmlattributes
- for attr in xmlattributes:
- internalAttrName = attr
- if (attr.startswith("__") and not attr.endswith("__")):
- internalAttrName = classNamePrefix + attr
- # Fail silently if a python attribute is specified to be
- # an XML attribute but is missing.
-## print "marshal: processing attribute ", internalAttrName
- try:
- value = obj.__dict__[internalAttrName]
- except KeyError:
- continue
-## # But, check and see if it is a property first:
-## if (objutils.hasPropertyValue(obj, attr)):
-## value = getattr(obj, attr)
-## else:
-## continue
- xsdElement = None
- if hasattr(obj, '__xsdcomplextype__'):
-## print "marshal: found __xsdcomplextype__"
- complexType = getattr(obj, '__xsdcomplextype__')
- xsdElement = complexType.findElement(attr)
- if xsdElement:
- default = xsdElement.default
- if default == value or default == _getXmlValue(value):
- continue
- elif value == None:
- continue
-
- # ToDO remove maxOccurs hack after bug 177 is fixed
- if attr == "maxOccurs" and value == -1:
- value = "unbounded"
-
- if isinstance(value, bool):
- if value == True:
- value = "true"
- else:
- value = "false"
-
- attrNameSpacePrefix = ''
- if hasattr(obj, '__xmlattrnamespaces__'):
-## print "marshal: found __xmlattrnamespaces__"
- for nameSpaceKey, nameSpaceAttributes in getattr(obj, '__xmlattrnamespaces__').items():
- if nameSpaceKey == nameSpacePrefix[:-1]: # Don't need to specify attribute namespace if it is the same as it's element
- continue
- if attr in nameSpaceAttributes:
- attrNameSpacePrefix = nameSpaceKey + ':'
- break
-## if attr.startswith('_'):
-## attr = attr[1:]
- if (hasattr(obj, "__xmlrename__") and attr in obj.__xmlrename__):
-## print "marshal: found __xmlrename__ (and its attribute)"
- attr = obj.__xmlrename__[attr]
+ prefix = DEFAULT_NAMESPACE_KEY
+ name = elementName
+ for shortNs, longNs in nse.nameSpaces.iteritems():
+ if shortNs == prefix:
+ tagLongNs = longNs
+ break
+ if tagLongNs == None:
+ knownTagName = elementName
+ else:
+ knownShortNs = self.knownNamespaces[tagLongNs]
+ knownTagName = knownShortNs + ':' + name
+ if (knownTagName in asDict(self.knownTypes)):
+ knownClass = self.knownTypes[knownTagName]
+ return True
+ return False
+
+ def popNSStack(self):
+ self.nsstack.pop()
- objattrs += ' %s%s="%s"' % (attrNameSpacePrefix, attr, value)
-## print "marshal: new objattrs is: ", objattrs
+ def appendNSStack(self, obj):
+ nameSpaces = {}
+ defaultLongNS = None
+ for nse in self.nsstack:
+ for k, v in nse.nsMap.iteritems():
+ nameSpaces[k] = v
+ if k == DEFAULT_NAMESPACE_KEY:
+ defaultLongNS = v
+ newNS = NsElement()
+ nameSpaceAttrs = ""
+ if hasattr(obj, "__xmlnamespaces__"):
+ ns = getattr(obj, "__xmlnamespaces__")
+ keys = ns.keys()
+ keys.sort()
+ for nameSpaceKey in keys:
+ nameSpaceUrl = ns[nameSpaceKey]
+ if nameSpaceUrl in nameSpaces.values():
+ for k, v in nameSpaces.iteritems():
+ if v == nameSpaceUrl:
+ nameSpaceKey = k
+ break
+ else:
+ if nameSpaceKey == "":
+ defaultLongNS = nameSpaceUrl
+ nameSpaces[DEFAULT_NAMESPACE_KEY] = nameSpaceUrl
+ newNS.nsMap[DEFAULT_NAMESPACE_KEY] = nameSpaceUrl
+ nameSpaceAttrs += ' xmlns="%s" ' % (nameSpaceUrl)
+ else:
+ nameSpaces[nameSpaceKey] = nameSpaceUrl
+ newNS.nsMap[nameSpaceKey] = nameSpaceUrl
+ nameSpaceAttrs += ' xmlns:%s="%s" ' % (nameSpaceKey, nameSpaceUrl)
+ nameSpaceAttrs = nameSpaceAttrs.rstrip()
+ if len(self.nsstack) > 0:
+ newNS.prefix = self.nsstack[-1].prefix
+ else:
+ newNS.prefix = ''
+ if obj != None and hasattr(obj, "__xmldefaultnamespace__"):
+ longPrefixNS = getattr(obj, "__xmldefaultnamespace__")
+ if longPrefixNS == defaultLongNS:
+ newNS.prefix = ''
+ else:
+ try:
+ for k, v in nameSpaces.iteritems():
+ if v == longPrefixNS:
+ newNS.prefix = k + ':'
+ break;
+ except:
+ if (longPrefixNS in asDict(self.knownNamespaces)):
+ newNS.prefix = self.knownNamespaces[longPrefixNS] + ':'
+ else:
+ raise MarshallerException('Error marshalling __xmldefaultnamespace__ ("%s") not defined in namespace stack' % (longPrefixNS))
+ if obj != None and hasattr(obj, "targetNamespace"):
+ newNS.targetNS = obj.targetNamespace
+ elif len(self.nsstack) > 0:
+ newNS.targetNS = self.nsstack[-1].targetNS
+ newNS.nameSpaces = nameSpaces
+ self.nsstack.append(newNS)
+ return nameSpaceAttrs
- if isinstance(obj, NoneType):
- return ''
- elif isinstance(obj, bool):
- return ['%s<%s objtype="bool">%s</%s>%s' % (prefix, elementName, obj, elementName, newline)]
- elif isinstance(obj, int):
- return ['''%s<%s objtype="int">%s</%s>%s''' % (prefix, elementName, str(obj), elementName, newline)]
- elif isinstance(obj, long):
- return ['%s<%s objtype="long">%s</%s>%s' % (prefix, elementName, str(obj), elementName, newline)]
- elif isinstance(obj, float):
- return ['%s<%s objtype="float">%s</%s>%s' % (prefix, elementName, str(obj), elementName, newline)]
- elif isinstance(obj, unicode): # have to check before basestring - unicode is instance of base string
- return ['''%s<%s>%s</%s>%s''' % (prefix, elementName, saxutils.escape(obj.encode()), elementName, newline)]
- elif isinstance(obj, basestring):
- return ['''%s<%s>%s</%s>%s''' % (prefix, elementName, saxutils.escape(obj), elementName, newline)]
- elif isinstance(obj, list):
- if len(obj) < 1:
- return ''
- xmlString = ['%s<%s objtype="list">%s' % (prefix, elementName, newline)]
- for item in obj:
- xmlString.extend(_marshal(item, nameSpaces=nameSpaces, indent=indent+increment, knownTypes=knownTypes))
- xmlString.append('%s</%s>%s' % (prefix, elementName, newline))
- return xmlString
- elif isinstance(obj, tuple):
- if len(obj) < 1:
- return ''
- xmlString = ['%s<%s objtype="list" mutable="false">%s' % (prefix, elementName, newline)]
- for item in obj:
- xmlString.extend(_marshal(item, nameSpaces=nameSpaces, indent=indent+increment, knownTypes=knownTypes))
- xmlString.append('%s</%s>%s' % (prefix, elementName, newline))
- return xmlString
- elif isinstance(obj, dict):
- xmlString = ['%s<%s objtype="dict">%s' % (prefix, elementName, newline)]
- subprefix = prefix + ' '*increment
- subindent = indent + 2*increment
- for key, val in obj.iteritems():
- xmlString.append("%s<key>%s" % (subprefix, newline))
- xmlString.extend(_marshal(key, indent=subindent, knownTypes=knownTypes))
- xmlString.append("%s</key>%s%s<value>%s" % (subprefix, newline, subprefix, newline))
- xmlString.extend(_marshal(val, nameSpaces=nameSpaces, indent=subindent, knownTypes=knownTypes))
- xmlString.append("%s</value>%s" % (subprefix, newline))
- xmlString.append('%s</%s>%s' % (prefix, elementName, newline))
- return xmlString
- else:
- moduleName = obj.__class__.__module__
- if (moduleName == "activegrid.model.schema"):
- xmlString = ['%s<%s%s%s' % (prefix, elementName, nameSpaceAttrs, objattrs)]
+ def contractQName(self, value, obj, attr):
+ value = langToXsdType(value)
+ i = value.rfind(':')
+ if i >= 0:
+ longNS = value[:i]
else:
- # Only add the objtype if the element tag is unknown to us.
- try:
- objname = knownTypes[elementName]
- xmlString = ['%s<%s%s%s' % (prefix, elementName, nameSpaceAttrs, objattrs)]
- except KeyError:
- xmlString = ['%s<%s%s%s objtype="%s.%s"' % (prefix, elementName, nameSpaceAttrs, objattrs, moduleName, className)]
-## print "UnknownTypeException: Unknown type (%s.%s) passed to marshaller" % (moduleName, className)
- # get the member, value pairs for the object, filtering out the types we don't support
- if (elementAdd != None):
- prefix += increment*' '
- indent += increment
+ # the value doesn't have a namespace and we couldn't map it to an XSD type...what to do?
+ # (a) just write it, as is, and hope it's in the default namespace (for now)
+ # (b) throw an exception so we can track down the bad code (later)
+ return value
+ if (longNS in self.nsstack[-1].nameSpaces.values()):
+ for kShort, vLong in self.nsstack[-1].nameSpaces.iteritems():
+ if vLong == longNS:
+ shortNS = kShort
+ break
+ else:
+ shortNS = longNS # if we can't find the long->short mappping, just use longNS
+ if shortNS == DEFAULT_NAMESPACE_KEY:
+ value = value[i+1:]
+ else:
+ value = shortNS + ':' + value[i+1:]
+ return value
+
+ def _genObjTypeStr(self, typeString):
+ if self.marshalType:
+ return ' objtype="%s"' % typeString
+ return ""
- xmlMemberString = []
- if hasattr(obj, '__xmlbody__'):
- xmlbody = getattr(obj, obj.__xmlbody__)
- if xmlbody != None:
- xmlMemberString.append(xmlbody)
+ def _marshal(self, obj, elementName=None, nameSpacePrefix="", indent=0):
+ if (obj != None):
+ aglogging.debug(xmlMarshallerLogger, "--> _marshal: elementName=%s%s, type=%s, obj=%s, indent=%d", nameSpacePrefix, elementName, type(obj), str(obj), indent)
else:
- entryList = obj.__dict__.items()
-## # Add in properties
-## for key in obj.__class__.__dict__.iterkeys():
-## if (key not in members_to_skip and key not in obj.__dict__
-## and objutils.hasPropertyValue(obj, key)):
-## value = getattr(obj, key)
-## entryList.append((key, value))
- entryList.sort()
- if hasattr(obj, '__xmlattrgroups__'):
- attrGroups = obj.__xmlattrgroups__
- if (not isinstance(attrGroups,dict)):
- raise "__xmlattrgroups__ is not a dict, but must be"
- for n in attrGroups:
- v = attrGroups[n]
- members_to_skip += v
+ aglogging.debug(xmlMarshallerLogger, "--> _marshal: elementName=%s%s, obj is None, indent=%d", nameSpacePrefix, elementName, indent)
+ if ((obj != None) and (hasattr(obj, 'preMarshal'))):
+ obj.preMarshal()
+ excludeAttrs = []
+ excludeAttrs.extend(self.xmldeepexclude)
+ if hasattr(obj, "__xmlexclude__"):
+ excludeAttrs.extend(obj.__xmlexclude__)
+ prettyPrint = self.prettyPrint
+ knownTypes = self.knownTypes
+ xmlString = None
+ if self.prettyPrint or indent:
+ prefix = " "*indent
+ newline = "\n"
+ increment = 2
+ else:
+ prefix = ""
+ newline = ""
+ increment = 0
+ ## Determine the XML element name. If it isn"t specified in the
+ ## parameter list, look for it in the __xmlname__ attribute,
+ ## else use the default generic BASETYPE_ELEMENT_NAME.
+ nameSpaceAttrs = self.appendNSStack(obj)
+ nameSpacePrefix = self.getNSPrefix()
+ if not elementName:
+ if hasattr(obj, "__xmlname__"):
+ elementName = nameSpacePrefix + obj.__xmlname__
else:
- attrGroups = {}
- # add the list of all attributes to attrGroups
- eList = []
- for x, z in entryList:
- eList.append(x)
- attrGroups['__nogroup__'] = eList
-
- for eName in attrGroups:
- eList = attrGroups[eName]
- if (eName != '__nogroup__'):
- prefix += increment*' '
- indent += increment
- xmlMemberString.append('%s<%s objtype="None">%s' % (prefix, eName, newline))
- for name in eList:
- value = obj.__dict__[name]
-## print " ", name, " = ", value
-## # special name handling for private "__*" attributes:
-## # remove the _<class-name> added by Python
-## if name.startswith(classNamePrefix): name = name[len(classNamePrefix):]
- if eName == '__nogroup__' and name in members_to_skip: continue
- if name.startswith('__') and name.endswith('__'): continue
-## idx = name.find('__')
-## if idx > 0:
-## newName = name[idx+2:]
-## if newName:
-## name = newName
-## print "marshal: processing subElement ", name
- subElementNameSpacePrefix = nameSpacePrefix
- if hasattr(obj, '__xmlattrnamespaces__'):
- for nameSpaceKey, nameSpaceValues in getattr(obj, '__xmlattrnamespaces__').items():
- if name in nameSpaceValues:
- subElementNameSpacePrefix = nameSpaceKey + ':'
- break
- # handle sequences listed in __xmlflattensequence__
- # specially: instead of listing the contained items inside
- # of a separate list, as god intended, list them inside
- # the object containing the sequence.
- if hasattr(obj, '__xmlflattensequence__') and name in obj.__xmlflattensequence__ and value:
- try:
+ elementName = nameSpacePrefix + BASETYPE_ELEMENT_NAME
+ else:
+ elementName = nameSpacePrefix + elementName
+
+ if (hasattr(obj, "__xmlsequencer__")) and (obj.__xmlsequencer__ != None):
+ if (XMLSCHEMA_XSD_URL in self.nsstack[-1].nameSpaces.values()):
+ for kShort, vLong in self.nsstack[-1].nameSpaces.iteritems():
+ if vLong == XMLSCHEMA_XSD_URL:
+ if kShort != DEFAULT_NAMESPACE_KEY:
+ xsdPrefix = kShort + ':'
+ else:
+ xsdPrefix = ''
+ break
+ else:
+ xsdPrefix = 'xs:'
+ elementAdd = xsdPrefix + obj.__xmlsequencer__
+ else:
+ elementAdd = None
+
+ members_to_skip = []
+ ## Add more members_to_skip based on ones the user has selected
+ ## via the __xmlexclude__ and __xmldeepexclude__ attributes.
+ members_to_skip.extend(excludeAttrs)
+ # Marshal the attributes that are selected to be XML attributes.
+ objattrs = ""
+ className = ag_className(obj)
+ classNamePrefix = "_" + className
+ if hasattr(obj, "__xmlattributes__"):
+ xmlattributes = obj.__xmlattributes__
+ members_to_skip.extend(xmlattributes)
+ for attr in xmlattributes:
+ internalAttrName = attr
+ ifDefPy()
+ if (attr.startswith("__") and not attr.endswith("__")):
+ internalAttrName = classNamePrefix + attr
+ endIfDef()
+ # Fail silently if a python attribute is specified to be
+ # an XML attribute but is missing.
+ attrNameSpacePrefix = ""
+ if hasattr(obj, "__xmlattrnamespaces__"):
+ for nameSpaceKey, nameSpaceAttributes in getattr(obj, "__xmlattrnamespaces__").iteritems():
+ if nameSpaceKey == nameSpacePrefix[:-1]: # Don't need to specify attribute namespace if it is the same as its element
+ continue
+ if attr in nameSpaceAttributes:
+ attrNameSpacePrefix = nameSpaceKey + ":"
+ break
+ attrs = obj.__dict__
+ value = attrs.get(internalAttrName)
+ if (hasattr(obj, "__xmlrename__") and attr in asDict(obj.__xmlrename__)):
+ attr = obj.__xmlrename__[attr]
+ xsdElement = None
+ complexType = getComplexType(obj)
+ if (complexType != None):
+ xsdElement = complexType.findElement(attr)
+ if (xsdElement != None):
+ default = xsdElement.default
+ if (default != None):
+ if ((default == value) or (default == _getXmlValue(value))):
+ continue
+ else:
+ if (value == None):
+ continue
+ elif xsdElement.type == TYPE_QNAME:
+ value = self.contractQName(value, obj, attr)
+ elif value == None:
+ continue
+
+ # ToDO remove maxOccurs hack after bug 177 is fixed
+ if attr == "maxOccurs" and value == -1:
+ value = "unbounded"
+
+ if isinstance(value, bool):
+ if value == True:
+ value = "true"
+ else:
+ value = "false"
+ else:
+ value = objutils.toDiffableRepr(value)
+
+ objattrs += ' %s%s="%s"' % (attrNameSpacePrefix, attr, utillang.escape(value))
+ if (obj == None):
+ xmlString = [""]
+ elif isinstance(obj, bool):
+ objTypeStr = self._genObjTypeStr("bool")
+ xmlString = ['%s<%s%s>%s</%s>%s' % (prefix, elementName, objTypeStr, obj, elementName, newline)]
+ elif isinstance(obj, int):
+ objTypeStr = self._genObjTypeStr("int")
+ xmlString = ['%s<%s%s>%s</%s>%s' % (prefix, elementName, objTypeStr, str(obj), elementName, newline)]
+ elif isinstance(obj, long):
+ objTypeStr = self._genObjTypeStr("long")
+ xmlString = ['%s<%s%s>%s</%s>%s' % (prefix, elementName, objTypeStr, str(obj), elementName, newline)]
+ elif isinstance(obj, float):
+ objTypeStr = self._genObjTypeStr("float")
+ xmlString = ['%s<%s%s>%s</%s>%s' % (prefix, elementName, objTypeStr, str(obj), elementName, newline)]
+ elif isinstance(obj, unicode): # have to check before basestring - unicode is instance of base string
+ xmlString = ['%s<%s>%s</%s>%s' % (prefix, elementName, utillang.escape(obj.encode()), elementName, newline)]
+ elif isinstance(obj, basestring):
+ xmlString = ['%s<%s>%s</%s>%s' % (prefix, elementName, utillang.escape(obj), elementName, newline)]
+ elif isinstance(obj, datetime.datetime):
+ objTypeStr = self._genObjTypeStr("datetime")
+ xmlString = ['%s<%s%s>%s</%s>%s' % (prefix, elementName, objTypeStr, str(obj), elementName, newline)]
+ elif isinstance(obj, datetime.date):
+ objTypeStr = self._genObjTypeStr("date")
+ xmlString = ['%s<%s%s>%s</%s>%s' % (prefix, elementName, objTypeStr, str(obj), elementName, newline)]
+ elif isinstance(obj, datetime.time):
+ objTypeStr = self._genObjTypeStr("time")
+ xmlString = ['%s<%s%s>%s</%s>%s' % (prefix, elementName, objTypeStr, str(obj), elementName, newline)]
+ elif isinstance(obj, list):
+ if len(obj) < 1:
+ xmlString = ""
+ else:
+ objTypeStr = self._genObjTypeStr("list")
+ xmlString = ['%s<%s%s>%s' % (prefix, elementName, objTypeStr, newline)]
+ for item in obj:
+ xmlString.extend(self._marshal(item, indent=indent+increment))
+ xmlString.append("%s</%s>%s" % (prefix, elementName, newline))
+ elif isinstance(obj, tuple):
+ if len(obj) < 1:
+ xmlString = ""
+ else:
+ objTypeStr = self._genObjTypeStr("list")
+ xmlString = ['%s<%s%s mutable="false">%s' % (prefix, elementName, objTypeStr, newline)]
+ for item in obj:
+ xmlString.extend(self._marshal(item, indent=indent+increment))
+ xmlString.append("%s</%s>%s" % (prefix, elementName, newline))
+ elif isinstance(obj, dict):
+ objTypeStr = self._genObjTypeStr("dict")
+ xmlString = ['%s<%s%s>%s' % (prefix, elementName, objTypeStr, newline)]
+ subprefix = prefix + " "*increment
+ subindent = indent + 2*increment
+ keys = obj.keys()
+ keys.sort()
+ for key in keys:
+ xmlString.append("%s<%s>%s" % (subprefix, DICT_ITEM_NAME, newline))
+ xmlString.extend(self._marshal(key, elementName=DICT_ITEM_KEY_NAME, indent=subindent))
+ xmlString.extend(self._marshal(obj[key], elementName=DICT_ITEM_VALUE_NAME, indent=subindent))
+ xmlString.append("%s</%s>%s" % (subprefix, DICT_ITEM_NAME, newline))
+ xmlString.append("%s</%s>%s" % (prefix, elementName, newline))
+ elif hasattr(obj, "__xmlcontent__"):
+ contentValue = getattr(obj, obj.__xmlcontent__)
+ if contentValue == None:
+ xmlString = ["%s<%s%s%s/>%s" % (prefix, elementName, nameSpaceAttrs, objattrs, newline)]
+ else:
+ contentValue = utillang.escape(contentValue)
+ xmlString = ["%s<%s%s%s>%s</%s>%s" % (prefix, elementName, nameSpaceAttrs, objattrs, contentValue, elementName, newline)]
+ else:
+ # Only add the objtype if the element tag is unknown to us.
+ if (isinstance(obj, GenericXMLObject)):
+ objTypeStr = ""
+ elif (self.isKnownType(elementName) == True):
+ objTypeStr = ""
+ else:
+ objTypeStr = self._genObjTypeStr("%s.%s" % (obj.__class__.__module__, className))
+ xmlString = ['%s<%s%s%s%s' % (prefix, elementName, nameSpaceAttrs, objattrs, objTypeStr)]
+ # get the member, value pairs for the object, filtering out the types we don"t support
+ if (elementAdd != None):
+ prefix += increment*" "
+ indent += increment
+ xmlMemberString = []
+ if hasattr(obj, "__xmlbody__"):
+ xmlbody = getattr(obj, obj.__xmlbody__)
+ if xmlbody != None:
+ xmlMemberString.append(utillang.escape(xmlbody))
+ else:
+ if hasattr(obj, "__xmlattrgroups__"):
+ attrGroups = obj.__xmlattrgroups__.copy()
+ if (not isinstance(attrGroups, dict)):
+ raise "__xmlattrgroups__ is not a dict, but must be"
+ for n in attrGroups.iterkeys():
+ members_to_skip.extend(attrGroups[n])
+ else:
+ attrGroups = {}
+ # add the list of all attributes to attrGroups
+ eList = obj.__dict__.keys()
+ eList.sort()
+ attrGroups["__nogroup__"] = eList
+
+ for eName, eList in attrGroups.iteritems():
+ if (eName != "__nogroup__"):
+ prefix += increment*" "
+ indent += increment
+ objTypeStr = self._genObjTypeStr("None")
+ xmlMemberString.append('%s<%s%s>%s' % (prefix, eName, objTypeStr, newline))
+ for name in eList:
+ value = obj.__dict__[name]
+ if eName == "__nogroup__" and name in members_to_skip: continue
+ if name.startswith("__") and name.endswith("__"): continue
+ if (hasattr(obj, "__xmlcdatacontent__") and (obj.__xmlcdatacontent__ == name)):
+ continue
+ subElementNameSpacePrefix = nameSpacePrefix
+ if hasattr(obj, "__xmlattrnamespaces__"):
+ for nameSpaceKey, nameSpaceValues in getattr(obj, "__xmlattrnamespaces__").iteritems():
+ if name in nameSpaceValues:
+ subElementNameSpacePrefix = nameSpaceKey + ":"
+ break
+ # handle sequences listed in __xmlflattensequence__
+ # specially: instead of listing the contained items inside
+ # of a separate list, as God intended, list them inside
+ # the object containing the sequence.
+ if (hasattr(obj, "__xmlflattensequence__") and (value != None) and (name in asDict(obj.__xmlflattensequence__))):
xmlnametuple = obj.__xmlflattensequence__[name]
+ if (xmlnametuple == None):
+ xmlnametuple = [name]
+ elif (not isinstance(xmlnametuple, (tuple,list))):
+ xmlnametuple = [str(xmlnametuple)]
xmlname = None
- if len(xmlnametuple) == 1:
+ if (len(xmlnametuple) == 1):
xmlname = xmlnametuple[0]
- except:
- xmlname = name
-## xmlname = name.lower()
- for seqitem in value:
- xmlMemberString.extend(_marshal(seqitem, xmlname, subElementNameSpacePrefix, nameSpaces=nameSpaces, indent=indent+increment, knownTypes=knownTypes))
- else:
- if (hasattr(obj, "__xmlrename__") and name in obj.__xmlrename__):
- xmlname = obj.__xmlrename__[name]
+ if not isinstance(value, (list, tuple)):
+ value = [value]
+ for seqitem in value:
+ xmlMemberString.extend(self._marshal(seqitem, xmlname, subElementNameSpacePrefix, indent=indent+increment))
else:
- xmlname = name
-## if (indent > 30):
-## print "getting pretty deep, xmlname = ", xmlname
- xmlMemberString.extend(_marshal(value, xmlname, subElementNameSpacePrefix, nameSpaces=nameSpaces, indent=indent+increment, knownTypes=knownTypes))
- if (eName != '__nogroup__'):
-## print "marshal: Completing attrGroup ", eName
- xmlMemberString.append('%s</%s>%s' % (prefix, eName, newline))
- prefix = prefix[:-increment]
- indent -= increment
-
- # if we have nested elements, add them here, otherwise close the element tag immediately.
- xmlMemberString = filter(lambda x: len(x)>0, xmlMemberString)
- if len(xmlMemberString) > 0:
- xmlString.append('>')
- if hasattr(obj, '__xmlbody__'):
- xmlString.extend(xmlMemberString)
- xmlString.append('</%s>%s' % (elementName, newline))
+ if (hasattr(obj, "__xmlrename__") and name in asDict(obj.__xmlrename__)):
+ xmlname = obj.__xmlrename__[name]
+ else:
+ xmlname = name
+ if (value != None):
+ xmlMemberString.extend(self._marshal(value, xmlname, subElementNameSpacePrefix, indent=indent+increment))
+ if (eName != "__nogroup__"):
+ xmlMemberString.append("%s</%s>%s" % (prefix, eName, newline))
+ prefix = prefix[:-increment]
+ indent -= increment
+
+ # if we have nested elements, add them here, otherwise close the element tag immediately.
+ newList = []
+ for s in xmlMemberString:
+ if (len(s) > 0): newList.append(s)
+ xmlMemberString = newList
+ if len(xmlMemberString) > 0:
+ xmlString.append(">")
+ if hasattr(obj, "__xmlbody__"):
+ xmlString.extend(xmlMemberString)
+ xmlString.append("</%s>%s" % (elementName, newline))
+ else:
+ xmlString.append(newline)
+ if (elementAdd != None):
+ xmlString.append("%s<%s>%s" % (prefix, elementAdd, newline))
+ xmlString.extend(xmlMemberString)
+ if (elementAdd != None):
+ xmlString.append("%s</%s>%s" % (prefix, elementAdd, newline))
+ prefix = prefix[:-increment]
+ indent -= increment
+ xmlString.append("%s</%s>%s" % (prefix, elementName, newline))
else:
- xmlString.append(newline)
- if (elementAdd != None):
- xmlString.append('%s<%s>%s' % (prefix, elementAdd, newline))
- xmlString.extend(xmlMemberString)
- if (elementAdd != None):
- xmlString.append('%s</%s>%s' % (prefix, elementAdd, newline))
- prefix = prefix[:-increment]
- indent -= increment
- xmlString.append('%s</%s>%s' % (prefix, elementName, newline))
- else:
- xmlString.append('/>%s' % newline)
+ if hasattr(obj, "__xmlcdatacontent__"):
+ cdataAttr = obj.__xmlcdatacontent__
+ cdataContent = obj.__dict__[cdataAttr]
+ xmlString.append("><![CDATA[%s]]></%s>%s" % (cdataContent, elementName, newline))
+ else:
+ xmlString.append("/>%s" % newline)
+ if aglogging.isEnabledForDebug(xmlMarshallerLogger):
+ aglogging.debug(xmlMarshallerLogger, "<-- _marshal: %s", objutils.toDiffableString(xmlString))
+ #print "<-- _marshal: %s" % str(xmlString)
+ self.popNSStack()
return xmlString
+
+# A simple test, to be executed when the xmlmarshaller is run standalone
+class MarshallerPerson:
+ __xmlname__ = "person"
+ __xmlexclude__ = ["fabulousness",]
+ __xmlattributes__ = ("nonSmoker",)
+ __xmlrename__ = {"_phoneNumber": "telephone"}
+ __xmlflattensequence__ = {"favoriteWords": ("vocabulary",)}
+ __xmlattrgroups__ = {"name": ["firstName", "lastName"], "address": ["addressLine1", "city", "state", "zip"]}
+
+ def setPerson(self):
+ self.firstName = "Albert"
+ self.lastName = "Camus"
+ self.addressLine1 = "23 Absurd St."
+ self.city = "Ennui"
+ self.state = "MO"
+ self.zip = "54321"
+ self._phoneNumber = "808-303-2323"
+ self.favoriteWords = ["angst", "ennui", "existence"]
+ self.phobias = ["war", "tuberculosis", "cars"]
+ self.weight = 150
+ self.fabulousness = "tres tres"
+ self.nonSmoker = False
+
+if isMain(__name__):
+ p1 = MarshallerPerson()
+ p1.setPerson()
+ xmlP1 = marshal(p1, prettyPrint=True, encoding="utf-8")
+ print "\n########################"
+ print "# testPerson test case #"
+ print "########################"
+ print xmlP1
+ p2 = unmarshal(xmlP1)
+ xmlP2 = marshal(p2, prettyPrint=True, encoding="utf-8")
+ if xmlP1 == xmlP2:
+ print "Success: repeated marshalling yields identical results"
+ else:
+ print "Failure: repeated marshalling yields different results"
+ print xmlP2
projects / wxWidgets.git / blobdiff