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)