home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2037 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  11.6 KB  |  435 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import urllib2
  6. import bisect
  7. import httplib
  8. import types
  9. import tempfile
  10.  
  11. try:
  12.     import threading as _threading
  13. except ImportError:
  14.     import dummy_threading as _threading
  15.  
  16.  
  17. try:
  18.     set
  19. except NameError:
  20.     import sets
  21.     set = sets.Set
  22.  
  23. import _file
  24. import _http
  25. from _request import Request
  26. import _response
  27. import _rfc3986
  28. import _sockettimeout
  29. import _upgrade
  30. from _util import isstringlike
  31.  
  32. class ContentTooShortError(urllib2.URLError):
  33.     
  34.     def __init__(self, reason, result):
  35.         urllib2.URLError.__init__(self, reason)
  36.         self.result = result
  37.  
  38.  
  39.  
  40. def set_request_attr(req, name, value, default):
  41.     
  42.     try:
  43.         getattr(req, name)
  44.     except AttributeError:
  45.         setattr(req, name, default)
  46.  
  47.     if value is not default:
  48.         setattr(req, name, value)
  49.     
  50.  
  51.  
  52. class OpenerDirector(urllib2.OpenerDirector):
  53.     
  54.     def __init__(self):
  55.         urllib2.OpenerDirector.__init__(self)
  56.         self.process_response = { }
  57.         self.process_request = { }
  58.         self._any_request = { }
  59.         self._any_response = { }
  60.         self._handler_index_valid = True
  61.         self._tempfiles = []
  62.  
  63.     
  64.     def add_handler(self, handler):
  65.         if handler in self.handlers:
  66.             return None
  67.         bisect.insort(self.handlers, handler)
  68.         handler.add_parent(self)
  69.         self._handler_index_valid = False
  70.  
  71.     
  72.     def _maybe_reindex_handlers(self):
  73.         if self._handler_index_valid:
  74.             return None
  75.         handle_error = { }
  76.         handle_open = { }
  77.         process_request = { }
  78.         process_response = { }
  79.         any_request = set()
  80.         any_response = set()
  81.         unwanted = []
  82.         for handler in self.handlers:
  83.             added = False
  84.             for meth in dir(handler):
  85.                 if meth in ('redirect_request', 'do_open', 'proxy_open'):
  86.                     continue
  87.                 
  88.                 if meth == 'any_request':
  89.                     any_request.add(handler)
  90.                     added = True
  91.                     continue
  92.                 elif meth == 'any_response':
  93.                     any_response.add(handler)
  94.                     added = True
  95.                     continue
  96.                 
  97.                 ii = meth.find('_')
  98.                 scheme = meth[:ii]
  99.                 condition = meth[ii + 1:]
  100.                 if condition.startswith('error'):
  101.                     jj = meth[ii + 1:].find('_') + ii + 1
  102.                     kind = meth[jj + 1:]
  103.                     
  104.                     try:
  105.                         kind = int(kind)
  106.                     except ValueError:
  107.                         pass
  108.  
  109.                     lookup = handle_error.setdefault(scheme, { })
  110.                 elif condition == 'open':
  111.                     kind = scheme
  112.                     lookup = handle_open
  113.                 elif condition == 'request':
  114.                     kind = scheme
  115.                     lookup = process_request
  116.                 elif condition == 'response':
  117.                     kind = scheme
  118.                     lookup = process_response
  119.                 
  120.                 lookup.setdefault(kind, set()).add(handler)
  121.                 added = True
  122.             
  123.             if not added:
  124.                 unwanted.append(handler)
  125.                 continue
  126.             condition.startswith('error')
  127.         
  128.         for handler in unwanted:
  129.             self.handlers.remove(handler)
  130.         
  131.         for lookup in [
  132.             process_request,
  133.             process_response]:
  134.             for scheme, handlers in lookup.iteritems():
  135.                 lookup[scheme] = handlers
  136.             
  137.         
  138.         for scheme, lookup in handle_error.iteritems():
  139.             for code, handlers in lookup.iteritems():
  140.                 handlers = list(handlers)
  141.                 handlers.sort()
  142.                 lookup[code] = handlers
  143.             
  144.         
  145.         for scheme, handlers in handle_open.iteritems():
  146.             handlers = list(handlers)
  147.             handlers.sort()
  148.             handle_open[scheme] = handlers
  149.         
  150.         self.handle_error = handle_error
  151.         self.handle_open = handle_open
  152.         self.process_request = process_request
  153.         self.process_response = process_response
  154.         self._any_request = any_request
  155.         self._any_response = any_response
  156.  
  157.     
  158.     def _request(self, url_or_req, data, visit, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  159.         if isstringlike(url_or_req):
  160.             req = Request(url_or_req, data, visit = visit, timeout = timeout)
  161.         else:
  162.             req = url_or_req
  163.             if data is not None:
  164.                 req.add_data(data)
  165.             
  166.             set_request_attr(req, 'visit', visit, None)
  167.             set_request_attr(req, 'timeout', timeout, _sockettimeout._GLOBAL_DEFAULT_TIMEOUT)
  168.         return req
  169.  
  170.     
  171.     def open(self, fullurl, data = None, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  172.         req = self._request(fullurl, data, None, timeout)
  173.         req_scheme = req.get_type()
  174.         self._maybe_reindex_handlers()
  175.         request_processors = set(self.process_request.get(req_scheme, []))
  176.         request_processors.update(self._any_request)
  177.         request_processors = list(request_processors)
  178.         request_processors.sort()
  179.         for processor in request_processors:
  180.             for meth_name in [
  181.                 'any_request',
  182.                 req_scheme + '_request']:
  183.                 meth = getattr(processor, meth_name, None)
  184.                 if meth:
  185.                     req = meth(req)
  186.                     continue
  187.             
  188.         
  189.         urlopen = getattr(urllib2.OpenerDirector, '_open', urllib2.OpenerDirector.open)
  190.         response = urlopen(self, req, data)
  191.         response_processors = set(self.process_response.get(req_scheme, []))
  192.         response_processors.update(self._any_response)
  193.         response_processors = list(response_processors)
  194.         response_processors.sort()
  195.         for processor in response_processors:
  196.             for meth_name in [
  197.                 'any_response',
  198.                 req_scheme + '_response']:
  199.                 meth = getattr(processor, meth_name, None)
  200.                 if meth:
  201.                     response = meth(req, response)
  202.                     continue
  203.             
  204.         
  205.         return response
  206.  
  207.     
  208.     def error(self, proto, *args):
  209.         if proto in ('http', 'https'):
  210.             dict = self.handle_error['http']
  211.             proto = args[2]
  212.             meth_name = 'http_error_%s' % proto
  213.             http_err = 1
  214.             orig_args = args
  215.         else:
  216.             dict = self.handle_error
  217.             meth_name = proto + '_error'
  218.             http_err = 0
  219.         args = (dict, proto, meth_name) + args
  220.         result = apply(self._call_chain, args)
  221.         if result:
  222.             return result
  223.         if http_err:
  224.             args = (dict, 'default', 'http_error_default') + orig_args
  225.             return apply(self._call_chain, args)
  226.  
  227.     BLOCK_SIZE = 8192
  228.     
  229.     def retrieve(self, fullurl, filename = None, reporthook = None, data = None, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  230.         req = self._request(fullurl, data, False, timeout)
  231.         scheme = req.get_type()
  232.         fp = self.open(req)
  233.         headers = fp.info()
  234.         if filename is None and scheme == 'file':
  235.             return (None, headers)
  236.         if filename:
  237.             tfp = open(filename, 'wb')
  238.         else:
  239.             path = _rfc3986.urlsplit(req.get_full_url())[2]
  240.             suffix = os.path.splitext(path)[1]
  241.             (fd, filename) = tempfile.mkstemp(suffix)
  242.             self._tempfiles.append(filename)
  243.             tfp = os.fdopen(fd, 'wb')
  244.         result = (filename, headers)
  245.         bs = self.BLOCK_SIZE
  246.         size = -1
  247.         read = 0
  248.         blocknum = 0
  249.         if reporthook:
  250.             if 'content-length' in headers:
  251.                 size = int(headers['Content-Length'])
  252.             
  253.             reporthook(blocknum, bs, size)
  254.         
  255.         while None:
  256.             block = fp.read(bs)
  257.             if block == '':
  258.                 break
  259.             
  260.             read += len(block)
  261.             blocknum += 1
  262.             if reporthook:
  263.                 reporthook(blocknum, bs, size)
  264.                 continue
  265.             continue
  266.             fp.close()
  267.             tfp.close()
  268.             del fp
  269.             del tfp
  270.             if size >= 0 and read < size:
  271.                 raise ContentTooShortError('retrieval incomplete: got only %i out of %i bytes' % (read, size), result)
  272.             read < size
  273.             return result
  274.  
  275.     
  276.     def close(self):
  277.         urllib2.OpenerDirector.close(self)
  278.         self.open = None
  279.         self.error = None
  280.         self.retrieve = None
  281.         self.add_handler = None
  282.         if self._tempfiles:
  283.             for filename in self._tempfiles:
  284.                 
  285.                 try:
  286.                     os.unlink(filename)
  287.                 continue
  288.                 except OSError:
  289.                     continue
  290.                 
  291.  
  292.             
  293.             del self._tempfiles[:]
  294.         
  295.  
  296.  
  297.  
  298. def wrapped_open(urlopen, process_response_object, fullurl, data = None, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  299.     success = True
  300.     
  301.     try:
  302.         response = urlopen(fullurl, data, timeout)
  303.     except urllib2.HTTPError:
  304.         error = None
  305.         success = False
  306.         if error.fp is None:
  307.             raise 
  308.         error.fp is None
  309.         response = error
  310.  
  311.     if response is not None:
  312.         response = process_response_object(response)
  313.     
  314.     if not success:
  315.         raise response
  316.     success
  317.     return response
  318.  
  319.  
  320. class ResponseProcessingOpener(OpenerDirector):
  321.     
  322.     def open(self, fullurl, data = None, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  323.         
  324.         def bound_open(fullurl, data = None, timeout = (_sockettimeout._GLOBAL_DEFAULT_TIMEOUT,)):
  325.             return OpenerDirector.open(self, fullurl, data, timeout)
  326.  
  327.         return wrapped_open(bound_open, self.process_response_object, fullurl, data, timeout)
  328.  
  329.     
  330.     def process_response_object(self, response):
  331.         return response
  332.  
  333.  
  334.  
  335. class SeekableResponseOpener(ResponseProcessingOpener):
  336.     
  337.     def process_response_object(self, response):
  338.         return _response.seek_wrapped_response(response)
  339.  
  340.  
  341.  
  342. class OpenerFactory:
  343.     default_classes = [
  344.         urllib2.ProxyHandler,
  345.         urllib2.UnknownHandler,
  346.         _http.HTTPHandler,
  347.         _http.HTTPDefaultErrorHandler,
  348.         _http.HTTPRedirectHandler,
  349.         urllib2.FTPHandler,
  350.         _file.FileHandler,
  351.         _upgrade.HTTPRequestUpgradeProcessor,
  352.         _http.HTTPCookieProcessor,
  353.         _http.HTTPErrorProcessor]
  354.     if hasattr(httplib, 'HTTPS'):
  355.         default_classes.append(_http.HTTPSHandler)
  356.     
  357.     handlers = []
  358.     replacement_handlers = []
  359.     
  360.     def __init__(self, klass = OpenerDirector):
  361.         self.klass = klass
  362.  
  363.     
  364.     def build_opener(self, *handlers):
  365.         opener = self.klass()
  366.         default_classes = list(self.default_classes)
  367.         skip = []
  368.         for klass in default_classes:
  369.             for check in handlers:
  370.                 if type(check) == types.ClassType:
  371.                     if issubclass(check, klass):
  372.                         skip.append(klass)
  373.                     
  374.                 issubclass(check, klass)
  375.                 if type(check) == types.InstanceType:
  376.                     if isinstance(check, klass):
  377.                         skip.append(klass)
  378.                     
  379.                 isinstance(check, klass)
  380.             
  381.         
  382.         for klass in skip:
  383.             default_classes.remove(klass)
  384.         
  385.         for klass in default_classes:
  386.             opener.add_handler(klass())
  387.         
  388.         for h in handlers:
  389.             if type(h) == types.ClassType:
  390.                 h = h()
  391.             
  392.             opener.add_handler(h)
  393.         
  394.         return opener
  395.  
  396.  
  397. build_opener = OpenerFactory().build_opener
  398. _opener = None
  399. urlopen_lock = _threading.Lock()
  400.  
  401. def urlopen(url, data = None, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  402.     global _opener
  403.     if _opener is None:
  404.         urlopen_lock.acquire()
  405.         
  406.         try:
  407.             if _opener is None:
  408.                 _opener = build_opener()
  409.         finally:
  410.             urlopen_lock.release()
  411.  
  412.     
  413.     return _opener.open(url, data, timeout)
  414.  
  415.  
  416. def urlretrieve(url, filename = None, reporthook = None, data = None, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  417.     global _opener
  418.     if _opener is None:
  419.         urlopen_lock.acquire()
  420.         
  421.         try:
  422.             if _opener is None:
  423.                 _opener = build_opener()
  424.         finally:
  425.             urlopen_lock.release()
  426.  
  427.     
  428.     return _opener.retrieve(url, filename, reporthook, data, timeout)
  429.  
  430.  
  431. def install_opener(opener):
  432.     global _opener
  433.     _opener = opener
  434.  
  435.