home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2040 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  14.2 KB  |  414 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import copy
  5. import mimetools
  6. from cStringIO import StringIO
  7. import urllib2
  8.  
  9. class seek_wrapper:
  10.     
  11.     def __init__(self, wrapped):
  12.         self.wrapped = wrapped
  13.         self._seek_wrapper__read_complete_state = [
  14.             False]
  15.         self._seek_wrapper__is_closed_state = [
  16.             False]
  17.         self._seek_wrapper__have_readline = hasattr(self.wrapped, 'readline')
  18.         self._seek_wrapper__cache = StringIO()
  19.         self._seek_wrapper__pos = 0
  20.  
  21.     
  22.     def invariant(self):
  23.         return self.wrapped.tell() == len(self._seek_wrapper__cache.getvalue())
  24.  
  25.     
  26.     def close(self):
  27.         self.wrapped.close()
  28.         self.is_closed = True
  29.  
  30.     
  31.     def __getattr__(self, name):
  32.         if name == 'is_closed':
  33.             return self._seek_wrapper__is_closed_state[0]
  34.         if name == 'read_complete':
  35.             return self._seek_wrapper__read_complete_state[0]
  36.         wrapped = self.__dict__.get('wrapped')
  37.         if wrapped:
  38.             return getattr(wrapped, name)
  39.         return getattr(self.__class__, name)
  40.  
  41.     
  42.     def __setattr__(self, name, value):
  43.         if name == 'is_closed':
  44.             self._seek_wrapper__is_closed_state[0] = bool(value)
  45.         elif name == 'read_complete':
  46.             if not self.is_closed:
  47.                 self._seek_wrapper__read_complete_state[0] = bool(value)
  48.             
  49.         else:
  50.             self.__dict__[name] = value
  51.  
  52.     
  53.     def seek(self, offset, whence = 0):
  54.         if whence == 2:
  55.             if offset < 0:
  56.                 raise ValueError('negative seek offset')
  57.             offset < 0
  58.             to_read = None
  59.         elif whence == 0:
  60.             if offset < 0:
  61.                 raise ValueError('negative seek offset')
  62.             offset < 0
  63.             dest = offset
  64.         else:
  65.             pos = self._seek_wrapper__pos
  66.             if pos < offset:
  67.                 raise ValueError('seek to before start of file')
  68.             pos < offset
  69.             dest = pos + offset
  70.         end = len(self._seek_wrapper__cache.getvalue())
  71.         to_read = dest - end
  72.         if to_read < 0:
  73.             to_read = 0
  74.         
  75.         if to_read != 0:
  76.             self._seek_wrapper__cache.seek(0, 2)
  77.             if to_read is None:
  78.                 self._seek_wrapper__cache.write(self.wrapped.read())
  79.                 self.read_complete = True
  80.                 self._seek_wrapper__pos = self._seek_wrapper__cache.tell() - offset
  81.             else:
  82.                 data = self.wrapped.read(to_read)
  83.                 if not data:
  84.                     self.read_complete = True
  85.                 else:
  86.                     self._seek_wrapper__cache.write(data)
  87.                 self._seek_wrapper__pos = dest
  88.         else:
  89.             self._seek_wrapper__pos = dest
  90.  
  91.     
  92.     def tell(self):
  93.         return self._seek_wrapper__pos
  94.  
  95.     
  96.     def __copy__(self):
  97.         cpy = self.__class__(self.wrapped)
  98.         cpy._seek_wrapper__cache = self._seek_wrapper__cache
  99.         cpy._seek_wrapper__read_complete_state = self._seek_wrapper__read_complete_state
  100.         cpy._seek_wrapper__is_closed_state = self._seek_wrapper__is_closed_state
  101.         return cpy
  102.  
  103.     
  104.     def get_data(self):
  105.         pos = self._seek_wrapper__pos
  106.         
  107.         try:
  108.             self.seek(0)
  109.             return self.read(-1)
  110.         finally:
  111.             self._seek_wrapper__pos = pos
  112.  
  113.  
  114.     
  115.     def read(self, size = -1):
  116.         pos = self._seek_wrapper__pos
  117.         end = len(self._seek_wrapper__cache.getvalue())
  118.         available = end - pos
  119.         if size <= available and size != -1:
  120.             self._seek_wrapper__cache.seek(pos)
  121.             self._seek_wrapper__pos = pos + size
  122.             return self._seek_wrapper__cache.read(size)
  123.         self._seek_wrapper__cache.seek(0, 2)
  124.         if size == -1:
  125.             self._seek_wrapper__cache.write(self.wrapped.read())
  126.             self.read_complete = True
  127.         else:
  128.             to_read = size - available
  129.             data = self.wrapped.read(to_read)
  130.             if not data:
  131.                 self.read_complete = True
  132.             else:
  133.                 self._seek_wrapper__cache.write(data)
  134.         self._seek_wrapper__cache.seek(pos)
  135.         data = self._seek_wrapper__cache.read(size)
  136.         self._seek_wrapper__pos = self._seek_wrapper__cache.tell()
  137.         return data
  138.  
  139.     
  140.     def readline(self, size = -1):
  141.         if not self._seek_wrapper__have_readline:
  142.             raise NotImplementedError('no readline method on wrapped object')
  143.         self._seek_wrapper__have_readline
  144.         pos = self._seek_wrapper__pos
  145.         self._seek_wrapper__cache.seek(0, 2)
  146.         data = self.wrapped.readline()
  147.         if not data:
  148.             self.read_complete = True
  149.         else:
  150.             self._seek_wrapper__cache.write(data)
  151.         self._seek_wrapper__cache.seek(pos)
  152.         data = self._seek_wrapper__cache.readline()
  153.         if size != -1:
  154.             r = data[:size]
  155.             self._seek_wrapper__pos = pos + size
  156.         else:
  157.             r = data
  158.             self._seek_wrapper__pos = pos + len(data)
  159.         return r
  160.  
  161.     
  162.     def readlines(self, sizehint = -1):
  163.         pos = self._seek_wrapper__pos
  164.         self._seek_wrapper__cache.seek(0, 2)
  165.         self._seek_wrapper__cache.write(self.wrapped.read())
  166.         self.read_complete = True
  167.         self._seek_wrapper__cache.seek(pos)
  168.         data = self._seek_wrapper__cache.readlines(sizehint)
  169.         self._seek_wrapper__pos = self._seek_wrapper__cache.tell()
  170.         return data
  171.  
  172.     
  173.     def __iter__(self):
  174.         return self
  175.  
  176.     
  177.     def next(self):
  178.         line = self.readline()
  179.         if line == '':
  180.             raise StopIteration
  181.         line == ''
  182.         return line
  183.  
  184.     xreadlines = __iter__
  185.     
  186.     def __repr__(self):
  187.         return '<%s at %s whose wrapped object = %r>' % (self.__class__.__name__, hex(abs(id(self))), self.wrapped)
  188.  
  189.  
  190.  
  191. class response_seek_wrapper(seek_wrapper):
  192.     
  193.     def __init__(self, wrapped):
  194.         seek_wrapper.__init__(self, wrapped)
  195.         self._headers = self.wrapped.info()
  196.  
  197.     
  198.     def __copy__(self):
  199.         cpy = seek_wrapper.__copy__(self)
  200.         cpy._headers = copy.copy(self.info())
  201.         return cpy
  202.  
  203.     
  204.     def info(self):
  205.         return self._headers
  206.  
  207.     
  208.     def geturl(self):
  209.         return self.wrapped.geturl()
  210.  
  211.     
  212.     def set_data(self, data):
  213.         self.seek(0)
  214.         self.read()
  215.         self.close()
  216.         cache = self._seek_wrapper__cache = StringIO()
  217.         cache.write(data)
  218.         self.seek(0)
  219.  
  220.  
  221.  
  222. class eoffile:
  223.     
  224.     def read(self, size = -1):
  225.         return ''
  226.  
  227.     
  228.     def readline(self, size = -1):
  229.         return ''
  230.  
  231.     
  232.     def __iter__(self):
  233.         return self
  234.  
  235.     
  236.     def next(self):
  237.         return ''
  238.  
  239.     
  240.     def close(self):
  241.         pass
  242.  
  243.  
  244.  
  245. class eofresponse(eoffile):
  246.     
  247.     def __init__(self, url, headers, code, msg):
  248.         self._url = url
  249.         self._headers = headers
  250.         self.code = code
  251.         self.msg = msg
  252.  
  253.     
  254.     def geturl(self):
  255.         return self._url
  256.  
  257.     
  258.     def info(self):
  259.         return self._headers
  260.  
  261.  
  262.  
  263. class closeable_response:
  264.     closeable_response = None
  265.     
  266.     def __init__(self, fp, headers, url, code, msg):
  267.         self._set_fp(fp)
  268.         self._headers = headers
  269.         self._url = url
  270.         self.code = code
  271.         self.msg = msg
  272.  
  273.     
  274.     def _set_fp(self, fp):
  275.         self.fp = fp
  276.         self.read = self.fp.read
  277.         self.readline = self.fp.readline
  278.         if hasattr(self.fp, 'readlines'):
  279.             self.readlines = self.fp.readlines
  280.         
  281.         if hasattr(self.fp, 'fileno'):
  282.             self.fileno = self.fp.fileno
  283.         else:
  284.             
  285.             self.fileno = lambda : pass
  286.         self.__iter__ = self.fp.__iter__
  287.         self.next = self.fp.next
  288.  
  289.     
  290.     def __repr__(self):
  291.         return '<%s at %s whose fp = %r>' % (self.__class__.__name__, hex(abs(id(self))), self.fp)
  292.  
  293.     
  294.     def info(self):
  295.         return self._headers
  296.  
  297.     
  298.     def geturl(self):
  299.         return self._url
  300.  
  301.     
  302.     def close(self):
  303.         wrapped = self.fp
  304.         wrapped.close()
  305.         new_wrapped = eofresponse(self._url, self._headers, self.code, self.msg)
  306.         self._set_fp(new_wrapped)
  307.  
  308.     
  309.     def __getstate__(self):
  310.         state = self.__dict__.copy()
  311.         new_wrapped = eofresponse(self._url, self._headers, self.code, self.msg)
  312.         state['wrapped'] = new_wrapped
  313.         return state
  314.  
  315.  
  316.  
  317. def test_response(data = 'test data', headers = [], url = 'http://example.com/', code = 200, msg = 'OK'):
  318.     return make_response(data, headers, url, code, msg)
  319.  
  320.  
  321. def test_html_response(data = 'test data', headers = [], url = 'http://example.com/', code = 200, msg = 'OK'):
  322.     headers += [
  323.         ('Content-type', 'text/html')]
  324.     return make_response(data, headers, url, code, msg)
  325.  
  326.  
  327. def make_response(data, headers, url, code, msg):
  328.     mime_headers = make_headers(headers)
  329.     r = closeable_response(StringIO(data), mime_headers, url, code, msg)
  330.     return response_seek_wrapper(r)
  331.  
  332.  
  333. def make_headers(headers):
  334.     hdr_text = []
  335.     for name_value in headers:
  336.         hdr_text.append('%s: %s' % name_value)
  337.     
  338.     return mimetools.Message(StringIO('\n'.join(hdr_text)))
  339.  
  340.  
  341. def get_seek_wrapper_class(response):
  342.     if isinstance(response, urllib2.HTTPError) and not hasattr(response, 'seek'):
  343.         if response.__class__.__module__ == '__builtin__':
  344.             exc_class_name = response.__class__.__name__
  345.         else:
  346.             exc_class_name = '%s.%s' % (response.__class__.__module__, response.__class__.__name__)
  347.         
  348.         class httperror_seek_wrapper((response_seek_wrapper, response.__class__)):
  349.             _exc_class_name = exc_class_name
  350.             
  351.             def __init__(self, wrapped):
  352.                 response_seek_wrapper.__init__(self, wrapped)
  353.                 self.hdrs = wrapped.info()
  354.                 self.filename = wrapped.geturl()
  355.  
  356.             
  357.             def __repr__(self):
  358.                 return '<%s (%s instance) at %s whose wrapped object = %r>' % (self.__class__.__name__, self._exc_class_name, hex(abs(id(self))), self.wrapped)
  359.  
  360.  
  361.         wrapper_class = httperror_seek_wrapper
  362.     else:
  363.         wrapper_class = response_seek_wrapper
  364.     return wrapper_class
  365.  
  366.  
  367. def seek_wrapped_response(response):
  368.     if not hasattr(response, 'seek'):
  369.         wrapper_class = get_seek_wrapper_class(response)
  370.         response = wrapper_class(response)
  371.     
  372.     return response
  373.  
  374.  
  375. def upgrade_response(response):
  376.     wrapper_class = get_seek_wrapper_class(response)
  377.     if hasattr(response, 'closeable_response'):
  378.         if not hasattr(response, 'seek'):
  379.             response = wrapper_class(response)
  380.         
  381.         return copy.copy(response)
  382.     
  383.     try:
  384.         code = response.code
  385.     except AttributeError:
  386.         hasattr(response, 'closeable_response')
  387.         hasattr(response, 'closeable_response')
  388.         code = None
  389.     except:
  390.         hasattr(response, 'closeable_response')
  391.  
  392.     
  393.     try:
  394.         msg = response.msg
  395.     except AttributeError:
  396.         hasattr(response, 'closeable_response')
  397.         hasattr(response, 'closeable_response')
  398.         msg = None
  399.     except:
  400.         hasattr(response, 'closeable_response')
  401.  
  402.     data = None
  403.     get_data = getattr(response, 'get_data', None)
  404.     if get_data:
  405.         data = get_data()
  406.     
  407.     response = closeable_response(response.fp, response.info(), response.geturl(), code, msg)
  408.     response = wrapper_class(response)
  409.     if data:
  410.         response.set_data(data)
  411.     
  412.     return response
  413.  
  414.