Emulating Ubuntu Terminal with LaTeX

from html.parser import HTMLParser
from colour import Color
from pylatex.utils import escape_latex
from collections import deque
import re


def get_default_entity():
    return {
        'tag': None,
        'data': [],
        'attrs': None,
        'last_pointer': None
    }


class AhaHTMLParser(HTMLParser):
    def __init__(self):
        super().__init__()

        self.root = get_default_entity()
        self.root['tag'] = '@root'
        self.treeStorage = [self.root]

        self.curPointer = self.root

    def handle_starttag(self, tag, attrs):
        # create new structure in the tree
        entity = get_default_entity()
        entity['last_pointer'] = self.curPointer
        entity['tag'] = tag
        entity['attrs'] = attrs
        self.treeStorage.append(entity)
        self.curPointer = entity

    def handle_endtag(self, tag):
        # append this entity to last pointer
        self.curPointer['last_pointer']['data'].append(self.curPointer)
        self.curPointer = self.curPointer['last_pointer']

    def handle_data(self, data):
        # append data to current pointer
        dataEntity = get_default_entity()
        dataEntity['data'].append(data)
        self.curPointer['data'].append(dataEntity)


def get_html_tree(filename):
    with open(filename, 'r') as infile:
        htmlContent = infile.read()
    parser = AhaHTMLParser()
    parser.feed(htmlContent)
    return (parser.root, parser.treeStorage)


def find_pre_in_tree(node):
    if node['tag'] == 'pre':
        return node

    for data in node['data']:
        if isinstance(data, dict):
            result = find_pre_in_tree(data)
            if result is not None:
                return result

    return None


def parse_css_style(styleStr):
    styles = styleStr.split(';')
    result = dict()
    for style in styles:
        if len(style) == 0:
            continue

        key, val = style.split(':')
        key = key.strip()
        val = val.strip()
        assert len(key) > 0
        assert len(val) > 0
        result[key] = val

    return result


class HTMLTree2Latex:

    def __init__(self):
        self.colorConv = dict()
        self.result = []

    def to_latex(self, node):
        self.result.clear()
        self.colorConv.clear()

        self._to_latex(node)
        # generate color definition
        colorDefFormat = r'\definecolor{%s}{HTML}{%s}'

        colorDefs = []
        for key, val in self.colorConv.items():
            colorDef = colorDefFormat % (val['latex_name'], val['value'])
            colorDefs.append(colorDef)

        colorDefStr = '\n'.join(colorDefs)

        return colorDefStr, self.result

    def _get_color_item(self, colorStr):
        if colorStr not in self.colorConv:
            # create new color item
            colorItem = dict()
            colorItem['latex_name'] = self._get_color_latex_name(colorStr)
            colorItem['value'] = Color(colorStr).get_hex_l()[1:]
            self.colorConv[colorStr] = colorItem

        colorItem = self.colorConv[colorStr]
        return colorItem

    def _get_color_latex_name(self, color):
        return 'xxxhtmlcolor{}'.format(color)

    def _to_latex(self, node):
        result = self.result

        # process style
        hasStyle = False
        textEscape = False
        endCap = []

        if node['attrs'] is not None:
            for key, val in node['attrs']:
                if key == 'style':
                    # if there is style, then the entity has to be escaped
                    hasStyle = True
                    textEscape = True
                    cssStyle = parse_css_style(val)
                    result.append('%*')
                    endCap.insert(0, '*)')

                    if 'font-weight' in cssStyle:
                        if cssStyle['font-weight'] == 'bold':
                            result.append(r'{\bfseries')
                            endCap.insert(0, '}')

                    if 'color' in cssStyle:
                        colorStr = cssStyle['color']
                        colorItem = self._get_color_item(colorStr)
                        result.append(r'{\color{%s}' % colorItem['latex_name'])
                        endCap.insert(0, '}')

                    if 'background-color' in cssStyle:
                        self.addColorBoxDef = True
                        colorStr = cssStyle['background-color']
                        colorItem = self._get_color_item(colorStr)
                        result.append(r'\smash{\colorbox{%s}{'%colorItem['latex_name'])
                        endCap.insert(0, '}}')


        startResultSize = len(result)

        for data in node['data']:
            if isinstance(data, str):
                result.append(data)
            elif isinstance(data, dict):
                self._to_latex(data)

        if textEscape:
            for i in range(startResultSize, len(result)):
                result[i] = escape_latex(result[i])

        if hasStyle:
            result.extend(endCap)


def html_to_console_style(filename):
    root, tree = get_html_tree(filename)
    preEntity = find_pre_in_tree(root)
    assert preEntity is not None
    html2altex = HTMLTree2Latex()
    colorDef, content = html2altex.to_latex(preEntity)

    outputFmt = r'''{
\lstconsolestyle
%s
\begin{lstlisting}
%s
\end{lstlisting}
}
'''

    return outputFmt%(colorDef, ''.join(content))



if __name__ == '__main__':
    filename = input('please enter filename: ')
    print(html_to_console_style(filename))