home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_313 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  17.7 KB  |  655 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import __builtin__
  5. import sys
  6.  
  7. try:
  8.     from _codecs import *
  9. except ImportError:
  10.     why = None
  11.     raise SystemError('Failed to load the builtin codecs: %s' % why)
  12.  
  13. __all__ = [
  14.     'register',
  15.     'lookup',
  16.     'open',
  17.     'EncodedFile',
  18.     'BOM',
  19.     'BOM_BE',
  20.     'BOM_LE',
  21.     'BOM32_BE',
  22.     'BOM32_LE',
  23.     'BOM64_BE',
  24.     'BOM64_LE',
  25.     'BOM_UTF8',
  26.     'BOM_UTF16',
  27.     'BOM_UTF16_LE',
  28.     'BOM_UTF16_BE',
  29.     'BOM_UTF32',
  30.     'BOM_UTF32_LE',
  31.     'BOM_UTF32_BE',
  32.     'strict_errors',
  33.     'ignore_errors',
  34.     'replace_errors',
  35.     'xmlcharrefreplace_errors',
  36.     'register_error',
  37.     'lookup_error']
  38. BOM_UTF8 = '\xef\xbb\xbf'
  39. BOM_LE = BOM_UTF16_LE = '\xff\xfe'
  40. BOM_BE = BOM_UTF16_BE = '\xfe\xff'
  41. BOM_UTF32_LE = '\xff\xfe\x00\x00'
  42. BOM_UTF32_BE = '\x00\x00\xfe\xff'
  43. if sys.byteorder == 'little':
  44.     BOM = BOM_UTF16 = BOM_UTF16_LE
  45.     BOM_UTF32 = BOM_UTF32_LE
  46. else:
  47.     BOM = BOM_UTF16 = BOM_UTF16_BE
  48.     BOM_UTF32 = BOM_UTF32_BE
  49. BOM32_LE = BOM_UTF16_LE
  50. BOM32_BE = BOM_UTF16_BE
  51. BOM64_LE = BOM_UTF32_LE
  52. BOM64_BE = BOM_UTF32_BE
  53.  
  54. class CodecInfo(tuple):
  55.     
  56.     def __new__(cls, encode, decode, streamreader = None, streamwriter = None, incrementalencoder = None, incrementaldecoder = None, name = None):
  57.         self = tuple.__new__(cls, (encode, decode, streamreader, streamwriter))
  58.         self.name = name
  59.         self.encode = encode
  60.         self.decode = decode
  61.         self.incrementalencoder = incrementalencoder
  62.         self.incrementaldecoder = incrementaldecoder
  63.         self.streamwriter = streamwriter
  64.         self.streamreader = streamreader
  65.         return self
  66.  
  67.     
  68.     def __repr__(self):
  69.         return '<%s.%s object for encoding %s at 0x%x>' % (self.__class__.__module__, self.__class__.__name__, self.name, id(self))
  70.  
  71.  
  72.  
  73. class Codec:
  74.     
  75.     def encode(self, input, errors = 'strict'):
  76.         raise NotImplementedError
  77.  
  78.     
  79.     def decode(self, input, errors = 'strict'):
  80.         raise NotImplementedError
  81.  
  82.  
  83.  
  84. class IncrementalEncoder(object):
  85.     
  86.     def __init__(self, errors = 'strict'):
  87.         self.errors = errors
  88.         self.buffer = ''
  89.  
  90.     
  91.     def encode(self, input, final = False):
  92.         raise NotImplementedError
  93.  
  94.     
  95.     def reset(self):
  96.         pass
  97.  
  98.     
  99.     def getstate(self):
  100.         return 0
  101.  
  102.     
  103.     def setstate(self, state):
  104.         pass
  105.  
  106.  
  107.  
  108. class BufferedIncrementalEncoder(IncrementalEncoder):
  109.     
  110.     def __init__(self, errors = 'strict'):
  111.         IncrementalEncoder.__init__(self, errors)
  112.         self.buffer = ''
  113.  
  114.     
  115.     def _buffer_encode(self, input, errors, final):
  116.         raise NotImplementedError
  117.  
  118.     
  119.     def encode(self, input, final = False):
  120.         data = self.buffer + input
  121.         (result, consumed) = self._buffer_encode(data, self.errors, final)
  122.         self.buffer = data[consumed:]
  123.         return result
  124.  
  125.     
  126.     def reset(self):
  127.         IncrementalEncoder.reset(self)
  128.         self.buffer = ''
  129.  
  130.     
  131.     def getstate(self):
  132.         if not self.buffer:
  133.             pass
  134.         return 0
  135.  
  136.     
  137.     def setstate(self, state):
  138.         if not state:
  139.             pass
  140.         self.buffer = ''
  141.  
  142.  
  143.  
  144. class IncrementalDecoder(object):
  145.     
  146.     def __init__(self, errors = 'strict'):
  147.         self.errors = errors
  148.  
  149.     
  150.     def decode(self, input, final = False):
  151.         raise NotImplementedError
  152.  
  153.     
  154.     def reset(self):
  155.         pass
  156.  
  157.     
  158.     def getstate(self):
  159.         return ('', 0)
  160.  
  161.     
  162.     def setstate(self, state):
  163.         pass
  164.  
  165.  
  166.  
  167. class BufferedIncrementalDecoder(IncrementalDecoder):
  168.     
  169.     def __init__(self, errors = 'strict'):
  170.         IncrementalDecoder.__init__(self, errors)
  171.         self.buffer = ''
  172.  
  173.     
  174.     def _buffer_decode(self, input, errors, final):
  175.         raise NotImplementedError
  176.  
  177.     
  178.     def decode(self, input, final = False):
  179.         data = self.buffer + input
  180.         (result, consumed) = self._buffer_decode(data, self.errors, final)
  181.         self.buffer = data[consumed:]
  182.         return result
  183.  
  184.     
  185.     def reset(self):
  186.         IncrementalDecoder.reset(self)
  187.         self.buffer = ''
  188.  
  189.     
  190.     def getstate(self):
  191.         return (self.buffer, 0)
  192.  
  193.     
  194.     def setstate(self, state):
  195.         self.buffer = state[0]
  196.  
  197.  
  198.  
  199. class StreamWriter(Codec):
  200.     
  201.     def __init__(self, stream, errors = 'strict'):
  202.         self.stream = stream
  203.         self.errors = errors
  204.  
  205.     
  206.     def write(self, object):
  207.         (data, consumed) = self.encode(object, self.errors)
  208.         self.stream.write(data)
  209.  
  210.     
  211.     def writelines(self, list):
  212.         self.write(''.join(list))
  213.  
  214.     
  215.     def reset(self):
  216.         pass
  217.  
  218.     
  219.     def __getattr__(self, name, getattr = getattr):
  220.         return getattr(self.stream, name)
  221.  
  222.     
  223.     def __enter__(self):
  224.         return self
  225.  
  226.     
  227.     def __exit__(self, type, value, tb):
  228.         self.stream.close()
  229.  
  230.  
  231.  
  232. class StreamReader(Codec):
  233.     
  234.     def __init__(self, stream, errors = 'strict'):
  235.         self.stream = stream
  236.         self.errors = errors
  237.         self.bytebuffer = ''
  238.         self.charbuffer = ''
  239.         self.linebuffer = None
  240.  
  241.     
  242.     def decode(self, input, errors = 'strict'):
  243.         raise NotImplementedError
  244.  
  245.     
  246.     def read(self, size = -1, chars = -1, firstline = False):
  247.         if self.linebuffer:
  248.             self.charbuffer = ''.join(self.linebuffer)
  249.             self.linebuffer = None
  250.         
  251.         while True:
  252.             if chars < 0:
  253.                 if size < 0:
  254.                     if self.charbuffer:
  255.                         break
  256.                     
  257.                 elif len(self.charbuffer) >= size:
  258.                     break
  259.                 
  260.             elif len(self.charbuffer) >= chars:
  261.                 break
  262.             
  263.             if size < 0:
  264.                 newdata = self.stream.read()
  265.             else:
  266.                 newdata = self.stream.read(size)
  267.             data = self.bytebuffer + newdata
  268.             
  269.             try:
  270.                 (newchars, decodedbytes) = self.decode(data, self.errors)
  271.             except UnicodeDecodeError:
  272.                 exc = None
  273.                 if firstline:
  274.                     (newchars, decodedbytes) = self.decode(data[:exc.start], self.errors)
  275.                     lines = newchars.splitlines(True)
  276.                     if len(lines) <= 1:
  277.                         raise 
  278.                     len(lines) <= 1
  279.                 else:
  280.                     raise 
  281.                 firstline
  282.  
  283.             self.bytebuffer = data[decodedbytes:]
  284.             self.charbuffer += newchars
  285.             if not newdata:
  286.                 break
  287.                 continue
  288.             self
  289.         if chars < 0:
  290.             result = self.charbuffer
  291.             self.charbuffer = ''
  292.         else:
  293.             result = self.charbuffer[:chars]
  294.             self.charbuffer = self.charbuffer[chars:]
  295.         return result
  296.  
  297.     
  298.     def readline(self, size = None, keepends = True):
  299.         if self.linebuffer:
  300.             line = self.linebuffer[0]
  301.             del self.linebuffer[0]
  302.             if len(self.linebuffer) == 1:
  303.                 self.charbuffer = self.linebuffer[0]
  304.                 self.linebuffer = None
  305.             
  306.             if not keepends:
  307.                 line = line.splitlines(False)[0]
  308.             
  309.             return line
  310.         if not size:
  311.             pass
  312.         readsize = 72
  313.         line = ''
  314.         while True:
  315.             data = self.read(readsize, firstline = True)
  316.             if data:
  317.                 if data.endswith('\r'):
  318.                     data += self.read(size = 1, chars = 1)
  319.                 
  320.             
  321.             line += data
  322.             lines = line.splitlines(True)
  323.             if lines:
  324.                 if len(lines) > 1:
  325.                     line = lines[0]
  326.                     del lines[0]
  327.                     if len(lines) > 1:
  328.                         lines[-1] += self.charbuffer
  329.                         self.linebuffer = lines
  330.                         self.charbuffer = None
  331.                     else:
  332.                         self.charbuffer = lines[0] + self.charbuffer
  333.                     if not keepends:
  334.                         line = line.splitlines(False)[0]
  335.                     
  336.                     break
  337.                 
  338.                 line0withend = lines[0]
  339.                 line0withoutend = lines[0].splitlines(False)[0]
  340.                 if line0withend != line0withoutend:
  341.                     self.charbuffer = ''.join(lines[1:]) + self.charbuffer
  342.                     if keepends:
  343.                         line = line0withend
  344.                     else:
  345.                         line = line0withoutend
  346.                     break
  347.                 
  348.             
  349.             if not data or size is not None:
  350.                 if line and not keepends:
  351.                     line = line.splitlines(False)[0]
  352.                 
  353.                 break
  354.             
  355.             if readsize < 8000:
  356.                 readsize *= 2
  357.                 continue
  358.         return line
  359.  
  360.     
  361.     def readlines(self, sizehint = None, keepends = True):
  362.         data = self.read()
  363.         return data.splitlines(keepends)
  364.  
  365.     
  366.     def reset(self):
  367.         self.bytebuffer = ''
  368.         self.charbuffer = u''
  369.         self.linebuffer = None
  370.  
  371.     
  372.     def seek(self, offset, whence = 0):
  373.         self.reset()
  374.         self.stream.seek(offset, whence)
  375.  
  376.     
  377.     def next(self):
  378.         line = self.readline()
  379.         if line:
  380.             return line
  381.         raise StopIteration
  382.  
  383.     
  384.     def __iter__(self):
  385.         return self
  386.  
  387.     
  388.     def __getattr__(self, name, getattr = getattr):
  389.         return getattr(self.stream, name)
  390.  
  391.     
  392.     def __enter__(self):
  393.         return self
  394.  
  395.     
  396.     def __exit__(self, type, value, tb):
  397.         self.stream.close()
  398.  
  399.  
  400.  
  401. class StreamReaderWriter:
  402.     encoding = 'unknown'
  403.     
  404.     def __init__(self, stream, Reader, Writer, errors = 'strict'):
  405.         self.stream = stream
  406.         self.reader = Reader(stream, errors)
  407.         self.writer = Writer(stream, errors)
  408.         self.errors = errors
  409.  
  410.     
  411.     def read(self, size = -1):
  412.         return self.reader.read(size)
  413.  
  414.     
  415.     def readline(self, size = None):
  416.         return self.reader.readline(size)
  417.  
  418.     
  419.     def readlines(self, sizehint = None):
  420.         return self.reader.readlines(sizehint)
  421.  
  422.     
  423.     def next(self):
  424.         return self.reader.next()
  425.  
  426.     
  427.     def __iter__(self):
  428.         return self
  429.  
  430.     
  431.     def write(self, data):
  432.         return self.writer.write(data)
  433.  
  434.     
  435.     def writelines(self, list):
  436.         return self.writer.writelines(list)
  437.  
  438.     
  439.     def reset(self):
  440.         self.reader.reset()
  441.         self.writer.reset()
  442.  
  443.     
  444.     def __getattr__(self, name, getattr = getattr):
  445.         return getattr(self.stream, name)
  446.  
  447.     
  448.     def __enter__(self):
  449.         return self
  450.  
  451.     
  452.     def __exit__(self, type, value, tb):
  453.         self.stream.close()
  454.  
  455.  
  456.  
  457. class StreamRecoder:
  458.     data_encoding = 'unknown'
  459.     file_encoding = 'unknown'
  460.     
  461.     def __init__(self, stream, encode, decode, Reader, Writer, errors = 'strict'):
  462.         self.stream = stream
  463.         self.encode = encode
  464.         self.decode = decode
  465.         self.reader = Reader(stream, errors)
  466.         self.writer = Writer(stream, errors)
  467.         self.errors = errors
  468.  
  469.     
  470.     def read(self, size = -1):
  471.         data = self.reader.read(size)
  472.         (data, bytesencoded) = self.encode(data, self.errors)
  473.         return data
  474.  
  475.     
  476.     def readline(self, size = None):
  477.         if size is None:
  478.             data = self.reader.readline()
  479.         else:
  480.             data = self.reader.readline(size)
  481.         (data, bytesencoded) = self.encode(data, self.errors)
  482.         return data
  483.  
  484.     
  485.     def readlines(self, sizehint = None):
  486.         data = self.reader.read()
  487.         (data, bytesencoded) = self.encode(data, self.errors)
  488.         return data.splitlines(1)
  489.  
  490.     
  491.     def next(self):
  492.         data = self.reader.next()
  493.         (data, bytesencoded) = self.encode(data, self.errors)
  494.         return data
  495.  
  496.     
  497.     def __iter__(self):
  498.         return self
  499.  
  500.     
  501.     def write(self, data):
  502.         (data, bytesdecoded) = self.decode(data, self.errors)
  503.         return self.writer.write(data)
  504.  
  505.     
  506.     def writelines(self, list):
  507.         data = ''.join(list)
  508.         (data, bytesdecoded) = self.decode(data, self.errors)
  509.         return self.writer.write(data)
  510.  
  511.     
  512.     def reset(self):
  513.         self.reader.reset()
  514.         self.writer.reset()
  515.  
  516.     
  517.     def __getattr__(self, name, getattr = getattr):
  518.         return getattr(self.stream, name)
  519.  
  520.     
  521.     def __enter__(self):
  522.         return self
  523.  
  524.     
  525.     def __exit__(self, type, value, tb):
  526.         self.stream.close()
  527.  
  528.  
  529.  
  530. def open(filename, mode = 'rb', encoding = None, errors = 'strict', buffering = 1):
  531.     if encoding is not None and 'b' not in mode:
  532.         mode = mode + 'b'
  533.     
  534.     file = __builtin__.open(filename, mode, buffering)
  535.     if encoding is None:
  536.         return file
  537.     info = lookup(encoding)
  538.     srw = StreamReaderWriter(file, info.streamreader, info.streamwriter, errors)
  539.     srw.encoding = encoding
  540.     return srw
  541.  
  542.  
  543. def EncodedFile(file, data_encoding, file_encoding = None, errors = 'strict'):
  544.     if file_encoding is None:
  545.         file_encoding = data_encoding
  546.     
  547.     data_info = lookup(data_encoding)
  548.     file_info = lookup(file_encoding)
  549.     sr = StreamRecoder(file, data_info.encode, data_info.decode, file_info.streamreader, file_info.streamwriter, errors)
  550.     sr.data_encoding = data_encoding
  551.     sr.file_encoding = file_encoding
  552.     return sr
  553.  
  554.  
  555. def getencoder(encoding):
  556.     return lookup(encoding).encode
  557.  
  558.  
  559. def getdecoder(encoding):
  560.     return lookup(encoding).decode
  561.  
  562.  
  563. def getincrementalencoder(encoding):
  564.     encoder = lookup(encoding).incrementalencoder
  565.     if encoder is None:
  566.         raise LookupError(encoding)
  567.     encoder is None
  568.     return encoder
  569.  
  570.  
  571. def getincrementaldecoder(encoding):
  572.     decoder = lookup(encoding).incrementaldecoder
  573.     if decoder is None:
  574.         raise LookupError(encoding)
  575.     decoder is None
  576.     return decoder
  577.  
  578.  
  579. def getreader(encoding):
  580.     return lookup(encoding).streamreader
  581.  
  582.  
  583. def getwriter(encoding):
  584.     return lookup(encoding).streamwriter
  585.  
  586.  
  587. def iterencode(iterator, encoding, errors = 'strict', **kwargs):
  588.     encoder = getincrementalencoder(encoding)(errors, **kwargs)
  589.     for input in iterator:
  590.         output = encoder.encode(input)
  591.         if output:
  592.             yield output
  593.             continue
  594.     
  595.     output = encoder.encode('', True)
  596.     if output:
  597.         yield output
  598.     
  599.  
  600.  
  601. def iterdecode(iterator, encoding, errors = 'strict', **kwargs):
  602.     decoder = getincrementaldecoder(encoding)(errors, **kwargs)
  603.     for input in iterator:
  604.         output = decoder.decode(input)
  605.         if output:
  606.             yield output
  607.             continue
  608.     
  609.     output = decoder.decode('', True)
  610.     if output:
  611.         yield output
  612.     
  613.  
  614.  
  615. def make_identity_dict(rng):
  616.     res = { }
  617.     for i in rng:
  618.         res[i] = i
  619.     
  620.     return res
  621.  
  622.  
  623. def make_encoding_map(decoding_map):
  624.     m = { }
  625.     for k, v in decoding_map.items():
  626.         if v not in m:
  627.             m[v] = k
  628.             continue
  629.         m[v] = None
  630.     
  631.     return m
  632.  
  633.  
  634. try:
  635.     strict_errors = lookup_error('strict')
  636.     ignore_errors = lookup_error('ignore')
  637.     replace_errors = lookup_error('replace')
  638.     xmlcharrefreplace_errors = lookup_error('xmlcharrefreplace')
  639.     backslashreplace_errors = lookup_error('backslashreplace')
  640. except LookupError:
  641.     strict_errors = None
  642.     ignore_errors = None
  643.     replace_errors = None
  644.     xmlcharrefreplace_errors = None
  645.     backslashreplace_errors = None
  646.  
  647. _false = 0
  648. if _false:
  649.     import encodings
  650.  
  651. if __name__ == '__main__':
  652.     sys.stdout = EncodedFile(sys.stdout, 'latin-1', 'utf-8')
  653.     sys.stdin = EncodedFile(sys.stdin, 'utf-8', 'latin-1')
  654.  
  655.