def __init__(self, location, transport):
"""Initialize a WSDL document.
The root definition properties are exposed as entry points.
:param location: Location of this WSDL
:type location: string
:param transport: The transport object to be used
:type transport: zeep.transports.Transport
"""
self.location = location if not hasattr(location, 'read') else None
self.transport = transport
# Dict with all definition objects within this WSDL
self._definitions = {}
self.types = Schema([], transport=self.transport)
# Dict with internal schema objects, used for lxml.ImportResolver
self._parser_context = ParserContext()
document = self._load_content(location)
root_definitions = Definition(self, document, self.location)
root_definitions.resolve_imports()
# Make the wsdl definitions public
self.messages = root_definitions.messages
self.port_types = root_definitions.port_types
self.bindings = root_definitions.bindings
self.services = root_definitions.services
def parse_schema_node(node):
parser_context = ParserContext()
schema = Schema(node=node,
transport=None,
location=None,
parser_context=parser_context)
return schema
def __init__(self,
node=None,
transport=None,
location=None,
parser_context=None):
self._parser_context = parser_context or ParserContext()
self._schemas = OrderedDict()
self._root = None
self._prefix_map = {}
if node is not None:
self._root = SchemaDocument(node, transport, location,
self._parser_context, location)
self._root.resolve()
def _collect_imports_recursive(schema, target=None):
if target is None:
target = OrderedDict()
target[schema._target_namespace] = schema
for ns, s in schema._imports.items():
if ns not in target:
_collect_imports_recursive(s, target)
return target
self._schemas = _collect_imports_recursive(self._root)
self._prefix_map = self._create_prefix_map()
def schema_visitor():
parser_context = ParserContext()
node = etree.Element('{http://www.w3.org/2001/XMLSchema}Schema')
schema = SchemaDocument(node=node,
transport=None,
location=None,
parser_context=parser_context,
base_url=None)
return visitor.SchemaVisitor(schema)
def __init__(self, node=None, transport=None, location=None,
parser_context=None):
self._parser_context = parser_context or ParserContext()
self._transport = transport
self._schemas = OrderedDict()
self._prefix_map_auto = {}
self._prefix_map_custom = {}
if not isinstance(node, list):
nodes = [node] if node is not None else []
else:
nodes = node
self.add_documents(nodes, location)
def __init__(self,
node=None,
transport=None,
location=None,
parser_context=None,
base_url=None):
logger.debug("Init schema for %r", location)
# Internal
self._base_url = base_url or location
self._location = location
self._transport = transport
self._target_namespace = None
self._elm_instances = []
self._types = {}
self._elements = {}
self._attributes = {}
self._imports = OrderedDict()
self._prefix_map = {}
self._xml_schema = None
self._element_form = 'unqualified'
self._attribute_form = 'unqualified'
is_root_schema = False
if not parser_context:
parser_context = ParserContext()
if not parser_context.schema_objects:
is_root_schema = True
parser_context.schema_objects.add(self)
if node is not None:
# Disable XML schema validation for now
# if len(node) > 0:
# self.xml_schema = etree.XMLSchema(node)
visitor = SchemaVisitor(self, parser_context)
visitor.visit_schema(node)
if is_root_schema:
for schema in self._imports.values():
schema.resolve()
self.resolve()
self._prefix_map = self.create_prefix_map()
def __init__(self, location, transport):
self.location = location if not hasattr(location, 'read') else None
self.transport = transport
# Dict with all definition objects within this WSDL
self._definitions = {}
# Dict with internal schema objects, used for lxml.ImportResolver
self._parser_context = ParserContext()
document = self._load_content(location)
root_definitions = Definitions(self, document, self.location)
root_definitions.resolve_imports()
# Make the wsdl definitions public
self.schema = root_definitions.schema
self.messages = root_definitions.messages
self.port_types = root_definitions.port_types
self.bindings = root_definitions.bindings
self.services = root_definitions.services
def test_sequence_parse_anytype_obj():
value_type = xsd.ComplexType(
xsd.Sequence([
xsd.Element(
'{http://tests.python-zeep.org/}value',
xsd.Integer()),
])
)
parser_context = ParserContext()
schema = SchemaDocument(
etree.Element('{http://www.w3.org/2001/XMLSchema}Schema'),
transport=None,
location=None,
parser_context=parser_context,
base_url=None)
schema._target_namespace = 'http://tests.python-zeep.org/'
schema.register_type('{http://tests.python-zeep.org/}something', value_type)
custom_type = xsd.Element(
etree.QName('http://tests.python-zeep.org/', 'container'),
xsd.ComplexType(
xsd.Sequence([
xsd.Element(
etree.QName('http://tests.python-zeep.org/', 'item_1'),
xsd.AnyType()),
])
))
expected = etree.fromstring("""
<ns0:container
xmlns:ns0="http://tests.python-zeep.org/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<ns0:item_1 xsi:type="ns0:something">
<ns0:value>100</ns0:value>
</ns0:item_1>
</ns0:container>
""")
obj = custom_type.parse(expected, schema)
assert obj.item_1.value == 100