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