Example #1
0
 def xml(self):
     """
     Get xml representation of the object.
     @return: The root node.
     @rtype: L{Element}
     """
     root = Element('Security', ns=wssens)
     root.set('mustUnderstand', str(self.mustUnderstand).lower())
     for t in self.tokens:
         root.append(t.xml())
     return root
Example #2
0
 def header(self, content):
     """
     Build the B{<Body/>} for an soap outbound message.
     @param content: The header content.
     @type content: L{Element}
     @return: the soap body fragment.
     @rtype: L{Element}
     """
     header = Element('Header', ns=envns)
     header.append(content)
     return header
Example #3
0
 def body(self, content):
     """
     Build the B{<Body/>} for an soap outbound message.
     @param content: The body content.
     @type content: L{Element}
     @return: the soap body fragment.
     @rtype: L{Element}
     """
     body = Element('Body', ns=envns)
     body.append(content)
     return body
Example #4
0
 def add(self, root):
     """
     Add an <xs:import/> to the specified schema root.
     @param root: A schema root.
     @type root: L{Element}
     """
     node = Element('import', ns=self.xsdns)
     node.set('namespace', self.ns)
     if self.location is not None:
         node.set('schemaLocation', self.location)
     log.debug('%s inserted', node)
     root.insert(node) 
Example #5
0
 def xml(self):
     root = Element("Timestamp", ns=wsuns)
     created = Element('Created', ns=wsuns)
     created.setText(str(UTC(self.created)))
     expires = Element('Expires', ns=wsuns)
     expires.setText(str(UTC(self.expires)))
     root.append(created)
     root.append(expires)
     return root
Example #6
0
 def startElement(self, name, attrs):
     top = self.top()
     node = Element(unicode(name))
     for a in attrs.getNames():
         n = unicode(a)
         v = unicode(attrs.getValue(a))
         attribute = Attribute(n,v)
         if self.mapPrefix(node, attribute):
             continue
         node.append(attribute)
     node.charbuffer = []
     top.append(node)
     self.push(node)
Example #7
0
 def node(self, content):
     #
     # Create an XML node and namespace qualify as defined
     # by the schema (elementFormDefault).
     #
     ns = content.type.namespace()
     if content.type.form_qualified:
         node = Element(content.tag, ns=ns)
         if ns[0]:
             node.addPrefix(ns[0], ns[1])
     else:
         node = Element(content.tag)
     self.encode(node, content)
     log.debug('created - node:\n%s', node)
     return node
Example #8
0
 def apply(self, root):
     """
     Apply the import (rule) to the specified schema.
     If the schema does not already contain an import for the
     I{namespace} specified here, it is added.
     @param root: A schema root.
     @type root: L{Element}
     """
     if not self.filter.match(root, self.ns):
         return
     if self.exists(root):
         return
     node = Element('import', ns=self.xsdns)
     node.set('namespace', self.ns)
     if self.location is not None:
         node.set('schemaLocation', self.location)
     log.debug('inserting: %s', node)
     root.insert(node)
Example #9
0
 def autoblend(self):
     """
     Ensure that all schemas within the collection
     import each other which has a blending effect.
     @return: self
     @rtype: L{SchemaCollection}
     """
     namespaces = self.namespaces.keys()
     for s in self.children:
         for ns in namespaces:
             tns = s.root.get('targetNamespace')
             if  tns == ns:
                 continue
             for imp in s.root.getChildren('import'):
                 if imp.get('namespace') == ns:
                     continue
             imp = Element('import', ns=Namespace.xsdns)
             imp.set('namespace', ns)
             s.root.append(imp)
     return self
Example #10
0
 def append(self, node):
     """
     Append (set) the document root.
     @param node: A root L{Element} or name used to build
         the document root element.
     @type node: (L{Element}|str|None)
     """
     if isinstance(node, basestring):
         self.__root = Element(node)
         return
     if isinstance(node, Element):
         self.__root = node
         return
Example #11
0
 def envelope(self, header, body):
     """
     Build the B{<Envelope/>} for an soap outbound message.
     @param header: The soap message B{header}.
     @type header: L{Element}
     @param body: The soap message B{body}.
     @type body: L{Element}
     @return: The soap envelope containing the body and header.
     @rtype: L{Element}
     """
     env = Element('Envelope', ns=envns)
     env.addPrefix(Namespace.xsins[0], Namespace.xsins[1])
     env.append(header)
     env.append(body)
     return env
Example #12
0
 def build_schema(self):
     """ Process L{Types} objects and create the schema collection """
     container = SchemaCollection(self)
     for t in [t for t in self.types if t.local()]:
         for root in t.contents():
             schema = Schema(root, self.url, self.options, container)
             yield schema.load()
             container.add(schema)
     if not len(container): # empty
         root = Element.buildPath(self.root, 'types/schema')
         schema = Schema(root, self.url, self.options, container)
         yield schema.load()
         container.add(schema)
     self.schema = yield container.load(self.options)
     for s in [t.schema() for t in self.types if t.imported()]:
         self.schema.merge(s)
     raise gen.Return(self.schema)
Example #13
0
 def add_operations(self, root, definitions):
     """ Add <operation/> children """
     dsop = Element('operation', ns=soapns)
     for c in root.getChildren('operation'):
         op = Facade('Operation')
         op.name = c.get('name')
         sop = c.getChild('operation', default=dsop)
         soap = Facade('soap')
         soap.action = '"%s"' % sop.get('soapAction', default='')
         soap.style = sop.get('style', default=self.soap.style)
         soap.input = Facade('Input')
         soap.input.body = Facade('Body')
         soap.input.headers = []
         soap.output = Facade('Output')
         soap.output.body = Facade('Body')
         soap.output.headers = []
         op.soap = soap
         input = c.getChild('input')
         if input is None:
             input = Element('input', ns=wsdlns)
         body = input.getChild('body')
         self.body(definitions, soap.input.body, body)
         for header in input.getChildren('header'):
             self.header(definitions, soap.input, header)
         output = c.getChild('output')
         if output is None:
             output = Element('output', ns=wsdlns)
         body = output.getChild('body')
         self.body(definitions, soap.output.body, body)
         for header in output.getChildren('header'):
             self.header(definitions, soap.output, header)
         faults = []
         for fault in c.getChildren('fault'):
             sf = fault.getChild('fault')
             if sf is None:
                 continue
             fn = fault.get('name')
             f = Facade('Fault')
             f.name = sf.get('name', default=fn)
             f.use = sf.get('use', default='literal')
             faults.append(f)
         soap.faults = faults
         self.operations[op.name] = op
Example #14
0
 def __init__(self, content):
     Element.__init__(self, content.name, content.parent)
     self.__content = content
Example #15
0
 def xml(self):
     """
     Get xml representation of the object.
     @return: The root node.
     @rtype: L{Element}
     """
     root = Element('UsernameToken', ns=wssens)
     u = Element('Username', ns=wssens)
     u.setText(self.username)
     root.append(u)
     p = Element('Password', ns=wssens)
     p.setText(self.password)
     root.append(p)
     if self.nonce is not None:
         n = Element('Nonce', ns=wssens)
         n.setText(self.nonce)
         root.append(n)
     if self.created is not None:
         n = Element('Created', ns=wsuns)
         n.setText(str(UTC(self.created)))
         root.append(n)
     return root
Example #16
0
class Document:
    """ An XML Document """
    
    DECL = '<?xml version="1.0" encoding="UTF-8"?>'

    def __init__(self, root=None):
        """
        @param root: A root L{Element} or name used to build
            the document root element.
        @type root: (L{Element}|str|None)
        """
        self.__root = None
        self.append(root)    

    def root(self):
        """
        Get the document root element (can be None)
        @return: The document root.
        @rtype: L{Element}
        """
        return self.__root
        
    def append(self, node):
        """
        Append (set) the document root.
        @param node: A root L{Element} or name used to build
            the document root element.
        @type node: (L{Element}|str|None)
        """
        if isinstance(node, basestring):
            self.__root = Element(node)
            return
        if isinstance(node, Element):
            self.__root = node
            return
        
    def getChild(self, name, ns=None, default=None):
        """
        Get a child by (optional) name and/or (optional) namespace.
        @param name: The name of a child element (may contain prefix).
        @type name: basestring
        @param ns: An optional namespace used to match the child.
        @type ns: (I{prefix}, I{name})
        @param default: Returned when child not-found.
        @type default: L{Element}
        @return: The requested child, or I{default} when not-found.
        @rtype: L{Element}
        """
        if self.__root is None:
            return default
        if ns is None:
            prefix, name = splitPrefix(name)
            if prefix is None:
                ns = None
            else:
                ns = self.__root.resolvePrefix(prefix)
        if self.__root.match(name, ns):
            return self.__root
        else:
            return default
        
    def childAtPath(self, path):
        """
        Get a child at I{path} where I{path} is a (/) separated
        list of element names that are expected to be children.
        @param path: A (/) separated list of element names.
        @type path: basestring
        @return: The leaf node at the end of I{path}
        @rtype: L{Element}
        """
        if self.__root is None:
            return None
        if path[0] == '/':
            path = path[1:]
        path = path.split('/',1)
        if self.getChild(path[0]) is None:
            return None
        if len(path) > 1:
            return self.__root.childAtPath(path[1])
        else:
            return self.__root
        
    def childrenAtPath(self, path):
        """
        Get a list of children at I{path} where I{path} is a (/) separated
        list of element names that are expected to be children.
        @param path: A (/) separated list of element names.
        @type path: basestring
        @return: The collection leaf nodes at the end of I{path}
        @rtype: [L{Element},...]
        """
        if self.__root is None:
            return []
        if path[0] == '/':
            path = path[1:]
        path = path.split('/',1)
        if self.getChild(path[0]) is None:
            return []
        if len(path) > 1:
            return self.__root.childrenAtPath(path[1])
        else:
            return [self.__root,]
        
    def getChildren(self, name=None, ns=None):
        """
        Get a list of children by (optional) name and/or (optional) namespace.
        @param name: The name of a child element (may contain prefix).
        @type name: basestring
        @param ns: An optional namespace used to match the child.
        @type ns: (I{prefix}, I{name})
        @return: The list of matching children.
        @rtype: [L{Element},...]
        """
        if name is None:
            matched = self.__root
        else:
            matched = self.getChild(name, ns)
        if matched is None:
            return []
        else:
            return [matched,]
        
    def str(self):
        """
        Get a string representation of this XML document.
        @return: A I{pretty} string.
        @rtype: basestring
        """
        s = []
        s.append(self.DECL)
        root = self.root()
        if root is not None:
            s.append('\n')
            s.append(root.str())
        return ''.join(s)
    
    def plain(self):
        """
        Get a string representation of this XML document.
        @return: A I{plain} string.
        @rtype: basestring
        """
        s = []
        s.append(self.DECL)
        root = self.root()
        if root is not None:
            s.append(root.plain())
        return ''.join(s)

    def __str__(self):
        return unicode(self).encode('utf-8')
    
    def __unicode__(self):
        return self.str()