Logo Search packages:      
Sourcecode: suds version File versions  Download package


# This program is free software; you can redistribute it and/or modify
# it under the terms of the (LGPL) GNU Lesser General Public License as
# published by the Free Software Foundation; either version 3 of the 
# License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# GNU Library Lesser General Public License for more details at
# ( http://www.gnu.org/licenses/lgpl.html ).
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# written by: Jeff Ortel ( jortel@redhat.com )

The I{schema} module provides a intelligent representation of
an XSD schema.  The I{raw} model is the XML tree and the I{model}
is the denormalized, objectified and intelligent view of the schema.
Most of the I{value-add} provided by the model is centered around
tranparent referenced type resolution and targeted denormalization.

from logging import getLogger
import suds.metrics
from suds import *
from suds.xsd import *
from suds.xsd.sxbuiltin import *
from suds.xsd.sxbasic import Factory as BasicFactory
from suds.xsd.sxbuiltin import Factory as BuiltinFactory
from suds.xsd.sxbase import SchemaObject
from suds.xsd.deplist import DepList
from suds.sax.element import Element
from suds.sax import splitPrefix, Namespace
from suds.plugin import PluginContainer

log = getLogger(__name__)

00041 class SchemaCollection:
    A collection of schema objects.  This class is needed because WSDLs 
    may contain more then one <schema/> node.
    @ivar wsdl: A wsdl object.
    @type wsdl: L{suds.wsdl.Definitions}
    @ivar children: A list contained schemas.
    @type children: [L{Schema},...]
    @ivar namespaces: A dictionary of contained schemas by namespace.
    @type namespaces: {str:L{Schema}}
00053     def __init__(self, wsdl):
        @param wsdl: A wsdl object.
        @type wsdl: L{suds.wsdl.Definitions}
        self.wsdl = wsdl
        self.children = []
        self.namespaces = {}
00062     def add(self, schema):
        Add a schema node to the collection.  Schema(s) within the same target
        namespace are consolidated.
        @param schema: A schema object.
        @type schema: (L{Schema})
        key = schema.tns[1]
        existing = self.namespaces.get(key)
        if existing is None:
            self.namespaces[key] = schema
            existing.root.children += schema.root.children
00078     def load(self, options):
        Load the schema objects for the root nodes.
            - de-references schemas
            - merge schemas
        @param options: An options dictionary.
        @type options: L{options.Options}
        @return: The merged schema.
        @rtype: L{Schema}
        if options.autoblend:
        for child in self.children:
        for child in self.children:
        for child in self.children:
        log.debug('loaded:\n%s', self)
        merged = self.merge()
        log.debug('MERGED:\n%s', merged)
        return merged
00101     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:
                for imp in s.root.getChildren('import'):
                    if imp.get('namespace') == ns:
                imp = Element('import', ns=Namespace.xsdns)
                imp.set('namespace', ns)
        return self
00122     def locate(self, ns):
        Find a schema by namespace.  Only the URI portion of
        the namespace is compared to each schema's I{targetNamespace}
        @param ns: A namespace.
        @type ns: (prefix,URI)
        @return: The schema matching the namesapce, else None.
        @rtype: L{Schema}
        return self.namespaces.get(ns[1])
00133     def merge(self):
        Merge the contained schemas into one.
        @return: The merged schema.
        @rtype: L{Schema}
        if len(self):
            schema = self.children[0]
            for s in self.children[1:]:
            return schema
            return None
    def __len__(self):
        return len(self.children)
    def __str__(self):
        return unicode(self).encode('utf-8')
    def __unicode__(self):
        result = ['\nschema collection']
        for s in self.children:
        return '\n'.join(result)

00160 class Schema:
    The schema is an objectification of a <schema/> (xsd) definition.
    It provides inspection, lookup and type resolution.
    @ivar root: The root node.
    @type root: L{sax.element.Element}
    @ivar baseurl: The I{base} URL for this schema.
    @type baseurl: str
    @ivar container: A schema collection containing this schema.
    @type container: L{SchemaCollection}
    @ivar children: A list of direct top level children.
    @type children: [L{SchemaObject},...]
    @ivar all: A list of all (includes imported) top level children.
    @type all: [L{SchemaObject},...]
    @ivar types: A schema types cache.
    @type types: {name:L{SchemaObject}}
    @ivar imports: A list of import objects.
    @type imports: [L{SchemaObject},...]
    @ivar elements: A list of <element/> objects.
    @type elements: [L{SchemaObject},...]
    @ivar attributes: A list of <attribute/> objects.
    @type attributes: [L{SchemaObject},...]
    @ivar groups: A list of group objects.
    @type groups: [L{SchemaObject},...]
    @ivar agrps: A list of attribute group objects.
    @type agrps: [L{SchemaObject},...]
    @ivar form_qualified: The flag indicating:
    @type form_qualified: bool
    Tag = 'schema'
00193     def __init__(self, root, baseurl, options, container=None):
        @param root: The xml root.
        @type root: L{sax.element.Element}
        @param baseurl: The base url used for importing.
        @type baseurl: basestring
        @param options: An options dictionary.
        @type options: L{options.Options}
        @param container: An optional container.
        @type container: L{SchemaCollection}
        self.root = root
        self.id = objid(self)
        self.tns = self.mktns()
        self.baseurl = baseurl
        self.container = container
        self.children = []
        self.all = []
        self.types = {}
        self.imports = []
        self.elements = {}
        self.attributes = {}
        self.groups = {}
        self.agrps = {}
        plugins = PluginContainer(options.plugins)
        if options.doctor is not None:
        form = self.root.get('elementFormDefault')
        if form is None:
            self.form_qualified = False
            self.form_qualified = ( form == 'qualified' )
        if container is None:
            log.debug('built:\n%s', self)
            log.debug('dereferenced:\n%s', self)
00233     def mktns(self):
        Make the schema's target namespace.
        @return: The namespace representation of the schema's
            targetNamespace value.
        @rtype: (prefix, uri)
        tns = [None, self.root.get('targetNamespace')]
        if tns[1] is not None:
            tns[0] = self.root.findPrefix(tns[1])
        return tuple(tns)
00245     def build(self):
        Build the schema (object graph) using the root node
        using the factory.
            - Build the graph.
            - Collate the children.
        self.children = BasicFactory.build(self.root, self)
        collated = BasicFactory.collate(self.children)
        self.children = collated[0]
        self.attributes = collated[2]
        self.imports = collated[1]
        self.elements = collated[3]
        self.types = collated[4]
        self.groups = collated[5]
        self.agrps = collated[6]
00262     def merge(self, schema):
        Merge the contents from the schema.  Only objects not already contained
        in this schema's collections are merged.  This is to provide for bidirectional
        import which produce cyclic includes.
        @returns: self
        @rtype: L{Schema} 
        for item in schema.attributes.items():
            if item[0] in self.attributes:
            self.attributes[item[0]] = item[1]
        for item in schema.elements.items():
            if item[0] in self.elements:
            self.elements[item[0]] = item[1]
        for item in schema.types.items():
            if item[0] in self.types:
            self.types[item[0]] = item[1]
        for item in schema.groups.items():
            if item[0] in self.groups:
            self.groups[item[0]] = item[1]
        for item in schema.agrps.items():
            if item[0] in self.agrps:
            self.agrps[item[0]] = item[1]
        schema.merged = True
        return self
00298     def open_imports(self, options):
        Instruct all contained L{sxbasic.Import} children to import
        the schema's which they reference.  The contents of the
        imported schema are I{merged} in.
        @param options: An options dictionary.
        @type options: L{options.Options}
        for imp in self.imports:
            imported = imp.open(options)
            if imported is None:
            log.debug('imported:\n%s', imported)
00314     def dereference(self):
        Instruct all children to perform dereferencing.
        all = []
        indexes = {}
        for child in self.children:
        deplist = DepList()
        for x in all:
            midx, deps = x.dependencies()
            item = (x, tuple(deps))
            indexes[x] = midx
        for x, deps in deplist.sort():
            midx = indexes.get(x)
            if midx is None: continue
            d = deps[midx]
            log.debug('(%s) merging %s <== %s', self.tns[1], Repr(x), Repr(d))
00336     def locate(self, ns):
        Find a schema by namespace.  Only the URI portion of
        the namespace is compared to each schema's I{targetNamespace}.
        The request is passed to the container.
        @param ns: A namespace.
        @type ns: (prefix,URI)
        @return: The schema matching the namesapce, else None.
        @rtype: L{Schema}
        if self.container is not None:
            return self.container.locate(ns)
            return None

00351     def custom(self, ref, context=None):
        Get whether the specified reference is B{not} an (xs) builtin.
        @param ref: A str or qref.
        @type ref: (str|qref)
        @return: True if B{not} a builtin, else False.
        @rtype: bool 
        if ref is None:
            return True
            return ( not self.builtin(ref, context) )
00364     def builtin(self, ref, context=None):
        Get whether the specified reference is an (xs) builtin.
        @param ref: A str or qref.
        @type ref: (str|qref)
        @return: True if builtin, else False.
        @rtype: bool 
        w3 = 'http://www.w3.org'
            if isqref(ref):
                ns = ref[1]
                return ( ref[0] in Factory.tags and ns.startswith(w3) )
            if context is None:
                context = self.root    
            prefix = splitPrefix(ref)[0]
            prefixes = context.findPrefixes(w3, 'startswith')
            return ( prefix in prefixes and ref[0] in Factory.tags )
            return False
00385     def instance(self, root, baseurl, options):
        Create and return an new schema object using the
        specified I{root} and I{url}.
        @param root: A schema root node.
        @type root: L{sax.element.Element}
        @param baseurl: A base URL.
        @type baseurl: str
        @param options: An options dictionary.
        @type options: L{options.Options}
        @return: The newly created schema object.
        @rtype: L{Schema}
        @note: This is only used by Import children.
        return Schema(root, baseurl, options)

    def str(self, indent=0):
        tab = '%*s'%(indent*3, '')
        result = []
        result.append('%s%s' % (tab, self.id))
        result.append('%s(raw)' % tab)
        result.append('%s(model)' % tab)
        for c in self.children:
        return '\n'.join(result)
    def __repr__(self):
        myrep = '<%s tns="%s"/>' % (self.id, self.tns[1])
        return myrep.encode('utf-8')
    def __str__(self):
        return unicode(self).encode('utf-8')
    def __unicode__(self):
        return self.str()

Generated by  Doxygen 1.6.0   Back to index