added venv

c5db80e over 2 years ago

15.8 kB

	from __future__ import absolute_import, division, unicode_literals
	from pip._vendor.six import text_type

	import re

	from codecs import register_error, xmlcharrefreplace_errors

	from .constants import voidElements, booleanAttributes, spaceCharacters
	from .constants import rcdataElements, entities, xmlEntities
	from . import treewalkers, _utils
	from xml.sax.saxutils import escape

	_quoteAttributeSpecChars = "".join(spaceCharacters) + "\"'=<>`"
	_quoteAttributeSpec = re.compile("[" + _quoteAttributeSpecChars + "]")
	_quoteAttributeLegacy = re.compile("[" + _quoteAttributeSpecChars +
	"\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n"
	"\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15"
	"\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
	"\x20\x2f\x60\xa0\u1680\u180e\u180f\u2000"
	"\u2001\u2002\u2003\u2004\u2005\u2006\u2007"
	"\u2008\u2009\u200a\u2028\u2029\u202f\u205f"
	"\u3000]")


	_encode_entity_map = {}
	_is_ucs4 = len("\U0010FFFF") == 1
	for k, v in list(entities.items()):
	# skip multi-character entities
	if ((_is_ucs4 and len(v) > 1) or
	(not _is_ucs4 and len(v) > 2)):
	continue
	if v != "&":
	if len(v) == 2:
	v = _utils.surrogatePairToCodepoint(v)
	else:
	v = ord(v)
	if v not in _encode_entity_map or k.islower():
	# prefer < over &LT; and similarly for &, >, etc.
	_encode_entity_map[v] = k


	def htmlentityreplace_errors(exc):
	if isinstance(exc, (UnicodeEncodeError, UnicodeTranslateError)):
	res = []
	codepoints = []
	skip = False
	for i, c in enumerate(exc.object[exc.start:exc.end]):
	if skip:
	skip = False
	continue
	index = i + exc.start
	if _utils.isSurrogatePair(exc.object[index:min([exc.end, index + 2])]):
	codepoint = _utils.surrogatePairToCodepoint(exc.object[index:index + 2])
	skip = True
	else:
	codepoint = ord(c)
	codepoints.append(codepoint)
	for cp in codepoints:
	e = _encode_entity_map.get(cp)
	if e:
	res.append("&")
	res.append(e)
	if not e.endswith(";"):
	res.append(";")
	else:
	res.append("&#x%s;" % (hex(cp)[2:]))
	return ("".join(res), exc.end)
	else:
	return xmlcharrefreplace_errors(exc)


	register_error("htmlentityreplace", htmlentityreplace_errors)


	def serialize(input, tree="etree", encoding=None, **serializer_opts):
	"""Serializes the input token stream using the specified treewalker

	:arg input: the token stream to serialize

	:arg tree: the treewalker to use

	:arg encoding: the encoding to use

	:arg serializer_opts: any options to pass to the
	:py:class:`html5lib.serializer.HTMLSerializer` that gets created

	:returns: the tree serialized as a string

	Example:

	>>> from html5lib.html5parser import parse
	>>> from html5lib.serializer import serialize
	>>> token_stream = parse('<html><body><p>Hi!</p></body></html>')
	>>> serialize(token_stream, omit_optional_tags=False)
	'<html><head></head><body><p>Hi!</p></body></html>'

	"""
	# XXX: Should we cache this?
	walker = treewalkers.getTreeWalker(tree)
	s = HTMLSerializer(**serializer_opts)
	return s.render(walker(input), encoding)


	class HTMLSerializer(object):

	# attribute quoting options
	quote_attr_values = "legacy" # be secure by default
	quote_char = '"'
	use_best_quote_char = True

	# tag syntax options
	omit_optional_tags = True
	minimize_boolean_attributes = True
	use_trailing_solidus = False
	space_before_trailing_solidus = True

	# escaping options
	escape_lt_in_attrs = False
	escape_rcdata = False
	resolve_entities = True

	# miscellaneous options
	alphabetical_attributes = False
	inject_meta_charset = True
	strip_whitespace = False
	sanitize = False

	options = ("quote_attr_values", "quote_char", "use_best_quote_char",
	"omit_optional_tags", "minimize_boolean_attributes",
	"use_trailing_solidus", "space_before_trailing_solidus",
	"escape_lt_in_attrs", "escape_rcdata", "resolve_entities",
	"alphabetical_attributes", "inject_meta_charset",
	"strip_whitespace", "sanitize")

	def __init__(self, **kwargs):
	"""Initialize HTMLSerializer

	:arg inject_meta_charset: Whether or not to inject the meta charset.

	Defaults to ``True``.

	:arg quote_attr_values: Whether to quote attribute values that don't
	require quoting per legacy browser behavior (``"legacy"``), when
	required by the standard (``"spec"``), or always (``"always"``).

	Defaults to ``"legacy"``.

	:arg quote_char: Use given quote character for attribute quoting.

	Defaults to ``"`` which will use double quotes unless attribute
	value contains a double quote, in which case single quotes are
	used.

	:arg escape_lt_in_attrs: Whether or not to escape ``<`` in attribute
	values.

	Defaults to ``False``.

	:arg escape_rcdata: Whether to escape characters that need to be
	escaped within normal elements within rcdata elements such as
	style.

	Defaults to ``False``.

	:arg resolve_entities: Whether to resolve named character entities that
	appear in the source tree. The XML predefined entities < >
	& " ' are unaffected by this setting.

	Defaults to ``True``.

	:arg strip_whitespace: Whether to remove semantically meaningless
	whitespace. (This compresses all whitespace to a single space
	except within ``pre``.)

	Defaults to ``False``.

	:arg minimize_boolean_attributes: Shortens boolean attributes to give
	just the attribute value, for example::

	<input disabled="disabled">

	becomes::

	<input disabled>

	Defaults to ``True``.

	:arg use_trailing_solidus: Includes a close-tag slash at the end of the
	start tag of void elements (empty elements whose end tag is
	forbidden). E.g. ``<hr/>``.

	Defaults to ``False``.

	:arg space_before_trailing_solidus: Places a space immediately before
	the closing slash in a tag using a trailing solidus. E.g.
	``<hr />``. Requires ``use_trailing_solidus=True``.

	Defaults to ``True``.

	:arg sanitize: Strip all unsafe or unknown constructs from output.
	See :py:class:`html5lib.filters.sanitizer.Filter`.

	Defaults to ``False``.

	:arg omit_optional_tags: Omit start/end tags that are optional.

	Defaults to ``True``.

	:arg alphabetical_attributes: Reorder attributes to be in alphabetical order.

	Defaults to ``False``.

	"""
	unexpected_args = frozenset(kwargs) - frozenset(self.options)
	if len(unexpected_args) > 0:
	raise TypeError("__init__() got an unexpected keyword argument '%s'" % next(iter(unexpected_args)))
	if 'quote_char' in kwargs:
	self.use_best_quote_char = False
	for attr in self.options:
	setattr(self, attr, kwargs.get(attr, getattr(self, attr)))
	self.errors = []
	self.strict = False

	def encode(self, string):
	assert(isinstance(string, text_type))
	if self.encoding:
	return string.encode(self.encoding, "htmlentityreplace")
	else:
	return string

	def encodeStrict(self, string):
	assert(isinstance(string, text_type))
	if self.encoding:
	return string.encode(self.encoding, "strict")
	else:
	return string

	def serialize(self, treewalker, encoding=None):
	# pylint:disable=too-many-nested-blocks
	self.encoding = encoding
	in_cdata = False
	self.errors = []

	if encoding and self.inject_meta_charset:
	from .filters.inject_meta_charset import Filter
	treewalker = Filter(treewalker, encoding)
	# Alphabetical attributes is here under the assumption that none of
	# the later filters add or change order of attributes; it needs to be
	# before the sanitizer so escaped elements come out correctly
	if self.alphabetical_attributes:
	from .filters.alphabeticalattributes import Filter
	treewalker = Filter(treewalker)
	# WhitespaceFilter should be used before OptionalTagFilter
	# for maximum efficiently of this latter filter
	if self.strip_whitespace:
	from .filters.whitespace import Filter
	treewalker = Filter(treewalker)
	if self.sanitize:
	from .filters.sanitizer import Filter
	treewalker = Filter(treewalker)
	if self.omit_optional_tags:
	from .filters.optionaltags import Filter
	treewalker = Filter(treewalker)

	for token in treewalker:
	type = token["type"]
	if type == "Doctype":
	doctype = "<!DOCTYPE %s" % token["name"]

	if token["publicId"]:
	doctype += ' PUBLIC "%s"' % token["publicId"]
	elif token["systemId"]:
	doctype += " SYSTEM"
	if token["systemId"]:
	if token["systemId"].find('"') >= 0:
	if token["systemId"].find("'") >= 0:
	self.serializeError("System identifier contains both single and double quote characters")
	quote_char = "'"
	else:
	quote_char = '"'
	doctype += " %s%s%s" % (quote_char, token["systemId"], quote_char)

	doctype += ">"
	yield self.encodeStrict(doctype)

	elif type in ("Characters", "SpaceCharacters"):
	if type == "SpaceCharacters" or in_cdata:
	if in_cdata and token["data"].find("</") >= 0:
	self.serializeError("Unexpected </ in CDATA")
	yield self.encode(token["data"])
	else:
	yield self.encode(escape(token["data"]))

	elif type in ("StartTag", "EmptyTag"):
	name = token["name"]
	yield self.encodeStrict("<%s" % name)
	if name in rcdataElements and not self.escape_rcdata:
	in_cdata = True
	elif in_cdata:
	self.serializeError("Unexpected child element of a CDATA element")
	for (_, attr_name), attr_value in token["data"].items():
	# TODO: Add namespace support here
	k = attr_name
	v = attr_value
	yield self.encodeStrict(' ')

	yield self.encodeStrict(k)
	if not self.minimize_boolean_attributes or \
	(k not in booleanAttributes.get(name, tuple()) and
	k not in booleanAttributes.get("", tuple())):
	yield self.encodeStrict("=")
	if self.quote_attr_values == "always" or len(v) == 0:
	quote_attr = True
	elif self.quote_attr_values == "spec":
	quote_attr = _quoteAttributeSpec.search(v) is not None
	elif self.quote_attr_values == "legacy":
	quote_attr = _quoteAttributeLegacy.search(v) is not None
	else:
	raise ValueError("quote_attr_values must be one of: "
	"'always', 'spec', or 'legacy'")
	v = v.replace("&", "&")
	if self.escape_lt_in_attrs:
	v = v.replace("<", "<")
	if quote_attr:
	quote_char = self.quote_char
	if self.use_best_quote_char:
	if "'" in v and '"' not in v:
	quote_char = '"'
	elif '"' in v and "'" not in v:
	quote_char = "'"
	if quote_char == "'":
	v = v.replace("'", "'")
	else:
	v = v.replace('"', """)
	yield self.encodeStrict(quote_char)
	yield self.encode(v)
	yield self.encodeStrict(quote_char)
	else:
	yield self.encode(v)
	if name in voidElements and self.use_trailing_solidus:
	if self.space_before_trailing_solidus:
	yield self.encodeStrict(" /")
	else:
	yield self.encodeStrict("/")
	yield self.encode(">")

	elif type == "EndTag":
	name = token["name"]
	if name in rcdataElements:
	in_cdata = False
	elif in_cdata:
	self.serializeError("Unexpected child element of a CDATA element")
	yield self.encodeStrict("</%s>" % name)

	elif type == "Comment":
	data = token["data"]
	if data.find("--") >= 0:
	self.serializeError("Comment contains --")
	yield self.encodeStrict("<!--%s-->" % token["data"])

	elif type == "Entity":
	name = token["name"]
	key = name + ";"
	if key not in entities:
	self.serializeError("Entity %s not recognized" % name)
	if self.resolve_entities and key not in xmlEntities:
	data = entities[key]
	else:
	data = "&%s;" % name
	yield self.encodeStrict(data)

	else:
	self.serializeError(token["data"])

	def render(self, treewalker, encoding=None):
	"""Serializes the stream from the treewalker into a string

	:arg treewalker: the treewalker to serialize

	:arg encoding: the string encoding to use

	:returns: the serialized tree

	Example:

	>>> from html5lib import parse, getTreeWalker
	>>> from html5lib.serializer import HTMLSerializer
	>>> token_stream = parse('<html><body>Hi!</body></html>')
	>>> walker = getTreeWalker('etree')
	>>> serializer = HTMLSerializer(omit_optional_tags=False)
	>>> serializer.render(walker(token_stream))
	'<html><head></head><body>Hi!</body></html>'

	"""
	if encoding:
	return b"".join(list(self.serialize(treewalker, encoding)))
	else:
	return "".join(list(self.serialize(treewalker)))

	def serializeError(self, data="XXX ERROR MESSAGE NEEDED"):
	# XXX The idea is to make data mandatory.
	self.errors.append(data)
	if self.strict:
	raise SerializeError


	class SerializeError(Exception):
	"""Error in serialized tree"""
	pass