<h2>Editing File: /lib/python3.6/site-packages/html2text/__init__.py</h2><form method='post'><textarea name='content' class='file-edit'>&quot;&quot;&quot;html2text: Turn HTML into equivalent Markdown-structured text.&quot;&quot;&quot;

import html.entities
import html.parser
import re
import urllib.parse as urlparse
from textwrap import wrap

from html2text import config
from html2text.utils import (
    dumb_css_parser,
    element_style,
    escape_md,
    escape_md_section,
    google_fixed_width_font,
    google_has_height,
    google_list_style,
    google_text_emphasis,
    hn,
    list_numbering_start,
    pad_tables_in_text,
    skipwrap,
    unifiable_n,
)

__version__ = (2019, 9, 26)


# TODO:
# Support decoded entities with UNIFIABLE.


class HTML2Text(html.parser.HTMLParser):
    def __init__(self, out=None, baseurl=&quot;&quot;, bodywidth=config.BODY_WIDTH):
        &quot;&quot;&quot;
        Input parameters:
            out: possible custom replacement for self.outtextf (which
                 appends lines of text).
            baseurl: base URL of the document we process
        &quot;&quot;&quot;
        super().__init__(convert_charrefs=False)

        # Config options
        self.split_next_td = False
        self.td_count = 0
        self.table_start = False
        self.unicode_snob = config.UNICODE_SNOB  # covered in cli
        self.escape_snob = config.ESCAPE_SNOB  # covered in cli
        self.links_each_paragraph = config.LINKS_EACH_PARAGRAPH
        self.body_width = bodywidth  # covered in cli
        self.skip_internal_links = config.SKIP_INTERNAL_LINKS  # covered in cli
        self.inline_links = config.INLINE_LINKS  # covered in cli
        self.protect_links = config.PROTECT_LINKS  # covered in cli
        self.google_list_indent = config.GOOGLE_LIST_INDENT  # covered in cli
        self.ignore_links = config.IGNORE_ANCHORS  # covered in cli
        self.ignore_images = config.IGNORE_IMAGES  # covered in cli
        self.images_as_html = config.IMAGES_AS_HTML  # covered in cli
        self.images_to_alt = config.IMAGES_TO_ALT  # covered in cli
        self.images_with_size = config.IMAGES_WITH_SIZE  # covered in cli
        self.ignore_emphasis = config.IGNORE_EMPHASIS  # covered in cli
        self.bypass_tables = config.BYPASS_TABLES  # covered in cli
        self.ignore_tables = config.IGNORE_TABLES  # covered in cli
        self.google_doc = False  # covered in cli
        self.ul_item_mark = &quot;*&quot;  # covered in cli
        self.emphasis_mark = &quot;_&quot;  # covered in cli
        self.strong_mark = &quot;**&quot;
        self.single_line_break = config.SINGLE_LINE_BREAK  # covered in cli
        self.use_automatic_links = config.USE_AUTOMATIC_LINKS  # covered in cli
        self.hide_strikethrough = False  # covered in cli
        self.mark_code = config.MARK_CODE
        self.wrap_list_items = config.WRAP_LIST_ITEMS  # covered in cli
        self.wrap_links = config.WRAP_LINKS  # covered in cli
        self.pad_tables = config.PAD_TABLES  # covered in cli
        self.default_image_alt = config.DEFAULT_IMAGE_ALT  # covered in cli
        self.tag_callback = None
        self.open_quote = config.OPEN_QUOTE  # covered in cli
        self.close_quote = config.CLOSE_QUOTE  # covered in cli

        if out is None:
            self.out = self.outtextf
        else:
            self.out = out

        # empty list to store output characters before they are &quot;joined&quot;
        self.outtextlist = []

        self.quiet = 0
        self.p_p = 0  # number of newline character to print before next output
        self.outcount = 0
        self.start = True
        self.space = False
        self.a = []
        self.astack = []
        self.maybe_automatic_link = None
        self.empty_link = False
        self.absolute_url_matcher = re.compile(r&quot;^[a-zA-Z+]+://&quot;)
        self.acount = 0
        self.list = []
        self.blockquote = 0
        self.pre = False
        self.startpre = False
        self.code = False
        self.quote = False
        self.br_toggle = &quot;&quot;
        self.lastWasNL = False
        self.lastWasList = False
        self.style = 0
        self.style_def = {}
        self.tag_stack = []
        self.emphasis = 0
        self.drop_white_space = 0
        self.inheader = False
        self.abbr_title = None  # current abbreviation definition
        self.abbr_data = None  # last inner HTML (for abbr being defined)
        self.abbr_list = {}  # stack of abbreviations to write later
        self.baseurl = baseurl
        self.stressed = False
        self.preceding_stressed = False
        self.preceding_data = None
        self.current_tag = None

        config.UNIFIABLE[&quot;nbsp&quot;] = &quot;&amp;nbsp_place_holder;&quot;

    def feed(self, data):
        data = data.replace(&quot;&lt;/' + 'script&gt;&quot;, &quot;&lt;/ignore&gt;&quot;)
        super().feed(data)

    def handle(self, data):
        self.feed(data)
        self.feed(&quot;&quot;)
        markdown = self.optwrap(self.close())
        if self.pad_tables:
            return pad_tables_in_text(markdown)
        else:
            return markdown

    def outtextf(self, s):
        self.outtextlist.append(s)
        if s:
            self.lastWasNL = s[-1] == &quot;\n&quot;

    def close(self):
        super().close()

        self.pbr()
        self.o(&quot;&quot;, force=&quot;end&quot;)

        outtext = &quot;&quot;.join(self.outtextlist)

        if self.unicode_snob:
            nbsp = html.entities.html5[&quot;nbsp;&quot;]
        else:
            nbsp = &quot; &quot;
        outtext = outtext.replace(&quot;&amp;nbsp_place_holder;&quot;, nbsp)

        # Clear self.outtextlist to avoid memory leak of its content to
        # the next handling.
        self.outtextlist = []

        return outtext

    def handle_charref(self, c):
        self.handle_data(self.charref(c), True)

    def handle_entityref(self, c):
        ref = self.entityref(c)

        # ref may be an empty string (e.g. for &amp;lrm;/&amp;rlm; markers that should
        # not contribute to the final output).
        # self.handle_data cannot handle a zero-length string right after a
        # stressed tag or mid-text within a stressed tag (text get split and
        # self.stressed/self.preceding_stressed gets switched after the first
        # part of that text).
        if ref:
            self.handle_data(ref, True)

    def handle_starttag(self, tag, attrs):
        self.handle_tag(tag, attrs, start=True)

    def handle_endtag(self, tag):
        self.handle_tag(tag, None, start=False)

    def previousIndex(self, attrs):
        &quot;&quot;&quot;
        :type attrs: dict

        :returns: The index of certain set of attributes (of a link) in the
        self.a list. If the set of attributes is not found, returns None
        :rtype: int
        &quot;&quot;&quot;
        if &quot;href&quot; not in attrs:
            return None

        match = False
        for i, a in enumerate(self.a):
            if &quot;href&quot; in a and a[&quot;href&quot;] == attrs[&quot;href&quot;]:
                if &quot;title&quot; in a or &quot;title&quot; in attrs:
                    if (
                        &quot;title&quot; in a
                        and &quot;title&quot; in attrs
                        and a[&quot;title&quot;] == attrs[&quot;title&quot;]
                    ):
                        match = True
                else:
                    match = True

            if match:
                return i
        return None

    def handle_emphasis(self, start, tag_style, parent_style):
        &quot;&quot;&quot;
        Handles various text emphases
        &quot;&quot;&quot;
        tag_emphasis = google_text_emphasis(tag_style)
        parent_emphasis = google_text_emphasis(parent_style)

        # handle Google's text emphasis
        strikethrough = &quot;line-through&quot; in tag_emphasis and self.hide_strikethrough

        # google and others may mark a font's weight as `bold` or `700`
        bold = False
        for bold_marker in config.BOLD_TEXT_STYLE_VALUES:
            bold = bold_marker in tag_emphasis and bold_marker not in parent_emphasis
            if bold:
                break

        italic = &quot;italic&quot; in tag_emphasis and &quot;italic&quot; not in parent_emphasis
        fixed = (
            google_fixed_width_font(tag_style)
            and not google_fixed_width_font(parent_style)
            and not self.pre
        )

        if start:
            # crossed-out text must be handled before other attributes
            # in order not to output qualifiers unnecessarily
            if bold or italic or fixed:
                self.emphasis += 1
            if strikethrough:
                self.quiet += 1
            if italic:
                self.o(self.emphasis_mark)
                self.drop_white_space += 1
            if bold:
                self.o(self.strong_mark)
                self.drop_white_space += 1
            if fixed:
                self.o(&quot;`&quot;)
                self.drop_white_space += 1
                self.code = True
        else:
            if bold or italic or fixed:
                # there must not be whitespace before closing emphasis mark
                self.emphasis -= 1
                self.space = False
            if fixed:
                if self.drop_white_space:
                    # empty emphasis, drop it
                    self.drop_white_space -= 1
                else:
                    self.o(&quot;`&quot;)
                self.code = False
            if bold:
                if self.drop_white_space:
                    # empty emphasis, drop it
                    self.drop_white_space -= 1
                else:
                    self.o(self.strong_mark)
            if italic:
                if self.drop_white_space:
                    # empty emphasis, drop it
                    self.drop_white_space -= 1
                else:
                    self.o(self.emphasis_mark)
            # space is only allowed after *all* emphasis marks
            if (bold or italic) and not self.emphasis:
                self.o(&quot; &quot;)
            if strikethrough:
                self.quiet -= 1

    def handle_tag(self, tag, attrs, start):
        self.current_tag = tag
        # attrs is None for endtags
        if attrs is None:
            attrs = {}
        else:
            attrs = dict(attrs)

        if self.tag_callback is not None:
            if self.tag_callback(self, tag, attrs, start) is True:
                return

        # first thing inside the anchor tag is another tag
        # that produces some output
        if (
            start
            and self.maybe_automatic_link is not None
            and tag not in [&quot;p&quot;, &quot;div&quot;, &quot;style&quot;, &quot;dl&quot;, &quot;dt&quot;]
            and (tag != &quot;img&quot; or self.ignore_images)
        ):
            self.o(&quot;[&quot;)
            self.maybe_automatic_link = None
            self.empty_link = False

        if self.google_doc:
            # the attrs parameter is empty for a closing tag. in addition, we
            # need the attributes of the parent nodes in order to get a
            # complete style description for the current element. we assume
            # that google docs export well formed html.
            parent_style = {}
            if start:
                if self.tag_stack:
                    parent_style = self.tag_stack[-1][2]
                tag_style = element_style(attrs, self.style_def, parent_style)
                self.tag_stack.append((tag, attrs, tag_style))
            else:
                dummy, attrs, tag_style = (
                    self.tag_stack.pop() if self.tag_stack else (None, {}, {})
                )
                if self.tag_stack:
                    parent_style = self.tag_stack[-1][2]

        if hn(tag):
            self.p()
            if start:
                self.inheader = True
                self.o(hn(tag) * &quot;#&quot; + &quot; &quot;)
            else:
                self.inheader = False
                return  # prevent redundant emphasis marks on headers

        if tag in [&quot;p&quot;, &quot;div&quot;]:
            if self.google_doc:
                if start and google_has_height(tag_style):
                    self.p()
                else:
                    self.soft_br()
            elif self.astack and tag == &quot;div&quot;:
                pass
            else:
                self.p()

        if tag == &quot;br&quot; and start:
            if self.blockquote &gt; 0:
                self.o(&quot;  \n&gt; &quot;)
            else:
                self.o(&quot;  \n&quot;)

        if tag == &quot;hr&quot; and start:
            self.p()
            self.o(&quot;* * *&quot;)
            self.p()

        if tag in [&quot;head&quot;, &quot;style&quot;, &quot;script&quot;]:
            if start:
                self.quiet += 1
            else:
                self.quiet -= 1

        if tag == &quot;style&quot;:
            if start:
                self.style += 1
            else:
                self.style -= 1

        if tag in [&quot;body&quot;]:
            self.quiet = 0  # sites like 9rules.com never close &lt;head&gt;

        if tag == &quot;blockquote&quot;:
            if start:
                self.p()
                self.o(&quot;&gt; &quot;, force=True)
                self.start = True
                self.blockquote += 1
            else:
                self.blockquote -= 1
                self.p()

        def no_preceding_space(self):
            return self.preceding_data and re.match(r&quot;[^\s]&quot;, self.preceding_data[-1])

        if tag in [&quot;em&quot;, &quot;i&quot;, &quot;u&quot;] and not self.ignore_emphasis:
            if start and no_preceding_space(self):
                emphasis = &quot; &quot; + self.emphasis_mark
            else:
                emphasis = self.emphasis_mark

            self.o(emphasis)
            if start:
                self.stressed = True

        if tag in [&quot;strong&quot;, &quot;b&quot;] and not self.ignore_emphasis:
            if start and no_preceding_space(self):
                strong = &quot; &quot; + self.strong_mark
            else:
                strong = self.strong_mark

            self.o(strong)
            if start:
                self.stressed = True

        if tag in [&quot;del&quot;, &quot;strike&quot;, &quot;s&quot;]:
            if start and no_preceding_space(self):
                strike = &quot; ~~&quot;
            else:
                strike = &quot;~~&quot;

            self.o(strike)
            if start:
                self.stressed = True

        if self.google_doc:
            if not self.inheader:
                # handle some font attributes, but leave headers clean
                self.handle_emphasis(start, tag_style, parent_style)

        if tag in [&quot;kbd&quot;, &quot;code&quot;, &quot;tt&quot;] and not self.pre:
            self.o(&quot;`&quot;)  # TODO: `` `this` ``
            self.code = not self.code

        if tag == &quot;abbr&quot;:
            if start:
                self.abbr_title = None
                self.abbr_data = &quot;&quot;
                if &quot;title&quot; in attrs:
                    self.abbr_title = attrs[&quot;title&quot;]
            else:
                if self.abbr_title is not None:
                    self.abbr_list[self.abbr_data] = self.abbr_title
                    self.abbr_title = None
                self.abbr_data = None

        if tag == &quot;q&quot;:
            if not self.quote:
                self.o(self.open_quote)
            else:
                self.o(self.close_quote)
            self.quote = not self.quote

        def link_url(self, link, title=&quot;&quot;):
            url = urlparse.urljoin(self.baseurl, link)
            title = ' &quot;{}&quot;'.format(title) if title.strip() else &quot;&quot;
            self.o(&quot;]({url}{title})&quot;.format(url=escape_md(url), title=title))

        if tag == &quot;a&quot; and not self.ignore_links:
            if start:
                if (
                    &quot;href&quot; in attrs
                    and attrs[&quot;href&quot;] is not None
                    and not (self.skip_internal_links and attrs[&quot;href&quot;].startswith(&quot;#&quot;))
                ):
                    self.astack.append(attrs)
                    self.maybe_automatic_link = attrs[&quot;href&quot;]
                    self.empty_link = True
                    if self.protect_links:
                        attrs[&quot;href&quot;] = &quot;&lt;&quot; + attrs[&quot;href&quot;] + &quot;&gt;&quot;
                else:
                    self.astack.append(None)
            else:
                if self.astack:
                    a = self.astack.pop()
                    if self.maybe_automatic_link and not self.empty_link:
                        self.maybe_automatic_link = None
                    elif a:
                        if self.empty_link:
                            self.o(&quot;[&quot;)
                            self.empty_link = False
                            self.maybe_automatic_link = None
                        if self.inline_links:
                            try:
                                title = a[&quot;title&quot;] if a[&quot;title&quot;] else &quot;&quot;
                                title = escape_md(title)
                            except KeyError:
                                link_url(self, a[&quot;href&quot;], &quot;&quot;)
                            else:
                                link_url(self, a[&quot;href&quot;], title)
                        else:
                            i = self.previousIndex(a)
                            if i is not None:
                                a = self.a[i]
                            else:
                                self.acount += 1
                                a[&quot;count&quot;] = self.acount
                                a[&quot;outcount&quot;] = self.outcount
                                self.a.append(a)
                            self.o(&quot;][&quot; + str(a[&quot;count&quot;]) + &quot;]&quot;)

        if tag == &quot;img&quot; and start and not self.ignore_images:
            if &quot;src&quot; in attrs:
                if not self.images_to_alt:
                    attrs[&quot;href&quot;] = attrs[&quot;src&quot;]
                alt = attrs.get(&quot;alt&quot;) or self.default_image_alt

                # If we have images_with_size, write raw html including width,
                # height, and alt attributes
                if self.images_as_html or (
                    self.images_with_size and (&quot;width&quot; in attrs or &quot;height&quot; in attrs)
                ):
                    self.o(&quot;&lt;img src='&quot; + attrs[&quot;src&quot;] + &quot;' &quot;)
                    if &quot;width&quot; in attrs:
                        self.o(&quot;width='&quot; + attrs[&quot;width&quot;] + &quot;' &quot;)
                    if &quot;height&quot; in attrs:
                        self.o(&quot;height='&quot; + attrs[&quot;height&quot;] + &quot;' &quot;)
                    if alt:
                        self.o(&quot;alt='&quot; + alt + &quot;' &quot;)
                    self.o(&quot;/&gt;&quot;)
                    return

                # If we have a link to create, output the start
                if self.maybe_automatic_link is not None:
                    href = self.maybe_automatic_link
                    if (
                        self.images_to_alt
                        and escape_md(alt) == href
                        and self.absolute_url_matcher.match(href)
                    ):
                        self.o(&quot;&lt;&quot; + escape_md(alt) + &quot;&gt;&quot;)
                        self.empty_link = False
                        return
                    else:
                        self.o(&quot;[&quot;)
                        self.maybe_automatic_link = None
                        self.empty_link = False

                # If we have images_to_alt, we discard the image itself,
                # considering only the alt text.
                if self.images_to_alt:
                    self.o(escape_md(alt))
                else:
                    self.o(&quot;![&quot; + escape_md(alt) + &quot;]&quot;)
                    if self.inline_links:
                        href = attrs.get(&quot;href&quot;) or &quot;&quot;
                        self.o(
                            &quot;(&quot; + escape_md(urlparse.urljoin(self.baseurl, href)) + &quot;)&quot;
                        )
                    else:
                        i = self.previousIndex(attrs)
                        if i is not None:
                            attrs = self.a[i]
                        else:
                            self.acount += 1
                            attrs[&quot;count&quot;] = self.acount
                            attrs[&quot;outcount&quot;] = self.outcount
                            self.a.append(attrs)
                        self.o(&quot;[&quot; + str(attrs[&quot;count&quot;]) + &quot;]&quot;)

        if tag == &quot;dl&quot; and start:
            self.p()
        if tag == &quot;dt&quot; and not start:
            self.pbr()
        if tag == &quot;dd&quot; and start:
            self.o(&quot;    &quot;)
        if tag == &quot;dd&quot; and not start:
            self.pbr()

        if tag in [&quot;ol&quot;, &quot;ul&quot;]:
            # Google Docs create sub lists as top level lists
            if not self.list and not self.lastWasList:
                self.p()
            if start:
                if self.google_doc:
                    list_style = google_list_style(tag_style)
                else:
                    list_style = tag
                numbering_start = list_numbering_start(attrs)
                self.list.append({&quot;name&quot;: list_style, &quot;num&quot;: numbering_start})
            else:
                if self.list:
                    self.list.pop()
                    if not self.google_doc and not self.list:
                        self.o(&quot;\n&quot;)
            self.lastWasList = True
        else:
            self.lastWasList = False

        if tag == &quot;li&quot;:
            self.pbr()
            if start:
                if self.list:
                    li = self.list[-1]
                else:
                    li = {&quot;name&quot;: &quot;ul&quot;, &quot;num&quot;: 0}
                if self.google_doc:
                    nest_count = self.google_nest_count(tag_style)
                else:
                    nest_count = len(self.list)
                # TODO: line up &lt;ol&gt;&lt;li&gt;s &gt; 9 correctly.
                self.o(&quot;  &quot; * nest_count)
                if li[&quot;name&quot;] == &quot;ul&quot;:
                    self.o(self.ul_item_mark + &quot; &quot;)
                elif li[&quot;name&quot;] == &quot;ol&quot;:
                    li[&quot;num&quot;] += 1
                    self.o(str(li[&quot;num&quot;]) + &quot;. &quot;)
                self.start = True

        if tag in [&quot;table&quot;, &quot;tr&quot;, &quot;td&quot;, &quot;th&quot;]:
            if self.ignore_tables:
                if tag == &quot;tr&quot;:
                    if start:
                        pass
                    else:
                        self.soft_br()
                else:
                    pass

            elif self.bypass_tables:
                if start:
                    self.soft_br()
                if tag in [&quot;td&quot;, &quot;th&quot;]:
                    if start:
                        self.o(&quot;&lt;{}&gt;\n\n&quot;.format(tag))
                    else:
                        self.o(&quot;\n&lt;/{}&gt;&quot;.format(tag))
                else:
                    if start:
                        self.o(&quot;&lt;{}&gt;&quot;.format(tag))
                    else:
                        self.o(&quot;&lt;/{}&gt;&quot;.format(tag))

            else:
                if tag == &quot;table&quot;:
                    if start:
                        self.table_start = True
                        if self.pad_tables:
                            self.o(&quot;&lt;&quot; + config.TABLE_MARKER_FOR_PAD + &quot;&gt;&quot;)
                            self.o(&quot;  \n&quot;)
                    else:
                        if self.pad_tables:
                            self.o(&quot;&lt;/&quot; + config.TABLE_MARKER_FOR_PAD + &quot;&gt;&quot;)
                            self.o(&quot;  \n&quot;)
                if tag in [&quot;td&quot;, &quot;th&quot;] and start:
                    if self.split_next_td:
                        self.o(&quot;| &quot;)
                    self.split_next_td = True

                if tag == &quot;tr&quot; and start:
                    self.td_count = 0
                if tag == &quot;tr&quot; and not start:
                    self.split_next_td = False
                    self.soft_br()
                if tag == &quot;tr&quot; and not start and self.table_start:
                    # Underline table header
                    self.o(&quot;|&quot;.join([&quot;---&quot;] * self.td_count))
                    self.soft_br()
                    self.table_start = False
                if tag in [&quot;td&quot;, &quot;th&quot;] and start:
                    self.td_count += 1

        if tag == &quot;pre&quot;:
            if start:
                self.startpre = True
                self.pre = True
            else:
                self.pre = False
                if self.mark_code:
                    self.out(&quot;\n[/code]&quot;)
            self.p()

    # TODO: Add docstring for these one letter functions
    def pbr(self):
        &quot;Pretty print has a line break&quot;
        if self.p_p == 0:
            self.p_p = 1

    def p(self):
        &quot;Set pretty print to 1 or 2 lines&quot;
        self.p_p = 1 if self.single_line_break else 2

    def soft_br(self):
        &quot;Soft breaks&quot;
        self.pbr()
        self.br_toggle = &quot;  &quot;

    def o(self, data, puredata=False, force=False):
        &quot;&quot;&quot;
        Deal with indentation and whitespace
        &quot;&quot;&quot;
        if self.abbr_data is not None:
            self.abbr_data += data

        if not self.quiet:
            if self.google_doc:
                # prevent white space immediately after 'begin emphasis'
                # marks ('**' and '_')
                lstripped_data = data.lstrip()
                if self.drop_white_space and not (self.pre or self.code):
                    data = lstripped_data
                if lstripped_data != &quot;&quot;:
                    self.drop_white_space = 0

            if puredata and not self.pre:
                # This is a very dangerous call ... it could mess up
                # all handling of &amp;nbsp; when not handled properly
                # (see entityref)
                data = re.sub(r&quot;\s+&quot;, r&quot; &quot;, data)
                if data and data[0] == &quot; &quot;:
                    self.space = True
                    data = data[1:]
            if not data and not force:
                return

            if self.startpre:
                # self.out(&quot; :&quot;) #TODO: not output when already one there
                if not data.startswith(&quot;\n&quot;) and not data.startswith(&quot;\r\n&quot;):
                    # &lt;pre&gt;stuff...
                    data = &quot;\n&quot; + data
                if self.mark_code:
                    self.out(&quot;\n[code]&quot;)
                    self.p_p = 0

            bq = &quot;&gt;&quot; * self.blockquote
            if not (force and data and data[0] == &quot;&gt;&quot;) and self.blockquote:
                bq += &quot; &quot;

            if self.pre:
                if not self.list:
                    bq += &quot;    &quot;
                # else: list content is already partially indented
                for i in range(len(self.list)):
                    bq += &quot;    &quot;
                data = data.replace(&quot;\n&quot;, &quot;\n&quot; + bq)

            if self.startpre:
                self.startpre = False
                if self.list:
                    # use existing initial indentation
                    data = data.lstrip(&quot;\n&quot;)

            if self.start:
                self.space = False
                self.p_p = 0
                self.start = False

            if force == &quot;end&quot;:
                # It's the end.
                self.p_p = 0
                self.out(&quot;\n&quot;)
                self.space = False

            if self.p_p:
                self.out((self.br_toggle + &quot;\n&quot; + bq) * self.p_p)
                self.space = False
                self.br_toggle = &quot;&quot;

            if self.space:
                if not self.lastWasNL:
                    self.out(&quot; &quot;)
                self.space = False

            if self.a and (
                (self.p_p == 2 and self.links_each_paragraph) or force == &quot;end&quot;
            ):
                if force == &quot;end&quot;:
                    self.out(&quot;\n&quot;)

                newa = []
                for link in self.a:
                    if self.outcount &gt; link[&quot;outcount&quot;]:
                        self.out(
                            &quot;   [&quot;
                            + str(link[&quot;count&quot;])
                            + &quot;]: &quot;
                            + urlparse.urljoin(self.baseurl, link[&quot;href&quot;])
                        )
                        if &quot;title&quot; in link:
                            self.out(&quot; (&quot; + link[&quot;title&quot;] + &quot;)&quot;)
                        self.out(&quot;\n&quot;)
                    else:
                        newa.append(link)

                # Don't need an extra line when nothing was done.
                if self.a != newa:
                    self.out(&quot;\n&quot;)

                self.a = newa

            if self.abbr_list and force == &quot;end&quot;:
                for abbr, definition in self.abbr_list.items():
                    self.out(&quot;  *[&quot; + abbr + &quot;]: &quot; + definition + &quot;\n&quot;)

            self.p_p = 0
            self.out(data)
            self.outcount += 1

    def handle_data(self, data, entity_char=False):
        if not data:
            # Data may be empty for some HTML entities. For example,
            # LEFT-TO-RIGHT MARK.
            return

        if self.stressed:
            data = data.strip()
            self.stressed = False
            self.preceding_stressed = True
        elif self.preceding_stressed:
            if (
                re.match(r&quot;[^\s.!?]&quot;, data[0])
                and not hn(self.current_tag)
                and self.current_tag not in [&quot;a&quot;, &quot;code&quot;, &quot;pre&quot;]
            ):
                # should match a letter or common punctuation
                data = &quot; &quot; + data
            self.preceding_stressed = False

        if self.style:
            self.style_def.update(dumb_css_parser(data))

        if self.maybe_automatic_link is not None:
            href = self.maybe_automatic_link
            if (
                href == data
                and self.absolute_url_matcher.match(href)
                and self.use_automatic_links
            ):
                self.o(&quot;&lt;&quot; + data + &quot;&gt;&quot;)
                self.empty_link = False
                return
            else:
                self.o(&quot;[&quot;)
                self.maybe_automatic_link = None
                self.empty_link = False

        if not self.code and not self.pre and not entity_char:
            data = escape_md_section(data, snob=self.escape_snob)
        self.preceding_data = data
        self.o(data, puredata=True)

    def charref(self, name):
        if name[0] in [&quot;x&quot;, &quot;X&quot;]:
            c = int(name[1:], 16)
        else:
            c = int(name)

        if not self.unicode_snob and c in unifiable_n:
            return unifiable_n[c]
        else:
            try:
                return chr(c)
            except ValueError:  # invalid unicode
                return &quot;&quot;

    def entityref(self, c):
        if not self.unicode_snob and c in config.UNIFIABLE:
            return config.UNIFIABLE[c]
        try:
            ch = html.entities.html5[c + &quot;;&quot;]
        except KeyError:
            return &quot;&amp;&quot; + c + &quot;;&quot;
        return config.UNIFIABLE[c] if c == &quot;nbsp&quot; else ch

    def google_nest_count(self, style):
        &quot;&quot;&quot;
        Calculate the nesting count of google doc lists

        :type style: dict

        :rtype: int
        &quot;&quot;&quot;
        nest_count = 0
        if &quot;margin-left&quot; in style:
            nest_count = int(style[&quot;margin-left&quot;][:-2]) // self.google_list_indent

        return nest_count

    def optwrap(self, text):
        &quot;&quot;&quot;
        Wrap all paragraphs in the provided text.

        :type text: str

        :rtype: str
        &quot;&quot;&quot;
        if not self.body_width:
            return text

        result = &quot;&quot;
        newlines = 0
        # I cannot think of a better solution for now.
        # To avoid the non-wrap behaviour for entire paras
        # because of the presence of a link in it
        if not self.wrap_links:
            self.inline_links = False
        for para in text.split(&quot;\n&quot;):
            if len(para) &gt; 0:
                if not skipwrap(para, self.wrap_links, self.wrap_list_items):
                    indent = &quot;&quot;
                    if para.startswith(&quot;  &quot; + self.ul_item_mark):
                        # list item continuation: add a double indent to the
                        # new lines
                        indent = &quot;    &quot;
                    elif para.startswith(&quot;&gt; &quot;):
                        # blockquote continuation: add the greater than symbol
                        # to the new lines
                        indent = &quot;&gt; &quot;
                    wrapped = wrap(
                        para,
                        self.body_width,
                        break_long_words=False,
                        subsequent_indent=indent,
                    )
                    result += &quot;\n&quot;.join(wrapped)
                    if para.endswith(&quot;  &quot;):
                        result += &quot;  \n&quot;
                        newlines = 1
                    elif indent:
                        result += &quot;\n&quot;
                        newlines = 1
                    else:
                        result += &quot;\n\n&quot;
                        newlines = 2
                else:
                    # Warning for the tempted!!!
                    # Be aware that obvious replacement of this with
                    # line.isspace()
                    # DOES NOT work! Explanations are welcome.
                    if not config.RE_SPACE.match(para):
                        result += para + &quot;\n&quot;
                        newlines = 1
            else:
                if newlines &lt; 2:
                    result += &quot;\n&quot;
                    newlines += 1
        return result


def html2text(html, baseurl=&quot;&quot;, bodywidth=None):
    if bodywidth is None:
        bodywidth = config.BODY_WIDTH
    h = HTML2Text(baseurl=baseurl, bodywidth=bodywidth)

    return h.handle(html)
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib%2Fpython3.6%2Fsite-packages%2Fhtml2text'>Back to Directory</a>