home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2032 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  23.5 KB  |  651 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import time
  5. import htmlentitydefs
  6. import logging
  7. import socket
  8. import urllib2
  9. import urllib
  10. import httplib
  11. import sgmllib
  12. from urllib2 import URLError, HTTPError, BaseHandler
  13. from cStringIO import StringIO
  14. from _clientcookie import CookieJar
  15. from _headersutil import is_html
  16. from _html import unescape, unescape_charref
  17. from _request import Request
  18. from _response import closeable_response, response_seek_wrapper
  19. import _rfc3986
  20. import _sockettimeout
  21. debug = logging.getLogger('mechanize').debug
  22. debug_robots = logging.getLogger('mechanize.robots').debug
  23. CHUNK = 1024
  24. DEFAULT_ENCODING = 'latin-1'
  25.  
  26. try:
  27.     socket._fileobject('fake socket', close = True)
  28. except TypeError:
  29.     create_readline_wrapper = socket._fileobject
  30.  
  31.  
  32. def create_readline_wrapper(fh):
  33.     return socket._fileobject(fh, close = True)
  34.  
  35.  
  36. class HTTPRedirectHandler(BaseHandler):
  37.     max_repeats = 4
  38.     max_redirections = 10
  39.     
  40.     def redirect_request(self, newurl, req, fp, code, msg, headers):
  41.         if (code in (301, 302, 303, 'refresh') or code == 307) and not req.has_data():
  42.             new = Request(newurl, headers = req.headers, origin_req_host = req.get_origin_req_host(), unverifiable = True, visit = False)
  43.             new._origin_req = getattr(req, '_origin_req', req)
  44.             return new
  45.         raise HTTPError(req.get_full_url(), code, msg, headers, fp)
  46.  
  47.     
  48.     def http_error_302(self, req, fp, code, msg, headers):
  49.         if headers.has_key('location'):
  50.             newurl = headers.getheaders('location')[0]
  51.         elif headers.has_key('uri'):
  52.             newurl = headers.getheaders('uri')[0]
  53.         else:
  54.             return None
  55.         newurl = headers.has_key('location').clean_url(newurl, 'latin-1')
  56.         newurl = _rfc3986.urljoin(req.get_full_url(), newurl)
  57.         new = self.redirect_request(newurl, req, fp, code, msg, headers)
  58.         if new is None:
  59.             return None
  60.         visited[newurl] = visited.get(newurl, 0) + 1
  61.         fp.read()
  62.         fp.close()
  63.         return self.parent.open(new)
  64.  
  65.     http_error_301 = http_error_303 = http_error_307 = http_error_302
  66.     http_error_refresh = http_error_302
  67.     inf_msg = 'The HTTP server returned a redirect error that would lead to an infinite loop.\nThe last 30x error message was:\n'
  68.  
  69.  
  70. class EndOfHeadError(Exception):
  71.     pass
  72.  
  73.  
  74. class AbstractHeadParser:
  75.     head_elems = ('html', 'head', 'title', 'base', 'script', 'style', 'meta', 'link', 'object')
  76.     _entitydefs = htmlentitydefs.name2codepoint
  77.     _encoding = DEFAULT_ENCODING
  78.     
  79.     def __init__(self):
  80.         self.http_equiv = []
  81.  
  82.     
  83.     def start_meta(self, attrs):
  84.         http_equiv = None
  85.         content = None
  86.         for key, value in attrs:
  87.             if key == 'http-equiv':
  88.                 http_equiv = self.unescape_attr_if_required(value)
  89.                 continue
  90.             if key == 'content':
  91.                 content = self.unescape_attr_if_required(value)
  92.                 continue
  93.         
  94.         if http_equiv is not None and content is not None:
  95.             self.http_equiv.append((http_equiv, content))
  96.         
  97.  
  98.     
  99.     def end_head(self):
  100.         raise EndOfHeadError()
  101.  
  102.     
  103.     def handle_entityref(self, name):
  104.         self.handle_data(unescape('&%s;' % name, self._entitydefs, self._encoding))
  105.  
  106.     
  107.     def handle_charref(self, name):
  108.         self.handle_data(unescape_charref(name, self._encoding))
  109.  
  110.     
  111.     def unescape_attr(self, name):
  112.         return unescape(name, self._entitydefs, self._encoding)
  113.  
  114.     
  115.     def unescape_attrs(self, attrs):
  116.         escaped_attrs = { }
  117.         for key, val in attrs.items():
  118.             escaped_attrs[key] = self.unescape_attr(val)
  119.         
  120.         return escaped_attrs
  121.  
  122.     
  123.     def unknown_entityref(self, ref):
  124.         self.handle_data('&%s;' % ref)
  125.  
  126.     
  127.     def unknown_charref(self, ref):
  128.         self.handle_data('&#%s;' % ref)
  129.  
  130.  
  131.  
  132. try:
  133.     import HTMLParser
  134. except ImportError:
  135.     pass
  136.  
  137.  
  138. class XHTMLCompatibleHeadParser(AbstractHeadParser, HTMLParser.HTMLParser):
  139.     
  140.     def __init__(self):
  141.         HTMLParser.HTMLParser.__init__(self)
  142.         AbstractHeadParser.__init__(self)
  143.  
  144.     
  145.     def handle_starttag(self, tag, attrs):
  146.         if tag not in self.head_elems:
  147.             raise EndOfHeadError()
  148.         tag not in self.head_elems
  149.         
  150.         try:
  151.             method = getattr(self, 'start_' + tag)
  152.         except AttributeError:
  153.             
  154.             try:
  155.                 method = getattr(self, 'do_' + tag)
  156.             except AttributeError:
  157.                 pass
  158.  
  159.             method(attrs)
  160.  
  161.         method(attrs)
  162.  
  163.     
  164.     def handle_endtag(self, tag):
  165.         if tag not in self.head_elems:
  166.             raise EndOfHeadError()
  167.         tag not in self.head_elems
  168.         
  169.         try:
  170.             method = getattr(self, 'end_' + tag)
  171.         except AttributeError:
  172.             pass
  173.  
  174.         method()
  175.  
  176.     
  177.     def unescape(self, name):
  178.         return self.unescape_attr(name)
  179.  
  180.     
  181.     def unescape_attr_if_required(self, name):
  182.         return name
  183.  
  184.  
  185.  
  186. class HeadParser(AbstractHeadParser, sgmllib.SGMLParser):
  187.     
  188.     def _not_called(self):
  189.         pass
  190.  
  191.     
  192.     def __init__(self):
  193.         sgmllib.SGMLParser.__init__(self)
  194.         AbstractHeadParser.__init__(self)
  195.  
  196.     
  197.     def handle_starttag(self, tag, method, attrs):
  198.         if tag not in self.head_elems:
  199.             raise EndOfHeadError()
  200.         tag not in self.head_elems
  201.         if tag == 'meta':
  202.             method(attrs)
  203.         
  204.  
  205.     
  206.     def unknown_starttag(self, tag, attrs):
  207.         self.handle_starttag(tag, self._not_called, attrs)
  208.  
  209.     
  210.     def handle_endtag(self, tag, method):
  211.         if tag in self.head_elems:
  212.             method()
  213.         else:
  214.             raise EndOfHeadError()
  215.         return tag in self.head_elems
  216.  
  217.     
  218.     def unescape_attr_if_required(self, name):
  219.         return self.unescape_attr(name)
  220.  
  221.  
  222.  
  223. def parse_head(fileobj, parser):
  224.     while None:
  225.         data = fileobj.read(CHUNK)
  226.         
  227.         try:
  228.             parser.feed(data)
  229.         except EndOfHeadError:
  230.             break
  231.  
  232.         if len(data) != CHUNK:
  233.             break
  234.             continue
  235.         continue
  236.         return parser.http_equiv
  237.  
  238.  
  239. class HTTPEquivProcessor(BaseHandler):
  240.     handler_order = 300
  241.     
  242.     def __init__(self, head_parser_class = HeadParser, i_want_broken_xhtml_support = False):
  243.         self.head_parser_class = head_parser_class
  244.         self._allow_xhtml = i_want_broken_xhtml_support
  245.  
  246.     
  247.     def http_response(self, request, response):
  248.         if not hasattr(response, 'seek'):
  249.             response = response_seek_wrapper(response)
  250.         
  251.         http_message = response.info()
  252.         url = response.geturl()
  253.         ct_hdrs = http_message.getheaders('content-type')
  254.         if is_html(ct_hdrs, url, self._allow_xhtml):
  255.             
  256.             try:
  257.                 
  258.                 try:
  259.                     html_headers = parse_head(response, self.head_parser_class())
  260.                 finally:
  261.                     response.seek(0)
  262.  
  263.             except (HTMLParser.HTMLParseError, sgmllib.SGMLParseError):
  264.                 pass
  265.  
  266.             for hdr, val in html_headers:
  267.                 http_message.dict[hdr.lower()] = val
  268.                 text = hdr + ': ' + val
  269.                 for line in text.split('\n'):
  270.                     http_message.headers.append(line + '\n')
  271.                 
  272.             
  273.         
  274.         return response
  275.  
  276.     https_response = http_response
  277.  
  278.  
  279. class HTTPCookieProcessor(BaseHandler):
  280.     
  281.     def __init__(self, cookiejar = None):
  282.         if cookiejar is None:
  283.             cookiejar = CookieJar()
  284.         
  285.         self.cookiejar = cookiejar
  286.  
  287.     
  288.     def http_request(self, request):
  289.         self.cookiejar.add_cookie_header(request)
  290.         return request
  291.  
  292.     
  293.     def http_response(self, request, response):
  294.         self.cookiejar.extract_cookies(response, request)
  295.         return response
  296.  
  297.     https_request = http_request
  298.     https_response = http_response
  299.  
  300.  
  301. try:
  302.     import robotparser
  303. except ImportError:
  304.     pass
  305.  
  306.  
  307. class MechanizeRobotFileParser(robotparser.RobotFileParser):
  308.     
  309.     def __init__(self, url = '', opener = None):
  310.         robotparser.RobotFileParser.__init__(self, url)
  311.         self._opener = opener
  312.         self._timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT
  313.  
  314.     
  315.     def set_opener(self, opener = None):
  316.         import _opener
  317.         if opener is None:
  318.             opener = _opener.OpenerDirector()
  319.         
  320.         self._opener = opener
  321.  
  322.     
  323.     def set_timeout(self, timeout):
  324.         self._timeout = timeout
  325.  
  326.     
  327.     def read(self):
  328.         if self._opener is None:
  329.             self.set_opener()
  330.         
  331.         req = Request(self.url, unverifiable = True, visit = False, timeout = self._timeout)
  332.         
  333.         try:
  334.             f = self._opener.open(req)
  335.         except HTTPError:
  336.             f = None
  337.         except (IOError, socket.error, OSError):
  338.             exc = None
  339.             debug_robots('ignoring error opening %r: %s' % (self.url, exc))
  340.             return None
  341.  
  342.         lines = []
  343.         line = f.readline()
  344.         while line:
  345.             lines.append(line.strip())
  346.             line = f.readline()
  347.         status = f.code
  348.         if status == 401 or status == 403:
  349.             self.disallow_all = True
  350.             debug_robots('disallow all')
  351.         elif status >= 400:
  352.             self.allow_all = True
  353.             debug_robots('allow all')
  354.         elif status == 200 and lines:
  355.             debug_robots('parse lines')
  356.             self.parse(lines)
  357.         
  358.  
  359.  
  360.  
  361. class RobotExclusionError(urllib2.HTTPError):
  362.     
  363.     def __init__(self, request, *args):
  364.         apply(urllib2.HTTPError.__init__, (self,) + args)
  365.         self.request = request
  366.  
  367.  
  368.  
  369. class HTTPRobotRulesProcessor(BaseHandler):
  370.     handler_order = 800
  371.     
  372.     try:
  373.         from httplib import HTTPMessage
  374.     except:
  375.         from mimetools import Message
  376.         http_response_class = Message
  377.  
  378.     http_response_class = HTTPMessage
  379.     
  380.     def __init__(self, rfp_class = MechanizeRobotFileParser):
  381.         self.rfp_class = rfp_class
  382.         self.rfp = None
  383.         self._host = None
  384.  
  385.     
  386.     def http_request(self, request):
  387.         scheme = request.get_type()
  388.         if scheme not in ('http', 'https'):
  389.             return request
  390.         if request.get_selector() == '/robots.txt':
  391.             return request
  392.         host = request.get_host()
  393.         origin_req = getattr(request, '_origin_req', None)
  394.         if origin_req is not None and origin_req.get_selector() == '/robots.txt' and origin_req.get_host() == host:
  395.             return request
  396.         if host != self._host:
  397.             self.rfp = self.rfp_class()
  398.             
  399.             try:
  400.                 self.rfp.set_opener(self.parent)
  401.             except AttributeError:
  402.                 origin_req.get_host() == host
  403.                 origin_req.get_host() == host
  404.                 request.get_selector() == '/robots.txt'
  405.                 debug('%r instance does not support set_opener' % self.rfp.__class__)
  406.             except:
  407.                 scheme not in ('http', 'https')
  408.  
  409.             self.rfp.set_url(scheme + '://' + host + '/robots.txt')
  410.             self.rfp.set_timeout(request.timeout)
  411.             self.rfp.read()
  412.             self._host = host
  413.         
  414.         ua = request.get_header('User-agent', '')
  415.         if self.rfp.can_fetch(ua, request.get_full_url()):
  416.             return request
  417.         msg = 'request disallowed by robots.txt'
  418.         raise RobotExclusionError(request, request.get_full_url(), 403, msg, self.http_response_class(StringIO()), StringIO(msg))
  419.  
  420.     https_request = http_request
  421.  
  422.  
  423. class HTTPRefererProcessor(BaseHandler):
  424.     
  425.     def __init__(self):
  426.         self.referer = None
  427.  
  428.     
  429.     def http_request(self, request):
  430.         if self.referer is not None and not request.has_header('Referer'):
  431.             request.add_unredirected_header('Referer', self.referer)
  432.         
  433.         return request
  434.  
  435.     
  436.     def http_response(self, request, response):
  437.         self.referer = response.geturl()
  438.         return response
  439.  
  440.     https_request = http_request
  441.     https_response = http_response
  442.  
  443.  
  444. def clean_refresh_url(url):
  445.     if (url.startswith('"') or url.endswith('"') or url.startswith("'")) and url.endswith("'"):
  446.         url = url[1:-1]
  447.     
  448.     return _rfc3986.clean_url(url, 'latin-1')
  449.  
  450.  
  451. def parse_refresh_header(refresh):
  452.     ii = refresh.find(';')
  453.     if ii != -1:
  454.         pause = float(refresh[:ii])
  455.         newurl_spec = refresh[ii + 1:]
  456.         jj = newurl_spec.find('=')
  457.         key = None
  458.         if jj != -1:
  459.             key = newurl_spec[:jj]
  460.             newurl = newurl_spec[jj + 1:]
  461.             newurl = clean_refresh_url(newurl)
  462.         
  463.         if key is None or key.strip().lower() != 'url':
  464.             raise ValueError()
  465.         key.strip().lower() != 'url'
  466.     else:
  467.         pause = float(refresh)
  468.         newurl = None
  469.     return (pause, newurl)
  470.  
  471.  
  472. class HTTPRefreshProcessor(BaseHandler):
  473.     handler_order = 1000
  474.     
  475.     def __init__(self, max_time = 0, honor_time = True):
  476.         self.max_time = max_time
  477.         self.honor_time = honor_time
  478.         self._sleep = time.sleep
  479.  
  480.     
  481.     def http_response(self, request, response):
  482.         code = response.code
  483.         msg = response.msg
  484.         hdrs = response.info()
  485.         if code == 200 and hdrs.has_key('refresh'):
  486.             refresh = hdrs.getheaders('refresh')[0]
  487.             
  488.             try:
  489.                 (pause, newurl) = parse_refresh_header(refresh)
  490.             except ValueError:
  491.                 debug('bad Refresh header: %r' % refresh)
  492.                 return response
  493.  
  494.             if newurl is None:
  495.                 newurl = response.geturl()
  496.             
  497.             if self.max_time is None or pause <= self.max_time:
  498.                 if pause > 0.001 and self.honor_time:
  499.                     self._sleep(pause)
  500.                 
  501.                 hdrs['location'] = newurl
  502.                 response = self.parent.error('http', request, response, 'refresh', msg, hdrs)
  503.             else:
  504.                 debug('Refresh header ignored: %r' % refresh)
  505.         
  506.         return response
  507.  
  508.     https_response = http_response
  509.  
  510.  
  511. class HTTPErrorProcessor(BaseHandler):
  512.     handler_order = 1000
  513.     
  514.     def http_response(self, request, response):
  515.         code = response.code
  516.         msg = response.msg
  517.         hdrs = response.info()
  518.         if code != 200:
  519.             response = self.parent.error('http', request, response, code, msg, hdrs)
  520.         
  521.         return response
  522.  
  523.     https_response = http_response
  524.  
  525.  
  526. class HTTPDefaultErrorHandler(BaseHandler):
  527.     
  528.     def http_error_default(self, req, fp, code, msg, hdrs):
  529.         if isinstance(fp, urllib2.HTTPError):
  530.             response = fp
  531.         else:
  532.             response = urllib2.HTTPError(req.get_full_url(), code, msg, hdrs, fp)
  533.         raise response
  534.  
  535.  
  536.  
  537. class AbstractHTTPHandler(BaseHandler):
  538.     
  539.     def __init__(self, debuglevel = 0):
  540.         self._debuglevel = debuglevel
  541.  
  542.     
  543.     def set_http_debuglevel(self, level):
  544.         self._debuglevel = level
  545.  
  546.     
  547.     def do_request_(self, request):
  548.         host = request.get_host()
  549.         if not host:
  550.             raise URLError('no host given')
  551.         host
  552.         if request.has_data():
  553.             data = request.get_data()
  554.             if not request.has_header('Content-type'):
  555.                 request.add_unredirected_header('Content-type', 'application/x-www-form-urlencoded')
  556.             
  557.             if not request.has_header('Content-length'):
  558.                 request.add_unredirected_header('Content-length', '%d' % len(data))
  559.             
  560.         
  561.         (scheme, sel) = urllib.splittype(request.get_selector())
  562.         (sel_host, sel_path) = urllib.splithost(sel)
  563.         if not request.has_header('Host'):
  564.             if not sel_host:
  565.                 pass
  566.             request.add_unredirected_header('Host', host)
  567.         
  568.         for name, value in self.parent.addheaders:
  569.             name = name.capitalize()
  570.             if not request.has_header(name):
  571.                 request.add_unredirected_header(name, value)
  572.                 continue
  573.         
  574.         return request
  575.  
  576.     
  577.     def do_open(self, http_class, req):
  578.         host_port = req.get_host()
  579.         if not host_port:
  580.             raise URLError('no host given')
  581.         host_port
  582.         
  583.         try:
  584.             h = http_class(host_port, timeout = req.timeout)
  585.         except TypeError:
  586.             h = http_class(host_port)
  587.  
  588.         h.set_debuglevel(self._debuglevel)
  589.         headers = dict(req.headers)
  590.         headers.update(req.unredirected_hdrs)
  591.         headers['Connection'] = 'close'
  592.         headers = []([ (name.title(), val) for name, val in headers.items() ])
  593.         
  594.         try:
  595.             h.request(req.get_method(), req.get_selector(), req.data, headers)
  596.             r = h.getresponse()
  597.         except socket.error:
  598.             []
  599.             err = []
  600.             dict
  601.             raise URLError(err)
  602.         except:
  603.             []
  604.  
  605.         r.recv = r.read
  606.         fp = create_readline_wrapper(r)
  607.         resp = closeable_response(fp, r.msg, req.get_full_url(), r.status, r.reason)
  608.         return resp
  609.  
  610.  
  611.  
  612. class HTTPHandler(AbstractHTTPHandler):
  613.     
  614.     def http_open(self, req):
  615.         return self.do_open(httplib.HTTPConnection, req)
  616.  
  617.     http_request = AbstractHTTPHandler.do_request_
  618.  
  619. if hasattr(httplib, 'HTTPS'):
  620.     
  621.     class HTTPSConnectionFactory:
  622.         
  623.         def __init__(self, key_file, cert_file):
  624.             self._key_file = key_file
  625.             self._cert_file = cert_file
  626.  
  627.         
  628.         def __call__(self, hostport):
  629.             return httplib.HTTPSConnection(hostport, key_file = self._key_file, cert_file = self._cert_file)
  630.  
  631.  
  632.     
  633.     class HTTPSHandler(AbstractHTTPHandler):
  634.         
  635.         def __init__(self, client_cert_manager = None):
  636.             AbstractHTTPHandler.__init__(self)
  637.             self.client_cert_manager = client_cert_manager
  638.  
  639.         
  640.         def https_open(self, req):
  641.             if self.client_cert_manager is not None:
  642.                 (key_file, cert_file) = self.client_cert_manager.find_key_cert(req.get_full_url())
  643.                 conn_factory = HTTPSConnectionFactory(key_file, cert_file)
  644.             else:
  645.                 conn_factory = httplib.HTTPSConnection
  646.             return self.do_open(conn_factory, req)
  647.  
  648.         https_request = AbstractHTTPHandler.do_request_
  649.  
  650.  
  651.