home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / codecs.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  18.1 KB  |  644 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  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 seek(self, offset, whence = 0):
  220.         self.stream.seek(offset, whence)
  221.         if whence == 0 and offset == 0:
  222.             self.reset()
  223.  
  224.     
  225.     def __getattr__(self, name, getattr = getattr):
  226.         return getattr(self.stream, name)
  227.  
  228.     
  229.     def __enter__(self):
  230.         return self
  231.  
  232.     
  233.     def __exit__(self, type, value, tb):
  234.         self.stream.close()
  235.  
  236.  
  237.  
  238. class StreamReader(Codec):
  239.     
  240.     def __init__(self, stream, errors = 'strict'):
  241.         self.stream = stream
  242.         self.errors = errors
  243.         self.bytebuffer = ''
  244.         self.charbuffer = ''
  245.         self.linebuffer = None
  246.  
  247.     
  248.     def decode(self, input, errors = 'strict'):
  249.         raise NotImplementedError
  250.  
  251.     
  252.     def read(self, size = -1, chars = -1, firstline = False):
  253.         if self.linebuffer:
  254.             self.charbuffer = ''.join(self.linebuffer)
  255.             self.linebuffer = None
  256.         while True:
  257.             if chars < 0:
  258.                 if size < 0 or self.charbuffer:
  259.                     break
  260.                 
  261.             elif len(self.charbuffer) >= size:
  262.                 break
  263.             
  264.         if len(self.charbuffer) >= chars:
  265.             break
  266.         if size < 0:
  267.             newdata = self.stream.read()
  268.         else:
  269.             newdata = self.stream.read(size)
  270.         data = self.bytebuffer + newdata
  271.         
  272.         try:
  273.             (newchars, decodedbytes) = self.decode(data, self.errors)
  274.         except UnicodeDecodeError:
  275.             exc = None
  276.             if firstline:
  277.                 (newchars, decodedbytes) = self.decode(data[:exc.start], self.errors)
  278.                 lines = newchars.splitlines(True)
  279.                 if len(lines) <= 1:
  280.                     raise 
  281.             else:
  282.                 raise 
  283.  
  284.         self.bytebuffer = data[decodedbytes:]
  285.         self.charbuffer += newchars
  286.         if not newdata:
  287.             break
  288.             continue
  289.         return result
  290.  
  291.     
  292.     def readline(self, size = None, keepends = True):
  293.         if self.linebuffer:
  294.             line = self.linebuffer[0]
  295.             del self.linebuffer[0]
  296.             if len(self.linebuffer) == 1:
  297.                 self.charbuffer = self.linebuffer[0]
  298.                 self.linebuffer = None
  299.             if not keepends:
  300.                 line = line.splitlines(False)[0]
  301.             return line
  302.         if not None:
  303.             pass
  304.         readsize = 72
  305.         line = ''
  306.         while True:
  307.             data = self.read(readsize, firstline = True)
  308.             if data and data.endswith('\r'):
  309.                 data += self.read(size = 1, chars = 1)
  310.             
  311.         line += data
  312.         lines = line.splitlines(True)
  313.         if lines:
  314.             if len(lines) > 1:
  315.                 line = lines[0]
  316.                 del lines[0]
  317.                 if len(lines) > 1:
  318.                     lines[-1] += self.charbuffer
  319.                     self.linebuffer = lines
  320.                     self.charbuffer = None
  321.                 else:
  322.                     self.charbuffer = lines[0] + self.charbuffer
  323.                 if not keepends:
  324.                     line = line.splitlines(False)[0]
  325.                 break
  326.             line0withend = lines[0]
  327.             line0withoutend = lines[0].splitlines(False)[0]
  328.             if line0withend != line0withoutend:
  329.                 self.charbuffer = ''.join(lines[1:]) + self.charbuffer
  330.                 if keepends:
  331.                     line = line0withend
  332.                 else:
  333.                     line = line0withoutend
  334.                 break
  335.             
  336.         if not data or size is not None:
  337.             if line and not keepends:
  338.                 line = line.splitlines(False)[0]
  339.             break
  340.         if readsize < 8000:
  341.             readsize *= 2
  342.             continue
  343.         return line
  344.  
  345.     
  346.     def readlines(self, sizehint = None, keepends = True):
  347.         data = self.read()
  348.         return data.splitlines(keepends)
  349.  
  350.     
  351.     def reset(self):
  352.         self.bytebuffer = ''
  353.         self.charbuffer = u''
  354.         self.linebuffer = None
  355.  
  356.     
  357.     def seek(self, offset, whence = 0):
  358.         self.stream.seek(offset, whence)
  359.         self.reset()
  360.  
  361.     
  362.     def next(self):
  363.         line = self.readline()
  364.         if line:
  365.             return line
  366.         raise None
  367.  
  368.     
  369.     def __iter__(self):
  370.         return self
  371.  
  372.     
  373.     def __getattr__(self, name, getattr = getattr):
  374.         return getattr(self.stream, name)
  375.  
  376.     
  377.     def __enter__(self):
  378.         return self
  379.  
  380.     
  381.     def __exit__(self, type, value, tb):
  382.         self.stream.close()
  383.  
  384.  
  385.  
  386. class StreamReaderWriter:
  387.     encoding = 'unknown'
  388.     
  389.     def __init__(self, stream, Reader, Writer, errors = 'strict'):
  390.         self.stream = stream
  391.         self.reader = Reader(stream, errors)
  392.         self.writer = Writer(stream, errors)
  393.         self.errors = errors
  394.  
  395.     
  396.     def read(self, size = -1):
  397.         return self.reader.read(size)
  398.  
  399.     
  400.     def readline(self, size = None):
  401.         return self.reader.readline(size)
  402.  
  403.     
  404.     def readlines(self, sizehint = None):
  405.         return self.reader.readlines(sizehint)
  406.  
  407.     
  408.     def next(self):
  409.         return self.reader.next()
  410.  
  411.     
  412.     def __iter__(self):
  413.         return self
  414.  
  415.     
  416.     def write(self, data):
  417.         return self.writer.write(data)
  418.  
  419.     
  420.     def writelines(self, list):
  421.         return self.writer.writelines(list)
  422.  
  423.     
  424.     def reset(self):
  425.         self.reader.reset()
  426.         self.writer.reset()
  427.  
  428.     
  429.     def seek(self, offset, whence = 0):
  430.         self.stream.seek(offset, whence)
  431.         self.reader.reset()
  432.         if whence == 0 and offset == 0:
  433.             self.writer.reset()
  434.  
  435.     
  436.     def __getattr__(self, name, getattr = getattr):
  437.         return getattr(self.stream, name)
  438.  
  439.     
  440.     def __enter__(self):
  441.         return self
  442.  
  443.     
  444.     def __exit__(self, type, value, tb):
  445.         self.stream.close()
  446.  
  447.  
  448.  
  449. class StreamRecoder:
  450.     data_encoding = 'unknown'
  451.     file_encoding = 'unknown'
  452.     
  453.     def __init__(self, stream, encode, decode, Reader, Writer, errors = 'strict'):
  454.         self.stream = stream
  455.         self.encode = encode
  456.         self.decode = decode
  457.         self.reader = Reader(stream, errors)
  458.         self.writer = Writer(stream, errors)
  459.         self.errors = errors
  460.  
  461.     
  462.     def read(self, size = -1):
  463.         data = self.reader.read(size)
  464.         (data, bytesencoded) = self.encode(data, self.errors)
  465.         return data
  466.  
  467.     
  468.     def readline(self, size = None):
  469.         if size is None:
  470.             data = self.reader.readline()
  471.         else:
  472.             data = self.reader.readline(size)
  473.         (data, bytesencoded) = self.encode(data, self.errors)
  474.         return data
  475.  
  476.     
  477.     def readlines(self, sizehint = None):
  478.         data = self.reader.read()
  479.         (data, bytesencoded) = self.encode(data, self.errors)
  480.         return data.splitlines(1)
  481.  
  482.     
  483.     def next(self):
  484.         data = self.reader.next()
  485.         (data, bytesencoded) = self.encode(data, self.errors)
  486.         return data
  487.  
  488.     
  489.     def __iter__(self):
  490.         return self
  491.  
  492.     
  493.     def write(self, data):
  494.         (data, bytesdecoded) = self.decode(data, self.errors)
  495.         return self.writer.write(data)
  496.  
  497.     
  498.     def writelines(self, list):
  499.         data = ''.join(list)
  500.         (data, bytesdecoded) = self.decode(data, self.errors)
  501.         return self.writer.write(data)
  502.  
  503.     
  504.     def reset(self):
  505.         self.reader.reset()
  506.         self.writer.reset()
  507.  
  508.     
  509.     def __getattr__(self, name, getattr = getattr):
  510.         return getattr(self.stream, name)
  511.  
  512.     
  513.     def __enter__(self):
  514.         return self
  515.  
  516.     
  517.     def __exit__(self, type, value, tb):
  518.         self.stream.close()
  519.  
  520.  
  521.  
  522. def open(filename, mode = 'rb', encoding = None, errors = 'strict', buffering = 1):
  523.     if encoding is not None:
  524.         if 'U' in mode:
  525.             mode = mode.strip().replace('U', '')
  526.             if mode[:1] not in set('rwa'):
  527.                 mode = 'r' + mode
  528.             
  529.         if 'b' not in mode:
  530.             mode = mode + 'b'
  531.         
  532.     file = __builtin__.open(filename, mode, buffering)
  533.     if encoding is None:
  534.         return file
  535.     info = None(encoding)
  536.     srw = StreamReaderWriter(file, info.streamreader, info.streamwriter, errors)
  537.     srw.encoding = encoding
  538.     return srw
  539.  
  540.  
  541. def EncodedFile(file, data_encoding, file_encoding = None, errors = 'strict'):
  542.     if file_encoding is None:
  543.         file_encoding = data_encoding
  544.     data_info = lookup(data_encoding)
  545.     file_info = lookup(file_encoding)
  546.     sr = StreamRecoder(file, data_info.encode, data_info.decode, file_info.streamreader, file_info.streamwriter, errors)
  547.     sr.data_encoding = data_encoding
  548.     sr.file_encoding = file_encoding
  549.     return sr
  550.  
  551.  
  552. def getencoder(encoding):
  553.     return lookup(encoding).encode
  554.  
  555.  
  556. def getdecoder(encoding):
  557.     return lookup(encoding).decode
  558.  
  559.  
  560. def getincrementalencoder(encoding):
  561.     encoder = lookup(encoding).incrementalencoder
  562.     if encoder is None:
  563.         raise LookupError(encoding)
  564.     return encoder
  565.  
  566.  
  567. def getincrementaldecoder(encoding):
  568.     decoder = lookup(encoding).incrementaldecoder
  569.     if decoder is None:
  570.         raise LookupError(encoding)
  571.     return decoder
  572.  
  573.  
  574. def getreader(encoding):
  575.     return lookup(encoding).streamreader
  576.  
  577.  
  578. def getwriter(encoding):
  579.     return lookup(encoding).streamwriter
  580.  
  581.  
  582. def iterencode(iterator, encoding, errors = 'strict', **kwargs):
  583.     encoder = getincrementalencoder(encoding)(errors, **kwargs)
  584.     for input in iterator:
  585.         output = encoder.encode(input)
  586.         if output:
  587.             yield output
  588.             continue
  589.     output = encoder.encode('', True)
  590.     if output:
  591.         yield output
  592.  
  593.  
  594. def iterdecode(iterator, encoding, errors = 'strict', **kwargs):
  595.     decoder = getincrementaldecoder(encoding)(errors, **kwargs)
  596.     for input in iterator:
  597.         output = decoder.decode(input)
  598.         if output:
  599.             yield output
  600.             continue
  601.     output = decoder.decode('', True)
  602.     if output:
  603.         yield output
  604.  
  605.  
  606. def make_identity_dict(rng):
  607.     res = { }
  608.     for i in rng:
  609.         res[i] = i
  610.     
  611.     return res
  612.  
  613.  
  614. def make_encoding_map(decoding_map):
  615.     m = { }
  616.     for k, v in decoding_map.items():
  617.         if v not in m:
  618.             m[v] = k
  619.             continue
  620.         m[v] = None
  621.     
  622.     return m
  623.  
  624.  
  625. try:
  626.     strict_errors = lookup_error('strict')
  627.     ignore_errors = lookup_error('ignore')
  628.     replace_errors = lookup_error('replace')
  629.     xmlcharrefreplace_errors = lookup_error('xmlcharrefreplace')
  630.     backslashreplace_errors = lookup_error('backslashreplace')
  631. except LookupError:
  632.     strict_errors = None
  633.     ignore_errors = None
  634.     replace_errors = None
  635.     xmlcharrefreplace_errors = None
  636.     backslashreplace_errors = None
  637.  
  638. _false = 0
  639. if _false:
  640.     import encodings
  641. if __name__ == '__main__':
  642.     sys.stdout = EncodedFile(sys.stdout, 'latin-1', 'utf-8')
  643.     sys.stdin = EncodedFile(sys.stdin, 'utf-8', 'latin-1')
  644.