def testRichComparisons (self):
s1 = 'alpha'
s2 = 'beta'
an1 = ExpandedName(None, s1)
en1 = ExpandedName(xsd, s1)
an2 = ExpandedName(None, s2)
en2 = ExpandedName(xsd, s2)
# an1 ? an2
self.assertFalse(an1 == an2)
self.assertTrue(an1 != an2)
self.assertTrue(an1 <= an2)
self.assertTrue(an1 < an2)
self.assertFalse(an1 >= an2)
self.assertFalse(an1 > an2)
# an1 ? en1
self.assertFalse(an1 == en1)
self.assertTrue(an1 != en1)
self.assertTrue(an1 <= en1)
self.assertTrue(an1 < en1)
self.assertFalse(an1 >= en1)
self.assertFalse(an1 > en1)
# s1 ? an1
self.assertTrue(s1 == an1)
self.assertFalse(s1 != an1)
self.assertTrue(s1 <= an1)
self.assertFalse(s1 < an1)
self.assertTrue(s1 >= an1)
self.assertFalse(s1 > an1)
# an1 ? a1
self.assertTrue(an1 == s1)
self.assertFalse(an1 != s1)
self.assertTrue(an1 <= s1)
self.assertFalse(an1 < s1)
self.assertTrue(an1 >= s1)
self.assertFalse(an1 > s1)
def nsuri(n: ExpandedName) -> str:
""" Return the string form of the namespace URI
:param n: expanded name to be returned
:return: stringified URI
"""
# There appears to be a flaw in pyxb -- anyType comes from a different 'xsd' than int, string, etc
rval = str(GAP['']) if not n.namespaceURI() else \
str(XSD['']) if n.namespaceURI() == "http://www.w3.org/2001/XMLSchema" else str(n.namespaceURI())
return rval # two steps so a breakpoint works
def testConstructor (self):
ln = 'local'
ns_uri = 'urn:ns'
en = ExpandedName(ln)
self.assertEqual(en.namespace(), None)
self.assertEqual(en.localName(), ln)
en2 = ExpandedName(en)
self.assertEqual(en2, en)
dom = pyxb.utils.domutils.StringToDOM('<ns1:%s xmlns:ns1="%s" attr="52">content</ns1:%s>' % (ln, ns_uri, ln))
en = ExpandedName(dom.documentElement)
ns = pyxb.namespace.NamespaceForURI(ns_uri)
self.assertTrue(ns is not None)
self.assertEqual(ns, en.namespace())
self.assertEqual(ln, en.localName())
en2 = ExpandedName(ns, ln)
self.assertEqual(en, en2)
attr = dom.documentElement.getAttributeNodeNS(None, 'attr')
self.assertTrue(attr is not None)
en = ExpandedName(attr)
self.assertEqual(xml.dom.EMPTY_NAMESPACE, en.namespaceURI())
self.assertEqual('attr', en.localName())
child = dom.documentElement.firstChild
self.assertTrue(child is not None)
self.assertEqual(xml.dom.Node.TEXT_NODE, child.nodeType)
self.assertRaises(pyxb.LogicError, ExpandedName, child)
def testOrdering (self):
s1 = "one"
s2 = "two"
en1 = ExpandedName(None, s1)
en2 = ExpandedName(None, s2)
xn1 = ExpandedName(xsd, s1)
xn2 = ExpandedName(xsd, s2)
self.assertTrue(s1 < s2)
self.assertTrue(s2 > s1)
self.assertTrue(en1 < s2)
self.assertTrue(en2 > s1)
def get_attribute_value(self, att_name):
"""
This function is a handy extension that allows us to easily look up attribute values regardless whether they
are local or namespaced attribute names. I did not find its equivalent in PyXB.
:param att_name:
:return:
"""
attr_en = ExpandedName(*att_name.split(':'))
# NOTE: At this point we should go to attribute map locate the attribute but for that the namespace has to be
# located too because its fully qualified name is required... etc. cutting corners here as we don't mix local
# and namespaced attributes of the same name so fairly safe to just take the localname bit. But this
# is not a fully XML compliant way to support all possibilities in all cases.
return getattr(self, attr_en.localName())
def testAbsent (self):
an = pyxb.namespace.CreateAbsentNamespace()
an2 = pyxb.namespace.CreateAbsentNamespace()
self.assertNotEqual(an, an2)
self.assertEqual(an.uri(), an2.uri())
ln = 'local'
en1 = ExpandedName(None, ln)
en2 = ExpandedName(an, ln)
en3 = ExpandedName(an2, ln)
self.assertEqual(en1, en2)
self.assertEqual(en1, en3)
self.assertEqual(en2, en3)
self.assertEqual(hash(en1), hash(en2))
self.assertEqual(hash(en1), hash(en3))
self.assertEqual(hash(en2), hash(en3))
def _parse_doc(self, s):
self.logger.debug("Reading XML input: %s", s)
try:
return binding.CreateFromDocument(s)
except UnrecognizedDOMRootNodeError:
raise SCLSyntaxError("Unrecognized document root node.")
except UnrecognizedContentError as e:
try:
nameinfo = e[2]._Name()
except AttributeError:
nameinfo = ExpandedName(e[2])
location = "%s:%s" % (e[3].lineNumber, e[3].columnNumber)
raise SCLSyntaxError("Unrecognized element: %s at %s" %
(nameinfo, location))
except UnrecognizedAttributeError as e:
raise SCLSyntaxError("Unrecognized attribute: {%s}%s" %
(e[1].uriTuple()))
except SimpleFacetValueError as e:
raise SCLValueError("Illegal value for %s: %s" %
(e[0]._ExpandedName, e[1]))
except (NonElementValidationError, SimpleTypeValueError) as e:
raise SCLValueError(e)
except IncompleteElementContentError as exc:
cfg = exc[1]
msg = 'Incomplete content, expect %s' % (' or '.join(
map(str, cfg.acceptableSymbols())))
raise SCLMissingValue(msg)
except Exception as e:
self.logger.exception("Parse error")
raise SCLSyntaxError("Failed to parse XML: %r" % (e, ))
def testMapping (self):
an1 = ExpandedName(None, 'string')
en1 = ExpandedName(xsd, 'string')
en2 = ExpandedName(xsd, 'string')
mymap = { }
mymap[en1] = 'Yes'
mymap[an1] = 'No'
mymap['key'] = 'Key'
self.assertEqual(mymap[en2], 'Yes')
self.assertEqual(mymap[an1], 'No')
self.assertEqual(mymap[an1.localName()], 'No')
self.assertNotEqual(mymap[en2.localName()], 'Yes')
self.assertEqual(mymap['key'], 'Key')
self.assertEqual(mymap[ExpandedName(None, 'key')], 'Key')
self.assertEqual(None, mymap.get('nokey'))
del mymap[en2]
self.assertEqual(None, mymap.get(en1))
def testEquivalence (self):
an1 = ExpandedName(None, 'string')
en1 = ExpandedName(xsd, 'string')
en2 = ExpandedName(xsd, 'string')
en3 = ExpandedName(xsd, 'notString')
self.assertEqual(en1, en2)
self.assertEqual(en1, ( en1.namespace(), en1.localName() ))
self.assertTrue(en1 == en2)
self.assertFalse(en1 == en3)
self.assertTrue(en1 != en3)
self.assertTrue(an1 == an1.localName())
self.assertFalse(an1 == en3.localName())
self.assertTrue(an1 != en3.localName())
self.assertFalse(an1 != an1.localName())
def testMapping (self):
an1 = ExpandedName(None, 'string')
en1 = ExpandedName(xsd, 'string')
en2 = ExpandedName(xsd, 'string')
mymap = { }
mymap[en1] = 'Yes'
mymap[an1] = 'No'
mymap['key'] = 'Key'
self.assertEqual(mymap[en2], 'Yes')
self.assertEqual(mymap[an1], 'No')
self.assertEqual(mymap[an1.localName()], 'No')
self.assertNotEqual(mymap[en2.localName()], 'Yes')
self.assertEqual(mymap['key'], 'Key')
self.assertEqual(mymap[ExpandedName(None, 'key')], 'Key')
self.assertEqual(None, mymap.get('nokey'))
del mymap[en2]
self.assertEqual(None, mymap.get(en1))
def __init__(self, value):
self.value = value
attributeDict = value._AttributeMap.copy()
xml_id_attr = ExpandedName('http://www.w3.org/XML/1998/namespace', 'id')
attributeDict.pop(xml_id_attr) # This shouldn't throw an error, but if it does, something's wrong
# sorted to make sure that for two elements with the same set of
# attributes the values are put into the hash string in the same order
sortedDict = sorted(attributeDict.items(), key=lambda t: t[0])
concatenatedStyleString = u''
for key,val in sortedDict:
styleValue = ReplaceNone(val.value(value))
concatenatedStyleString += str(styleValue) + '%'
for key,val in value.wildcardAttributeMap().items():
namespace = ReplaceNone(key.namespaceURI())
localName = key.localName()
wildcardValue = ReplaceNone(val)
concatenatedStyleString += namespace + '%' + localName + '%' + wildcardValue
self.my_hash = hash(concatenatedStyleString)
def fulluri(n: ExpandedName) -> URIRef:
""" Return the full uri of the expanded name
:param n: expanded name
:return: full URI
"""
return URIRef(nsuri(n) + n.localName())
def testConstructor (self):
ln = 'local'
ns_uri = 'urn:ns'
en = ExpandedName(ln)
self.assertEqual(en.namespace(), None)
self.assertEqual(en.localName(), ln)
en2 = ExpandedName(en)
self.assertEqual(en2, en)
dom = pyxb.utils.domutils.StringToDOM('<ns1:%s xmlns:ns1="%s" attr="52">content</ns1:%s>' % (ln, ns_uri, ln))
en = ExpandedName(dom.documentElement)
ns = pyxb.namespace.NamespaceForURI(ns_uri)
self.assertTrue(ns is not None)
self.assertEqual(ns, en.namespace())
self.assertEqual(ln, en.localName())
en2 = ExpandedName(ns, ln)
self.assertEqual(en, en2)
attr = dom.documentElement.getAttributeNodeNS(None, 'attr')
self.assertTrue(attr is not None)
en = ExpandedName(attr)
self.assertEqual(xml.dom.EMPTY_NAMESPACE, en.namespaceURI())
self.assertEqual('attr', en.localName())
child = dom.documentElement.firstChild
self.assertTrue(child is not None)
self.assertEqual(xml.dom.Node.TEXT_NODE, child.nodeType)
self.assertRaises(pyxb.LogicError, ExpandedName, child)
def testEquivalence (self):
an1 = ExpandedName(None, 'string')
en1 = ExpandedName(xsd, 'string')
en2 = ExpandedName(xsd, 'string')
en3 = ExpandedName(xsd, 'notString')
self.assertEqual(en1, en2)
self.assertEqual(en1, ( en1.namespace(), en1.localName() ))
self.assertTrue(en1 == en2)
self.assertFalse(en1 == en3)
self.assertTrue(en1 != en3)
self.assertTrue(an1 == an1.localName())
self.assertFalse(an1 == en3.localName())
self.assertTrue(an1 != en3.localName())
self.assertFalse(an1 != an1.localName())
