def parse(self, elt, ps):
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Array has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
if self.nilled(elt, ps): return None
if not _find_arraytype(elt) and not self.undeclared:
raise EvaluateException('Array expected', ps.Backtrace(elt))
t = _find_type(elt)
if t:
pass # XXX should check the type, but parsing that is hairy.
offset = self.parse_offset(elt, ps)
v, vlen = [], 0
if offset and not self.sparse:
while vlen < offset:
vlen += 1
v.append(self.fill)
for c in _child_elements(elt):
item = self.ofwhat.parse(c, ps)
position = self.parse_position(c, ps) or offset
if self.sparse:
v.append((position, item))
else:
while offset < position:
offset += 1
v.append(self.fill)
v.append(item)
offset += 1
return v
def parse(self, elt, ps):
(ns,type) = self.checkname(elt, ps)
if not type and self.nilled(elt, ps): return None
if len(_children(elt)) == 0:
href = _find_href(elt)
if not href:
if self.optional: return None
raise EvaluateException('Non-optional Any missing',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
(ns,type) = self.checktype(elt, ps)
if not type and elt.namespaceURI == SOAP.ENC:
ns,type = SOAP.ENC, elt.localName
if not type or (ns,type) == (SOAP.ENC,'Array'):
if self.aslist or _find_arraytype(elt):
return [ Any(aslist=self.aslist).parse(e, ps)
for e in _child_elements(elt) ]
if len(_child_elements(elt)) == 0:
raise EvaluateException("Any cannot parse untyped element",
ps.Backtrace(elt))
return self.parse_into_dict_or_list(elt, ps)
parser = Any.parsemap.get((ns,type))
if not parser and _is_xsd_or_soap_ns(ns):
parser = Any.parsemap.get((None,type))
if not parser:
raise EvaluateException('''Any can't parse element''',
ps.Backtrace(elt))
return parser.parse(elt, ps)
def parse(self, elt, ps):
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Array has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
if self.nilled(elt, ps): return Nilled
if not _find_arraytype(elt) and self.undeclared is False:
raise EvaluateException('Array expected', ps.Backtrace(elt))
t = _find_type(elt)
if t:
pass # XXX should check the type, but parsing that is hairy.
offset = self.parse_offset(elt, ps)
v, vlen = [], 0
if offset and not self.sparse:
while vlen < offset:
vlen += 1
v.append(self.fill)
for c in _child_elements(elt):
item = self.ofwhat.parse(c, ps)
position = self.parse_position(c, ps) or offset
if self.sparse:
v.append((position, item))
else:
while offset < position:
offset += 1
v.append(self.fill)
v.append(item)
offset += 1
return v
def SimpleHREF(self, elt, ps, tag):
'''Simple HREF for non-string and non-struct and non-array.
'''
if len(_children(elt)): return elt
href = _find_href(elt)
if not href:
if self.optional: return None
raise EvaluateException('Non-optional ' + tag + ' missing',
ps.Backtrace(elt))
return ps.FindLocalHREF(href, elt, 0)
def parse_into_dict_or_list(self, elt, ps):
c = _child_elements(elt)
count = len(c)
v = {}
if count == 0:
href = _find_href(elt)
if not href: return v
elt = ps.FindLocalHREF(href, elt)
self.checktype(elt, ps)
c = _child_elements(elt)
count = len(c)
if count == 0: return self.listify(v)
if self.nilled(elt, ps): return None
for c_elt in c:
v[str(c_elt.nodeName)] = self.parse(c_elt, ps)
return self.listify(v)
def parse(self, elt, ps):
self.checkname(elt, ps)
if len(_children(elt)) == 0:
href = _find_href(elt)
if not href:
if _find_nil(elt) not in [ "true", "1"]:
# No content, no HREF, not NIL: empty string
return ""
# No content, no HREF, and is NIL...
if self.optional: return None
raise EvaluateException('Non-optional string missing',
ps.Backtrace(elt))
if href[0] != '#':
return ps.ResolveHREF(href, self)
elt = ps.FindLocalHREF(href, elt)
self.checktype(elt, ps)
if self.nilled(elt, ps): return None
if len(_children(elt)) == 0: return ''
v = self.simple_value(elt, ps)
if self.strip: v = v.strip()
return v
def parse(self, elt, ps):
if not self.wrapped:
return elt
c = _child_elements(elt)
if not c:
href = _find_href(elt)
if not href:
if self.optional: return None
raise EvaluateException('Embedded XML document missing',
ps.Backtrace(elt))
if href[0] != '#':
return ps.ResolveHREF(href, self)
elt = ps.FindLocalHREF(href, elt)
c = _child_elements(elt)
if _find_encstyle(elt) != "":
#raise EvaluateException('Embedded XML has unknown encodingStyle',
# ps.Backtrace(elt)
pass
if len(c) != 1:
raise EvaluateException('Embedded XML has more than one child',
ps.Backtrace(elt))
if self.copyit: return c[0].cloneNode(1)
return c[0]
def parse(self, elt, ps):
debug = self.logger.debugOn()
debug and self.logger.debug('parse')
xtype = self.checkname(elt, ps)
if self.type and xtype not in [self.type, (None, None)]:
if not isinstance(self, TypeDefinition):
raise EvaluateException(\
'ComplexType for %s has wrong type(%s), looking for %s' %
(self.pname, self.checktype(elt,ps), self.type),
ps.Backtrace(elt))
else:
#TODO: mabye change MRO to handle this
debug and self.logger.debug('delegate to substitute type')
what = TypeDefinition.getSubstituteType(self, elt, ps)
return what.parse(elt, ps)
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Struct has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
c = _child_elements(elt)
count = len(c)
if self.nilled(elt, ps): return Nilled
# Create the object.
if self.pyclass:
# type definition must be informed of element tag (nspname,pname),
# element declaration is initialized with a tag.
try:
pyobj = self.pyclass()
except Exception, e:
raise TypeError("Constructing element (%s,%s) with pyclass(%s), %s" \
%(self.nspname, self.pname, self.pyclass.__name__, str(e)))
def parse(self, elt, ps):
debug = self.logger.debugOn()
debug and self.logger.debug('parse')
xtype = self.checkname(elt, ps)
if self.type and xtype not in [ self.type, (None,None) ]:
if not isinstance(self, TypeDefinition):
raise EvaluateException(\
'ComplexType for %s has wrong type(%s), looking for %s' %
(self.pname, self.checktype(elt,ps), self.type),
ps.Backtrace(elt))
else:
#TODO: mabye change MRO to handle this
debug and self.logger.debug('delegate to substitute type')
what = TypeDefinition.getSubstituteType(self, elt, ps)
return what.parse(elt, ps)
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Struct has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
c = _child_elements(elt)
count = len(c)
if self.nilled(elt, ps): return Nilled
# Create the object.
if self.pyclass:
# type definition must be informed of element tag (nspname,pname),
# element declaration is initialized with a tag.
try:
pyobj = self.pyclass()
except Exception, e:
raise TypeError("Constructing element (%s,%s) with pyclass(%s), %s" \
%(self.nspname, self.pname, self.pyclass.__name__, str(e)))
def parse(self, elt, ps):
#if elt.localName != self.pname:
# elt = elt.getElementsByTagName(self.pname)[0]
self.checkname(elt, ps)
if self.type and \
self.checktype(elt, ps) not in [ self.type, (None,None) ]:
raise EvaluateException('Struct has wrong type', ps.Backtrace(elt))
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Struct has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
c = _child_elements(elt)
count = len(c)
if self.nilled(elt, ps): return None
repeatable_args = False
for tc in self.ofwhat:
if tc.repeatable:
repeatable_args = True
break
if not repeatable_args:
if count > len(self.ofwhat) and not self.hasextras:
raise EvaluateException('Too many sub-elements', ps.Backtrace(elt))
# Create the object.
v = {}
# Clone list of kids (we null it out as we process)
c, crange = c[:], range(len(c))
# Loop over all items we're expecting
for i,what in [ (i, self.ofwhat[i]) for i in range(len(self.ofwhat)) ]:
# Loop over all available kids
for j,c_elt in [ (j, c[j]) for j in crange if c[j] ]:
if what.name_match(c_elt):
# Parse value, and mark this one done.
try:
value = what.parse(c_elt, ps)
except EvaluateException, e:
e.str = '%s.%s: %s' % \
(self.pname or '?', what.aname or '?', e.str)
raise e
if what.repeatable:
if v.has_key(what.aname):
v[what.aname].append(value)
else:
v[what.aname] = [value]
c[j] = None
continue
else:
v[what.aname] = value
c[j] = None
break
# No match; if it was supposed to be here, that's an error.
if self.inorder and i == j:
raise EvaluateException('Out of order struct',
ps.Backtrace(c_elt))
else:
if not what.optional and not v.has_key(what.aname):
raise EvaluateException('Element "' + what.aname + \
'" missing from struct', ps.Backtrace(elt))
if hasattr(what, 'default'):
v[what.aname] = what.default
def parse(self, elt, ps):
debug = self.logger.debugOn()
debug and self.logger.debug('parse')
xtype = self.checkname(elt, ps)
if self.type and xtype not in [ self.type, (None,None) ]:
if not isinstance(self, TypeDefinition):
raise EvaluateException(\
'ComplexType for %s has wrong type(%s), looking for %s' %
(self.pname, self.checktype(elt,ps), self.type),
ps.Backtrace(elt))
else:
#TODO: mabye change MRO to handle this
debug and self.logger.debug('delegate to substitute type')
what = TypeDefinition.getSubstituteType(self, elt, ps)
return what.parse(elt, ps)
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Struct has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
c = _child_elements(elt)
count = len(c)
if self.nilled(elt, ps): return Nilled
# Create the object.
v = {}
# parse all attributes contained in attribute_typecode_dict (user-defined attributes),
# the values (if not None) will be keyed in self.attributes dictionary.
attributes = self.parse_attributes(elt, ps)
if attributes:
v[self.attrs_aname] = attributes
#MIXED
if self.mixed is True:
v[self.mixed_aname] = self.simple_value(elt,ps, mixed=True)
# Clone list of kids (we null it out as we process)
c, crange = c[:], range(len(c))
# Loop over all items we're expecting
if debug:
self.logger.debug("ofwhat: %s",str(self.ofwhat))
any = None
for i,what in [ (i, self.ofwhat[i]) for i in range(len(self.ofwhat)) ]:
# retrieve typecode if it is hidden
if callable(what): what = what()
# Loop over all available kids
if debug:
self.logger.debug("what: (%s,%s)", what.nspname, what.pname)
for j,c_elt in [ (j, c[j]) for j in crange if c[j] ]:
if debug:
self.logger.debug("child node: (%s,%s)", c_elt.namespaceURI,
c_elt.tagName)
if what.name_match(c_elt):
# Parse value, and mark this one done.
try:
value = what.parse(c_elt, ps)
except EvaluateException, e:
#what = _get_substitute_element(c_elt, what)
#value = what.parse(c_elt, ps)
raise
if what.maxOccurs > 1:
if v.has_key(what.aname):
v[what.aname].append(value)
else:
v[what.aname] = [value]
c[j] = None
continue
else:
v[what.aname] = value
c[j] = None
break
else:
if debug:
self.logger.debug("no element (%s,%s)",
what.nspname, what.pname)
# No match; if it was supposed to be here, that's an error.
if self.inorder is True and i == j:
raise EvaluateException('Out of order complexType',
ps.Backtrace(c_elt))
else:
# only supporting 1 <any> declaration in content.
if isinstance(what,AnyElement):
any = what
elif hasattr(what, 'default'):
v[what.aname] = what.default
elif what.minOccurs > 0 and not v.has_key(what.aname):
raise EvaluateException('Element "' + what.aname + \
'" missing from complexType', ps.Backtrace(elt))
def parse(self, elt, ps):
debug = self.logger.debugOn()
debug and self.logger.debug('parse')
xtype = self.checkname(elt, ps)
if self.type and xtype not in [ self.type, (None,None) ]:
if not isinstance(self, TypeDefinition):
raise EvaluateException(\
'ComplexType for %s has wrong type(%s), looking for %s' %
(self.pname, self.checktype(elt,ps), self.type),
ps.Backtrace(elt))
else:
#TODO: mabye change MRO to handle this
debug and self.logger.debug('delegate to substitute type')
what = TypeDefinition.getSubstituteType(self, elt, ps)
return what.parse(elt, ps)
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Struct has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
c = _child_elements(elt)
count = len(c)
if self.nilled(elt, ps): return Nilled
# Create the object.
v = {}
# parse all attributes contained in attribute_typecode_dict (user-defined attributes),
# the values (if not None) will be keyed in self.attributes dictionary.
attributes = self.parse_attributes(elt, ps)
if attributes:
v[self.attrs_aname] = attributes
#MIXED
if self.mixed is True:
v[self.mixed_aname] = self.simple_value(elt,ps, mixed=True)
# Clone list of kids (we null it out as we process)
c, crange = c[:], range(len(c))
# Loop over all items we're expecting
if debug:
self.logger.debug("ofwhat: %s",str(self.ofwhat))
any = None
for i,what in [ (i, self.ofwhat[i]) for i in range(len(self.ofwhat)) ]:
# retrieve typecode if it is hidden
if callable(what): what = what()
# Loop over all available kids
if debug:
self.logger.debug("what: (%s,%s)", what.nspname, what.pname)
for j,c_elt in [ (j, c[j]) for j in crange if c[j] ]:
if debug:
self.logger.debug("child node: (%s,%s)", c_elt.namespaceURI,
c_elt.tagName)
if what.name_match(c_elt):
# Parse value, and mark this one done.
try:
value = what.parse(c_elt, ps)
except EvaluateException, e:
#what = _get_substitute_element(c_elt, what)
#value = what.parse(c_elt, ps)
raise
if what.maxOccurs > 1:
if v.has_key(what.aname):
v[what.aname].append(value)
else:
v[what.aname] = [value]
c[j] = None
continue
else:
v[what.aname] = value
c[j] = None
break
else:
if debug:
self.logger.debug("no element (%s,%s)",
what.nspname, what.pname)
# No match; if it was supposed to be here, that's an error.
if self.inorder is True and i == j:
raise EvaluateException('Out of order complexType',
ps.Backtrace(c_elt))
else:
# only supporting 1 <any> declaration in content.
if isinstance(what,AnyElement):
any = what
elif hasattr(what, 'default'):
v[what.aname] = what.default
elif what.minOccurs > 0 and not v.has_key(what.aname):
raise EvaluateException('Element "' + what.aname + \
'" missing from complexType', ps.Backtrace(elt))
def parse(self, elt, ps):
debug = self.logger.debugOn()
debug and self.logger.debug('parse')
xtype = self.checkname(elt, ps)
if self.type and xtype not in [self.type, (None, None)]:
if not isinstance(self, TypeDefinition):
raise EvaluateException(\
'ComplexType for %s has wrong type(%s), looking for %s' %
(self.pname, self.checktype(elt,ps), self.type),
ps.Backtrace(elt))
else:
#TODO: mabye change MRO to handle this
debug and self.logger.debug('delegate to substitute type')
what = TypeDefinition.getSubstituteType(self, elt, ps)
return what.parse(elt, ps)
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Struct has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
c = _child_elements(elt)
count = len(c)
if self.nilled(elt, ps): return Nilled
# Create the object.
v = {}
# parse all attributes contained in attribute_typecode_dict (user-defined attributes),
# the values (if not None) will be keyed in self.attributes dictionary.
attributes = self.parse_attributes(elt, ps)
if attributes:
v[self.attrs_aname] = attributes
#MIXED
if self.mixed is True:
v[self.mixed_aname] = self.simple_value(elt, ps, mixed=True)
# Clone list of kids (we null it out as we process)
c, crange = c[:], range(len(c))
# Loop over all items we're expecting
if debug:
self.logger.debug("ofwhat: %s", str(self.ofwhat))
any = None
for i, what in [(i, self.ofwhat[i]) for i in range(len(self.ofwhat))]:
# retrieve typecode if it is hidden
if callable(what): what = what()
# Loop over all available kids
if debug:
self.logger.debug("what: (%s,%s)", what.nspname, what.pname)
for j, c_elt in [(j, c[j]) for j in crange if c[j]]:
# Parse value, and mark this one done.
if debug:
self.logger.debug("child node: (%s,%s)",
c_elt.namespaceURI, c_elt.tagName)
match = False
if what.name_match(c_elt):
match = True
value = what.parse(c_elt, ps)
else:
# substitutionGroup head must be a global element declaration
# if successful delegate to matching GED
subwhat = _get_substitute_element(what, c_elt, ps)
if subwhat:
match = True
value = subwhat.parse(c_elt, ps)
if debug:
self.logger.debug("substitutionGroup: %s", subwhat)
if match:
if what.maxOccurs > 1:
if v.has_key(what.aname):
v[what.aname].append(value)
else:
v[what.aname] = [value]
c[j] = None
continue
else:
v[what.aname] = value
c[j] = None
break
if debug:
self.logger.debug("no element (%s,%s)", what.nspname,
what.pname)
# No match; if it was supposed to be here, that's an error.
if self.inorder is True and i == j:
raise EvaluateException('Out of order complexType',
ps.Backtrace(c_elt))
else:
# only supporting 1 <any> declaration in content.
if isinstance(what, AnyElement):
any = what
elif hasattr(what, 'default'):
v[what.aname] = what.default
elif what.minOccurs > 0 and not v.has_key(what.aname):
raise EvaluateException('Element "' + what.aname + \
'" missing from complexType', ps.Backtrace(elt))
# Look for wildcards and unprocessed children
# XXX Stick all this stuff in "any", hope for no collisions
if any is not None:
occurs = 0
v[any.aname] = []
for j, c_elt in [(j, c[j]) for j in crange if c[j]]:
value = any.parse(c_elt, ps)
if any.maxOccurs == UNBOUNDED or any.maxOccurs > 1:
v[any.aname].append(value)
else:
v[any.aname] = value
occurs += 1
# No such thing as nillable <any>
if any.maxOccurs == 1 and occurs == 0:
v[any.aname] = None
elif occurs < any.minOccurs or (any.maxOccurs != UNBOUNDED
and any.maxOccurs < occurs):
raise EvaluateException(
'occurances of <any> elements(#%d) bound by (%d,%s)' %
(occurs, any.minOccurs, str(any.maxOccurs)),
ps.Backtrace(elt))
if not self.pyclass:
return v
# type definition must be informed of element tag (nspname,pname),
# element declaration is initialized with a tag.
try:
pyobj = self.pyclass()
except Exception, e:
raise TypeError("Constructing element (%s,%s) with pyclass(%s), %s" \
%(self.nspname, self.pname, self.pyclass.__name__, str(e)))
def parse(self, elt, ps):
debug = self.logger.debugOn()
debug and self.logger.debug('parse')
xtype = self.checkname(elt, ps)
if self.type and xtype not in [ self.type, (None,None) ]:
if not isinstance(self, TypeDefinition):
raise EvaluateException(\
'ComplexType for %s has wrong type(%s), looking for %s' %
(self.pname, self.checktype(elt,ps), self.type),
ps.Backtrace(elt))
else:
#TODO: mabye change MRO to handle this
debug and self.logger.debug('delegate to substitute type')
what = TypeDefinition.getSubstituteType(self, elt, ps)
return what.parse(elt, ps)
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Struct has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
c = _child_elements(elt)
count = len(c)
if self.nilled(elt, ps): return Nilled
# Create the object.
v = {}
# parse all attributes contained in attribute_typecode_dict (user-defined attributes),
# the values (if not None) will be keyed in self.attributes dictionary.
attributes = self.parse_attributes(elt, ps)
if attributes:
v[self.attrs_aname] = attributes
#MIXED
if self.mixed is True:
v[self.mixed_aname] = self.simple_value(elt,ps, mixed=True)
# Clone list of kids (we null it out as we process)
c, crange = c[:], range(len(c))
# Loop over all items we're expecting
if debug:
self.logger.debug("ofwhat: %s",str(self.ofwhat))
any = None
for i,what in [ (i, self.ofwhat[i]) for i in range(len(self.ofwhat)) ]:
# retrieve typecode if it is hidden
if callable(what): what = what()
# Loop over all available kids
if debug:
self.logger.debug("what: (%s,%s)", what.nspname, what.pname)
for j,c_elt in [ (j, c[j]) for j in crange if c[j] ]:
# Parse value, and mark this one done.
if debug:
self.logger.debug("child node: (%s,%s)", c_elt.namespaceURI, c_elt.tagName)
match = False
if what.name_match(c_elt):
match = True
value = what.parse(c_elt, ps)
else:
# substitutionGroup head must be a global element declaration
# if successful delegate to matching GED
subwhat = _get_substitute_element(what, c_elt, ps)
if subwhat:
match = True
value = subwhat.parse(c_elt, ps)
if debug:
self.logger.debug("substitutionGroup: %s", subwhat)
if match:
if what.maxOccurs > 1:
if v.has_key(what.aname):
v[what.aname].append(value)
else:
v[what.aname] = [value]
c[j] = None
continue
else:
v[what.aname] = value
c[j] = None
break
if debug:
self.logger.debug("no element (%s,%s)", what.nspname, what.pname)
# No match; if it was supposed to be here, that's an error.
if self.inorder is True and i == j:
raise EvaluateException('Out of order complexType',
ps.Backtrace(c_elt))
else:
# only supporting 1 <any> declaration in content.
if isinstance(what,AnyElement):
any = what
elif hasattr(what, 'default'):
v[what.aname] = what.default
elif what.minOccurs > 0 and not v.has_key(what.aname):
raise EvaluateException('Element "' + what.aname + \
'" missing from complexType', ps.Backtrace(elt))
# Look for wildcards and unprocessed children
# XXX Stick all this stuff in "any", hope for no collisions
if any is not None:
occurs = 0
v[any.aname] = []
for j,c_elt in [ (j, c[j]) for j in crange if c[j] ]:
value = any.parse(c_elt, ps)
if any.maxOccurs == UNBOUNDED or any.maxOccurs > 1:
v[any.aname].append(value)
else:
v[any.aname] = value
occurs += 1
# No such thing as nillable <any>
if any.maxOccurs == 1 and occurs == 0:
v[any.aname] = None
elif occurs < any.minOccurs or (any.maxOccurs!=UNBOUNDED and any.maxOccurs<occurs):
raise EvaluateException('occurances of <any> elements(#%d) bound by (%d,%s)' %(
occurs, any.minOccurs,str(any.maxOccurs)), ps.Backtrace(elt))
if not self.pyclass:
return v
# type definition must be informed of element tag (nspname,pname),
# element declaration is initialized with a tag.
try:
pyobj = self.pyclass()
except Exception, e:
raise TypeError("Constructing element (%s,%s) with pyclass(%s), %s" \
%(self.nspname, self.pname, self.pyclass.__name__, str(e)))
def parse(self, elt, ps):
debug = self.logger.debugOn()
debug and self.logger.debug('parse')
xtype = self.checkname(elt, ps)
if self.type and xtype not in [self.type, (None, None)]:
if not isinstance(self, TypeDefinition):
raise EvaluateException(\
'ComplexType for %s has wrong type(%s), looking for %s' %
(self.pname, self.checktype(elt,ps), self.type),
ps.Backtrace(elt))
else:
#TODO: mabye change MRO to handle this
debug and self.logger.debug('delegate to substitute type')
what = TypeDefinition.getSubstituteType(self, elt, ps)
return what.parse(elt, ps)
href = _find_href(elt)
if href:
if _children(elt):
raise EvaluateException('Struct has content and HREF',
ps.Backtrace(elt))
elt = ps.FindLocalHREF(href, elt)
c = _child_elements(elt)
if self.nilled(elt, ps): return Nilled
# Create the object.
if self.pyclass:
# type definition must be informed of element tag (nspname,pname),
# element declaration is initialized with a tag.
try:
pyobj = self.pyclass()
except Exception as e:
raise TypeError("Constructing element (%s,%s) with pyclass(%s), %s" \
%(self.nspname, self.pname, self.pyclass.__name__, str(e)))
else:
pyobj = ComplexType._DictHolder()
# parse all attributes contained in attribute_typecode_dict (user-defined attributes),
# the values (if not None) will be keyed in self.attributes dictionary.
attributes = self.parse_attributes(elt, ps)
if attributes:
setattr(pyobj, self.attrs_aname, attributes)
#MIXED
if self.mixed is True:
setattr(pyobj, self.mixed_aname,
self.simple_value(elt, ps, mixed=True))
# Clone list of kids (we null it out as we process)
c, crange = c[:], list(range(len(c)))
# Loop over all items we're expecting
for j, c_elt in [(j, c[j]) for j in crange if c[j]]:
for i, what in [(i, self.ofwhat[i])
for i in range(len(self.ofwhat))]:
# retrieve typecode if it is hidden
if callable(what): what = what()
# Loop over all available kids
# if debug:
# self.logger.debug("what: (%s,%s)", what.nspname, what.pname)
# Parse value, and mark this one done.
# if debug:
# self.logger.debug("child node: (%s,%s)", c_elt.namespaceURI, c_elt.tagName)
match = False
if what.name_match(c_elt):
match = True
value = what.parse(c_elt, ps)
elif isinstance(what, AnyElement):
match = True
value = what.parse(c_elt, ps)
else:
# substitutionGroup head must be a global element declaration
# if successful delegate to matching GED
subwhat = _get_substitute_element(what, c_elt, ps)
if subwhat:
match = True
value = subwhat.parse(c_elt, ps)
if debug:
self.logger.debug("substitutionGroup: %s", subwhat)
if match:
if what.maxOccurs > 1:
attr = getattr(pyobj, what.aname, None)
if attr is not None:
attr.append(value)
else:
setattr(pyobj, what.aname, [value])
c[j] = None
continue
else:
setattr(pyobj, what.aname, value)
c[j] = None
break
if debug:
self.logger.debug("no element (%s,%s)", what.nspname,
what.pname)
# No match; if it was supposed to be here, that's an error.
if self.inorder is True and i == j:
raise EvaluateException('Out of order complexType',
ps.Backtrace(c_elt))
else:
if hasattr(what, 'default'):
setattr(pyobj, what.aname, what.default)
# elif what.minOccurs > 0 and not hasattr(pyobj, what.aname):
# raise EvaluateException('Element "' + what.aname + '" missing from complexType', ps.Backtrace(elt))
if isinstance(pyobj, ComplexType._DictHolder):
return pyobj.__dict__
return pyobj