parse_html/bkmk_parse_html.py

   1 """HTML Parsers
   2
   3 This file is a part of Bookmarks database and Internet robot.
   4
   5 """
   6
   7 __author__ = "Oleg Broytman <phd@phdru.name>"
   8 __copyright__ = "Copyright (C) 1997-2017 PhiloSoft Design"
   9 __license__ = "GNU GPL"
  10
  11 __all__ = ['parse_html', 'parse_filename', 'universal_charset']
  12
  13
  14 import codecs
  15
  16 universal_charset = "utf-8"
  17 DEFAULT_CHARSET = "cp1251" # Stupid default for Russian Cyrillic
  18
  19 parsers = []
  20
  21 try:
  22    from . import bkmk_ph_beautifulsoup
  23 except ImportError:
  24    pass
  25 else:
  26    bkmk_ph_beautifulsoup.DEFAULT_CHARSET = DEFAULT_CHARSET
  27    parsers.append(bkmk_ph_beautifulsoup.parse_html)
  28
  29 try:
  30    from . import bkmk_ph_html5
  31 except ImportError:
  32    pass
  33 else:
  34    parsers.append(bkmk_ph_html5.parse_html)
  35
  36 try:
  37    from . import bkmk_ph_lxml
  38 except ImportError:
  39    pass
  40 else:
  41     parsers.append(bkmk_ph_lxml.parse_html)
  42
  43 try:
  44    from . import bkmk_ph_htmlparser
  45 except ImportError:
  46    pass
  47 else:
  48     parsers.append(bkmk_ph_htmlparser.parse_html)
  49
  50 # ElementTidy often segfaults
  51 #try:
  52 #   from . import bkmk_ph_etreetidy
  53 #except ImportError:
  54 #   pass
  55 #else:
  56 #   parsers.append(bkmk_ph_etreetidy.parse_html)
  57
  58 import re
  59 from htmlentitydefs import name2codepoint
  60
  61 entity_re = re.compile("(&\w+;)")
  62 num_entity_re = re.compile("(&#[0-9]+;)")
  63
  64 def recode_entities(title, charset):
  65    output = []
  66    for part in entity_re.split(title):
  67       if part not in ("&amp;", "&lt;", "&gt;", "&quot;") and \
  68             entity_re.match(part):
  69          _part = name2codepoint.get(part[1:-1], None)
  70          if _part is not None:
  71              part = unichr(_part).encode(charset)
  72       output.append(part)
  73    title = ''.join(output)
  74
  75    output = []
  76    for part in num_entity_re.split(title):
  77       if num_entity_re.match(part):
  78          try:
  79             part = unichr(int(part[2:-1])).encode(charset)
  80          except UnicodeEncodeError:
  81             pass # Leave the entity as is
  82       output.append(part)
  83
  84    return ''.join(output)
  85
  86
  87 import os
  88 BKMK_DEBUG_HTML_PARSERS = os.environ.get("BKMK_DEBUG_HTML_PARSERS")
  89
  90 def parse_html(html_text, charset=None, log=None):
  91    if not parsers:
  92        return None
  93
  94    if charset:
  95       try:
  96          codecs.lookup(charset) # In case of unknown charset...
  97       except (ValueError, LookupError):
  98          charset = None         # ...try charset from HTML
  99
 100    charsets = [universal_charset, DEFAULT_CHARSET]
 101    if charset:
 102       charset = charset.lower().replace("windows-", "cp")
 103       if charset in charsets:
 104          charsets.remove(charset)
 105       charsets.insert(0, charset)
 106
 107    if BKMK_DEBUG_HTML_PARSERS:
 108       _parsers = []
 109    for p in parsers:
 110       parser = None
 111       for c in charsets:
 112          try:
 113             parser = p(html_text, c, log)
 114          except UnicodeError:
 115             pass
 116          else:
 117             if parser:
 118                if BKMK_DEBUG_HTML_PARSERS:
 119                   if log: log("   Parser %s: ok" % p.__module__)
 120                   _parsers.append((p, parser))
 121                break
 122       else:
 123          if log: log("   Parser %s: fail" % p.__module__)
 124       if not BKMK_DEBUG_HTML_PARSERS and parser:
 125          break
 126
 127    if BKMK_DEBUG_HTML_PARSERS:
 128       if not _parsers:
 129          if log: log("   All parsers have failed")
 130          return None
 131    elif not parser:
 132        if log: log("   All parsers have failed")
 133        return None
 134
 135    if BKMK_DEBUG_HTML_PARSERS:
 136       p, parser = _parsers[0]
 137    if log: log("   Using %s" % p.__module__)
 138
 139    converted_title = title = parser.title
 140    if title and (not parser.charset):
 141       try:
 142          unicode(title, "ascii")
 143       except UnicodeDecodeError:
 144          parser.charset = DEFAULT_CHARSET
 145
 146    if parser.charset:
 147       parser.charset = parser.charset.lower().replace("windows-", "cp")
 148
 149    if title and parser.charset and (
 150          (parser.charset != universal_charset) or
 151          ((not charset) or (charset != parser.charset))):
 152       try:
 153          if parser.meta_charset:
 154             if log: log("   META charset   : %s" % parser.charset)
 155          elif (not charset) or (charset != parser.charset):
 156             if log: log("   guessed charset: %s" % parser.charset)
 157          #if log: log("   current charset: %s" % universal_charset)
 158          if log: log("   title          : %s" % title)
 159          if parser.charset != universal_charset:
 160             try:
 161                converted_title = unicode(title, parser.charset).encode(universal_charset)
 162             except UnicodeError:
 163                if log: log("   incorrect conversion from %s, converting from %s" % (parser.charset, DEFAULT_CHARSET))
 164                converted_title = unicode(title, DEFAULT_CHARSET, "replace").encode(universal_charset, "replace")
 165                parser.charset = DEFAULT_CHARSET
 166          if log and (converted_title != title): log("   converted title: %s" % converted_title)
 167       except LookupError:
 168          if log: log("   unknown charset: '%s'" % parser.charset)
 169    else:
 170       if log: log("   title          : %s" % title)
 171
 172    if title:
 173       final_title = recode_entities(converted_title, universal_charset)
 174       parts = [s.strip() for s in final_title.replace('\r', '').split('\n')]
 175       final_title = ' '.join([s for s in parts if s])
 176       if log and (final_title != converted_title): log("   final title    : %s" % final_title)
 177       parser.title = final_title
 178
 179    icon = parser.icon
 180    if isinstance(icon, unicode):
 181        try:
 182            parser.icon = icon.encode('ascii')
 183        except UnicodeEncodeError:
 184            if parser.charset:
 185                parser.icon = icon.encode(parser.charset)
 186    return parser
 187
 188 def parse_filename(filename, charset=None, log=None):
 189     fp = open(filename, 'r')
 190     try:
 191         parser = parse_html(fp.read(), charset=charset, log=log)
 192     finally:
 193         fp.close()
 194     return parser