diff options
author | Shubham Saini <shubham6405@gmail.com> | 2019-08-05 08:32:33 +0000 |
---|---|---|
committer | Shubham Saini <shubham6405@gmail.com> | 2019-08-05 08:32:33 +0000 |
commit | 227b2d30a8675b44918f9d9ca89b24144a938215 (patch) | |
tree | 9f8e6a28724514b6fdf463a9ab2067a7ef309b72 /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/html5lib/treebuilders/etree.py | |
parent | 842a8cfbbbdb1f92889d892e4859dbd5d40c5be8 (diff) |
removing venv files
Diffstat (limited to 'venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/html5lib/treebuilders/etree.py')
-rw-r--r-- | venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/html5lib/treebuilders/etree.py | 340 |
1 files changed, 0 insertions, 340 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/html5lib/treebuilders/etree.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/html5lib/treebuilders/etree.py deleted file mode 100644 index 9a4aa95..0000000 --- a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/html5lib/treebuilders/etree.py +++ /dev/null | |||
@@ -1,340 +0,0 @@ | |||
1 | from __future__ import absolute_import, division, unicode_literals | ||
2 | # pylint:disable=protected-access | ||
3 | |||
4 | from pip._vendor.six import text_type | ||
5 | |||
6 | import re | ||
7 | |||
8 | from . import base | ||
9 | from .. import _ihatexml | ||
10 | from .. import constants | ||
11 | from ..constants import namespaces | ||
12 | from .._utils import moduleFactoryFactory | ||
13 | |||
14 | tag_regexp = re.compile("{([^}]*)}(.*)") | ||
15 | |||
16 | |||
17 | def getETreeBuilder(ElementTreeImplementation, fullTree=False): | ||
18 | ElementTree = ElementTreeImplementation | ||
19 | ElementTreeCommentType = ElementTree.Comment("asd").tag | ||
20 | |||
21 | class Element(base.Node): | ||
22 | def __init__(self, name, namespace=None): | ||
23 | self._name = name | ||
24 | self._namespace = namespace | ||
25 | self._element = ElementTree.Element(self._getETreeTag(name, | ||
26 | namespace)) | ||
27 | if namespace is None: | ||
28 | self.nameTuple = namespaces["html"], self._name | ||
29 | else: | ||
30 | self.nameTuple = self._namespace, self._name | ||
31 | self.parent = None | ||
32 | self._childNodes = [] | ||
33 | self._flags = [] | ||
34 | |||
35 | def _getETreeTag(self, name, namespace): | ||
36 | if namespace is None: | ||
37 | etree_tag = name | ||
38 | else: | ||
39 | etree_tag = "{%s}%s" % (namespace, name) | ||
40 | return etree_tag | ||
41 | |||
42 | def _setName(self, name): | ||
43 | self._name = name | ||
44 | self._element.tag = self._getETreeTag(self._name, self._namespace) | ||
45 | |||
46 | def _getName(self): | ||
47 | return self._name | ||
48 | |||
49 | name = property(_getName, _setName) | ||
50 | |||
51 | def _setNamespace(self, namespace): | ||
52 | self._namespace = namespace | ||
53 | self._element.tag = self._getETreeTag(self._name, self._namespace) | ||
54 | |||
55 | def _getNamespace(self): | ||
56 | return self._namespace | ||
57 | |||
58 | namespace = property(_getNamespace, _setNamespace) | ||
59 | |||
60 | def _getAttributes(self): | ||
61 | return self._element.attrib | ||
62 | |||
63 | def _setAttributes(self, attributes): | ||
64 | # Delete existing attributes first | ||
65 | # XXX - there may be a better way to do this... | ||
66 | for key in list(self._element.attrib.keys()): | ||
67 | del self._element.attrib[key] | ||
68 | for key, value in attributes.items(): | ||
69 | if isinstance(key, tuple): | ||
70 | name = "{%s}%s" % (key[2], key[1]) | ||
71 | else: | ||
72 | name = key | ||
73 | self._element.set(name, value) | ||
74 | |||
75 | attributes = property(_getAttributes, _setAttributes) | ||
76 | |||
77 | def _getChildNodes(self): | ||
78 | return self._childNodes | ||
79 | |||
80 | def _setChildNodes(self, value): | ||
81 | del self._element[:] | ||
82 | self._childNodes = [] | ||
83 | for element in value: | ||
84 | self.insertChild(element) | ||
85 | |||
86 | childNodes = property(_getChildNodes, _setChildNodes) | ||
87 | |||
88 | def hasContent(self): | ||
89 | """Return true if the node has children or text""" | ||
90 | return bool(self._element.text or len(self._element)) | ||
91 | |||
92 | def appendChild(self, node): | ||
93 | self._childNodes.append(node) | ||
94 | self._element.append(node._element) | ||
95 | node.parent = self | ||
96 | |||
97 | def insertBefore(self, node, refNode): | ||
98 | index = list(self._element).index(refNode._element) | ||
99 | self._element.insert(index, node._element) | ||
100 | node.parent = self | ||
101 | |||
102 | def removeChild(self, node): | ||
103 | self._childNodes.remove(node) | ||
104 | self._element.remove(node._element) | ||
105 | node.parent = None | ||
106 | |||
107 | def insertText(self, data, insertBefore=None): | ||
108 | if not(len(self._element)): | ||
109 | if not self._element.text: | ||
110 | self._element.text = "" | ||
111 | self._element.text += data | ||
112 | elif insertBefore is None: | ||
113 | # Insert the text as the tail of the last child element | ||
114 | if not self._element[-1].tail: | ||
115 | self._element[-1].tail = "" | ||
116 | self._element[-1].tail += data | ||
117 | else: | ||
118 | # Insert the text before the specified node | ||
119 | children = list(self._element) | ||
120 | index = children.index(insertBefore._element) | ||
121 | if index > 0: | ||
122 | if not self._element[index - 1].tail: | ||
123 | self._element[index - 1].tail = "" | ||
124 | self._element[index - 1].tail += data | ||
125 | else: | ||
126 | if not self._element.text: | ||
127 | self._element.text = "" | ||
128 | self._element.text += data | ||
129 | |||
130 | def cloneNode(self): | ||
131 | element = type(self)(self.name, self.namespace) | ||
132 | for name, value in self.attributes.items(): | ||
133 | element.attributes[name] = value | ||
134 | return element | ||
135 | |||
136 | def reparentChildren(self, newParent): | ||
137 | if newParent.childNodes: | ||
138 | newParent.childNodes[-1]._element.tail += self._element.text | ||
139 | else: | ||
140 | if not newParent._element.text: | ||
141 | newParent._element.text = "" | ||
142 | if self._element.text is not None: | ||
143 | newParent._element.text += self._element.text | ||
144 | self._element.text = "" | ||
145 | base.Node.reparentChildren(self, newParent) | ||
146 | |||
147 | class Comment(Element): | ||
148 | def __init__(self, data): | ||
149 | # Use the superclass constructor to set all properties on the | ||
150 | # wrapper element | ||
151 | self._element = ElementTree.Comment(data) | ||
152 | self.parent = None | ||
153 | self._childNodes = [] | ||
154 | self._flags = [] | ||
155 | |||
156 | def _getData(self): | ||
157 | return self._element.text | ||
158 | |||
159 | def _setData(self, value): | ||
160 | self._element.text = value | ||
161 | |||
162 | data = property(_getData, _setData) | ||
163 | |||
164 | class DocumentType(Element): | ||
165 | def __init__(self, name, publicId, systemId): | ||
166 | Element.__init__(self, "<!DOCTYPE>") | ||
167 | self._element.text = name | ||
168 | self.publicId = publicId | ||
169 | self.systemId = systemId | ||
170 | |||
171 | def _getPublicId(self): | ||
172 | return self._element.get("publicId", "") | ||
173 | |||
174 | def _setPublicId(self, value): | ||
175 | if value is not None: | ||
176 | self._element.set("publicId", value) | ||
177 | |||
178 | publicId = property(_getPublicId, _setPublicId) | ||
179 | |||
180 | def _getSystemId(self): | ||
181 | return self._element.get("systemId", "") | ||
182 | |||
183 | def _setSystemId(self, value): | ||
184 | if value is not None: | ||
185 | self._element.set("systemId", value) | ||
186 | |||
187 | systemId = property(_getSystemId, _setSystemId) | ||
188 | |||
189 | class Document(Element): | ||
190 | def __init__(self): | ||
191 | Element.__init__(self, "DOCUMENT_ROOT") | ||
192 | |||
193 | class DocumentFragment(Element): | ||
194 | def __init__(self): | ||
195 | Element.__init__(self, "DOCUMENT_FRAGMENT") | ||
196 | |||
197 | def testSerializer(element): | ||
198 | rv = [] | ||
199 | |||
200 | def serializeElement(element, indent=0): | ||
201 | if not(hasattr(element, "tag")): | ||
202 | element = element.getroot() | ||
203 | if element.tag == "<!DOCTYPE>": | ||
204 | if element.get("publicId") or element.get("systemId"): | ||
205 | publicId = element.get("publicId") or "" | ||
206 | systemId = element.get("systemId") or "" | ||
207 | rv.append("""<!DOCTYPE %s "%s" "%s">""" % | ||
208 | (element.text, publicId, systemId)) | ||
209 | else: | ||
210 | rv.append("<!DOCTYPE %s>" % (element.text,)) | ||
211 | elif element.tag == "DOCUMENT_ROOT": | ||
212 | rv.append("#document") | ||
213 | if element.text is not None: | ||
214 | rv.append("|%s\"%s\"" % (' ' * (indent + 2), element.text)) | ||
215 | if element.tail is not None: | ||
216 | raise TypeError("Document node cannot have tail") | ||
217 | if hasattr(element, "attrib") and len(element.attrib): | ||
218 | raise TypeError("Document node cannot have attributes") | ||
219 | elif element.tag == ElementTreeCommentType: | ||
220 | rv.append("|%s<!-- %s -->" % (' ' * indent, element.text)) | ||
221 | else: | ||
222 | assert isinstance(element.tag, text_type), \ | ||
223 | "Expected unicode, got %s, %s" % (type(element.tag), element.tag) | ||
224 | nsmatch = tag_regexp.match(element.tag) | ||
225 | |||
226 | if nsmatch is None: | ||
227 | name = element.tag | ||
228 | else: | ||
229 | ns, name = nsmatch.groups() | ||
230 | prefix = constants.prefixes[ns] | ||
231 | name = "%s %s" % (prefix, name) | ||
232 | rv.append("|%s<%s>" % (' ' * indent, name)) | ||
233 | |||
234 | if hasattr(element, "attrib"): | ||
235 | attributes = [] | ||
236 | for name, value in element.attrib.items(): | ||
237 | nsmatch = tag_regexp.match(name) | ||
238 | if nsmatch is not None: | ||
239 | ns, name = nsmatch.groups() | ||
240 | prefix = constants.prefixes[ns] | ||
241 | attr_string = "%s %s" % (prefix, name) | ||
242 | else: | ||
243 | attr_string = name | ||
244 | attributes.append((attr_string, value)) | ||
245 | |||
246 | for name, value in sorted(attributes): | ||
247 | rv.append('|%s%s="%s"' % (' ' * (indent + 2), name, value)) | ||
248 | if element.text: | ||
249 | rv.append("|%s\"%s\"" % (' ' * (indent + 2), element.text)) | ||
250 | indent += 2 | ||
251 | for child in element: | ||
252 | serializeElement(child, indent) | ||
253 | if element.tail: | ||
254 | rv.append("|%s\"%s\"" % (' ' * (indent - 2), element.tail)) | ||
255 | serializeElement(element, 0) | ||
256 | |||
257 | return "\n".join(rv) | ||
258 | |||
259 | def tostring(element): # pylint:disable=unused-variable | ||
260 | """Serialize an element and its child nodes to a string""" | ||
261 | rv = [] | ||
262 | filter = _ihatexml.InfosetFilter() | ||
263 | |||
264 | def serializeElement(element): | ||
265 | if isinstance(element, ElementTree.ElementTree): | ||
266 | element = element.getroot() | ||
267 | |||
268 | if element.tag == "<!DOCTYPE>": | ||
269 | if element.get("publicId") or element.get("systemId"): | ||
270 | publicId = element.get("publicId") or "" | ||
271 | systemId = element.get("systemId") or "" | ||
272 | rv.append("""<!DOCTYPE %s PUBLIC "%s" "%s">""" % | ||
273 | (element.text, publicId, systemId)) | ||
274 | else: | ||
275 | rv.append("<!DOCTYPE %s>" % (element.text,)) | ||
276 | elif element.tag == "DOCUMENT_ROOT": | ||
277 | if element.text is not None: | ||
278 | rv.append(element.text) | ||
279 | if element.tail is not None: | ||
280 | raise TypeError("Document node cannot have tail") | ||
281 | if hasattr(element, "attrib") and len(element.attrib): | ||
282 | raise TypeError("Document node cannot have attributes") | ||
283 | |||
284 | for child in element: | ||
285 | serializeElement(child) | ||
286 | |||
287 | elif element.tag == ElementTreeCommentType: | ||
288 | rv.append("<!--%s-->" % (element.text,)) | ||
289 | else: | ||
290 | # This is assumed to be an ordinary element | ||
291 | if not element.attrib: | ||
292 | rv.append("<%s>" % (filter.fromXmlName(element.tag),)) | ||
293 | else: | ||
294 | attr = " ".join(["%s=\"%s\"" % ( | ||
295 | filter.fromXmlName(name), value) | ||
296 | for name, value in element.attrib.items()]) | ||
297 | rv.append("<%s %s>" % (element.tag, attr)) | ||
298 | if element.text: | ||
299 | rv.append(element.text) | ||
300 | |||
301 | for child in element: | ||
302 | serializeElement(child) | ||
303 | |||
304 | rv.append("</%s>" % (element.tag,)) | ||
305 | |||
306 | if element.tail: | ||
307 | rv.append(element.tail) | ||
308 | |||
309 | serializeElement(element) | ||
310 | |||
311 | return "".join(rv) | ||
312 | |||
313 | class TreeBuilder(base.TreeBuilder): # pylint:disable=unused-variable | ||
314 | documentClass = Document | ||
315 | doctypeClass = DocumentType | ||
316 | elementClass = Element | ||
317 | commentClass = Comment | ||
318 | fragmentClass = DocumentFragment | ||
319 | implementation = ElementTreeImplementation | ||
320 | |||
321 | def testSerializer(self, element): | ||
322 | return testSerializer(element) | ||
323 | |||
324 | def getDocument(self): | ||
325 | if fullTree: | ||
326 | return self.document._element | ||
327 | else: | ||
328 | if self.defaultNamespace is not None: | ||
329 | return self.document._element.find( | ||
330 | "{%s}html" % self.defaultNamespace) | ||
331 | else: | ||
332 | return self.document._element.find("html") | ||
333 | |||
334 | def getFragment(self): | ||
335 | return base.TreeBuilder.getFragment(self)._element | ||
336 | |||
337 | return locals() | ||
338 | |||
339 | |||
340 | getETreeModule = moduleFactoryFactory(getETreeBuilder) | ||