def test_property_default_type(self):
element = ElementBase()
self.assertEqual("string", element.default_type)
element = ElementBase()
element.ns_map["xsd"] = Namespace.XS.uri
self.assertEqual("xsd:string", element.default_type)
def test_property_prefix(self):
element = ElementBase()
self.assertIsNone(element.prefix)
element.ref = "foo"
self.assertIsNone(element.prefix)
element.ref = "foo:bar"
self.assertEqual("foo", element.prefix)
def test_property_is_abstract(self):
element = ElementBase()
self.assertFalse(element.is_abstract)
element.abstract = False
self.assertFalse(element.is_abstract)
element.abstract = True
self.assertTrue(element.is_abstract)
def test_property_has_children(self):
element = ElementBase()
self.assertFalse(element.has_children)
element = Element.create()
self.assertFalse(element.has_children)
element.complex_type = ComplexType.create()
self.assertTrue(element.has_children)
def test_property_is_fixed(self):
element = ElementBase()
self.assertFalse(element.is_fixed)
element.fixed = None
self.assertFalse(element.is_fixed)
element.fixed = "foo"
self.assertTrue(element.is_fixed)
def test_property_real_name(self):
element = ElementBase()
with self.assertRaises(SchemaValueError):
element.real_name
element.ref = "foo"
self.assertEqual("foo", element.real_name)
element.name = "bar"
self.assertEqual("bar", element.real_name)
def set_namespace_map(element: Element, obj: ElementBase):
"""Add common namespaces like xml, xsi, xlink if they are missing."""
obj.ns_map = element.nsmap
namespaces = obj.ns_map.values()
for namespace in Namespace:
if namespace.uri not in namespaces:
obj.ns_map[namespace.prefix] = namespace.uri
def test_property_is_qualified(self):
element = ElementBase()
self.assertFalse(element.is_qualified)
element.form = None
self.assertFalse(element.is_qualified)
element.form = FormType.UNQUALIFIED
self.assertFalse(element.is_qualified)
element.form = FormType.QUALIFIED
self.assertTrue(element.is_qualified)
element = ElementBase()
element.form = FormType.UNQUALIFIED
element.ref = None
self.assertFalse(element.is_qualified)
element.ref = "foo"
self.assertTrue(element.is_qualified)
def test_property_extensions(self):
element = ElementBase()
self.assertIsInstance(element.extensions, Iterator)
self.assertEqual([], list(element.extensions))
class Foo(ElementBase):
@property
def extends(self) -> Optional[str]:
return "a b c"
self.assertEqual(["a", "b", "c"], list(Foo().extensions))
def build_class_extensions(cls, obj: ElementBase, target: Class):
"""Build the item class extensions from the given ElementBase
children."""
restrictions = obj.get_restrictions()
extensions = [
cls.build_class_extension(target, base, restrictions)
for base in obj.bases
]
extensions.extend(cls.children_extensions(obj, target))
target.extensions = collections.unique_sequence(extensions)
def test_schema_prefix(self):
element = ElementBase()
self.assertIsNone(element.schema_prefix())
element = ElementBase(ns_map=dict(a="b", c=Namespace.XS.uri))
self.assertEqual("c", element.schema_prefix())
def build_inner_classes(self, obj: ElementBase) -> Iterator[Class]:
"""Find and convert anonymous types to a class instances."""
if isinstance(obj, SimpleType) and obj.is_enumeration:
yield self.build_class(obj)
else:
for child in obj.children():
if isinstance(child,
ComplexType) or (isinstance(child, SimpleType)
and child.is_enumeration):
child.name = obj.real_name
yield self.build_class(child)
else:
yield from self.build_inner_classes(child)
def element_children(
cls, obj: ElementBase, restrictions: Restrictions
) -> Iterator[Tuple[ElementBase, Restrictions]]:
"""Recursively find and return all child elements that are qualified to
be class attributes."""
for child in obj.children():
if child.is_attribute:
yield child, restrictions
else:
yield from cls.element_children(
child, restrictions=Restrictions.from_element(child)
)
def element_children(
self, obj: ElementBase, restrictions: Optional[Restrictions] = None
) -> Iterator[Tuple[AttributeElement, Restrictions]]:
"""Recursively find and return all child elements that are qualified to
be class attributes."""
for child in obj.children():
if child.is_attribute:
yield child, restrictions or Restrictions()
else:
yield from self.element_children(
child, restrictions=Restrictions.from_element(child)
)
def build_class_extensions(cls, obj: ElementBase, target: Class):
"""Build the item class extensions from the given ElementBase
children."""
extensions = set()
raw_type = obj.raw_type
if raw_type:
restrictions = obj.get_restrictions()
extensions.add(
cls.build_class_extension(target, raw_type, restrictions))
extensions.update(cls.children_extensions(obj, target))
target.extensions = list(extensions)
def build_class_extensions(cls, obj: ElementBase, target: Class):
"""Build the item class extensions from the given ElementBase
children."""
extensions = {}
raw_type = obj.raw_type
if raw_type:
restrictions = obj.get_restrictions()
extension = cls.build_class_extension(target, raw_type, 0, restrictions)
extensions[raw_type] = extension
for extension in cls.children_extensions(obj, target):
extensions[extension.type.name] = extension
target.extensions = sorted(extensions.values(), key=lambda x: x.type.index)
def build_inner_classes(
cls, obj: ElementBase, module: str, namespace: Optional[str]
) -> Iterator[Class]:
"""Find and convert anonymous types to a class instances."""
if isinstance(obj, SimpleType) and obj.is_enumeration:
yield cls.build_class(obj, obj.class_name, module, namespace)
else:
for child in obj.children():
if isinstance(child, ComplexType) or (
isinstance(child, SimpleType) and child.is_enumeration
):
child.name = obj.real_name
yield cls.build_class(child, obj.class_name, module, namespace)
else:
yield from cls.build_inner_classes(child, module, namespace)
def children_extensions(self, obj: ElementBase,
target: Class) -> Iterator[Extension]:
"""
Recursively find and return all target's Extension classes.
If the initial given obj has a type attribute include it in
result.
"""
for child in obj.children():
if child.is_attribute:
continue
for ext in child.extensions:
yield self.build_class_extension(target, ext, child.index,
child.get_restrictions())
yield from self.children_extensions(child, target)
def test_property_default_value(self):
element = ElementBase()
self.assertIsNone(element.default_value)
element.fixed = "foo"
self.assertEqual("foo", element.default_value)
element.default = "bar"
self.assertEqual("bar", element.default_value)
element.default = ""
self.assertEqual("", element.default_value)
element.default = None
element.fixed = ""
self.assertEqual("", element.default_value)
def test_property_raw_type(self):
element = ElementBase()
self.assertIsNone(element.raw_namespace)
element.type = "xs:int"
self.assertEqual("xs:int", element.raw_type)
def test_property_is_attribute(self):
element = ElementBase()
self.assertFalse(element.is_attribute)
def test_property_has_form(self):
element = ElementBase()
self.assertFalse(element.has_form)
element.form = None
self.assertTrue(element.has_form)
def test_property_extends(self):
element = ElementBase()
self.assertIsNone(element.extends)
def test_property_display_help(self):
element = ElementBase()
self.assertIsNone(element.display_help)
def test_property_default_type(self):
element = ElementBase()
self.assertEqual(DataType.STRING, element.default_type)
def test_property_is_mixed(self):
element = ElementBase()
self.assertFalse(element.is_mixed)
def test_property_substitutions(self):
element = ElementBase()
self.assertEqual([], element.substitutions)
def test_property_real_type(self):
element = ElementBase()
with self.assertRaises(SchemaValueError):
element.real_type
def test_property_is_wildcard(self):
element = ElementBase()
self.assertFalse(element.is_wildcard)
def test_property_raw_namespace(self):
element = ElementBase()
self.assertIsNone(element.raw_namespace)
element.target_namespace = "tns"
self.assertEqual("tns", element.raw_namespace)
