thanks to vye16 ❤

fb5159d over 2 years ago

26.8 kB

	# encoding: utf-8
	# This file is part of ansi2html
	# Convert ANSI (terminal) colours and attributes to HTML
	# Copyright (C) 2012 Ralph Bean <rbean@redhat.com>
	# Copyright (C) 2013 Sebastian Pipping <sebastian@pipping.org>
	#
	# Inspired by and developed off of the work by pixelbeat and blackjack.
	#
	# This program is free software: you can redistribute it and/or
	# modify it under the terms of the GNU General Public License as
	# published by the Free Software Foundation, either version 3 of
	# the License, or (at your option) any later version.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	# General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program. If not, see
	# <http://www.gnu.org/licenses/>.

	import io
	import optparse
	import re
	import sys
	from collections import OrderedDict
	from typing import Iterator, List, Optional, Set, Tuple, Union

	from ansi2html.style import (
	SCHEME,
	add_truecolor_style_rule,
	get_styles,
	pop_truecolor_styles,
	)

	if sys.version_info >= (3, 8):
	from importlib.metadata import version
	else:
	from importlib_metadata import version

	if sys.version_info >= (3, 8):
	from typing import TypedDict
	else:
	from typing_extensions import TypedDict


	ANSI_FULL_RESET = 0
	ANSI_INTENSITY_INCREASED = 1
	ANSI_INTENSITY_REDUCED = 2
	ANSI_INTENSITY_NORMAL = 22
	ANSI_STYLE_ITALIC = 3
	ANSI_STYLE_NORMAL = 23
	ANSI_BLINK_SLOW = 5
	ANSI_BLINK_FAST = 6
	ANSI_BLINK_OFF = 25
	ANSI_UNDERLINE_ON = 4
	ANSI_UNDERLINE_OFF = 24
	ANSI_CROSSED_OUT_ON = 9
	ANSI_CROSSED_OUT_OFF = 29
	ANSI_VISIBILITY_ON = 28
	ANSI_VISIBILITY_OFF = 8
	ANSI_FOREGROUND_CUSTOM_MIN = 30
	ANSI_FOREGROUND_CUSTOM_MAX = 37
	ANSI_FOREGROUND = 38
	ANSI_FOREGROUND_DEFAULT = 39
	ANSI_BACKGROUND_CUSTOM_MIN = 40
	ANSI_BACKGROUND_CUSTOM_MAX = 47
	ANSI_BACKGROUND = 48
	ANSI_BACKGROUND_DEFAULT = 49
	ANSI_NEGATIVE_ON = 7
	ANSI_NEGATIVE_OFF = 27
	ANSI_FOREGROUND_HIGH_INTENSITY_MIN = 90
	ANSI_FOREGROUND_HIGH_INTENSITY_MAX = 97
	ANSI_BACKGROUND_HIGH_INTENSITY_MIN = 100
	ANSI_BACKGROUND_HIGH_INTENSITY_MAX = 107
	ANSI_256_COLOR_ID = 5
	ANSI_TRUECOLOR_ID = 2

	VT100_BOX_CODES = {
	"0x71": "─",
	"0x74": "├",
	"0x75": "┤",
	"0x76": "┴",
	"0x77": "┬",
	"0x78": "│",
	"0x6a": "┘",
	"0x6b": "┐",
	"0x6c": "┌",
	"0x6d": "└",
	"0x6e": "┼",
	}

	# http://stackoverflow.com/a/15190498
	_latex_template = """\\documentclass{scrartcl}
	\\usepackage[utf8]{inputenc}
	\\usepackage{fancyvrb}
	\\usepackage[usenames,dvipsnames]{xcolor}
	%% \\definecolor{red-sd}{HTML}{7ed2d2}
	%(hyperref)s
	\\title{%(title)s}

	\\fvset{commandchars=\\\\\\{\\}}

	\\begin{document}

	\\begin{Verbatim}
	%(content)s
	\\end{Verbatim}
	\\end{document}
	"""

	_html_template = """<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
	<html>
	<head>
	<meta http-equiv="Content-Type" content="text/html; charset=%(output_encoding)s">
	<title>%(title)s</title>
	<style type="text/css">\n%(style)s\n</style>
	</head>
	<body class="body_foreground body_background" style="font-size: %(font_size)s;" >
	<pre class="ansi2html-content">
	%(content)s
	</pre>
	</body>

	</html>
	"""


	class _State:
	def __init__(self) -> None:
	self.inside_span = False
	self.reset()

	def reset(self) -> None:
	self.intensity: int = ANSI_INTENSITY_NORMAL
	self.style: int = ANSI_STYLE_NORMAL
	self.blink: int = ANSI_BLINK_OFF
	self.underline: int = ANSI_UNDERLINE_OFF
	self.crossedout: int = ANSI_CROSSED_OUT_OFF
	self.visibility: int = ANSI_VISIBILITY_ON
	self.foreground: Tuple[int, Optional[str]] = (ANSI_FOREGROUND_DEFAULT, None)
	self.background: Tuple[int, Optional[str]] = (ANSI_BACKGROUND_DEFAULT, None)
	self.negative: int = ANSI_NEGATIVE_OFF

	def adjust(self, ansi_code: int, parameter: Optional[str] = None) -> None:
	if ansi_code in (
	ANSI_INTENSITY_INCREASED,
	ANSI_INTENSITY_REDUCED,
	ANSI_INTENSITY_NORMAL,
	):
	self.intensity = ansi_code
	elif ansi_code in (ANSI_STYLE_ITALIC, ANSI_STYLE_NORMAL):
	self.style = ansi_code
	elif ansi_code in (ANSI_BLINK_SLOW, ANSI_BLINK_FAST, ANSI_BLINK_OFF):
	self.blink = ansi_code
	elif ansi_code in (ANSI_UNDERLINE_ON, ANSI_UNDERLINE_OFF):
	self.underline = ansi_code
	elif ansi_code in (ANSI_CROSSED_OUT_ON, ANSI_CROSSED_OUT_OFF):
	self.crossedout = ansi_code
	elif ansi_code in (ANSI_VISIBILITY_ON, ANSI_VISIBILITY_OFF):
	self.visibility = ansi_code
	elif ANSI_FOREGROUND_CUSTOM_MIN <= ansi_code <= ANSI_FOREGROUND_CUSTOM_MAX:
	self.foreground = (ansi_code, None)
	elif (
	ANSI_FOREGROUND_HIGH_INTENSITY_MIN
	<= ansi_code
	<= ANSI_FOREGROUND_HIGH_INTENSITY_MAX
	):
	self.foreground = (ansi_code, None)
	elif ansi_code == ANSI_FOREGROUND:
	self.foreground = (ansi_code, parameter)
	elif ansi_code == ANSI_FOREGROUND_DEFAULT:
	self.foreground = (ansi_code, None)
	elif ANSI_BACKGROUND_CUSTOM_MIN <= ansi_code <= ANSI_BACKGROUND_CUSTOM_MAX:
	self.background = (ansi_code, None)
	elif (
	ANSI_BACKGROUND_HIGH_INTENSITY_MIN
	<= ansi_code
	<= ANSI_BACKGROUND_HIGH_INTENSITY_MAX
	):
	self.background = (ansi_code, None)
	elif ansi_code == ANSI_BACKGROUND:
	self.background = (ansi_code, parameter)
	elif ansi_code == ANSI_BACKGROUND_DEFAULT:
	self.background = (ansi_code, None)
	elif ansi_code in (ANSI_NEGATIVE_ON, ANSI_NEGATIVE_OFF):
	self.negative = ansi_code

	def adjust_truecolor(self, ansi_code: int, r: int, g: int, b: int) -> None:
	parameter = "{:03d}{:03d}{:03d}".format(
	r, g, b
	) # r=1, g=64, b=255 -> 001064255

	is_foreground = ansi_code == ANSI_FOREGROUND
	add_truecolor_style_rule(is_foreground, ansi_code, r, g, b, parameter)
	if is_foreground:
	self.foreground = (ansi_code, parameter)
	else:
	self.background = (ansi_code, parameter)

	def to_css_classes(self) -> List[str]:
	css_classes: List[str] = []

	def append_unless_default(output: List[str], value: int, default: int) -> None:
	if value != default:
	css_class = "ansi%d" % value
	output.append(css_class)

	def append_color_unless_default(
	output: List[str],
	color: Tuple[int, Optional[str]],
	default: int,
	negative: bool,
	neg_css_class: str,
	) -> None:
	value, parameter = color
	if value != default:
	prefix = "inv" if negative else "ansi"
	css_class_index = (
	str(value) if (parameter is None) else "%d-%s" % (value, parameter)
	)
	output.append(prefix + css_class_index)
	elif negative:
	output.append(neg_css_class)

	append_unless_default(css_classes, self.intensity, ANSI_INTENSITY_NORMAL)
	append_unless_default(css_classes, self.style, ANSI_STYLE_NORMAL)
	append_unless_default(css_classes, self.blink, ANSI_BLINK_OFF)
	append_unless_default(css_classes, self.underline, ANSI_UNDERLINE_OFF)
	append_unless_default(css_classes, self.crossedout, ANSI_CROSSED_OUT_OFF)
	append_unless_default(css_classes, self.visibility, ANSI_VISIBILITY_ON)

	flip_fore_and_background = self.negative == ANSI_NEGATIVE_ON
	append_color_unless_default(
	css_classes,
	self.foreground,
	ANSI_FOREGROUND_DEFAULT,
	flip_fore_and_background,
	"inv_background",
	)
	append_color_unless_default(
	css_classes,
	self.background,
	ANSI_BACKGROUND_DEFAULT,
	flip_fore_and_background,
	"inv_foreground",
	)

	return css_classes


	class OSC_Link:
	def __init__(self, url: str, text: str) -> None:
	self.url = url
	self.text = text


	def map_vt100_box_code(char: str) -> str:
	char_hex = hex(ord(char))
	return VT100_BOX_CODES[char_hex] if char_hex in VT100_BOX_CODES else char


	def _needs_extra_newline(text: str) -> bool:
	if not text or text.endswith("\n"):
	return False
	return True


	class CursorMoveUp:
	pass


	class Attributes(TypedDict):
	dark_bg: bool
	line_wrap: bool
	font_size: str
	body: str
	styles: Set[str]


	class Ansi2HTMLConverter:
	"""Convert Ansi color codes to CSS+HTML

	Example:

	>>> conv = Ansi2HTMLConverter()
	>>> ansi = " ".join(sys.stdin.readlines())
	>>> html = conv.convert(ansi)
	"""

	def __init__(
	self,
	latex: bool = False,
	inline: bool = False,
	dark_bg: bool = True,
	line_wrap: bool = True,
	font_size: str = "normal",
	linkify: bool = False,
	escaped: bool = True,
	markup_lines: bool = False,
	output_encoding: str = "utf-8",
	scheme: str = "ansi2html",
	title: str = "",
	) -> None:

	self.latex = latex
	self.inline = inline
	self.dark_bg = dark_bg
	self.line_wrap = line_wrap
	self.font_size = font_size
	self.linkify = linkify
	self.escaped = escaped
	self.markup_lines = markup_lines
	self.output_encoding = output_encoding
	self.scheme = scheme
	self.title = title
	self._attrs: Attributes
	self.hyperref = False
	if inline:
	self.styles = dict(
	[
	(item.klass.strip("."), item)
	for item in get_styles(self.dark_bg, self.line_wrap, self.scheme)
	]
	)

	self.vt100_box_codes_prog = re.compile("\033\\(([B0])")
	self.ansi_codes_prog = re.compile("\033\\[([\\d;:]*)([a-zA-z])")
	self.url_matcher = re.compile(
	r"(((((https?\|ftps?\|gopher\|telnet\|nntp)://)\|"
	r"(mailto:\|news:))(%[0-9A-Fa-f]{2}\|[-()_.!~*"
	r"\';/?:@&=+$,A-Za-z0-9])+)([).!\';/?:,][\s])?)"
	)
	self.osc_link_re = re.compile("\033\\]8;;(.?)\007(.?)\033\\]8;;\007")

	def do_linkify(self, line: str) -> str:
	if not isinstance(line, str):
	return line # If line is an object, e.g. OSC_Link, it
	# will be expanded to a string later
	if self.latex:
	return self.url_matcher.sub(r"\\url{\1}", line)
	return self.url_matcher.sub(r'<a href="\1">\1</a>', line)

	def handle_osc_links(self, part: OSC_Link) -> str:
	if self.latex:
	self.hyperref = True
	return """\\href{%s}{%s}""" % (part.url, part.text)
	return """<a href="%s">%s</a>""" % (part.url, part.text)

	def apply_regex(self, ansi: str) -> Tuple[str, Set[str]]:
	styles_used: Set[str] = set()
	all_parts = self._apply_regex(ansi, styles_used)
	no_cursor_parts = self._collapse_cursor(all_parts)
	no_cursor_parts = list(no_cursor_parts)

	def _check_links(parts: List[Union[str, OSC_Link]]) -> Iterator[str]:
	for part in parts:
	if isinstance(part, str):
	if self.linkify:
	yield self.do_linkify(part)
	else:
	yield part
	elif isinstance(part, OSC_Link):
	yield self.handle_osc_links(part)
	else:
	yield part

	parts = list(_check_links(no_cursor_parts))
	combined = "".join(parts)
	if self.markup_lines and not self.latex:
	combined = "\n".join(
	[
	"""<span id="line-%i">%s</span>""" % (i, line)
	for i, line in enumerate(combined.split("\n"))
	]
	)
	return combined, styles_used

	def _apply_regex(
	self, ansi: str, styles_used: Set[str]
	) -> Iterator[Union[str, OSC_Link, CursorMoveUp]]:
	if self.escaped:
	if (
	self.latex
	): # Known Perl function which does this: https://tex.stackexchange.com/questions/34580/escape-character-in-latex/119383#119383
	specials = OrderedDict([])
	else:
	specials = OrderedDict(
	[
	("&", "&"),
	("<", "<"),
	(">", ">"),
	]
	)
	for pattern, special in specials.items():
	ansi = ansi.replace(pattern, special)

	def _vt100_box_drawing() -> Iterator[str]:
	last_end = 0 # the index of the last end of a code we've seen
	box_drawing_mode = False
	for match in self.vt100_box_codes_prog.finditer(ansi):
	trailer = ansi[last_end : match.start()]
	if box_drawing_mode:
	for char in trailer:
	yield map_vt100_box_code(char)
	else:
	yield trailer
	last_end = match.end()
	box_drawing_mode = match.groups()[0] == "0"
	yield ansi[last_end:]

	ansi = "".join(_vt100_box_drawing())

	def _osc_link(ansi: str) -> Iterator[Union[str, OSC_Link]]:
	last_end = 0
	for match in self.osc_link_re.finditer(ansi):
	trailer = ansi[last_end : match.start()]
	yield trailer
	url = match.groups()[0]
	text = match.groups()[1]
	yield OSC_Link(url, text)
	last_end = match.end()
	yield ansi[last_end:]

	state = _State()
	for part in _osc_link(ansi):
	if isinstance(part, OSC_Link):
	yield part
	else:
	yield from self._handle_ansi_code(part, styles_used, state)
	if state.inside_span:
	if self.latex:
	yield "}"
	else:
	yield "</span>"

	def _handle_ansi_code(
	self, ansi: str, styles_used: Set[str], state: _State
	) -> Iterator[Union[str, CursorMoveUp]]:
	last_end = 0 # the index of the last end of a code we've seen
	for match in self.ansi_codes_prog.finditer(ansi):
	yield ansi[last_end : match.start()]
	last_end = match.end()

	params: Union[str, List[int]]
	params, command = match.groups()

	if command not in "mMA":
	continue

	# Special cursor-moving code. The only supported one.
	if command == "A":
	yield CursorMoveUp()
	continue

	while True:
	param_len = len(params)
	params = params.replace("::", ":")
	params = params.replace(";;", ";")
	if len(params) == param_len:
	break

	try:
	params = [int(x) for x in re.split("[;:]", params)]
	except ValueError:
	params = [ANSI_FULL_RESET]

	# Find latest reset marker
	last_null_index = None
	skip_after_index = -1
	for i, v in enumerate(params):
	if i <= skip_after_index:
	continue

	if v == ANSI_FULL_RESET:
	last_null_index = i
	elif v in (ANSI_FOREGROUND, ANSI_BACKGROUND):
	try:
	x_bit_color_id = params[i + 1]
	except IndexError:
	x_bit_color_id = -1
	is_256_color = x_bit_color_id == ANSI_256_COLOR_ID
	shift = 2 if is_256_color else 4
	skip_after_index = i + shift

	# Process reset marker, drop everything before
	if last_null_index is not None:
	params = params[last_null_index + 1 :]
	if state.inside_span:
	state.inside_span = False
	if self.latex:
	yield "}"
	else:
	yield "</span>"
	state.reset()

	if not params:
	continue

	# Turn codes into CSS classes
	skip_after_index = -1
	for i, v in enumerate(params):
	if i <= skip_after_index:
	continue

	is_x_bit_color = v in (ANSI_FOREGROUND, ANSI_BACKGROUND)
	try:
	x_bit_color_id = params[i + 1]
	except IndexError:
	x_bit_color_id = -1
	is_256_color = x_bit_color_id == ANSI_256_COLOR_ID
	is_truecolor = x_bit_color_id == ANSI_TRUECOLOR_ID
	if is_x_bit_color and is_256_color:
	try:
	parameter: Optional[str] = str(params[i + 2])
	except IndexError:
	continue
	skip_after_index = i + 2
	elif is_x_bit_color and is_truecolor:
	try:
	state.adjust_truecolor(
	v, params[i + 2], params[i + 3], params[i + 4]
	)
	except IndexError:
	continue
	skip_after_index = i + 4
	continue
	else:
	parameter = None
	state.adjust(v, parameter=parameter)

	if state.inside_span:
	if self.latex:
	yield "}"
	else:
	yield "</span>"
	state.inside_span = False

	css_classes = state.to_css_classes()
	if not css_classes:
	continue
	styles_used.update(css_classes)

	if self.inline:
	self.styles.update(pop_truecolor_styles())
	if self.latex:
	style = [
	self.styles[klass].kwl[0][1]
	for klass in css_classes
	if self.styles[klass].kwl[0][0] == "color"
	]
	yield "\\textcolor[HTML]{%s}{" % style[0]
	else:
	style = [
	self.styles[klass].kw
	for klass in css_classes
	if klass in self.styles
	]
	yield '<span style="%s">' % "; ".join(style)
	else:
	if self.latex:
	yield "\\textcolor{%s}{" % " ".join(css_classes)
	else:
	yield '<span class="%s">' % " ".join(css_classes)
	state.inside_span = True
	yield ansi[last_end:]

	def _collapse_cursor(
	self, parts: Iterator[Union[str, OSC_Link, CursorMoveUp]]
	) -> List[Union[str, OSC_Link]]:
	"""Act on any CursorMoveUp commands by deleting preceding tokens"""

	final_parts: List[Union[str, OSC_Link]] = []
	for part in parts:

	# Throw out empty string tokens ("")
	if not part:
	continue

	# Go back, deleting every token in the last 'line'
	if isinstance(part, CursorMoveUp):
	if final_parts:
	final_parts.pop()

	while final_parts and (
	isinstance(final_parts[-1], OSC_Link)
	or (
	isinstance(final_parts[-1], str) and "\n" not in final_parts[-1]
	)
	):
	final_parts.pop()

	continue

	# Otherwise, just pass this token forward
	final_parts.append(part)

	return final_parts

	def prepare(
	self, ansi: str = "", ensure_trailing_newline: bool = False
	) -> Attributes:
	"""Load the contents of 'ansi' into this object"""

	body, styles = self.apply_regex(ansi)

	if ensure_trailing_newline and _needs_extra_newline(body):
	body += "\n"

	self._attrs = {
	"dark_bg": self.dark_bg,
	"line_wrap": self.line_wrap,
	"font_size": self.font_size,
	"body": body,
	"styles": styles,
	}

	return self._attrs

	def convert(
	self, ansi: str, full: bool = True, ensure_trailing_newline: bool = False
	) -> str:
	r"""
	:param ansi: ANSI sequence to convert.
	:param full: Whether to include the full HTML document or only the body.
	:param ensure_trailing_newline: Ensures that ``\n`` character is present at the end of the output.
	"""
	attrs = self.prepare(ansi, ensure_trailing_newline=ensure_trailing_newline)
	if not full:
	return attrs["body"]
	if self.latex:
	_template = _latex_template
	else:
	_template = _html_template
	all_styles = get_styles(self.dark_bg, self.line_wrap, self.scheme)
	backgrounds = all_styles[:5]
	used_styles = filter(
	lambda e: e.klass.lstrip(".") in attrs["styles"], all_styles
	)

	return _template % {
	"style": "\n".join(list(map(str, backgrounds + list(used_styles)))),
	"title": self.title,
	"font_size": self.font_size,
	"content": attrs["body"],
	"output_encoding": self.output_encoding,
	"hyperref": "\\usepackage{hyperref}" if self.hyperref else "",
	}

	def produce_headers(self) -> str:
	return '<style type="text/css">\n%(style)s\n</style>\n' % {
	"style": "\n".join(
	map(str, get_styles(self.dark_bg, self.line_wrap, self.scheme))
	)
	}


	def main() -> None:
	"""
	$ ls --color=always \| ansi2html > directories.html
	$ sudo tail /var/log/messages \| ccze -A \| ansi2html > logs.html
	$ task burndown \| ansi2html > burndown.html
	"""

	scheme_names = sorted(SCHEME.keys())
	version_str = version("ansi2html")
	parser = optparse.OptionParser(
	usage=main.__doc__, version="%%prog %s" % version_str
	)
	parser.add_option(
	"-p",
	"--partial",
	dest="partial",
	default=False,
	action="store_true",
	help="Process lines as them come in. No headers are produced.",
	)
	parser.add_option(
	"-L",
	"--latex",
	dest="latex",
	default=False,
	action="store_true",
	help="Export as LaTeX instead of HTML.",
	)
	parser.add_option(
	"-i",
	"--inline",
	dest="inline",
	default=False,
	action="store_true",
	help="Inline style without headers or template.",
	)
	parser.add_option(
	"-H",
	"--headers",
	dest="headers",
	default=False,
	action="store_true",
	help="Just produce the <style> tag.",
	)
	parser.add_option(
	"-f",
	"--font-size",
	dest="font_size",
	metavar="SIZE",
	default="normal",
	help="Set the global font size in the output.",
	)
	parser.add_option(
	"-l",
	"--light-background",
	dest="light_background",
	default=False,
	action="store_true",
	help="Set output to 'light background' mode.",
	)
	parser.add_option(
	"-W",
	"--no-line-wrap",
	dest="no_line_wrap",
	default=False,
	action="store_true",
	help="Disable line wrapping.",
	)
	parser.add_option(
	"-a",
	"--linkify",
	dest="linkify",
	default=False,
	action="store_true",
	help="Transform URLs into <a> links.",
	)
	parser.add_option(
	"-u",
	"--unescape",
	dest="escaped",
	default=True,
	action="store_false",
	help="Do not escape XML tags found in the input.",
	)
	parser.add_option(
	"-m",
	"--markup-lines",
	dest="markup_lines",
	default=False,
	action="store_true",
	help="Surround lines with <span id='line-n'>..</span>.",
	)
	parser.add_option(
	"--input-encoding",
	dest="input_encoding",
	metavar="ENCODING",
	default="utf-8",
	help="Specify input encoding",
	)
	parser.add_option(
	"--output-encoding",
	dest="output_encoding",
	metavar="ENCODING",
	default="utf-8",
	help="Specify output encoding",
	)
	parser.add_option(
	"-s",
	"--scheme",
	dest="scheme",
	metavar="SCHEME",
	default="ansi2html",
	choices=scheme_names,
	help=(
	"Specify color palette scheme. Default: %%default. Choices: %s"
	% scheme_names
	),
	)
	parser.add_option(
	"-t", "--title", dest="output_title", default="", help="Specify output title"
	)

	opts, args = parser.parse_args()

	conv = Ansi2HTMLConverter(
	latex=opts.latex,
	inline=opts.inline,
	dark_bg=not opts.light_background,
	line_wrap=not opts.no_line_wrap,
	font_size=opts.font_size,
	linkify=opts.linkify,
	escaped=opts.escaped,
	markup_lines=opts.markup_lines,
	output_encoding=opts.output_encoding,
	scheme=opts.scheme,
	title=opts.output_title,
	)

	if hasattr(sys.stdin, "detach") and not isinstance(
	sys.stdin, io.StringIO
	): # e.g. during tests
	input_buffer = sys.stdin.detach() # type: ignore
	sys.stdin = io.TextIOWrapper(input_buffer, opts.input_encoding, "replace")

	def _print(output_unicode: str, end: str = "\n") -> None:
	if hasattr(sys.stdout, "buffer"):
	output_bytes = (output_unicode + end).encode(opts.output_encoding)
	sys.stdout.buffer.write(output_bytes)
	else:
	sys.stdout.write(output_unicode + end)

	# Produce only the headers and quit
	if opts.headers:
	_print(conv.produce_headers(), end="")
	return

	full = not bool(opts.partial or opts.inline)
	output = conv.convert(
	"".join(sys.stdin.readlines()), full=full, ensure_trailing_newline=True
	)
	_print(output, end="")