def build_parts_attributes(cls, parts: List[Part],
ns_map: Dict) -> Iterator[Attr]:
"""
Build attributes for the given list of parts.
:param parts: List of parts
:param ns_map: Namespace prefix-URI map
"""
for part in parts:
if part.element:
prefix, type_name = text.split(part.element)
name = type_name
elif part.type:
prefix, type_name = text.split(part.type)
name = part.name
else:
logger.warning("Skip untyped message part %s", part.name)
continue
ns_map.update(part.ns_map)
namespace = part.ns_map.get(prefix)
type_qname = build_qname(namespace, type_name)
native = namespace == Namespace.XS.uri
namespace = "" if part.type else namespace
yield cls.build_attr(name,
type_qname,
namespace=namespace,
native=native)
def to_qname(value: str, ns_map: Optional[Dict]) -> QName:
if ns_map is None:
return QName(value)
prefix, suffix = text.split(value)
namespace = ns_map.get(prefix)
return QName(namespace, suffix)
def parse_any_attribute(cls, value: str, ns_map: Dict) -> str:
"""Attempt to parse any attribute."""
prefix, suffix = text.split(value)
if prefix and prefix in ns_map and not suffix.startswith("//"):
value = build_qname(ns_map[prefix], suffix)
return value
def map_port_type_message(cls, message: PortTypeMessage,
namespace: Optional[str]) -> Iterator[Attr]:
"""Build an attribute for the given port type message."""
prefix, name = text.split(message.message)
source_namespace = message.ns_map.get(prefix)
yield cls.build_attr(name,
qname=build_qname(source_namespace, name),
namespace=namespace)
def split_qname(tag: str) -> Tuple:
"""Split namespace qualified strings."""
if tag[0] == "{":
left, right = text.split(tag[1:], "}")
if left:
return left, right
return None, tag
def qname(name: str, ns_map: Dict, default_namespace: Optional[str] = None) -> str:
prefix, suffix = text.split(name)
namespace = default_namespace
if prefix:
name = suffix
namespace = ns_map.get(prefix, prefix)
return QName(namespace, name)
def resolve(value: str, ns_map: Optional[Dict]) -> Tuple:
value = value.strip()
if not value:
raise ConverterError()
if value[0] == "{":
uri, name = text.split(value[1:], "}")
if not namespaces.is_uri(uri):
raise ConverterError()
else:
prefix, name = text.split(value, ":")
uri = ns_map.get(prefix) if ns_map else None
if prefix and not uri:
raise ConverterError(f"Unknown namespace prefix: `{prefix}`")
if " " in name or not namespaces.is_ncname(name):
raise ConverterError()
return uri, name
def clean_uri(namespace: str) -> str:
"""Remove common prefixes and suffixes from a uri string."""
if namespace[:2] == "##":
namespace = namespace[2:]
left, right = text.split(namespace)
if left == "urn":
namespace = right
elif left in ("http", "https"):
namespace = right[2:]
return "_".join(x for x in namespace.split(".") if x not in __uri_ignore__)
def build_data_type(
cls, target: Class, name: str, index: int = 0, forward: bool = False
) -> AttrType:
"""Create an attribute type for the target class."""
prefix, suffix = text.split(name)
native = False
namespace = target.ns_map.get(prefix)
if Namespace.get_enum(namespace) and DataType.get_enum(suffix):
name = suffix
native = True
return AttrType(name=name, index=index, native=native, forward=forward,)
def build_data_type(
cls, target: Class, name: str, index: int = 0, forward: bool = False
) -> AttrType:
"""Create an attribute type for the target class."""
prefix, suffix = text.split(name)
namespace = target.ns_map.get(prefix, target.qname.namespace)
native = (
Namespace.get_enum(namespace) is not None
and DataType.get_enum(suffix) is not None
)
return AttrType(
qname=QName(namespace, suffix), index=index, native=native, forward=forward,
)
def build_data_type(cls,
target: Class,
name: str,
forward: bool = False) -> AttrType:
"""Create an attribute type for the target class."""
prefix, suffix = text.split(name)
namespace = target.ns_map.get(prefix, target.target_namespace)
qname = build_qname(namespace, suffix)
datatype = DataType.from_qname(qname)
return AttrType(
qname=qname,
native=datatype is not None,
forward=forward,
)
def qname(name: str,
ns_map: Dict,
default_namespace: Optional[str] = None) -> QName:
"""
Create an :class:`lxml.etree.QName` for the given name and namespaces map.
Use the default namespace if the prefix is not in the ns_map.
"""
prefix, suffix = text.split(name)
namespace = default_namespace
if prefix:
name = suffix
namespace = ns_map.get(prefix, prefix)
return QName(namespace, name)
def resolve(value: str, ns_map: Optional[Dict]) -> Tuple:
if not value:
raise ConverterError("Invalid QName")
if value[0] == "{":
return value, None
if ns_map is None:
raise ConverterError(
"QName converter needs ns_map to support prefixes")
prefix, suffix = text.split(value.strip())
namespace = ns_map.get(prefix)
if prefix and not namespace:
raise ConverterError(f"Unknown namespace prefix: `{prefix}`")
return namespace, suffix
def build_data_type(self,
target: Class,
name: str,
index: int = 0,
forward_ref: bool = False) -> AttrType:
prefix, suffix = text.split(name)
native = False
namespace = target.ns_map.get(prefix)
if Namespace.get_enum(namespace) and DataType.get_enum(suffix):
name = suffix
native = True
return AttrType(
name=name,
index=index,
native=native,
forward_ref=forward_ref,
)
def qname(name):
prefix, suffix = text.split(name)
if prefix and prefix in element.nsmap:
return QName(element.nsmap[prefix], suffix)
return name
def qname(value: Any) -> Any:
prefix, suffix = text.split(value)
if prefix and prefix in element.nsmap:
return QName(element.nsmap[prefix], suffix)
return value
def to_qname(value, ns_map):
prefix, suffix = text.split(value)
namespace = ns_map[prefix]
return QName(namespace, suffix)
