def apply_aliases(self, obj: Class):
"""Walk the attributes tree and set the type aliases."""
for attr in obj.attrs:
for attr_type in attr.types:
attr_type.alias = self.aliases.get(attr_type.qname)
collections.apply(obj.inner, self.apply_aliases)
def process(self, uris: List[str], package: str):
"""
Run main processes.
:param uris: list of uris to process
:param package: package name eg foo.bar.xxx
"""
collections.apply(uris, self.process_schema)
classes = [
cls for classes in self.class_map.values() for cls in classes
]
class_num, inner_num = self.count_classes(classes)
if class_num:
logger.info("Analyzer input: %d main and %d inner classes",
class_num, inner_num)
self.assign_packages(package)
classes = self.analyze_classes(classes)
class_num, inner_num = self.count_classes(classes)
logger.info("Analyzer output: %d main and %d inner classes",
class_num, inner_num)
writer.designate(classes, self.output)
if self.print:
writer.print(classes, self.output)
else:
writer.write(classes, self.output)
else:
logger.warning("Analyzer returned zero classes!")
def process_definitions(self, uri: str):
"""Process a single wsdl resource."""
definitions = self.parse_definitions(uri, namespace=None)
collections.apply(definitions.schemas, self.convert_schema)
self.convert_definitions(definitions)
self.process_classes()
def process(cls, container: ClassContainer, config: GeneratorConfig):
"""Iterate through all classes and run the sanitizer procedure."""
sanitizer = cls(container, config)
collections.apply(container.iterate(), sanitizer.process_class)
sanitizer.resolve_conflicts()
def process_schemas(self, uris: List[str]):
"""
Run main processes.
:param uris: list of uris to process
"""
collections.apply(uris, self.process_schema)
self.process_classes()
def process_definitions(self, uris: List[str]):
"""Process a list of wsdl resources."""
definitions = None
for uri in uris:
services = self.parse_definitions(uri, namespace=None)
if definitions is None:
definitions = services
elif services:
definitions.merge(services)
if definitions is not None:
collections.apply(definitions.schemas, self.convert_schema)
self.convert_definitions(definitions)
def apply_aliases(self, target: Class):
"""Iterate over the target class dependencies and set the type
aliases."""
for attr in target.attrs:
for attr_type in attr.types:
attr_type.alias = self.aliases.get(attr_type.qname)
for choice in attr.choices:
for choice_type in choice.types:
choice_type.alias = self.aliases.get(choice_type.qname)
for ext in target.extensions:
ext.type.alias = self.aliases.get(ext.type.qname)
collections.apply(target.inner, self.apply_aliases)
def process_class(self, target: Class):
"""
Sanitize the attributes of the given class. After applying all the
flattening handlers the attributes need to be further sanitized to
squash common issues like duplicate attribute names.
Steps:
1. Sanitize inner classes
2. Sanitize attributes default value
3. Sanitize attributes name
4. Sanitize attributes sequential flag
5. Sanitize duplicate attribute names
"""
collections.apply(target.inner, self.process_class)
for attr in target.attrs:
self.process_attribute_default(target, attr)
self.process_attribute_restrictions(attr)
self.process_attribute_name(attr)
self.process_attribute_sequence(target, attr)
self.process_duplicate_attribute_names(target.attrs)
def process(cls, container: ClassContainer):
"""Iterate through all classes and run the sanitizer procedure."""
sanitizer = cls(container)
collections.apply(container.iterate(), sanitizer.process_class)
def extend(self, items: List[Class]):
"""Add a list of classes the container."""
collections.apply(items, self.add)
def process(self):
"""Iterate through all classes and run the sanitizing procedure."""
collections.apply(self.container.iterate(), self.process_class)
