def FindLocalHREF(self, href, elt, headers=1):
'''Find a local HREF in the data elements.
'''
if href[0] != '#':
raise EvaluateException(
'Absolute HREF ("%s") not implemented' % href,
self.Backtrace(elt))
frag = href[1:]
# Already found?
e = self.id_cache.get(frag)
if e: return e
# Do a breadth-first search, in the data first. Most likely
# to find multi-ref targets shallow in the data area.
list = self.data_elements[:] + [self.body_root]
if headers: list.extend(self.header_elements)
while list:
e = list.pop()
if e.nodeType == _Node.ELEMENT_NODE:
nodeid = _find_id(e)
if nodeid:
self.id_cache[nodeid] = e
if nodeid == frag: return e
list += _children(e)
raise EvaluateException('''Can't find node for HREF "%s"''' % href,
self.Backtrace(elt))
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 getSubstituteType(self, elt, ps):
'''if xsi:type does not match the instance type attr,
check to see if it is a derived type substitution.
DONT Return the element's type.
Parameters:
elt -- the DOM element being parsed
ps -- the ParsedSoap object.
'''
pyclass = SchemaInstanceType.getTypeDefinition(*self.type)
if pyclass is None:
raise EvaluateException(
'No Type registed for xsi:type=(%s, %s)' %
(self.type[0], self.type[1]), ps.Backtrace(elt))
typeName = _find_type(elt)
prefix, typeName = SplitQName(typeName)
uri = ps.GetElementNSdict(elt).get(prefix)
subclass = SchemaInstanceType.getTypeDefinition(uri, typeName)
if subclass is None:
raise EvaluateException(
'No registered xsi:type=(%s, %s), substitute for xsi:type=(%s, %s)'
% (uri, typeName, self.type[0], self.type[1]),
ps.Backtrace(elt))
if not issubclass(subclass, pyclass) and subclass(
None) and not issubclass(subclass, pyclass):
raise TypeError(
'Substitute Type (%s, %s) is not derived from %s' %
(self.type[0], self.type[1], pyclass), ps.Backtrace(elt))
return subclass((self.nspname, self.pname))
def parse_position(self, elt, ps):
o = _find_arrayposition(elt)
if not o: return None
if o.find(',') > -1:
raise EvaluateException('Sorry, no multi-dimensional arrays',
ps.Backtrace(elt))
if not _position_pat.match(o):
raise EvaluateException('Bad array position "' + o + '"',
ps.Backtrace(elt))
return int(o[1:-1])
def ResolveHREF(self, uri, tc, **keywords):
r = getattr(tc, 'resolver', self.resolver)
if not r:
raise EvaluateException('No resolver for "' + uri + '"')
try:
if type(uri) == types.UnicodeType: uri = str(uri)
retval = r(uri, tc, self, **keywords)
except Exception, e:
raise EvaluateException('''Can't resolve "''' + uri + '" (' + \
str(e.__class__) + "): " + str(e))
def text_to_data(self, text, elt, ps):
'''convert text into typecode specific data.
'''
if text is None:
return None
m = Duration.lex_pattern.match(text)
if m is None:
raise EvaluateException('Illegal duration', ps.Backtrace(elt))
d = m.groupdict()
if d['T'] and (d['h'] is None and d['m'] is None and d['s'] is None):
raise EvaluateException('Duration has T without time')
try:
retval = _dict_to_tuple(d)
except ValueError, e:
raise EvaluateException(str(e))
def parse_offset(self, elt, ps):
o = _find_arrayoffset(elt)
if not o: return 0
if not _offset_pat.match(o):
raise EvaluateException('Bad offset "' + o + '"',
ps.Backtrace(elt))
return int(o[1:-1])
def XML(self, uri, tc, ps, **keywords):
content = self.get(uri)
if content:
dom = ps.readerclass().fromStream(content)
return _child_elements(dom)[0]
if not self.next: raise EvaluateException("Unresolvable URI " + uri)
return self.next.XML(uri, tc, ps, **keywords)
def parse(self, elt, ps):
val = Decimal.parse(self, elt, ps)
if val not in self.choices:
raise EvaluateException('Value "' + str(val) + \
'" not in enumeration list',
ps.Backtrace(elt))
return val
def text_to_data(self, text, elt, ps):
'''convert text into typecode specific data.
'''
if text is None:
return None
m = self.lex_pattern.match(text)
if not m:
raise EvaluateException('Bad Gregorian: %s' %text, ps.Backtrace(elt))
try:
retval = _dict_to_tuple(m.groupdict())
except ValueError, e:
#raise EvaluateException(str(e))
raise
def cb(self, elt, sw, pyobj, name=None, **kw):
debug = self.logger.debugOn()
if debug:
self.logger.debug("cb: %s" % str(self.ofwhat))
objid = _get_idstr(pyobj)
ns, n = self.get_name(name, objid)
if pyobj is None:
if self.nillable is True:
elem = elt.createAppendElement(ns, n)
self.serialize_as_nil(elem)
return
raise EvaluateException, 'element(%s,%s) is not nillable(%s)' % (
self.nspname, self.pname, self.nillable)
if self.mutable is False and sw.Known(pyobj):
return
if debug:
self.logger.debug("element: (%s, %s)", str(ns), n)
if n is not None:
elem = elt.createAppendElement(ns, n)
self.set_attributes(elem, pyobj)
if kw.get('typed', self.typed) is True:
self.set_attribute_xsi_type(elem)
#MIXED For now just stick it in front.
if self.mixed is True and self.mixed_aname is not None:
if hasattr(pyobj, self.mixed_aname):
textContent = getattr(pyobj, self.mixed_aname)
if hasattr(textContent, 'typecode'):
textContent.typecode.serialize_text_node(
elem, sw, textContent)
elif type(textContent) in _stringtypes:
if debug:
self.logger.debug("mixed text content:\n\t%s",
textContent)
elem.createAppendTextNode(textContent)
else:
raise EvaluateException(
'mixed test content in element (%s,%s) must be a string type'
% (self.nspname, self.pname), sw.Backtrace(elt))
else:
if debug:
self.logger.debug("mixed NO text content in %s",
self.mixed_aname)
else:
#For information items w/o tagNames
# ie. model groups,SOAP-ENC:Header
elem = elt
if self.inline:
pass
elif not self.inline and self.unique:
raise EvaluateException(
'Not inline, but unique makes no sense. No href/id.',
sw.Backtrace(elt))
elif n is not None:
self.set_attribute_id(elem, objid)
if self.pyclass and type(self.pyclass) is type:
f = lambda attr: getattr(pyobj, attr, None)
elif self.pyclass:
d = pyobj.__dict__
f = lambda attr: d.get(attr)
else:
d = pyobj
f = lambda attr: pyobj.get(attr)
if TypeCode.typechecks and type(d) != types.DictType:
raise TypeError("Classless complexType didn't get dictionary")
indx, lenofwhat = 0, len(self.ofwhat)
if debug:
self.logger.debug('element declaration (%s,%s)', self.nspname,
self.pname)
if self.type:
self.logger.debug('xsi:type definition (%s,%s)', self.type[0],
self.type[1])
else:
self.logger.warning('NO xsi:type')
while indx < lenofwhat:
occurs = 0
what = self.ofwhat[indx]
# retrieve typecode if hidden
if callable(what): what = what()
if debug:
self.logger.debug('serialize what -- %s',
what.__class__.__name__)
# No way to order <any> instances, so just grab any unmatched
# anames and serialize them. Only support one <any> in all content.
# Must be self-describing instances
# Regular handling of declared elements
aname = what.aname
v = f(aname)
indx += 1
if what.minOccurs == 0 and v is None:
continue
# Default to typecode, if self-describing instance, and check
# to make sure it is derived from what.
whatTC = what
if whatTC.maxOccurs > 1 and v is not None:
if type(v) not in _seqtypes:
raise EvaluateException(
'pyobj (%s,%s), aname "%s": maxOccurs %s, expecting a %s'
% (self.nspname, self.pname, what.aname,
whatTC.maxOccurs, _seqtypes), sw.Backtrace(elt))
for v2 in v:
occurs += 1
if occurs > whatTC.maxOccurs:
raise EvaluateException(
'occurances (%d) exceeded maxOccurs(%d) for <%s>' %
(occurs, whatTC.maxOccurs, what.pname),
sw.Backtrace(elt))
what = _get_type_or_substitute(whatTC, v2, sw, elt)
if debug and what is not whatTC:
self.logger.debug('substitute derived type: %s' %
what.__class__)
what.serialize(elem, sw, v2, **kw)
# try:
# what.serialize(elem, sw, v2, **kw)
# except Exception, e:
# raise EvaluateException('Serializing %s.%s, %s %s' %
# (n, whatTC.aname or '?', e.__class__.__name__, str(e)))
if occurs < whatTC.minOccurs:
raise EvaluateException(\
'occurances(%d) less than minOccurs(%d) for <%s>' %
(occurs, whatTC.minOccurs, what.pname), sw.Backtrace(elt))
continue
if v is not None or what.nillable is True:
what = _get_type_or_substitute(whatTC, v, sw, elt)
if debug and what is not whatTC:
self.logger.debug('substitute derived type: %s' %
what.__class__)
what.serialize(elem, sw, v, **kw)
# try:
# what.serialize(elem, sw, v, **kw)
# except (ParseException, EvaluateException), e:
# raise
# except Exception, e:
# raise EvaluateException('Serializing %s.%s, %s %s' %
# (n, whatTC.aname or '?', e.__class__.__name__, str(e)),
# sw.Backtrace(elt))
continue
raise EvaluateException(
'Got None for nillable(%s), minOccurs(%d) element (%s,%s), %s'
% (what.nillable, what.minOccurs, what.nspname, what.pname,
elem), sw.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 _check_allowed(self, uri):
for a in self.allowed:
if uri.startswith(a): return
raise EvaluateException("Disallowed URI prefix")
def Opaque(self, uri, tc, ps, **keywords):
content = self.get(uri)
if content: return content.getvalue()
if not self.next: raise EvaluateException("Unresolvable URI " + uri)
return self.next.Opaque(uri, tc, ps, **keywords)
def serialize(self, elt, sw, pyobj, name=None, orig=None, **kw):
if pyobj not in self.choices:
raise EvaluateException('Value not in int enumeration list',
ps.Backtrace(elt))
Decimal.serialize(self, elt, sw, pyobj, name=name, orig=orig, **kw)