Lines Matching refs:self
43 def __bool__(self):
46 def toxml(self, encoding=None, standalone=None):
47 return self.toprettyxml("", "", encoding, standalone)
49 def toprettyxml(self, indent="\t", newl="\n", encoding=None,
58 if self.nodeType == Node.DOCUMENT_NODE:
60 self.writexml(writer, "", indent, newl, encoding, standalone)
62 self.writexml(writer, "", indent, newl)
68 def hasChildNodes(self):
69 return bool(self.childNodes)
71 def _get_childNodes(self):
72 return self.childNodes
74 def _get_firstChild(self):
75 if self.childNodes:
76 return self.childNodes[0]
78 def _get_lastChild(self):
79 if self.childNodes:
80 return self.childNodes[-1]
82 def insertBefore(self, newChild, refChild):
83 if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
85 self.insertBefore(c, refChild)
88 if newChild.nodeType not in self._child_node_types:
90 "%s cannot be child of %s" % (repr(newChild), repr(self)))
94 self.appendChild(newChild)
97 index = self.childNodes.index(refChild)
101 _clear_id_cache(self)
102 self.childNodes.insert(index, newChild)
106 node = self.childNodes[index-1]
111 newChild.parentNode = self
114 def appendChild(self, node):
115 if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:
117 self.appendChild(c)
120 if node.nodeType not in self._child_node_types:
122 "%s cannot be child of %s" % (repr(node), repr(self)))
124 _clear_id_cache(self)
127 _append_child(self, node)
131 def replaceChild(self, newChild, oldChild):
132 if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
134 self.removeChild(oldChild)
135 return self.insertBefore(newChild, refChild)
136 if newChild.nodeType not in self._child_node_types:
138 "%s cannot be child of %s" % (repr(newChild), repr(self)))
144 index = self.childNodes.index(oldChild)
147 self.childNodes[index] = newChild
148 newChild.parentNode = self
152 _clear_id_cache(self)
163 def removeChild(self, oldChild):
165 self.childNodes.remove(oldChild)
174 _clear_id_cache(self)
179 def normalize(self):
181 for child in self.childNodes:
204 self.childNodes[:] = L
206 def cloneNode(self, deep):
207 return _clone_node(self, deep, self.ownerDocument or self)
209 def isSupported(self, feature, version):
210 return self.ownerDocument.implementation.hasFeature(feature, version)
212 def _get_localName(self):
218 def isSameNode(self, other):
219 return self is other
221 def getInterface(self, feature):
222 if self.isSupported(feature, None):
223 return self
231 def getUserData(self, key):
233 return self._user_data[key][0]
237 def setUserData(self, key, data, handler):
240 d = self._user_data
243 self._user_data = d
255 def _call_user_data_handler(self, operation, src, dst):
256 if hasattr(self, "_user_data"):
257 for key, (data, handler) in list(self._user_data.items()):
263 def unlink(self):
264 self.parentNode = self.ownerDocument = None
265 if self.childNodes:
266 for child in self.childNodes:
268 self.childNodes = NodeList()
269 self.previousSibling = None
270 self.nextSibling = None
274 def __enter__(self):
275 return self
277 def __exit__(self, et, ev, tb):
278 self.unlink()
285 def _append_child(self, node):
287 childNodes = self.childNodes
293 node.parentNode = self
341 def __init__(self):
342 self.childNodes = NodeList()
355 def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,
357 self.ownerElement = None
358 self._name = qName
359 self.namespaceURI = namespaceURI
360 self._prefix = prefix
362 self._localName = localName
363 self.childNodes = NodeList()
366 self.childNodes.append(Text())
370 def _get_localName(self):
372 return self._localName
374 return self.nodeName.split(":", 1)[-1]
376 def _get_specified(self):
377 return self.specified
379 def _get_name(self):
380 return self._name
382 def _set_name(self, value):
383 self._name = value
384 if self.ownerElement is not None:
385 _clear_id_cache(self.ownerElement)
389 def _get_value(self):
390 return self._value
392 def _set_value(self, value):
393 self._value = value
394 self.childNodes[0].data = value
395 if self.ownerElement is not None:
396 _clear_id_cache(self.ownerElement)
397 self.childNodes[0].data = value
401 def _get_prefix(self):
402 return self._prefix
404 def _set_prefix(self, prefix):
405 nsuri = self.namespaceURI
410 self._prefix = prefix
412 newName = self.localName
414 newName = "%s:%s" % (prefix, self.localName)
415 if self.ownerElement:
416 _clear_id_cache(self.ownerElement)
417 self.name = newName
421 def unlink(self):
426 elem = self.ownerElement
428 del elem._attrs[self.nodeName]
429 del elem._attrsNS[(self.namespaceURI, self.localName)]
430 if self._is_id:
431 self._is_id = False
433 self.ownerDocument._magic_id_count -= 1
434 for child in self.childNodes:
436 del self.childNodes[:]
438 def _get_isId(self):
439 if self._is_id:
441 doc = self.ownerDocument
442 elem = self.ownerElement
449 if self.namespaceURI:
450 return info.isIdNS(self.namespaceURI, self.localName)
452 return info.isId(self.nodeName)
454 def _get_schemaType(self):
455 doc = self.ownerDocument
456 elem = self.ownerElement
463 if self.namespaceURI:
464 return info.getAttributeTypeNS(self.namespaceURI, self.localName)
466 return info.getAttributeType(self.nodeName)
484 def __init__(self, attrs, attrsNS, ownerElement):
485 self._attrs = attrs
486 self._attrsNS = attrsNS
487 self._ownerElement = ownerElement
489 def _get_length(self):
490 return len(self._attrs)
492 def item(self, index):
494 return self[list(self._attrs.keys())[index]]
498 def items(self):
500 for node in self._attrs.values():
504 def itemsNS(self):
506 for node in self._attrs.values():
510 def __contains__(self, key):
512 return key in self._attrs
514 return key in self._attrsNS
516 def keys(self):
517 return self._attrs.keys()
519 def keysNS(self):
520 return self._attrsNS.keys()
522 def values(self):
523 return self._attrs.values()
525 def get(self, name, value=None):
526 return self._attrs.get(name, value)
530 def _cmp(self, other):
531 if self._attrs is getattr(other, "_attrs", None):
534 return (id(self) > id(other)) - (id(self) < id(other))
536 def __eq__(self, other):
537 return self._cmp(other) == 0
539 def __ge__(self, other):
540 return self._cmp(other) >= 0
542 def __gt__(self, other):
543 return self._cmp(other) > 0
545 def __le__(self, other):
546 return self._cmp(other) <= 0
548 def __lt__(self, other):
549 return self._cmp(other) < 0
551 def __getitem__(self, attname_or_tuple):
553 return self._attrsNS[attname_or_tuple]
555 return self._attrs[attname_or_tuple]
558 def __setitem__(self, attname, value):
561 node = self._attrs[attname]
564 node.ownerDocument = self._ownerElement.ownerDocument
565 self.setNamedItem(node)
571 self.setNamedItem(node)
573 def getNamedItem(self, name):
575 return self._attrs[name]
579 def getNamedItemNS(self, namespaceURI, localName):
581 return self._attrsNS[(namespaceURI, localName)]
585 def removeNamedItem(self, name):
586 n = self.getNamedItem(name)
588 _clear_id_cache(self._ownerElement)
589 del self._attrs[n.nodeName]
590 del self._attrsNS[(n.namespaceURI, n.localName)]
597 def removeNamedItemNS(self, namespaceURI, localName):
598 n = self.getNamedItemNS(namespaceURI, localName)
600 _clear_id_cache(self._ownerElement)
601 del self._attrsNS[(n.namespaceURI, n.localName)]
602 del self._attrs[n.nodeName]
609 def setNamedItem(self, node):
612 "%s cannot be child of %s" % (repr(node), repr(self)))
613 old = self._attrs.get(node.name)
616 self._attrs[node.name] = node
617 self._attrsNS[(node.namespaceURI, node.localName)] = node
618 node.ownerElement = self._ownerElement
622 def setNamedItemNS(self, node):
623 return self.setNamedItem(node)
625 def __delitem__(self, attname_or_tuple):
626 node = self[attname_or_tuple]
630 def __getstate__(self):
631 return self._attrs, self._attrsNS, self._ownerElement
633 def __setstate__(self, state):
634 self._attrs, self._attrsNS, self._ownerElement = state
645 def __init__(self, namespace, name):
646 self.namespace = namespace
647 self.name = name
649 def __repr__(self):
650 if self.namespace:
651 return "<%s %r (from %r)>" % (self.__class__.__name__, self.name,
652 self.namespace)
654 return "<%s %r>" % (self.__class__.__name__, self.name)
656 def _get_name(self):
657 return self.name
659 def _get_namespace(self):
660 return self.namespace
681 def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None,
683 self.parentNode = None
684 self.tagName = self.nodeName = tagName
685 self.prefix = prefix
686 self.namespaceURI = namespaceURI
687 self.childNodes = NodeList()
688 self.nextSibling = self.previousSibling = None
698 self._attrs = None
699 self._attrsNS = None
701 def _ensure_attributes(self):
702 if self._attrs is None:
703 self._attrs = {}
704 self._attrsNS = {}
706 def _get_localName(self):
708 return self._localName
710 return self.tagName.split(":", 1)[-1]
712 def _get_tagName(self):
713 return self.tagName
715 def unlink(self):
716 if self._attrs is not None:
717 for attr in list(self._attrs.values()):
719 self._attrs = None
720 self._attrsNS = None
721 Node.unlink(self)
723 def getAttribute(self, attname):
732 if self._attrs is None:
735 return self._attrs[attname].value
739 def getAttributeNS(self, namespaceURI, localName):
740 if self._attrsNS is None:
743 return self._attrsNS[(namespaceURI, localName)].value
747 def setAttribute(self, attname, value):
748 attr = self.getAttributeNode(attname)
752 attr.ownerDocument = self.ownerDocument
753 self.setAttributeNode(attr)
757 _clear_id_cache(self)
759 def setAttributeNS(self, namespaceURI, qualifiedName, value):
761 attr = self.getAttributeNodeNS(namespaceURI, localname)
765 attr.ownerDocument = self.ownerDocument
766 self.setAttributeNode(attr)
771 _clear_id_cache(self)
776 def getAttributeNode(self, attrname):
777 if self._attrs is None:
779 return self._attrs.get(attrname)
781 def getAttributeNodeNS(self, namespaceURI, localName):
782 if self._attrsNS is None:
784 return self._attrsNS.get((namespaceURI, localName))
786 def setAttributeNode(self, attr):
787 if attr.ownerElement not in (None, self):
789 self._ensure_attributes()
790 old1 = self._attrs.get(attr.name, None)
792 self.removeAttributeNode(old1)
793 old2 = self._attrsNS.get((attr.namespaceURI, attr.localName), None)
795 self.removeAttributeNode(old2)
796 _set_attribute_node(self, attr)
807 def removeAttribute(self, name):
808 if self._attrsNS is None:
811 attr = self._attrs[name]
814 self.removeAttributeNode(attr)
816 def removeAttributeNS(self, namespaceURI, localName):
817 if self._attrsNS is None:
820 attr = self._attrsNS[(namespaceURI, localName)]
823 self.removeAttributeNode(attr)
825 def removeAttributeNode(self, node):
829 self._attrs[node.name]
832 _clear_id_cache(self)
836 node.ownerDocument = self.ownerDocument
841 def hasAttribute(self, name):
847 if self._attrs is None:
849 return name in self._attrs
851 def hasAttributeNS(self, namespaceURI, localName):
852 if self._attrsNS is None:
854 return (namespaceURI, localName) in self._attrsNS
856 def getElementsByTagName(self, name):
862 return _get_elements_by_tagName_helper(self, name, NodeList())
864 def getElementsByTagNameNS(self, namespaceURI, localName):
866 self, namespaceURI, localName, NodeList())
868 def __repr__(self):
869 return "<DOM Element: %s at %#x>" % (self.tagName, id(self))
871 def writexml(self, writer, indent="", addindent="", newl=""):
880 writer.write(indent+"<" + self.tagName)
882 attrs = self._get_attributes()
888 if self.childNodes:
890 if (len(self.childNodes) == 1 and
891 self.childNodes[0].nodeType in (
893 self.childNodes[0].writexml(writer, '', '', '')
896 for node in self.childNodes:
899 writer.write("</%s>%s" % (self.tagName, newl))
903 def _get_attributes(self):
904 self._ensure_attributes()
905 return NamedNodeMap(self._attrs, self._attrsNS, self)
907 def hasAttributes(self):
908 if self._attrs:
915 def setIdAttribute(self, name):
916 idAttr = self.getAttributeNode(name)
917 self.setIdAttributeNode(idAttr)
919 def setIdAttributeNS(self, namespaceURI, localName):
920 idAttr = self.getAttributeNodeNS(namespaceURI, localName)
921 self.setIdAttributeNode(idAttr)
923 def setIdAttributeNode(self, idAttr):
924 if idAttr is None or not self.isSameNode(idAttr.ownerElement):
926 if _get_containing_entref(self) is not None:
930 self._magic_id_nodes += 1
931 self.ownerDocument._magic_id_count += 1
932 _clear_id_cache(self)
962 def _get_firstChild(self):
965 def _get_lastChild(self):
968 def appendChild(self, node):
970 self.nodeName + " nodes cannot have children")
972 def hasChildNodes(self):
975 def insertBefore(self, newChild, refChild):
977 self.nodeName + " nodes do not have children")
979 def removeChild(self, oldChild):
981 self.nodeName + " nodes do not have children")
983 def normalize(self):
987 def replaceChild(self, newChild, oldChild):
989 self.nodeName + " nodes do not have children")
996 def __init__(self, target, data):
997 self.target = target
998 self.data = data
1001 def _get_nodeValue(self):
1002 return self.data
1003 def _set_nodeValue(self, value):
1004 self.data = value
1008 def _get_nodeName(self):
1009 return self.target
1010 def _set_nodeName(self, value):
1011 self.target = value
1014 def writexml(self, writer, indent="", addindent="", newl=""):
1015 writer.write("%s<?%s %s?>%s" % (indent,self.target, self.data, newl))
1021 def __init__(self):
1022 self.ownerDocument = self.parentNode = None
1023 self.previousSibling = self.nextSibling = None
1024 self._data = ''
1025 Node.__init__(self)
1027 def _get_length(self):
1028 return len(self.data)
1031 def _get_data(self):
1032 return self._data
1033 def _set_data(self, data):
1034 self._data = data
1038 def __repr__(self):
1039 data = self.data
1045 self.__class__.__name__, data[0:10], dotdotdot)
1047 def substringData(self, offset, count):
1050 if offset >= len(self.data):
1054 return self.data[offset:offset+count]
1056 def appendData(self, arg):
1057 self.data = self.data + arg
1059 def insertData(self, offset, arg):
1062 if offset >= len(self.data):
1065 self.data = "%s%s%s" % (
1066 self.data[:offset], arg, self.data[offset:])
1068 def deleteData(self, offset, count):
1071 if offset >= len(self.data):
1076 self.data = self.data[:offset] + self.data[offset+count:]
1078 def replaceData(self, offset, count, arg):
1081 if offset >= len(self.data):
1086 self.data = "%s%s%s" % (
1087 self.data[:offset], arg, self.data[offset+count:])
1099 def splitText(self, offset):
1100 if offset < 0 or offset > len(self.data):
1102 newText = self.__class__()
1103 newText.data = self.data[offset:]
1104 newText.ownerDocument = self.ownerDocument
1105 next = self.nextSibling
1106 if self.parentNode and self in self.parentNode.childNodes:
1108 self.parentNode.appendChild(newText)
1110 self.parentNode.insertBefore(newText, next)
1111 self.data = self.data[:offset]
1114 def writexml(self, writer, indent="", addindent="", newl=""):
1115 _write_data(writer, "%s%s%s" % (indent, self.data, newl))
1119 def _get_wholeText(self):
1120 L = [self.data]
1121 n = self.previousSibling
1128 n = self.nextSibling
1137 def replaceWholeText(self, content):
1140 parent = self.parentNode
1141 n = self.previousSibling
1149 n = self.nextSibling
1151 parent.removeChild(self)
1160 self.data = content
1161 return self
1165 def _get_isWhitespaceInElementContent(self):
1166 if self.data.strip():
1168 elem = _get_containing_element(self)
1171 info = self.ownerDocument._get_elem_info(elem)
1205 def __init__(self, data):
1206 CharacterData.__init__(self)
1207 self._data = data
1209 def writexml(self, writer, indent="", addindent="", newl=""):
1210 if "--" in self.data:
1212 writer.write("%s<!--%s-->%s" % (indent, self.data, newl))
1221 def writexml(self, writer, indent="", addindent="", newl=""):
1222 if self.data.find("]]>") >= 0:
1224 writer.write("<![CDATA[%s]]>" % self.data)
1230 def __init__(self, seq=()):
1232 self._seq = seq
1234 def __len__(self):
1235 return len(self._seq)
1237 def _get_length(self):
1238 return len(self._seq)
1240 def getNamedItem(self, name):
1241 for n in self._seq:
1245 def getNamedItemNS(self, namespaceURI, localName):
1246 for n in self._seq:
1250 def __getitem__(self, name_or_tuple):
1252 node = self.getNamedItemNS(*name_or_tuple)
1254 node = self.getNamedItem(name_or_tuple)
1259 def item(self, index):
1263 return self._seq[index]
1267 def removeNamedItem(self, name):
1271 def removeNamedItemNS(self, namespaceURI, localName):
1275 def setNamedItem(self, node):
1279 def setNamedItemNS(self, node):
1283 def __getstate__(self):
1284 return [self._seq]
1286 def __setstate__(self, state):
1287 self._seq = state[0]
1298 def _identified_mixin_init(self, publicId, systemId):
1299 self.publicId = publicId
1300 self.systemId = systemId
1302 def _get_publicId(self):
1303 return self.publicId
1305 def _get_systemId(self):
1306 return self.systemId
1316 def __init__(self, qualifiedName):
1317 self.entities = ReadOnlySequentialNamedNodeMap()
1318 self.notations = ReadOnlySequentialNamedNodeMap()
1321 self.name = localname
1322 self.nodeName = self.name
1324 def _get_internalSubset(self):
1325 return self.internalSubset
1327 def cloneNode(self, deep):
1328 if self.ownerDocument is None:
1331 clone.name = self.name
1332 clone.nodeName = self.name
1337 for n in self.notations._seq:
1341 for e in self.entities._seq:
1349 self._call_user_data_handler(operation, self, clone)
1354 def writexml(self, writer, indent="", addindent="", newl=""):
1356 writer.write(self.name)
1357 if self.publicId:
1359 % (newl, self.publicId, newl, self.systemId))
1360 elif self.systemId:
1361 writer.write("%s SYSTEM '%s'" % (newl, self.systemId))
1362 if self.internalSubset is not None:
1364 writer.write(self.internalSubset)
1377 def __init__(self, name, publicId, systemId, notation):
1378 self.nodeName = name
1379 self.notationName = notation
1380 self.childNodes = NodeList()
1381 self._identified_mixin_init(publicId, systemId)
1383 def _get_actualEncoding(self):
1384 return self.actualEncoding
1386 def _get_encoding(self):
1387 return self.encoding
1389 def _get_version(self):
1390 return self.version
1392 def appendChild(self, newChild):
1396 def insertBefore(self, newChild, refChild):
1400 def removeChild(self, oldChild):
1404 def replaceChild(self, newChild, oldChild):
1412 def __init__(self, name, publicId, systemId):
1413 self.nodeName = name
1414 self._identified_mixin_init(publicId, systemId)
1428 def hasFeature(self, feature, version):
1431 return (feature.lower(), version) in self._features
1433 def createDocument(self, namespaceURI, qualifiedName, doctype):
1437 doc = self._create_document()
1475 doc.implementation = self
1478 def createDocumentType(self, qualifiedName, publicId, systemId):
1486 def getInterface(self, feature):
1487 if self.hasFeature(feature, None):
1488 return self
1493 def _create_document(self):
1507 def __init__(self, name):
1508 self.tagName = name
1510 def getAttributeType(self, aname):
1513 def getAttributeTypeNS(self, namespaceURI, localName):
1516 def isElementContent(self):
1519 def isEmpty(self):
1524 def isId(self, aname):
1528 def isIdNS(self, namespaceURI, localName):
1532 def __getstate__(self):
1533 return self.tagName
1535 def __setstate__(self, state):
1536 self.tagName = state
1573 def __init__(self):
1574 self.doctype = None
1575 self.childNodes = NodeList()
1578 self._elem_info = {}
1579 self._id_cache = {}
1580 self._id_search_stack = None
1582 def _get_elem_info(self, element):
1587 return self._elem_info.get(key)
1589 def _get_actualEncoding(self):
1590 return self.actualEncoding
1592 def _get_doctype(self):
1593 return self.doctype
1595 def _get_documentURI(self):
1596 return self.documentURI
1598 def _get_encoding(self):
1599 return self.encoding
1601 def _get_errorHandler(self):
1602 return self.errorHandler
1604 def _get_standalone(self):
1605 return self.standalone
1607 def _get_strictErrorChecking(self):
1608 return self.strictErrorChecking
1610 def _get_version(self):
1611 return self.version
1613 def appendChild(self, node):
1614 if node.nodeType not in self._child_node_types:
1616 "%s cannot be child of %s" % (repr(node), repr(self)))
1624 and self._get_documentElement():
1627 return Node.appendChild(self, node)
1629 def removeChild(self, oldChild):
1631 self.childNodes.remove(oldChild)
1636 if self.documentElement is oldChild:
1637 self.documentElement = None
1641 def _get_documentElement(self):
1642 for node in self.childNodes:
1646 def unlink(self):
1647 if self.doctype is not None:
1648 self.doctype.unlink()
1649 self.doctype = None
1650 Node.unlink(self)
1652 def cloneNode(self, deep):
1655 clone = self.implementation.createDocument(None, None, None)
1656 clone.encoding = self.encoding
1657 clone.standalone = self.standalone
1658 clone.version = self.version
1659 for n in self.childNodes:
1669 self._call_user_data_handler(xml.dom.UserDataHandler.NODE_CLONED,
1670 self, clone)
1673 def createDocumentFragment(self):
1675 d.ownerDocument = self
1678 def createElement(self, tagName):
1680 e.ownerDocument = self
1683 def createTextNode(self, data):
1688 t.ownerDocument = self
1691 def createCDATASection(self, data):
1696 c.ownerDocument = self
1699 def createComment(self, data):
1701 c.ownerDocument = self
1704 def createProcessingInstruction(self, target, data):
1706 p.ownerDocument = self
1709 def createAttribute(self, qName):
1711 a.ownerDocument = self
1715 def createElementNS(self, namespaceURI, qualifiedName):
1718 e.ownerDocument = self
1721 def createAttributeNS(self, namespaceURI, qualifiedName):
1724 a.ownerDocument = self
1731 def _create_entity(self, name, publicId, systemId, notationName):
1733 e.ownerDocument = self
1736 def _create_notation(self, name, publicId, systemId):
1738 n.ownerDocument = self
1741 def getElementById(self, id):
1742 if id in self._id_cache:
1743 return self._id_cache[id]
1744 if not (self._elem_info or self._magic_id_count):
1747 stack = self._id_search_stack
1750 stack = [self.documentElement]
1751 self._id_search_stack = stack
1764 info = self._get_elem_info(node)
1772 self._id_cache[attr.value] = node
1778 self._id_cache[attr.value] = node
1784 self._id_cache[attr.value] = node
1792 self._id_cache[attr.value] = node
1799 def getElementsByTagName(self, name):
1800 return _get_elements_by_tagName_helper(self, name, NodeList())
1802 def getElementsByTagNameNS(self, namespaceURI, localName):
1804 self, namespaceURI, localName, NodeList())
1806 def isSupported(self, feature, version):
1807 return self.implementation.hasFeature(feature, version)
1809 def importNode(self, node, deep):
1814 return _clone_node(node, deep, self)
1816 def writexml(self, writer, indent="", addindent="", newl="", encoding=None,
1827 for node in self.childNodes:
1832 def renameNode(self, n, namespaceURI, name):
1833 if n.ownerDocument is not self:
1836 "expected %s,\nfound %s" % (self, n.ownerDocument))