Exemple #1
0
 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))
Exemple #2
0
 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
Exemple #3
0
    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))
Exemple #4
0
 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])
Exemple #5
0
 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))
Exemple #6
0
 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))
Exemple #7
0
 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)
Exemple #9
0
 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
Exemple #10
0
 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
Exemple #11
0
    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))
Exemple #12
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.
        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)))
Exemple #13
0
 def _check_allowed(self, uri):
     for a in self.allowed:
         if uri.startswith(a): return
     raise EvaluateException("Disallowed URI prefix")
Exemple #14
0
 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)
Exemple #15
0
 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)