Esempio n. 1
0
    def envelope(self, headers, body, bodytag=None):
        '''
        Build a SOAP envelope given headers and body.
        '''
        env = ET.Element(ns.expand('soapenv:Envelope', self.nsmap), nsmap=self.nsmap)
        envheader = ET.Element(ns.expand('soapenv:Header', self.nsmap))
        envbody = ET.Element(ns.expand('soapenv:Body', self.nsmap))
        env.append(envheader)
        env.append(envbody)

        for header in headers:
            if not ET.iselement(header):
                if hasattr(header, '__xml__'):
                    header = header.__xml__()
                else:
                    raise Exception('Cannott create SOAP:header')
            envheader.append(header)
        if body is not None:
            if not ET.iselement(body):
                if hasattr(body, '__xml__'):
                    body = body.__xml__(tag=bodytag)
                else:
                    raise Exception('Cannot create SOAP:body')
            envbody.append(body)
        return env
Esempio n. 2
0
    def __xml__(self, tag=None, node=None, nsmap=None, ignore=[]):
        '''
        Convert a DynamicObject to XML elements

        @type tag: str
        @param tag: Optional.  The name of the tag of the root node.
        @type node: L{ElementTree.Element}
        @param node: Optional.  A root node to populate.
        @type nsmap: dict
        @param nsmap: Optional.  A dictionary of namespace prefixes and namespaces to use.
        @type ignore: list
        @param ignore: Optional.  A list of fields to ignore during serialization to XML.
        @rtype: L{ElementTree.Element}
        @return: An XML Element representing this object.
        '''
        at = self.__attrchar__
        prop = self.__property__
        if tag is None:
            tag = self.__class__.__name__
        tag = self.__nsx__(tag)
        if node is None:
            node = ET.Element(tag, nsmap=nsmap)

        for key, value in self:
            if key in ignore:
                continue
            if key[0] == at:
                node.set(key[1:], unicode(value))
                continue
            name = self.__nsx__(key)
            if key == prop:
                node.text = unicode(value)
                continue
            if not isinstance(value, (list, tuple)):
                value = [value]
            for v in value:
                if isinstance(v, DynamicObject):
                    node.append(v.__xml__(key))
                elif ET.iselement(v):
                    node.append(v)
                else:
                    n = ET.Element(name)
                    if v is not None:
                        n.text = unicode(v)
                    node.append(n)
        return node
Esempio n. 3
0
    def load(self,
             schema,
             force=False,
             fragment=False,
             pathinfo='',
             basecls=None):
        '''
        Load and pre-process an XML schema.

        @type schema: L{ElementTree.Element} or URL
        @param schema: A schema to load.
        @type force: bool
        @param force: Optional.  Reload an already loaded schema.
        @type fragment: bool
        @param fragment: Optional.  The schema is actually a fragment of a
            an already-loaded schema and should be integrated with it.
        @type pathinfo: str
        @param pathinfo: Optional.  A URL to help with loading the schema.
            Usually used by SchemaLoader to process xs:import directives.
        @rtype: str
        @return: The targetNamespace of the loaded schema
        '''
        # Is schema already parsed
        if ET.iselement(schema):
            root = schema
        else:
            schema = urljoin(pathinfo, schema)
            root = ET.parse(u2.urlopen(schema)).getroot()

        # Get the target namespace.  Exit early if we already know this schema.
        targetNamespace = root.get('targetNamespace')
        if targetNamespace in self.schemas and not (force or fragment):
            return targetNamespace

        # Add a new entry to our dictionary
        if not fragment:
            self.schemas[targetNamespace] = {
                'root': root,
                'types': {},
                'elements': {},
                'groups': {},
                'validator': None,
                'basecls': basecls
            }

        # Update our "all namespaces" dictionary and get references to the
        # various subdictionaries we'll need
        self.allns.update(root.nsmap)
        self.revns.update(
            (v, k) for k, v in root.nsmap.items() if k not in (None, 'tns'))
        types = self.schemas[targetNamespace]['types']
        elements = self.schemas[targetNamespace]['elements']
        groups = self.schemas[targetNamespace]['groups']

        # Process includes
        includes = []
        while True:
            # Get the list of includes
            inclist = root.findall(ns.expand('xs:include'))
            if not inclist:
                break

            for el in inclist:
                # remove it from the document
                root.remove(el)

                # Get the schemaLocation and compute the URL
                location = el.get('schemaLocation')
                if location in includes:
                    # skip if we've processed this schema
                    continue
                includes.append(location)
                url = urljoin(pathinfo, location)

                # Parse the XML and append it to the root document
                # We probably *should* include it into the place where the
                # xs:include node was, but for now, punt and append it
                # to the end of the document
                inc = ET.parse(u2.urlopen(url)).getroot()
                root.extend(inc)

        # Process imports
        for el in root.findall(ns.expand('xs:import')):
            location = el.get('schemaLocation')
            if location:
                self.load(location, pathinfo=pathinfo)
        # Find all first-level tags we care about and reference them
        # in the types/elements/groups dictionaries
        for el in root.findall(ns.expand('xs:complexType')):
            types[el.get('name')] = el
        for el in root.findall(ns.expand('xs:simpleType')):
            types[el.get('name')] = el
        for el in root.findall(ns.expand('xs:element')):
            elements[el.get('name')] = el
        for el in root.findall(ns.expand('xs:group')):
            groups[el.get('name')] = el

        # If this is a schema fragment, integrate it into the
        # original schema element tree in memory
        if fragment:
            realroot = self.schemas[targetNamespace]['root']
            nsmap = dict(realroot.nsmap)
            nsmap.update(root.nsmap)
            attrib = dict(realroot.attrib)
            attrib.update(root.attrib)
            newroot = ET.Element(realroot.tag, attrib=attrib, nsmap=nsmap)
            newroot.text = realroot.text

            newroot.extend(realroot.getchildren())
            newroot.extend(root.getchildren())
            self.schemas[targetNamespace]['root'] = newroot

        return targetNamespace
Esempio n. 4
0
    def __xml__(self, tag=None, node=None, nsmap=None):
        lat = len(self.__attrchar__)
        done = []
        extra = False
        if tag is None:
            tag = self.__class__.__name__
        tag = self.__nsx__(tag)
        if node is None:
            node = ET.Element(tag, nsmap=nsmap)

        # Construct reverse namespace map for doing xsi:type
        rmap = dict((v, k) for k, v in node.nsmap.items() if k is not None)

        # Iterate over the template to construct the XML representation.
        for (name, type, default, minmax, flags) in self.__template__:
            # If this field is an "xs:any" node, note it for later and skip
            if (flags & ANY):
                extra = True
                continue
            # If the field is choice/optional and doesn't exist, skip it
            if ((flags & CHOICE) or minmax[0] == 0) and name not in self:
                continue
            # Get the value
            value = self[name]
            done.append(name)

            if value is None and minmax[0] == 0 and not (flags & XSINIL):
                # Skip fields that are none and don't have to exist, as long
                # as they aren't nillable
                continue
            elif (flags & ATTRIBUTE):
                # Handle attributes.  Skip attributes that are optional
                value = converter(type).tostr(value)
                if value is None:
                    value = ''
                if value is not None or minmax[0]:
                    node.set(self.__nsx__(name[lat:], flags & QUALIFIED),
                             value)
                continue
            elif (flags & PROPERTY):
                # Property
                node.text = converter(type).tostr(value)
                continue

            qname = self.__nsx__(name)
            if not isinstance(value, (list, tuple)):
                value = [value]
            for v in value:
                if v is None and (flags & XSINIL):
                    # Nil node
                    n = ET.Element(qname, xsi_nil_true)
                    node.append(n)
                elif ET.iselement(v):
                    # User supplied XML Elements, so just add them
                    node.append(v)
                elif type.startswith('xs:'):
                    # Primitive type
                    n = ET.Element(qname)
                    n.text = converter(type).tostr(v)
                    node.append(n)
                elif flags & SIMPLE:
                    # Primitive type
                    type = self.__builder__.factory(type).__simple__
                    n = ET.Element(qname)
                    n.text = converter(type).tostr(v)
                    node.append(n)
                elif isinstance(v, DynamicObject):
                    # Dynamic object or subclass, so marshall and append
                    n = v.__xml__(name)
                    if type != v.__class__.__name__:
                        (namespace, datatype) = ns.split(v.__class__.__name__)
                        n.set(xsi_type, '%s:%s' % (rmap[namespace], datatype))
                    node.append(n)
                elif v == '':
                    # Carry-over for dealing with SUDS bug
                    pass
                else:
                    if not self.__relax__:
                        raise TypeError('Unknown type', name, type)

        # If there was an xs:any node, fall back to the schemaless marshaller
        # in the base class
        if extra:
            DynamicObject.__xml__(self, tag, node, ignore=done)
        return node