1
2
3 """
4 Tests specific to the lxml.objectify API
5 """
6
7
8 import unittest, operator, sys
9
10 from common_imports import etree, StringIO, HelperTestCase, fileInTestDir
11 from common_imports import SillyFileLike, canonicalize, doctest
12
13 from lxml import objectify
14
15 PYTYPE_NAMESPACE = "http://codespeak.net/lxml/objectify/pytype"
16 XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema"
17 XML_SCHEMA_INSTANCE_NS = "http://www.w3.org/2001/XMLSchema-instance"
18 XML_SCHEMA_INSTANCE_TYPE_ATTR = "{%s}type" % XML_SCHEMA_INSTANCE_NS
19 XML_SCHEMA_NIL_ATTR = "{%s}nil" % XML_SCHEMA_INSTANCE_NS
20 TREE_PYTYPE = "TREE"
21 DEFAULT_NSMAP = { "py" : PYTYPE_NAMESPACE,
22 "xsi" : XML_SCHEMA_INSTANCE_NS,
23 "xsd" : XML_SCHEMA_NS}
24
25 objectclass2xsitype = {
26
27 objectify.IntElement: ("int", "short", "byte", "unsignedShort",
28 "unsignedByte",),
29 objectify.LongElement: ("integer", "nonPositiveInteger", "negativeInteger",
30 "long", "nonNegativeInteger", "unsignedLong",
31 "unsignedInt", "positiveInteger",),
32 objectify.FloatElement: ("float", "double"),
33 objectify.BoolElement: ("boolean",),
34 objectify.StringElement: ("string", "normalizedString", "token", "language",
35 "Name", "NCName", "ID", "IDREF", "ENTITY",
36 "NMTOKEN", ),
37
38 }
39
40 xsitype2objclass = dict([ (v, k) for k in objectclass2xsitype
41 for v in objectclass2xsitype[k] ])
42
43 objectclass2pytype = {
44
45 objectify.IntElement: "int",
46 objectify.LongElement: "long",
47 objectify.FloatElement: "float",
48 objectify.BoolElement: "bool",
49 objectify.StringElement: "str",
50
51 }
52
53 pytype2objclass = dict([ (objectclass2pytype[k], k)
54 for k in objectclass2pytype])
55
56 xml_str = '''\
57 <obj:root xmlns:obj="objectified" xmlns:other="otherNS">
58 <obj:c1 a1="A1" a2="A2" other:a3="A3">
59 <obj:c2>0</obj:c2>
60 <obj:c2>1</obj:c2>
61 <obj:c2>2</obj:c2>
62 <other:c2>3</other:c2>
63 <c2>3</c2>
64 </obj:c1>
65 </obj:root>'''
66
68 """Test cases for lxml.objectify
69 """
70 etree = etree
71
74
88
102
103
107
112
119
121 nsmap = {"my": "someNS",
122 "myother": "someOtherNS",
123 "myxsd": XML_SCHEMA_NS}
124 elt = objectify.Element("test", nsmap=nsmap)
125 self.assert_(PYTYPE_NAMESPACE in elt.nsmap.values())
126 for prefix, ns in nsmap.items():
127 self.assert_(prefix in elt.nsmap)
128 self.assertEquals(nsmap[prefix], elt.nsmap[prefix])
129
134
140
148
159
163
168
175
177 nsmap = {"my": "someNS",
178 "myother": "someOtherNS",
179 "myxsd": XML_SCHEMA_NS,}
180 value = objectify.DataElement("test", nsmap=nsmap)
181 self.assert_(PYTYPE_NAMESPACE in value.nsmap.values())
182 for prefix, ns in nsmap.items():
183 self.assert_(prefix in value.nsmap)
184 self.assertEquals(nsmap[prefix], value.nsmap[prefix])
185
190
196
204
215
217
218 value = objectify.DataElement(23, _pytype="str", _xsi="foobar",
219 attrib={"gnu": "muh", "cat": "meeow",
220 "dog": "wuff"},
221 bird="tchilp", dog="grrr")
222 self.assertEquals(value.get("gnu"), "muh")
223 self.assertEquals(value.get("cat"), "meeow")
224 self.assertEquals(value.get("dog"), "grrr")
225 self.assertEquals(value.get("bird"), "tchilp")
226
238
240
241
242 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
243 attrib={"gnu": "muh", "cat": "meeow",
244 "dog": "wuff"},
245 bird="tchilp", dog="grrr")
246 value = objectify.DataElement(arg, _pytype="NoneType")
247 self.assert_(isinstance(value, objectify.NoneElement))
248 self.assertEquals(value.get(XML_SCHEMA_NIL_ATTR), "true")
249 self.assertEquals(value.text, None)
250 self.assertEquals(value.pyval, None)
251 for attr in arg.attrib:
252
253 self.assertEquals(value.get(attr), arg.get(attr))
254
256
257
258 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
259 attrib={"gnu": "muh", "cat": "meeow",
260 "dog": "wuff"},
261 bird="tchilp", dog="grrr")
262 value = objectify.DataElement(arg, _pytype="int")
263 self.assert_(isinstance(value, objectify.IntElement))
264 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int")
265 for attr in arg.attrib:
266 if not attr == objectify.PYTYPE_ATTRIBUTE:
267 self.assertEquals(value.get(attr), arg.get(attr))
268
270
271
272 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
273 attrib={"gnu": "muh", "cat": "meeow",
274 "dog": "wuff"},
275 bird="tchilp", dog="grrr")
276 value = objectify.DataElement(arg, _xsi="xsd:int")
277 self.assert_(isinstance(value, objectify.IntElement))
278 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int")
279 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int")
280 for attr in arg.attrib:
281 if not attr in [objectify.PYTYPE_ATTRIBUTE,
282 XML_SCHEMA_INSTANCE_TYPE_ATTR]:
283 self.assertEquals(value.get(attr), arg.get(attr))
284
286
287
288 arg = objectify.DataElement(23, _pytype="str", _xsi="foobar",
289 attrib={"gnu": "muh", "cat": "meeow",
290 "dog": "wuff"},
291 bird="tchilp", dog="grrr")
292 value = objectify.DataElement(arg, _pytype="int", _xsi="xsd:int")
293 self.assert_(isinstance(value, objectify.IntElement))
294 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), "int")
295 self.assertEquals(value.get(XML_SCHEMA_INSTANCE_TYPE_ATTR), "xsd:int")
296 for attr in arg.attrib:
297 if not attr in [objectify.PYTYPE_ATTRIBUTE,
298 XML_SCHEMA_INSTANCE_TYPE_ATTR]:
299 self.assertEquals(value.get(attr), arg.get(attr))
300
304
308
313
318
322
326
330
335
337 root = self.XML(xml_str)
338 self.assertEquals("0", getattr(root.c1, "{objectified}c2").text)
339 self.assertEquals("3", getattr(root.c1, "{otherNS}c2").text)
340
342 root = self.XML(xml_str)
343 self.assertRaises(AttributeError, getattr, root.c1, "NOT_THERE")
344 self.assertRaises(AttributeError, getattr, root.c1, "{unknownNS}c2")
345
352
354 root = self.XML(xml_str)
355 self.assertEquals(1, len(root.c1))
356
357 new_el = self.Element("test", myattr="5")
358 root.addattr("c1", new_el)
359 self.assertEquals(2, len(root.c1))
360 self.assertEquals(None, root.c1[0].get("myattr"))
361 self.assertEquals("5", root.c1[1].get("myattr"))
362
364 root = self.XML(xml_str)
365 self.assertEquals(1, len(root.c1))
366
367 new_el = self.Element("test")
368 self.etree.SubElement(new_el, "a", myattr="A")
369 self.etree.SubElement(new_el, "a", myattr="B")
370
371 root.addattr("c1", list(new_el.a))
372 self.assertEquals(3, len(root.c1))
373 self.assertEquals(None, root.c1[0].get("myattr"))
374 self.assertEquals("A", root.c1[1].get("myattr"))
375 self.assertEquals("B", root.c1[2].get("myattr"))
376
383
385 root = self.XML(xml_str)
386 self.assertEquals("0", root.c1.c2[0].text)
387 self.assertEquals("1", root.c1.c2[1].text)
388 self.assertEquals("2", root.c1.c2[2].text)
389 self.assertRaises(IndexError, operator.getitem, root.c1.c2, 3)
390
392 root = self.XML(xml_str)
393 self.assertEquals("0", root.c1.c2[0].text)
394 self.assertEquals("0", root.c1.c2[-3].text)
395 self.assertEquals("1", root.c1.c2[-2].text)
396 self.assertEquals("2", root.c1.c2[-1].text)
397 self.assertRaises(IndexError, operator.getitem, root.c1.c2, -4)
398
400 root = self.XML(xml_str)
401 self.assertEquals(1, len(root))
402 self.assertEquals(1, len(root.c1))
403 self.assertEquals(3, len(root.c1.c2))
404
406 root = self.XML(xml_str)
407 self.assertEquals([root],
408 list(iter(root)))
409 self.assertEquals([root.c1],
410 list(iter(root.c1)))
411 self.assertEquals([root.c1.c2[0], root.c1.c2[1], root.c1.c2[2]],
412 list(iter((root.c1.c2))))
413
419
429
434
439
440
441
443 root = self.XML("<root><c>c1</c><c>c2</c></root>")
444 self.assertEquals(["c1", "c2"],
445 [ c.text for c in root.c[:] ])
446
448 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>")
449 test_list = ["c1", "c2", "c3", "c4"]
450
451 self.assertEquals(test_list,
452 [ c.text for c in root.c[:] ])
453 self.assertEquals(test_list[1:2],
454 [ c.text for c in root.c[1:2] ])
455 self.assertEquals(test_list[-3:-1],
456 [ c.text for c in root.c[-3:-1] ])
457 self.assertEquals(test_list[-3:3],
458 [ c.text for c in root.c[-3:3] ])
459 self.assertEquals(test_list[-3000:3],
460 [ c.text for c in root.c[-3000:3] ])
461 self.assertEquals(test_list[-3:3000],
462 [ c.text for c in root.c[-3:3000] ])
463
465 root = self.XML("<root><c>c1</c><c>c2</c><c>c3</c><c>c4</c></root>")
466 test_list = ["c1", "c2", "c3", "c4"]
467
468 self.assertEquals(test_list,
469 [ c.text for c in root.c[:] ])
470 self.assertEquals(test_list[2:1:-1],
471 [ c.text for c in root.c[2:1:-1] ])
472 self.assertEquals(test_list[-1:-3:-1],
473 [ c.text for c in root.c[-1:-3:-1] ])
474 self.assertEquals(test_list[2:-3:-1],
475 [ c.text for c in root.c[2:-3:-1] ])
476 self.assertEquals(test_list[2:-3000:-1],
477 [ c.text for c in root.c[2:-3000:-1] ])
478
479
480
492
494 Element = self.Element
495 root = Element("root")
496 root.c = ["c1", "c2"]
497
498 c1 = root.c[0]
499 c2 = root.c[1]
500
501 self.assertEquals([c1,c2], list(root.c))
502 self.assertEquals(["c1", "c2"],
503 [ c.text for c in root.c ])
504
505 root2 = Element("root2")
506 root2.el = [ "test", "test" ]
507 self.assertEquals(["test", "test"],
508 [ el.text for el in root2.el ])
509
510 root.c = [ root2.el, root2.el ]
511 self.assertEquals(["test", "test"],
512 [ c.text for c in root.c ])
513 self.assertEquals(["test", "test"],
514 [ el.text for el in root2.el ])
515
516 root.c[:] = [ c1, c2, c2, c1 ]
517 self.assertEquals(["c1", "c2", "c2", "c1"],
518 [ c.text for c in root.c ])
519
521 Element = self.Element
522 root = Element("root")
523 l = ["c1", "c2", "c3", "c4"]
524 root.c = l
525
526 self.assertEquals(["c1", "c2", "c3", "c4"],
527 [ c.text for c in root.c ])
528 self.assertEquals(l,
529 [ c.text for c in root.c ])
530
531 new_slice = ["cA", "cB"]
532 l[1:2] = new_slice
533 root.c[1:2] = new_slice
534
535 self.assertEquals(["c1", "cA", "cB", "c3", "c4"], l)
536 self.assertEquals(["c1", "cA", "cB", "c3", "c4"],
537 [ c.text for c in root.c ])
538 self.assertEquals(l,
539 [ c.text for c in root.c ])
540
542 Element = self.Element
543 root = Element("root")
544 l = ["c1", "c2", "c3", "c4"]
545 root.c = l
546
547 self.assertEquals(["c1", "c2", "c3", "c4"],
548 [ c.text for c in root.c ])
549 self.assertEquals(l,
550 [ c.text for c in root.c ])
551
552 new_slice = ["cA", "cB"]
553 l[1:1] = new_slice
554 root.c[1:1] = new_slice
555
556 self.assertEquals(["c1", "cA", "cB", "c2", "c3", "c4"], l)
557 self.assertEquals(["c1", "cA", "cB", "c2", "c3", "c4"],
558 [ c.text for c in root.c ])
559 self.assertEquals(l,
560 [ c.text for c in root.c ])
561
563 Element = self.Element
564 root = Element("root")
565 l = ["c1", "c2", "c3", "c4"]
566 root.c = l
567
568 self.assertEquals(["c1", "c2", "c3", "c4"],
569 [ c.text for c in root.c ])
570 self.assertEquals(l,
571 [ c.text for c in root.c ])
572
573 new_slice = ["cA", "cB"]
574 l[-2:-2] = new_slice
575 root.c[-2:-2] = new_slice
576
577 self.assertEquals(["c1", "c2", "cA", "cB", "c3", "c4"], l)
578 self.assertEquals(["c1", "c2", "cA", "cB", "c3", "c4"],
579 [ c.text for c in root.c ])
580 self.assertEquals(l,
581 [ c.text for c in root.c ])
582
590
592 Element = self.Element
593 root = Element("root")
594 l = ["c1", "c2", "c3", "c4"]
595 root.c = l
596
597 self.assertEquals(["c1", "c2", "c3", "c4"],
598 [ c.text for c in root.c ])
599 self.assertEquals(l,
600 [ c.text for c in root.c ])
601
602 new_slice = ["cA", "cB", "cC"]
603 self.assertRaises(
604 ValueError, operator.setitem,
605 l, slice(1,2,-1), new_slice)
606 self.assertRaises(
607 ValueError, operator.setitem,
608 root.c, slice(1,2,-1), new_slice)
609
611 Element = self.Element
612 root = Element("root")
613 l = ["c1", "c2", "c3", "c4"]
614 root.c = l
615
616 self.assertEquals(["c1", "c2", "c3", "c4"],
617 [ c.text for c in root.c ])
618 self.assertEquals(l,
619 [ c.text for c in root.c ])
620
621 new_slice = ["cA", "cB"]
622 l[-1:1:-1] = new_slice
623 root.c[-1:1:-1] = new_slice
624
625 self.assertEquals(["c1", "c2", "cB", "cA"], l)
626 self.assertEquals(["c1", "c2", "cB", "cA"],
627 [ c.text for c in root.c ])
628 self.assertEquals(l,
629 [ c.text for c in root.c ])
630
632 Element = self.Element
633 root = Element("root")
634 l = ["c1", "c2", "c3", "c4"]
635 root.c = l
636
637 self.assertEquals(["c1", "c2", "c3", "c4"],
638 [ c.text for c in root.c ])
639 self.assertEquals(l,
640 [ c.text for c in root.c ])
641
642 new_slice = ["cA", "cB"]
643 l[-1:-4:-2] = new_slice
644 root.c[-1:-4:-2] = new_slice
645
646 self.assertEquals(["c1", "cB", "c3", "cA"], l)
647 self.assertEquals(["c1", "cB", "c3", "cA"],
648 [ c.text for c in root.c ])
649 self.assertEquals(l,
650 [ c.text for c in root.c ])
651
652
653
661
669
671
672 Element = self.Element
673 root = Element("root")
674
675 root["text"] = "TEST"
676 self.assertEquals(["TEST"],
677 [ c.text for c in root["text"] ])
678
679 root["tail"] = "TEST"
680 self.assertEquals(["TEST"],
681 [ c.text for c in root["tail"] ])
682
683 root["pyval"] = "TEST"
684 self.assertEquals(["TEST"],
685 [ c.text for c in root["pyval"] ])
686
687 root["tag"] = "TEST"
688 self.assertEquals(["TEST"],
689 [ c.text for c in root["tag"] ])
690
698
700 XML = self.XML
701 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')
702 self.assertEquals(2, len(root.findall(".//{X}b")))
703 self.assertEquals(3, len(root.findall(".//b")))
704 self.assertEquals(2, len(root.findall("b")))
705
713
727
733
735 Element = self.Element
736 SubElement = self.etree.SubElement
737 root = Element("{objectified}root")
738 root.bool = True
739 self.assertEquals(root.bool, True)
740 self.assertEquals(root.bool + root.bool, True + True)
741 self.assertEquals(True + root.bool, True + root.bool)
742 self.assertEquals(root.bool * root.bool, True * True)
743 self.assertEquals(int(root.bool), int(True))
744 self.assertEquals(complex(root.bool), complex(True))
745 self.assert_(isinstance(root.bool, objectify.BoolElement))
746
747 root.bool = False
748 self.assertEquals(root.bool, False)
749 self.assertEquals(root.bool + root.bool, False + False)
750 self.assertEquals(False + root.bool, False + root.bool)
751 self.assertEquals(root.bool * root.bool, False * False)
752 self.assertEquals(int(root.bool), int(False))
753 self.assertEquals(complex(root.bool), complex(False))
754 self.assert_(isinstance(root.bool, objectify.BoolElement))
755
764
771
778
785
787 Element = self.Element
788 SubElement = self.etree.SubElement
789 root = Element("{objectified}root")
790 root.s = "test"
791
792 self.assertEquals("test" * 5, root.s * 5)
793 self.assertEquals(5 * "test", 5 * root.s)
794
795 self.assertRaises(TypeError, operator.mul, root.s, "honk")
796 self.assertRaises(TypeError, operator.mul, "honk", root.s)
797
807
828
833
838
843
848
857
862
867
872
879
886
893
895 Element = self.Element
896 SubElement = self.etree.SubElement
897 root = Element("{objectified}root")
898 root.s = u"test"
899
900 self.assertEquals(u"test" * 5, root.s * 5)
901 self.assertEquals(5 * u"test", 5 * root.s)
902
903 self.assertRaises(TypeError, operator.mul, root.s, u"honk")
904 self.assertRaises(TypeError, operator.mul, u"honk", root.s)
905
915
920
925
930
937
942
949
954
956 for xsi, objclass in xsitype2objclass.iteritems():
957
958 pyval = 1
959 value = objectify.DataElement(pyval, _xsi=xsi)
960 self.assert_(isinstance(value, objclass),
961 "DataElement(%s, _xsi='%s') returns %s, expected %s"
962 % (pyval, xsi, type(value), objclass))
963
965 for xsi, objclass in xsitype2objclass.iteritems():
966
967 pyval = 1
968 value = objectify.DataElement(pyval, _xsi="xsd:%s" % xsi)
969 self.assert_(isinstance(value, objclass),
970 "DataElement(%s, _xsi='%s') returns %s, expected %s"
971 % (pyval, xsi, type(value), objclass))
972
978
980 for pytype, objclass in pytype2objclass.iteritems():
981
982 pyval = 1
983 value = objectify.DataElement(pyval, _pytype=pytype)
984 self.assert_(isinstance(value, objclass),
985 "DataElement(%s, _pytype='%s') returns %s, expected %s"
986 % (pyval, pytype, type(value), objclass))
987
989 pyval = 1
990 pytype = "NoneType"
991 objclass = objectify.NoneElement
992 value = objectify.DataElement(pyval, _pytype=pytype)
993 self.assert_(isinstance(value, objclass),
994 "DataElement(%s, _pytype='%s') returns %s, expected %s"
995 % (pyval, pytype, type(value), objclass))
996 self.assertEquals(value.text, None)
997 self.assertEquals(value.pyval, None)
998
1000
1001 pyval = 1
1002 pytype = "none"
1003 objclass = objectify.NoneElement
1004 value = objectify.DataElement(pyval, _pytype=pytype)
1005 self.assert_(isinstance(value, objclass),
1006 "DataElement(%s, _pytype='%s') returns %s, expected %s"
1007 % (pyval, pytype, type(value), objclass))
1008 self.assertEquals(value.text, None)
1009 self.assertEquals(value.pyval, None)
1010
1016 root = Element("{objectified}root")
1017 root.myfloat = MyFloat(5.5)
1018 self.assert_(isinstance(root.myfloat, objectify.FloatElement))
1019 self.assertEquals(root.myfloat.get(objectify.PYTYPE_ATTRIBUTE), None)
1020
1022 class MyFloat(float):
1023 pass
1024 value = objectify.DataElement(MyFloat(5.5))
1025 self.assert_(isinstance(value, objectify.FloatElement))
1026 self.assertEquals(value, 5.5)
1027 self.assertEquals(value.get(objectify.PYTYPE_ATTRIBUTE), None)
1028
1030 XML = self.XML
1031 root = XML('''\
1032 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
1033 <b xsi:type="boolean">true</b>
1034 <b xsi:type="boolean">false</b>
1035 <b xsi:type="boolean">1</b>
1036 <b xsi:type="boolean">0</b>
1037
1038 <f xsi:type="float">5</f>
1039 <f xsi:type="double">5</f>
1040
1041 <s xsi:type="string">5</s>
1042 <s xsi:type="normalizedString">5</s>
1043 <s xsi:type="token">5</s>
1044 <s xsi:type="language">5</s>
1045 <s xsi:type="Name">5</s>
1046 <s xsi:type="NCName">5</s>
1047 <s xsi:type="ID">5</s>
1048 <s xsi:type="IDREF">5</s>
1049 <s xsi:type="ENTITY">5</s>
1050 <s xsi:type="NMTOKEN">5</s>
1051
1052 <l xsi:type="integer">5</l>
1053 <l xsi:type="nonPositiveInteger">5</l>
1054 <l xsi:type="negativeInteger">5</l>
1055 <l xsi:type="long">5</l>
1056 <l xsi:type="nonNegativeInteger">5</l>
1057 <l xsi:type="unsignedLong">5</l>
1058 <l xsi:type="unsignedInt">5</l>
1059 <l xsi:type="positiveInteger">5</l>
1060
1061 <i xsi:type="int">5</i>
1062 <i xsi:type="short">5</i>
1063 <i xsi:type="byte">5</i>
1064 <i xsi:type="unsignedShort">5</i>
1065 <i xsi:type="unsignedByte">5</i>
1066
1067 <n xsi:nil="true"/>
1068 </root>
1069 ''')
1070
1071 for b in root.b:
1072 self.assert_(isinstance(b, objectify.BoolElement))
1073 self.assertEquals(True, root.b[0])
1074 self.assertEquals(False, root.b[1])
1075 self.assertEquals(True, root.b[2])
1076 self.assertEquals(False, root.b[3])
1077
1078 for f in root.f:
1079 self.assert_(isinstance(f, objectify.FloatElement))
1080 self.assertEquals(5, f)
1081
1082 for s in root.s:
1083 self.assert_(isinstance(s, objectify.StringElement))
1084 self.assertEquals("5", s)
1085
1086 for l in root.l:
1087 self.assert_(isinstance(l, objectify.LongElement))
1088 self.assertEquals(5L, l)
1089
1090 for i in root.i:
1091 self.assert_(isinstance(i, objectify.IntElement))
1092 self.assertEquals(5, i)
1093
1094 self.assert_(isinstance(root.n, objectify.NoneElement))
1095 self.assertEquals(None, root.n)
1096
1098 XML = self.XML
1099 root = XML('''\
1100 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1101 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
1102 <b xsi:type="xsd:boolean">true</b>
1103 <b xsi:type="xsd:boolean">false</b>
1104 <b xsi:type="xsd:boolean">1</b>
1105 <b xsi:type="xsd:boolean">0</b>
1106
1107 <f xsi:type="xsd:float">5</f>
1108 <f xsi:type="xsd:double">5</f>
1109
1110 <s xsi:type="xsd:string">5</s>
1111 <s xsi:type="xsd:normalizedString">5</s>
1112 <s xsi:type="xsd:token">5</s>
1113 <s xsi:type="xsd:language">5</s>
1114 <s xsi:type="xsd:Name">5</s>
1115 <s xsi:type="xsd:NCName">5</s>
1116 <s xsi:type="xsd:ID">5</s>
1117 <s xsi:type="xsd:IDREF">5</s>
1118 <s xsi:type="xsd:ENTITY">5</s>
1119 <s xsi:type="xsd:NMTOKEN">5</s>
1120
1121 <l xsi:type="xsd:integer">5</l>
1122 <l xsi:type="xsd:nonPositiveInteger">5</l>
1123 <l xsi:type="xsd:negativeInteger">5</l>
1124 <l xsi:type="xsd:long">5</l>
1125 <l xsi:type="xsd:nonNegativeInteger">5</l>
1126 <l xsi:type="xsd:unsignedLong">5</l>
1127 <l xsi:type="xsd:unsignedInt">5</l>
1128 <l xsi:type="xsd:positiveInteger">5</l>
1129
1130 <i xsi:type="xsd:int">5</i>
1131 <i xsi:type="xsd:short">5</i>
1132 <i xsi:type="xsd:byte">5</i>
1133 <i xsi:type="xsd:unsignedShort">5</i>
1134 <i xsi:type="xsd:unsignedByte">5</i>
1135
1136 <n xsi:nil="true"/>
1137 </root>
1138 ''')
1139
1140 for b in root.b:
1141 self.assert_(isinstance(b, objectify.BoolElement))
1142 self.assertEquals(True, root.b[0])
1143 self.assertEquals(False, root.b[1])
1144 self.assertEquals(True, root.b[2])
1145 self.assertEquals(False, root.b[3])
1146
1147 for f in root.f:
1148 self.assert_(isinstance(f, objectify.FloatElement))
1149 self.assertEquals(5, f)
1150
1151 for s in root.s:
1152 self.assert_(isinstance(s, objectify.StringElement))
1153 self.assertEquals("5", s)
1154
1155 for l in root.l:
1156 self.assert_(isinstance(l, objectify.LongElement))
1157 self.assertEquals(5L, l)
1158
1159 for i in root.i:
1160 self.assert_(isinstance(i, objectify.IntElement))
1161 self.assertEquals(5, i)
1162
1163 self.assert_(isinstance(root.n, objectify.NoneElement))
1164 self.assertEquals(None, root.n)
1165
1167 XML = self.XML
1168 root = XML(u'<root><b>why</b><b>try</b></root>')
1169 strs = [ str(s) for s in root.b ]
1170 self.assertEquals(["why", "try"],
1171 strs)
1172
1174 XML = self.XML
1175 root = XML(u'<root><b>test</b><b>taste</b><b></b><b/></root>')
1176 self.assertFalse(root.b[0] < root.b[1])
1177 self.assertFalse(root.b[0] <= root.b[1])
1178 self.assertFalse(root.b[0] == root.b[1])
1179
1180 self.assert_(root.b[0] != root.b[1])
1181 self.assert_(root.b[0] >= root.b[1])
1182 self.assert_(root.b[0] > root.b[1])
1183
1184 self.assertEquals(root.b[0], "test")
1185 self.assertEquals("test", root.b[0])
1186 self.assert_(root.b[0] > 5)
1187 self.assert_(5 < root.b[0])
1188
1189 self.assertEquals("", root.b[2])
1190 self.assertEquals(root.b[2], "")
1191 self.assertEquals("", root.b[3])
1192 self.assertEquals(root.b[3], "")
1193 self.assertEquals(root.b[2], root.b[3])
1194
1195 root.b = "test"
1196 self.assert_(root.b)
1197 root.b = ""
1198 self.assertFalse(root.b)
1199 self.assertEquals(root.b, "")
1200 self.assertEquals("", root.b)
1201
1222
1223
1224
1248
1250 XML = self.XML
1251 root = XML(u"""
1252 <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
1253 <b xsi:nil="true"></b><b xsi:nil="true"/>
1254 </root>""")
1255 self.assert_(root.b[0] == root.b[1])
1256 self.assertFalse(root.b[0])
1257 self.assertEquals(root.b[0], None)
1258 self.assertEquals(None, root.b[0])
1259
1260 for comparison in ["abc", 5, 7.3, True, [], ()]:
1261 none = root.b[1]
1262 self.assert_(none < comparison, "%s (%s) should be < %s" %
1263 (none, type(none), comparison) )
1264 self.assert_(comparison > none, "%s should be > %s (%s)" %
1265 (comparison, none, type(none)) )
1266
1272
1279
1283
1285 XML = self.XML
1286 root = XML(u'''\
1287 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1288 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1289 <b>5</b>
1290 <b>test</b>
1291 <c>1.1</c>
1292 <c>\uF8D2</c>
1293 <x>true</x>
1294 <n xsi:nil="true" />
1295 <n></n>
1296 <b xsi:type="double">5</b>
1297 <b xsi:type="float">5</b>
1298 <s xsi:type="string">23</s>
1299 <s py:pytype="str">42</s>
1300 <f py:pytype="float">300</f>
1301 <l py:pytype="long">2</l>
1302 <t py:pytype="TREE"></t>
1303 </a>
1304 ''')
1305 objectify.annotate(root)
1306
1307 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1308 for c in root.iterchildren() ]
1309 self.assertEquals("int", child_types[ 0])
1310 self.assertEquals("str", child_types[ 1])
1311 self.assertEquals("float", child_types[ 2])
1312 self.assertEquals("str", child_types[ 3])
1313 self.assertEquals("bool", child_types[ 4])
1314 self.assertEquals("NoneType", child_types[ 5])
1315 self.assertEquals(None, child_types[ 6])
1316 self.assertEquals("float", child_types[ 7])
1317 self.assertEquals("float", child_types[ 8])
1318 self.assertEquals("str", child_types[ 9])
1319 self.assertEquals("int", child_types[10])
1320 self.assertEquals("int", child_types[11])
1321 self.assertEquals("int", child_types[12])
1322 self.assertEquals(None, child_types[13])
1323
1324 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1325
1345
1347 XML = self.XML
1348 root = XML(u'''\
1349 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1350 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1351 <b>5</b>
1352 <b>test</b>
1353 <c>1.1</c>
1354 <c>\uF8D2</c>
1355 <x>true</x>
1356 <n xsi:nil="true" />
1357 <n></n>
1358 <b xsi:type="double">5</b>
1359 <b xsi:type="float">5</b>
1360 <s xsi:type="string">23</s>
1361 <s py:pytype="str">42</s>
1362 <f py:pytype="float">300</f>
1363 <l py:pytype="long">2</l>
1364 <t py:pytype="TREE"></t>
1365 </a>
1366 ''')
1367 objectify.annotate(root, ignore_old=False)
1368
1369 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1370 for c in root.iterchildren() ]
1371 self.assertEquals("int", child_types[ 0])
1372 self.assertEquals("str", child_types[ 1])
1373 self.assertEquals("float", child_types[ 2])
1374 self.assertEquals("str", child_types[ 3])
1375 self.assertEquals("bool", child_types[ 4])
1376 self.assertEquals("NoneType", child_types[ 5])
1377 self.assertEquals(None, child_types[ 6])
1378 self.assertEquals("float", child_types[ 7])
1379 self.assertEquals("float", child_types[ 8])
1380 self.assertEquals("str", child_types[ 9])
1381 self.assertEquals("str", child_types[10])
1382 self.assertEquals("float", child_types[11])
1383 self.assertEquals("long", child_types[12])
1384 self.assertEquals(TREE_PYTYPE, child_types[13])
1385
1386 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1387
1389 XML = self.XML
1390 root = XML(u'''\
1391 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1392 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1393 <b>5</b>
1394 <b>test</b>
1395 <c>1.1</c>
1396 <c>\uF8D2</c>
1397 <x>true</x>
1398 <n xsi:nil="true" />
1399 <n></n>
1400 <b xsi:type="double">5</b>
1401 <b xsi:type="float">5</b>
1402 <s xsi:type="string">23</s>
1403 <s py:pytype="str">42</s>
1404 <f py:pytype="float">300</f>
1405 <l py:pytype="long">2</l>
1406 <t py:pytype="TREE"></t>
1407 </a>
1408 ''')
1409 objectify.annotate(root, ignore_old=False, ignore_xsi=False,
1410 annotate_xsi=1, annotate_pytype=1)
1411
1412
1413 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1414 for c in root.iterchildren() ]
1415 self.assertEquals("int", child_types[ 0])
1416 self.assertEquals("str", child_types[ 1])
1417 self.assertEquals("float", child_types[ 2])
1418 self.assertEquals("str", child_types[ 3])
1419 self.assertEquals("bool", child_types[ 4])
1420 self.assertEquals("NoneType", child_types[ 5])
1421 self.assertEquals(None, child_types[ 6])
1422 self.assertEquals("float", child_types[ 7])
1423 self.assertEquals("float", child_types[ 8])
1424 self.assertEquals("str", child_types[ 9])
1425 self.assertEquals("str", child_types[10])
1426 self.assertEquals("float", child_types[11])
1427 self.assertEquals("long", child_types[12])
1428 self.assertEquals(TREE_PYTYPE, child_types[13])
1429
1430 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1431
1432 child_xsitypes = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1433 for c in root.iterchildren() ]
1434
1435
1436 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1437 for c in root.iterchildren() ]
1438 self.assertEquals("xsd:int", child_types[ 0])
1439 self.assertEquals("xsd:string", child_types[ 1])
1440 self.assertEquals("xsd:double", child_types[ 2])
1441 self.assertEquals("xsd:string", child_types[ 3])
1442 self.assertEquals("xsd:boolean", child_types[ 4])
1443 self.assertEquals(None, child_types[ 5])
1444 self.assertEquals(None, child_types[ 6])
1445 self.assertEquals("xsd:double", child_types[ 7])
1446 self.assertEquals("xsd:float", child_types[ 8])
1447 self.assertEquals("xsd:string", child_types[ 9])
1448 self.assertEquals("xsd:string", child_types[10])
1449 self.assertEquals("xsd:double", child_types[11])
1450 self.assertEquals("xsd:integer", child_types[12])
1451 self.assertEquals(None, child_types[13])
1452
1453 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1454
1456 XML = self.XML
1457 root = XML(u'''\
1458 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1459 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1460 <b>5</b>
1461 <b>test</b>
1462 <c>1.1</c>
1463 <c>\uF8D2</c>
1464 <x>true</x>
1465 <n xsi:nil="true" />
1466 <n></n>
1467 <b xsi:type="double">5</b>
1468 <b xsi:type="float">5</b>
1469 <s xsi:type="string">23</s>
1470 <s py:pytype="str">42</s>
1471 <f py:pytype="float">300</f>
1472 <l py:pytype="long">2</l>
1473 <t py:pytype="TREE"></t>
1474 </a>
1475 ''')
1476 objectify.xsiannotate(root, ignore_old=False)
1477
1478 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1479 for c in root.iterchildren() ]
1480 self.assertEquals("xsd:int", child_types[ 0])
1481 self.assertEquals("xsd:string", child_types[ 1])
1482 self.assertEquals("xsd:double", child_types[ 2])
1483 self.assertEquals("xsd:string", child_types[ 3])
1484 self.assertEquals("xsd:boolean", child_types[ 4])
1485 self.assertEquals(None, child_types[ 5])
1486 self.assertEquals(None, child_types[ 6])
1487 self.assertEquals("xsd:double", child_types[ 7])
1488 self.assertEquals("xsd:float", child_types[ 8])
1489 self.assertEquals("xsd:string", child_types[ 9])
1490 self.assertEquals("xsd:string", child_types[10])
1491 self.assertEquals("xsd:double", child_types[11])
1492 self.assertEquals("xsd:integer", child_types[12])
1493 self.assertEquals(None, child_types[13])
1494
1496 XML = self.XML
1497 root = XML(u'''\
1498 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1499 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1500 <b>5</b>
1501 <b>test</b>
1502 <c>1.1</c>
1503 <c>\uF8D2</c>
1504 <x>true</x>
1505 <n xsi:nil="true" />
1506 <n></n>
1507 <b xsi:type="double">5</b>
1508 <b xsi:type="float">5</b>
1509 <s xsi:type="string">23</s>
1510 <s py:pytype="str">42</s>
1511 <f py:pytype="float">300</f>
1512 <l py:pytype="long">2</l>
1513 <t py:pytype="TREE"></t>
1514 </a>
1515 ''')
1516 objectify.pyannotate(root, ignore_old=True)
1517
1518 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1519 for c in root.iterchildren() ]
1520 self.assertEquals("int", child_types[ 0])
1521 self.assertEquals("str", child_types[ 1])
1522 self.assertEquals("float", child_types[ 2])
1523 self.assertEquals("str", child_types[ 3])
1524 self.assertEquals("bool", child_types[ 4])
1525 self.assertEquals("NoneType", child_types[ 5])
1526 self.assertEquals(None, child_types[ 6])
1527 self.assertEquals("float", child_types[ 7])
1528 self.assertEquals("float", child_types[ 8])
1529 self.assertEquals("str", child_types[ 9])
1530 self.assertEquals("int", child_types[10])
1531 self.assertEquals("int", child_types[11])
1532 self.assertEquals("int", child_types[12])
1533 self.assertEquals(None, child_types[13])
1534
1535 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1536
1556
1558 XML = self.XML
1559 root = XML(u'''\
1560 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1561 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1562 <b>5</b>
1563 <b>test</b>
1564 <c>1.1</c>
1565 <c>\uF8D2</c>
1566 <x>true</x>
1567 <n xsi:nil="true" />
1568 <n></n>
1569 <b xsi:type="double">5</b>
1570 <b xsi:type="float">5</b>
1571 <s xsi:type="string">23</s>
1572 <s py:pytype="str">42</s>
1573 <f py:pytype="float">300</f>
1574 <l py:pytype="long">2</l>
1575 <t py:pytype="TREE"></t>
1576 </a>
1577 ''')
1578 objectify.pyannotate(root)
1579
1580 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1581 for c in root.iterchildren() ]
1582 self.assertEquals("int", child_types[ 0])
1583 self.assertEquals("str", child_types[ 1])
1584 self.assertEquals("float", child_types[ 2])
1585 self.assertEquals("str", child_types[ 3])
1586 self.assertEquals("bool", child_types[ 4])
1587 self.assertEquals("NoneType", child_types[ 5])
1588 self.assertEquals(None, child_types[ 6])
1589 self.assertEquals("float", child_types[ 7])
1590 self.assertEquals("float", child_types[ 8])
1591 self.assertEquals("str", child_types[ 9])
1592 self.assertEquals("str", child_types[10])
1593 self.assertEquals("float", child_types[11])
1594 self.assertEquals("long", child_types[12])
1595 self.assertEquals(TREE_PYTYPE, child_types[13])
1596
1597 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1598
1600 XML = self.XML
1601 root = XML(u'''\
1602 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1603 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1604 <b>5</b>
1605 <b>test</b>
1606 <c>1.1</c>
1607 <c>\uF8D2</c>
1608 <x>true</x>
1609 <n xsi:nil="true" />
1610 <n></n>
1611 <b xsi:type="double">5</b>
1612 <b xsi:type="float">5</b>
1613 <s xsi:type="string">23</s>
1614 <s py:pytype="str">42</s>
1615 <f py:pytype="float">300</f>
1616 <l py:pytype="long">2</l>
1617 <t py:pytype="TREE"></t>
1618 </a>
1619 ''')
1620 objectify.xsiannotate(root, ignore_old=True)
1621
1622 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1623 for c in root.iterchildren() ]
1624 self.assertEquals("xsd:int", child_types[ 0])
1625 self.assertEquals("xsd:string", child_types[ 1])
1626 self.assertEquals("xsd:double", child_types[ 2])
1627 self.assertEquals("xsd:string", child_types[ 3])
1628 self.assertEquals("xsd:boolean", child_types[ 4])
1629 self.assertEquals(None, child_types[ 5])
1630 self.assertEquals(None, child_types[ 6])
1631 self.assertEquals("xsd:int", child_types[ 7])
1632 self.assertEquals("xsd:int", child_types[ 8])
1633 self.assertEquals("xsd:int", child_types[ 9])
1634 self.assertEquals("xsd:string", child_types[10])
1635 self.assertEquals("xsd:double", child_types[11])
1636 self.assertEquals("xsd:integer", child_types[12])
1637 self.assertEquals(None, child_types[13])
1638
1639 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1640
1642 XML = self.XML
1643 root = XML(u'''\
1644 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1645 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1646 <b>5</b>
1647 <b>test</b>
1648 <c>1.1</c>
1649 <c>\uF8D2</c>
1650 <x>true</x>
1651 <n xsi:nil="true" />
1652 <n></n>
1653 <b xsi:type="double">5</b>
1654 <b xsi:type="float">5</b>
1655 <s xsi:type="string">23</s>
1656 <s py:pytype="str">42</s>
1657 <f py:pytype="float">300</f>
1658 <l py:pytype="long">2</l>
1659 <t py:pytype="TREE"></t>
1660 </a>
1661 ''')
1662 objectify.deannotate(root)
1663
1664 for c in root.getiterator():
1665 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1666 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1667
1668 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1669
1671 XML = self.XML
1672 root = XML(u'''\
1673 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1674 xmlns:py="http://codespeak.net/lxml/objectify/pytype">
1675 <b>5</b>
1676 <b>test</b>
1677 <c>1.1</c>
1678 <c>\uF8D2</c>
1679 <x>true</x>
1680 <n xsi:nil="true" />
1681 <n></n>
1682 <b xsi:type="double">5</b>
1683 <b xsi:type="float">5</b>
1684 <s xsi:type="string">23</s>
1685 <s py:pytype="str">42</s>
1686 <f py:pytype="float">300</f>
1687 <l py:pytype="long">2</l>
1688 <t py:pytype="TREE"></t>
1689 </a>
1690 ''')
1691 objectify.xsiannotate(root)
1692 objectify.deannotate(root, xsi=False)
1693
1694 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1695 for c in root.iterchildren() ]
1696 self.assertEquals("xsd:int", child_types[ 0])
1697 self.assertEquals("xsd:string", child_types[ 1])
1698 self.assertEquals("xsd:double", child_types[ 2])
1699 self.assertEquals("xsd:string", child_types[ 3])
1700 self.assertEquals("xsd:boolean", child_types[ 4])
1701 self.assertEquals(None, child_types[ 5])
1702 self.assertEquals(None, child_types[ 6])
1703 self.assertEquals("xsd:int", child_types[ 7])
1704 self.assertEquals("xsd:int", child_types[ 8])
1705 self.assertEquals("xsd:int", child_types[ 9])
1706 self.assertEquals("xsd:string", child_types[10])
1707 self.assertEquals("xsd:double", child_types[11])
1708 self.assertEquals("xsd:integer", child_types[12])
1709 self.assertEquals(None, child_types[13])
1710
1711 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1712
1713 for c in root.getiterator():
1714 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1715
1717 XML = self.XML
1718 root = XML(u'''\
1719 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1720 xmlns:py="http://codespeak.net/lxml/objectify/pytype"
1721 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
1722 <b>5</b>
1723 <b>test</b>
1724 <c>1.1</c>
1725 <c>\uF8D2</c>
1726 <x>true</x>
1727 <n xsi:nil="true" />
1728 <n></n>
1729 <b xsi:type="xsd:double">5</b>
1730 <b xsi:type="xsd:float">5</b>
1731 <s xsi:type="xsd:string">23</s>
1732 <s py:pytype="str">42</s>
1733 <f py:pytype="float">300</f>
1734 <l py:pytype="long">2</l>
1735 <t py:pytype="TREE"></t>
1736 </a>
1737 ''')
1738 objectify.annotate(root)
1739 objectify.deannotate(root, pytype=False)
1740
1741 child_types = [ c.get(objectify.PYTYPE_ATTRIBUTE)
1742 for c in root.iterchildren() ]
1743 self.assertEquals("int", child_types[ 0])
1744 self.assertEquals("str", child_types[ 1])
1745 self.assertEquals("float", child_types[ 2])
1746 self.assertEquals("str", child_types[ 3])
1747 self.assertEquals("bool", child_types[ 4])
1748 self.assertEquals("NoneType", child_types[ 5])
1749 self.assertEquals(None, child_types[ 6])
1750 self.assertEquals("float", child_types[ 7])
1751 self.assertEquals("float", child_types[ 8])
1752 self.assertEquals("str", child_types[ 9])
1753 self.assertEquals("int", child_types[10])
1754 self.assertEquals("int", child_types[11])
1755 self.assertEquals("int", child_types[12])
1756 self.assertEquals(None, child_types[13])
1757
1758 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1759
1760 for c in root.getiterator():
1761 self.assertEquals(None, c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR))
1762
1764 XML = self.XML
1765 root = XML(u'''\
1766 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1767 xmlns:py="http://codespeak.net/lxml/objectify/pytype"
1768 xmlns:xsd="http://www.w3.org/2001/XMLSchema">
1769 <b xsi:type="xsd:int">5</b>
1770 <b xsi:type="xsd:string">test</b>
1771 <c xsi:type="xsd:float">1.1</c>
1772 <c xsi:type="xsd:string">\uF8D2</c>
1773 <x xsi:type="xsd:boolean">true</x>
1774 <n xsi:nil="true" />
1775 <n></n>
1776 <b xsi:type="xsd:double">5</b>
1777 <b xsi:type="xsd:float">5</b>
1778 <s xsi:type="xsd:string">23</s>
1779 <s xsi:type="xsd:string">42</s>
1780 <f xsi:type="xsd:float">300</f>
1781 <l xsi:type="xsd:long">2</l>
1782 <t py:pytype="TREE"></t>
1783 </a>
1784 ''')
1785 objectify.annotate(root)
1786 objectify.deannotate(root, xsi=False)
1787
1788 child_types = [ c.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
1789 for c in root.iterchildren() ]
1790 self.assertEquals("xsd:int", child_types[ 0])
1791 self.assertEquals("xsd:string", child_types[ 1])
1792 self.assertEquals("xsd:float", child_types[ 2])
1793 self.assertEquals("xsd:string", child_types[ 3])
1794 self.assertEquals("xsd:boolean", child_types[ 4])
1795 self.assertEquals(None, child_types[ 5])
1796 self.assertEquals(None, child_types[ 6])
1797 self.assertEquals("xsd:double", child_types[ 7])
1798 self.assertEquals("xsd:float", child_types[ 8])
1799 self.assertEquals("xsd:string", child_types[ 9])
1800 self.assertEquals("xsd:string", child_types[10])
1801 self.assertEquals("xsd:float", child_types[11])
1802 self.assertEquals("xsd:long", child_types[12])
1803 self.assertEquals(None, child_types[13])
1804
1805 self.assertEquals("true", root.n.get(XML_SCHEMA_NIL_ATTR))
1806
1807 for c in root.getiterator():
1808 self.assertEquals(None, c.get(objectify.PYTYPE_ATTRIBUTE))
1809
1811 XML = self.XML
1812
1813 xml = u'''\
1814 <a xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
1815 <b>5</b>
1816 <b>test</b>
1817 <c>1.1</c>
1818 <c>\uF8D2</c>
1819 <x>true</x>
1820 <n xsi:nil="true" />
1821 <n></n>
1822 <b xsi:type="double">5</b>
1823 </a>
1824 '''
1825
1826 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}')
1827 objectify.set_pytype_attribute_tag("{TEST}test")
1828
1829 root = XML(xml)
1830 objectify.annotate(root)
1831
1832 attribs = root.xpath("//@py:%s" % pytype_name,
1833 namespaces={"py" : pytype_ns})
1834 self.assertEquals(0, len(attribs))
1835 attribs = root.xpath("//@py:test",
1836 namespaces={"py" : "TEST"})
1837 self.assertEquals(7, len(attribs))
1838
1839 objectify.set_pytype_attribute_tag()
1840 pytype_ns, pytype_name = objectify.PYTYPE_ATTRIBUTE[1:].split('}')
1841
1842 self.assertNotEqual("test", pytype_ns.lower())
1843 self.assertNotEqual("test", pytype_name.lower())
1844
1845 root = XML(xml)
1846 attribs = root.xpath("//@py:%s" % pytype_name,
1847 namespaces={"py" : pytype_ns})
1848 self.assertEquals(0, len(attribs))
1849
1850 objectify.annotate(root)
1851 attribs = root.xpath("//@py:%s" % pytype_name,
1852 namespaces={"py" : pytype_ns})
1853 self.assertEquals(7, len(attribs))
1854
1862
1863 def checkMyType(s):
1864 return True
1865
1866 pytype = objectify.PyType("mytype", checkMyType, NewType)
1867 self.assert_(pytype not in objectify.getRegisteredTypes())
1868 pytype.register()
1869 self.assert_(pytype in objectify.getRegisteredTypes())
1870 pytype.unregister()
1871 self.assert_(pytype not in objectify.getRegisteredTypes())
1872
1873 pytype.register(before = [objectify.getRegisteredTypes()[0].name])
1874 self.assertEquals(pytype, objectify.getRegisteredTypes()[0])
1875 pytype.unregister()
1876
1877 pytype.register(after = [objectify.getRegisteredTypes()[0].name])
1878 self.assertNotEqual(pytype, objectify.getRegisteredTypes()[0])
1879 pytype.unregister()
1880
1881 self.assertRaises(ValueError, pytype.register,
1882 before = [objectify.getRegisteredTypes()[0].name],
1883 after = [objectify.getRegisteredTypes()[1].name])
1884
1886 from datetime import datetime
1887 def parse_date(value):
1888 if len(value) != 14:
1889 raise ValueError(value)
1890 Y = int(value[0:4])
1891 M = int(value[4:6])
1892 D = int(value[6:8])
1893 h = int(value[8:10])
1894 m = int(value[10:12])
1895 s = int(value[12:14])
1896 return datetime(Y, M, D, h, m, s)
1897
1898 def stringify_date(date):
1899 return date.strftime("%Y%m%d%H%M%S")
1900
1901 class DatetimeElement(objectify.ObjectifiedDataElement):
1902 def pyval(self):
1903 return parse_date(self.text)
1904 pyval = property(pyval)
1905
1906 datetime_type = objectify.PyType(
1907 "datetime", parse_date, DatetimeElement, stringify_date)
1908 datetime_type.xmlSchemaTypes = "dateTime"
1909 datetime_type.register()
1910
1911 NAMESPACE = "http://foo.net/xmlns"
1912 NAMESPACE_MAP = {'ns': NAMESPACE}
1913
1914 r = objectify.Element("{%s}root" % NAMESPACE, nsmap=NAMESPACE_MAP)
1915 time = datetime.now()
1916 r.date = time
1917
1918 self.assert_(isinstance(r.date, DatetimeElement))
1919 self.assert_(isinstance(r.date.pyval, datetime))
1920
1921 self.assertEquals(r.date.pyval, parse_date(stringify_date(time)))
1922 self.assertEquals(r.date.text, stringify_date(time))
1923
1924 r.date = objectify.E.date(time)
1925
1926 self.assert_(isinstance(r.date, DatetimeElement))
1927 self.assert_(isinstance(r.date.pyval, datetime))
1928
1929 self.assertEquals(r.date.pyval, parse_date(stringify_date(time)))
1930 self.assertEquals(r.date.text, stringify_date(time))
1931
1937
1943
1949
1957
1976
1981
1986
1991
1996
2016
2018 root = self.XML(xml_str)
2019 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[0]'] )
2020 self.assertEquals(root.c1.c2.text, path(root).text)
2021
2022 path = objectify.ObjectPath( ['root', 'c1[0]', 'c2[2]'] )
2023 self.assertEquals(root.c1.c2[2].text, path(root).text)
2024
2025 path = objectify.ObjectPath( ['root', 'c1', 'c2[2]'] )
2026 self.assertEquals(root.c1.c2[2].text, path(root).text)
2027
2028 path = objectify.ObjectPath( ['root', 'c1', 'c2[-1]'] )
2029 self.assertEquals(root.c1.c2[-1].text, path(root).text)
2030
2031 path = objectify.ObjectPath( ['root', 'c1', 'c2[-3]'] )
2032 self.assertEquals(root.c1.c2[-3].text, path(root).text)
2033
2035 self.assertRaises(ValueError, objectify.ObjectPath,
2036 "root.c1[0].c2[-1-2]")
2037 self.assertRaises(ValueError, objectify.ObjectPath,
2038 ['root', 'c1[0]', 'c2[-1-2]'])
2039
2040 self.assertRaises(ValueError, objectify.ObjectPath,
2041 "root[2].c1.c2")
2042 self.assertRaises(ValueError, objectify.ObjectPath,
2043 ['root[2]', 'c1', 'c2'])
2044
2045 self.assertRaises(ValueError, objectify.ObjectPath,
2046 [])
2047 self.assertRaises(ValueError, objectify.ObjectPath,
2048 ['', '', ''])
2049
2051 root = self.XML(xml_str)
2052 path = objectify.ObjectPath("root.c1[9999].c2")
2053 self.assertRaises(AttributeError, path, root)
2054
2055 path = objectify.ObjectPath("root.c1[0].c2[9999]")
2056 self.assertRaises(AttributeError, path, root)
2057
2058 path = objectify.ObjectPath(".c1[9999].c2[0]")
2059 self.assertRaises(AttributeError, path, root)
2060
2061 path = objectify.ObjectPath("root.c1[-2].c2")
2062 self.assertRaises(AttributeError, path, root)
2063
2064 path = objectify.ObjectPath("root.c1[0].c2[-4]")
2065 self.assertRaises(AttributeError, path, root)
2066
2080
2082 root = self.XML(xml_str)
2083 path = objectify.ObjectPath( ['{objectified}root', 'c1', 'c2'] )
2084 self.assertEquals(root.c1.c2.text, path.find(root).text)
2085 path = objectify.ObjectPath( ['{objectified}root', '{objectified}c1', 'c2'] )
2086 self.assertEquals(root.c1.c2.text, path.find(root).text)
2087 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2'] )
2088 self.assertEquals(root.c1.c2.text, path.find(root).text)
2089 path = objectify.ObjectPath( ['root', '{objectified}c1', '{objectified}c2[2]'] )
2090 self.assertEquals(root.c1.c2[2].text, path.find(root).text)
2091 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2'] )
2092 self.assertEquals(root.c1.c2.text, path.find(root).text)
2093 path = objectify.ObjectPath( ['root', 'c1', '{objectified}c2[2]'] )
2094 self.assertEquals(root.c1.c2[2].text, path.find(root).text)
2095 path = objectify.ObjectPath( ['root', 'c1', '{otherNS}c2'] )
2096 self.assertEquals(getattr(root.c1, '{otherNS}c2').text,
2097 path.find(root).text)
2098
2111
2126
2138
2152
2154 root = self.XML(xml_str)
2155 path = objectify.ObjectPath( "root.c1.c99" )
2156 self.assertRaises(AttributeError, path.find, root)
2157
2158 new_el = self.Element("{objectified}test")
2159 new_el.a = ["TEST1", "TEST2"]
2160 new_el.a[0].set("myattr", "ATTR1")
2161 new_el.a[1].set("myattr", "ATTR2")
2162
2163 path.setattr(root, list(new_el.a))
2164
2165 self.assertEquals(2, len(root.c1.c99))
2166 self.assertEquals("ATTR1", root.c1.c99[0].get("myattr"))
2167 self.assertEquals("TEST1", root.c1.c99[0].text)
2168 self.assertEquals("ATTR2", root.c1.c99[1].get("myattr"))
2169 self.assertEquals("TEST2", root.c1.c99[1].text)
2170 self.assertEquals("TEST1", path(root).text)
2171
2180
2194
2206
2220
2235
2237 root = self.XML(xml_str)
2238 self.assertEquals(
2239 ['{objectified}root', '{objectified}root.c1',
2240 '{objectified}root.c1.c2',
2241 '{objectified}root.c1.c2[1]', '{objectified}root.c1.c2[2]',
2242 '{objectified}root.c1.{otherNS}c2', '{objectified}root.c1.{}c2'],
2243 root.descendantpaths())
2244
2246 root = self.XML(xml_str)
2247 self.assertEquals(
2248 ['{objectified}c1', '{objectified}c1.c2',
2249 '{objectified}c1.c2[1]', '{objectified}c1.c2[2]',
2250 '{objectified}c1.{otherNS}c2', '{objectified}c1.{}c2'],
2251 root.c1.descendantpaths())
2252
2254 root = self.XML(xml_str)
2255 self.assertEquals(
2256 ['root.{objectified}c1', 'root.{objectified}c1.c2',
2257 'root.{objectified}c1.c2[1]', 'root.{objectified}c1.c2[2]',
2258 'root.{objectified}c1.{otherNS}c2',
2259 'root.{objectified}c1.{}c2'],
2260 root.c1.descendantpaths('root'))
2261
2273
2274
2275
2280
2285
2290
2295
2300
2305
2310
2315
2320
2322 E = objectify.E
2323 DataElement = objectify.DataElement
2324 root = E.root("text", E.sub(E.subsub()), "tail", DataElement(1),
2325 DataElement(2.0))
2326 self.assert_(isinstance(root, objectify.ObjectifiedElement))
2327 self.assertEquals(root.text, "text")
2328 self.assert_(isinstance(root.sub, objectify.ObjectifiedElement))
2329 self.assertEquals(root.sub.tail, "tail")
2330 self.assert_(isinstance(root.sub.subsub, objectify.StringElement))
2331 self.assertEquals(len(root.value), 2)
2332 self.assert_(isinstance(root.value[0], objectify.IntElement))
2333 self.assert_(isinstance(root.value[1], objectify.FloatElement))
2334
2336 suite = unittest.TestSuite()
2337 suite.addTests([unittest.makeSuite(ObjectifyTestCase)])
2338 if sys.version_info >= (2,4):
2339 suite.addTests(
2340 [doctest.DocFileSuite('../../../doc/objectify.txt')])
2341 return suite
2342
2343 if __name__ == '__main__':
2344 print 'to test use test.py %s' % __file__
2345