home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1538 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  8.9 KB  |  260 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'CSSCapture',
  6.     'csscombine']
  7. __docformat__ = 'restructuredtext'
  8. __version__ = '$Id: parse.py 1323 2008-07-06 18:13:57Z cthedot $'
  9. import HTMLParser
  10. import codecs
  11. import cssutils
  12. import errno
  13. import logging
  14. import os
  15. import sys
  16. import urllib2
  17. import urlparse
  18.  
  19. try:
  20.     import cssutils.encutils as encutils
  21. except ImportError:
  22.     
  23.     try:
  24.         import encutils
  25.     except ImportError:
  26.         sys.exit('You need encutils from http://cthedot.de/encutils/')
  27.     except:
  28.         None<EXCEPTION MATCH>ImportError
  29.     
  30.  
  31.     None<EXCEPTION MATCH>ImportError
  32.  
  33. LINK = 0
  34. STYLE = 1
  35.  
  36. class CSSCaptureHTMLParser(HTMLParser.HTMLParser):
  37.     curtag = u''
  38.     sheets = []
  39.     
  40.     def _loweratts(self, atts):
  41.         return []([ (a.lower(), v.lower()) for a, v in atts ])
  42.  
  43.     
  44.     def handle_starttag(self, tag, atts):
  45.         if tag == u'link':
  46.             atts = self._loweratts(atts)
  47.             if u'text/css' == atts.get(u'type', u''):
  48.                 self.sheets.append((LINK, atts))
  49.             
  50.         elif tag == u'style':
  51.             atts = self._loweratts(atts)
  52.             if u'text/css' == atts.get(u'type', u''):
  53.                 self.sheets.append((STYLE, [
  54.                     atts,
  55.                     u'']))
  56.                 self.curtag = tag
  57.             
  58.         else:
  59.             self.curtag = u''
  60.  
  61.     
  62.     def handle_data(self, data):
  63.         if self.curtag == u'style':
  64.             self.sheets[-1][1][1] = data
  65.         
  66.  
  67.     
  68.     def handle_comment(self, data):
  69.         self.handle_data(data)
  70.  
  71.     
  72.     def handle_endtag(self, tag):
  73.         self.curtag = u''
  74.  
  75.  
  76.  
  77. class CSSCapture(object):
  78.     
  79.     def __init__(self, ua = None, log = None, defaultloglevel = logging.INFO):
  80.         self._ua = ua
  81.         if log:
  82.             self._log = log
  83.         else:
  84.             self._log = logging.getLogger('CSSCapture')
  85.             hdlr = logging.StreamHandler(sys.stderr)
  86.             formatter = logging.Formatter('%(message)s')
  87.             hdlr.setFormatter(formatter)
  88.             self._log.addHandler(hdlr)
  89.             self._log.setLevel(defaultloglevel)
  90.             self._log.debug(u'Using default log')
  91.         self._htmlparser = CSSCaptureHTMLParser()
  92.         self._cssparser = cssutils.CSSParser(log = self._log)
  93.  
  94.     
  95.     def _doRequest(self, url):
  96.         self._log.debug(u'    CSSCapture._doRequest\n        * URL: %s' % url)
  97.         req = urllib2.Request(url)
  98.         if self._ua:
  99.             req.add_header('User-agent', self._ua)
  100.             self._log.info('        * Using User-Agent: %s', self._ua)
  101.         
  102.         
  103.         try:
  104.             res = urllib2.urlopen(req)
  105.         except urllib2.HTTPError:
  106.             e = None
  107.             self._log.critical('    %s\n%s %s\n%s' % (e.geturl(), e.code, e.msg, e.headers))
  108.             return (None, None)
  109.  
  110.         if url != res.geturl():
  111.             url = res.geturl()
  112.             self._log.info('        URL retrieved: %s', url)
  113.         
  114.         return (url, res)
  115.  
  116.     
  117.     def _createStyleSheet(self, href = None, media = None, parentStyleSheet = None, title = u'', cssText = None, encoding = None):
  118.         if cssText is None:
  119.             (encoding, enctype, cssText) = cssutils.util._readUrl(href, parentEncoding = self.docencoding)
  120.             encoding = None
  121.         
  122.         sheet = self._cssparser.parseString(cssText, href = href, media = media, title = title, encoding = encoding)
  123.         if not sheet:
  124.             return None
  125.         self._log.info(u'    %s\n' % sheet)
  126.         self._nonparsed[sheet] = cssText
  127.         return sheet
  128.  
  129.     
  130.     def _findStyleSheets(self, docurl, doctext):
  131.         self._htmlparser.feed(doctext)
  132.         for typ, data in self._htmlparser.sheets:
  133.             sheet = None
  134.             if LINK == typ:
  135.                 self._log.info(u'+ PROCESSING <link> %r' % data)
  136.                 atts = data
  137.                 href = urlparse.urljoin(docurl, atts.get(u'href', None))
  138.                 sheet = self._createStyleSheet(href = href, media = atts.get(u'media', None), title = atts.get(u'title', None))
  139.             elif STYLE == typ:
  140.                 self._log.info(u'+ PROCESSING <style> %r' % data)
  141.                 (atts, cssText) = data
  142.                 sheet = self._createStyleSheet(cssText = cssText, href = docurl, media = atts.get(u'media', None), title = atts.get(u'title', None), encoding = self.docencoding)
  143.                 if sheet:
  144.                     sheet._href = None
  145.                 
  146.                 print sheet.cssText
  147.             
  148.             if sheet:
  149.                 self.stylesheetlist.append(sheet)
  150.                 self._doImports(sheet, base = docurl)
  151.                 continue
  152.         
  153.  
  154.     
  155.     def _doImports(self, parentStyleSheet, base = None):
  156.         for rule in parentStyleSheet.cssRules:
  157.             if rule.type == rule.IMPORT_RULE:
  158.                 self._log.info(u'+ PROCESSING @import:')
  159.                 self._log.debug(u'    IN: %s\n' % parentStyleSheet.href)
  160.                 sheet = rule.styleSheet
  161.                 href = urlparse.urljoin(base, rule.href)
  162.                 if sheet:
  163.                     self._log.info(u'    %s\n' % sheet)
  164.                     self.stylesheetlist.append(sheet)
  165.                     self._doImports(sheet, base = href)
  166.                 
  167.             sheet
  168.         
  169.  
  170.     
  171.     def capture(self, url):
  172.         self._log.info(u'\nCapturing CSS from URL:\n    %s\n', url)
  173.         self._nonparsed = { }
  174.         self.stylesheetlist = cssutils.stylesheets.StyleSheetList()
  175.         (scheme, loc, path, query, fragment) = urlparse.urlsplit(url)
  176.         self._filename = os.path.basename(path)
  177.         (url, res) = self._doRequest(url)
  178.         if not res:
  179.             sys.exit(1)
  180.         
  181.         rawdoc = res.read()
  182.         self.docencoding = encutils.getEncodingInfo(res, rawdoc, log = self._log).encoding
  183.         self._log.info(u'\nUsing Encoding: %s\n', self.docencoding)
  184.         doctext = rawdoc.decode(self.docencoding)
  185.         self._findStyleSheets(url, doctext)
  186.         return self.stylesheetlist
  187.  
  188.     
  189.     def saveto(self, dir, saveraw = False, minified = False):
  190.         msg = 'parsed'
  191.         if saveraw:
  192.             msg = 'raw'
  193.         
  194.         if minified:
  195.             cssutils.ser.prefs.useMinified()
  196.             msg = 'minified'
  197.         
  198.         inlines = 0
  199.         for i, sheet in enumerate(self.stylesheetlist):
  200.             url = sheet.href
  201.             if not url:
  202.                 inlines += 1
  203.                 url = u'%s_INLINE_%s.css' % (self._filename, inlines)
  204.             
  205.             (scheme, loc, path, query, fragment) = urlparse.urlsplit(url)
  206.             if path and path.startswith('/'):
  207.                 path = path[1:]
  208.             
  209.             path = os.path.normpath(path)
  210.             (path, fn) = os.path.split(path)
  211.             savepath = os.path.join(dir, path)
  212.             savefn = os.path.join(savepath, fn)
  213.             
  214.             try:
  215.                 os.makedirs(savepath)
  216.             except OSError:
  217.                 e = None
  218.                 if e.errno != errno.EEXIST:
  219.                     raise e
  220.                 e.errno != errno.EEXIST
  221.                 self._log.debug(u'Path "%s" already exists.', savepath)
  222.  
  223.             self._log.info(u'SAVING %s, %s %r' % (i + 1, msg, savefn))
  224.             sf = open(savefn, 'wb')
  225.             if saveraw:
  226.                 cssText = self._nonparsed[sheet]
  227.                 uf = codecs.getwriter('css')(sf)
  228.                 uf.write(cssText)
  229.             else:
  230.                 sf.write(sheet.cssText)
  231.             sf.close()
  232.         
  233.  
  234.  
  235.  
  236. def csscombine(path = None, url = None, sourceencoding = None, targetencoding = None, minify = True):
  237.     cssutils.log.info(u'Combining files from %r' % url, neverraise = True)
  238.     if sourceencoding is not None:
  239.         cssutils.log.info(u'Using source encoding %r' % sourceencoding, neverraise = True)
  240.     
  241.     if path:
  242.         src = cssutils.parseFile(path, encoding = sourceencoding)
  243.     elif url:
  244.         src = cssutils.parseUrl(url, encoding = sourceencoding)
  245.     else:
  246.         sys.exit('Path or URL must be given')
  247.     result = cssutils.resolveImports(src)
  248.     result.encoding = targetencoding
  249.     cssutils.log.info(u'Using target encoding: %r' % targetencoding, neverraise = True)
  250.     if minify:
  251.         oldser = cssutils.ser
  252.         cssutils.setSerializer(cssutils.serialize.CSSSerializer())
  253.         cssutils.ser.prefs.useMinified()
  254.         cssText = result.cssText
  255.         cssutils.setSerializer(oldser)
  256.     else:
  257.         cssText = result.cssText
  258.     return cssText
  259.  
  260.