Maximum CD 2010 November/maximum-cd-2010-11.iso/DiscContents/calibre-0.7.13.msi/file_605

Python Compiled Bytecode | 2010-08-06 | 38.6 KB | 1,548 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

from __future__ import print_function
from __future__ import unicode_literals
__author__ = 'Guido van Rossum <[e-mail]>, Mike Verdone <[e-mail]>, Mark Russell <[e-mail]>'
__all__ = [
    'BlockingIOError',
    'open',
    'IOBase',
    'RawIOBase',
    'FileIO',
    'BytesIO',
    'StringIO',
    'BufferedIOBase',
    'BufferedReader',
    'BufferedWriter',
    'BufferedRWPair',
    'BufferedRandom',
    'TextIOBase',
    'TextIOWrapper']
import os
import abc
import codecs
import _fileio
import threading
DEFAULT_BUFFER_SIZE = 8 * 1024
__metaclass__ = type

class BlockingIOError(IOError):

    def __init__(self, errno, strerror, characters_written = 0):
        IOError.__init__(self, errno, strerror)
        self.characters_written = characters_written



def open(file, mode = 'r', buffering = None, encoding = None, errors = None, newline = None, closefd = True):
    if not isinstance(file, (basestring, int)):
        raise TypeError('invalid file: %r' % file)
    isinstance(file, (basestring, int))
    if not isinstance(mode, basestring):
        raise TypeError('invalid mode: %r' % mode)
    isinstance(mode, basestring)
    if buffering is not None and not isinstance(buffering, int):
        raise TypeError('invalid buffering: %r' % buffering)
    not isinstance(buffering, int)
    if encoding is not None and not isinstance(encoding, basestring):
        raise TypeError('invalid encoding: %r' % encoding)
    not isinstance(encoding, basestring)
    if errors is not None and not isinstance(errors, basestring):
        raise TypeError('invalid errors: %r' % errors)
    not isinstance(errors, basestring)
    modes = set(mode)
    if modes - set('arwb+tU') or len(mode) > len(modes):
        raise ValueError('invalid mode: %r' % mode)
    len(mode) > len(modes)
    reading = 'r' in modes
    writing = 'w' in modes
    appending = 'a' in modes
    updating = '+' in modes
    text = 't' in modes
    binary = 'b' in modes
    if 'U' in modes:
        if writing or appending:
            raise ValueError("can't use U and writing mode at once")
        appending
        reading = True

    if text and binary:
        raise ValueError("can't have text and binary mode at once")
    binary
    if reading + writing + appending > 1:
        raise ValueError("can't have read/write/append mode at once")
    reading + writing + appending > 1
    if not reading and writing or appending:
        raise ValueError('must have exactly one of read/write/append mode')
    appending
    if binary and encoding is not None:
        raise ValueError("binary mode doesn't take an encoding argument")
    encoding is not None
    if binary and errors is not None:
        raise ValueError("binary mode doesn't take an errors argument")
    errors is not None
    if binary and newline is not None:
        raise ValueError("binary mode doesn't take a newline argument")
    newline is not None
    if not reading or 'r':
        pass
    if not writing or 'w':
        pass
    if not appending or 'a':
        pass
    if not updating or '+':
        pass
    raw = FileIO(file, '' + '' + '' + '', closefd)
    if buffering is None:
        buffering = -1

    line_buffering = False
    if (buffering == 1 or buffering < 0) and raw.isatty():
        buffering = -1
        line_buffering = True

    if buffering < 0:
        buffering = DEFAULT_BUFFER_SIZE

        try:
            bs = os.fstat(raw.fileno()).st_blksize
        except (os.error, AttributeError):
            pass

        if bs > 1:
            buffering = bs


    if buffering < 0:
        raise ValueError('invalid buffering size')
    buffering < 0
    if buffering == 0:
        if binary:
            return raw
        raise ValueError("can't have unbuffered text I/O")
    buffering == 0
    if updating:
        buffer = BufferedRandom(raw, buffering)
    elif writing or appending:
        buffer = BufferedWriter(raw, buffering)
    elif reading:
        buffer = BufferedReader(raw, buffering)
    else:
        raise ValueError('unknown mode: %r' % mode)
    if appending:
        return buffer
    text = TextIOWrapper(buffer, encoding, errors, newline, line_buffering)
    text.mode = mode
    return text


class _DocDescriptor:

    def __get__(self, obj, typ):
        return "open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)\n\n" + open.__doc__



class OpenWrapper:
    __doc__ = _DocDescriptor()

    def __new__(cls, *args, **kwargs):
        return open(*args, **kwargs)



class UnsupportedOperation(ValueError, IOError):
    pass


class IOBase(object):
    __metaclass__ = abc.ABCMeta

    def _unsupported(self, name):
        raise UnsupportedOperation('%s.%s() not supported' % (self.__class__.__name__, name))


    def seek(self, pos, whence = 0):
        self._unsupported('seek')


    def tell(self):
        return self.seek(0, 1)


    def truncate(self, pos = None):
        self._unsupported('truncate')


    def flush(self):
        pass

    __closed = False

    def close(self):
        if not self._IOBase__closed:

            try:
                self.flush()
            except IOError:
                pass

            self._IOBase__closed = True



    def __del__(self):

        try:
            self.close()
        except:
            pass



    def seekable(self):
        return False


    def _checkSeekable(self, msg = None):
        if not self.seekable():
            raise None(IOError if msg is None else msg)
        self.seekable()


    def readable(self):
        return False


    def _checkReadable(self, msg = None):
        if not self.readable():
            raise None(IOError if msg is None else msg)
        self.readable()


    def writable(self):
        return False


    def _checkWritable(self, msg = None):
        if not self.writable():
            raise None(IOError if msg is None else msg)
        self.writable()


    def closed(self):
        return self._IOBase__closed

    closed = property(closed)

    def _checkClosed(self, msg = None):
        if self.closed:
            raise None(ValueError if msg is None else msg)
        self.closed


    def __enter__(self):
        self._checkClosed()
        return self


    def __exit__(self, *args):
        self.close()


    def fileno(self):
        self._unsupported('fileno')


    def isatty(self):
        self._checkClosed()
        return False


    def readline(self, limit = -1):
        self._checkClosed()
        if hasattr(self, 'peek'):

            def nreadahead():
                readahead = self.peek(1)
                if not readahead:
                    return 1
                if not readahead.find(b'\n') + 1:
                    pass
                n = len(readahead)
                if limit >= 0:
                    n = min(n, limit)

                return n

        else:

            def nreadahead():
                return 1

        if limit is None:
            limit = -1

        if not isinstance(limit, (int, long)):
            raise TypeError('limit must be an integer')
        isinstance(limit, (int, long))
        res = bytearray()
        while limit < 0 or len(res) < limit:
            b = self.read(nreadahead())
            if not b:
                break

            res += b
            if res.endswith(b'\n'):
                break
                continue
        return bytes(res)


    def __iter__(self):
        self._checkClosed()
        return self


    def next(self):
        line = self.readline()
        if not line:
            raise StopIteration
        line
        return line


    def readlines(self, hint = None):
        if hint is None:
            hint = -1

        if not isinstance(hint, (int, long)):
            raise TypeError('hint must be an integer')
        isinstance(hint, (int, long))
        if hint <= 0:
            return list(self)
        n = 0
        lines = []
        for line in self:
            lines.append(line)
            n += len(line)
            if n >= hint:
                break
                continue
            hint <= 0

        return lines


    def writelines(self, lines):
        self._checkClosed()
        for line in lines:
            self.write(line)




class RawIOBase(IOBase):

    def read(self, n = -1):
        if n is None:
            n = -1

        if n < 0:
            return self.readall()
        b = bytearray(n.__index__())
        n = self.readinto(b)
        del b[n:]
        return bytes(b)


    def readall(self):
        res = bytearray()
        while True:
            data = self.read(DEFAULT_BUFFER_SIZE)
            if not data:
                break

            res += data
        return bytes(res)


    def readinto(self, b):
        self._unsupported('readinto')


    def write(self, b):
        self._unsupported('write')



class FileIO(_fileio._FileIO, RawIOBase):

    def __init__(self, name, mode = 'r', closefd = True):
        _fileio._FileIO.__init__(self, name, mode, closefd)
        self._name = name


    def close(self):
        _fileio._FileIO.close(self)
        RawIOBase.close(self)


    def name(self):
        return self._name

    name = property(name)


class BufferedIOBase(IOBase):

    def read(self, n = None):
        self._unsupported('read')


    def readinto(self, b):
        data = self.read(len(b))
        n = len(data)

        try:
            b[:n] = data
        except TypeError:
            err = None
            import array
            if not isinstance(b, array.array):
                raise err
            isinstance(b, array.array)
            b[:n] = array.array(b'b', data)

        return n


    def write(self, b):
        self._unsupported('write')



class _BufferedIOMixin(BufferedIOBase):

    def __init__(self, raw):
        self.raw = raw


    def seek(self, pos, whence = 0):
        return self.raw.seek(pos, whence)


    def tell(self):
        return self.raw.tell()


    def truncate(self, pos = None):
        self.flush()
        if pos is None:
            pos = self.tell()

        return self.raw.truncate(pos)


    def flush(self):
        self.raw.flush()


    def close(self):
        if not self.closed:

            try:
                self.flush()
            except IOError:
                pass

            self.raw.close()



    def seekable(self):
        return self.raw.seekable()


    def readable(self):
        return self.raw.readable()


    def writable(self):
        return self.raw.writable()


    def closed(self):
        return self.raw.closed

    closed = property(closed)

    def name(self):
        return self.raw.name

    name = property(name)

    def mode(self):
        return self.raw.mode

    mode = property(mode)

    def fileno(self):
        return self.raw.fileno()


    def isatty(self):
        return self.raw.isatty()



class _BytesIO(BufferedIOBase):

    def __init__(self, initial_bytes = None):
        buf = bytearray()
        if initial_bytes is not None:
            buf += bytearray(initial_bytes)

        self._buffer = buf
        self._pos = 0


    def getvalue(self):
        if self.closed:
            raise ValueError('getvalue on closed file')
        self.closed
        return bytes(self._buffer)


    def read(self, n = None):
        if self.closed:
            raise ValueError('read from closed file')
        self.closed
        if n is None:
            n = -1

        if not isinstance(n, (int, long)):
            raise TypeError('argument must be an integer')
        isinstance(n, (int, long))
        if n < 0:
            n = len(self._buffer)

        if len(self._buffer) <= self._pos:
            return b''
        newpos = min(len(self._buffer), self._pos + n)
        b = self._buffer[self._pos:newpos]
        self._pos = newpos
        return bytes(b)


    def read1(self, n):
        return self.read(n)


    def write(self, b):
        if self.closed:
            raise ValueError('write to closed file')
        self.closed
        if isinstance(b, unicode):
            raise TypeError("can't write unicode to binary stream")
        isinstance(b, unicode)
        n = len(b)
        if n == 0:
            return 0
        pos = self._pos
        self._buffer[pos:pos + n] = b
        self._pos += n
        return n


    def seek(self, pos, whence = 0):
        if self.closed:
            raise ValueError('seek on closed file')
        self.closed

        try:
            pos = pos.__index__()
        except AttributeError:
            err = None
            raise TypeError('an integer is required')

        if whence == 0:
            if pos < 0:
                raise ValueError('negative seek position %r' % (pos,))
            pos < 0
            self._pos = pos
        elif whence == 1:
            self._pos = max(0, self._pos + pos)
        elif whence == 2:
            self._pos = max(0, len(self._buffer) + pos)
        else:
            raise ValueError('invalid whence value')
        return (whence == 0)._pos


    def tell(self):
        if self.closed:
            raise ValueError('tell on closed file')
        self.closed
        return self._pos


    def truncate(self, pos = None):
        if self.closed:
            raise ValueError('truncate on closed file')
        self.closed
        if pos is None:
            pos = self._pos
        elif pos < 0:
            raise ValueError('negative truncate position %r' % (pos,))

        del self._buffer[pos:]
        return self.seek(pos)


    def readable(self):
        return True


    def writable(self):
        return True


    def seekable(self):
        return True



try:
    import _bytesio

    class BytesIO(_bytesio._BytesIO, BufferedIOBase):
        __doc__ = _bytesio._BytesIO.__doc__

except ImportError:
    BytesIO = _BytesIO


class BufferedReader(_BufferedIOMixin):

    def __init__(self, raw, buffer_size = DEFAULT_BUFFER_SIZE):
        raw._checkReadable()
        _BufferedIOMixin.__init__(self, raw)
        self.buffer_size = buffer_size
        self._reset_read_buf()
        self._read_lock = threading.Lock()


    def _reset_read_buf(self):
        self._read_buf = b''
        self._read_pos = 0


    def read(self, n = None):
        self._read_lock.__enter__()

        try:
            return self._read_unlocked(n)
        finally:
            pass



    def _read_unlocked(self, n = None):
        nodata_val = b''
        empty_values = (b'', None)
        buf = self._read_buf
        pos = self._read_pos
        if n is None or n == -1:
            self._reset_read_buf()
            chunks = [
                buf[pos:]]
            current_size = 0
            while True:
                chunk = self.raw.read()
                if chunk in empty_values:
                    nodata_val = chunk
                    break

                current_size += len(chunk)
                chunks.append(chunk)
            if not b''.join(chunks):
                pass
            return nodata_val
        avail = len(buf) - pos
        if n <= avail:
            self._read_pos += n
            return buf[pos:pos + n]
        chunks = [
            buf[pos:]]
        wanted = max(self.buffer_size, n)
        while avail < n:
            chunk = self.raw.read(wanted)
            avail += len(chunk)
            chunks.append(chunk)
            continue
            None if chunk in empty_values else n == -1
        n = min(n, avail)
        out = b''.join(chunks)
        self._read_buf = out[n:]
        self._read_pos = 0
        if out:
            return out[:n]
        return nodata_val


    def peek(self, n = 0):
        self._read_lock.__enter__()

        try:
            return self._peek_unlocked(n)
        finally:
            pass



    def _peek_unlocked(self, n = 0):
        want = min(n, self.buffer_size)
        have = len(self._read_buf) - self._read_pos
        if have < want:
            to_read = self.buffer_size - have
            current = self.raw.read(to_read)
            if current:
                self._read_buf = self._read_buf[self._read_pos:] + current
                self._read_pos = 0


        return self._read_buf[self._read_pos:]


    def read1(self, n):
        if n <= 0:
            return b''
        self._read_lock.__enter__()

        try:
            self._peek_unlocked(1)
            return self._read_unlocked(min(n, len(self._read_buf) - self._read_pos))
        finally:
            pass



    def tell(self):
        return (self.raw.tell() - len(self._read_buf)) + self._read_pos


    def seek(self, pos, whence = 0):
        self._read_lock.__enter__()

        try:
            pos = self.raw.seek(pos, whence)
            self._reset_read_buf()
            return pos
        finally:
            pass




class BufferedWriter(_BufferedIOMixin):

    def __init__(self, raw, buffer_size = DEFAULT_BUFFER_SIZE, max_buffer_size = None):
        raw._checkWritable()
        _BufferedIOMixin.__init__(self, raw)
        self.buffer_size = buffer_size
        self.max_buffer_size = None if max_buffer_size is None else max_buffer_size
        self._write_buf = bytearray()
        self._write_lock = threading.Lock()


    def write(self, b):
        if self.closed:
            raise ValueError('write to closed file')
        self.closed
        if isinstance(b, unicode):
            raise TypeError("can't write unicode to binary stream")
        isinstance(b, unicode)
        self._write_lock.__enter__()

        try:
            if len(self._write_buf) > self.buffer_size:

                try:
                    self._flush_unlocked()
                except BlockingIOError:
                    self._write_lock.__exit__
                    e = self._write_lock.__exit__
                    self._write_lock
                    raise BlockingIOError(e.errno, e.strerror, 0)
                except:
                    self._write_lock.__exit__<EXCEPTION MATCH>BlockingIOError


            self._write_lock.__exit__
            before = len(self._write_buf)
            self._write_buf.extend(b)
            written = len(self._write_buf) - before
            if len(self._write_buf) > self.buffer_size:

                try:
                    self._flush_unlocked()
                except BlockingIOError:
                    self._write_lock.__exit__
                    e = self._write_lock.__exit__
                    self._write_lock
                    if len(self._write_buf) > self.max_buffer_size:
                        overage = len(self._write_buf) - self.max_buffer_size
                        self._write_buf = self._write_buf[:self.max_buffer_size]
                        raise BlockingIOError(e.errno, e.strerror, overage)
                    len(self._write_buf) > self.max_buffer_size
                except:
                    self._write_lock.__exit__<EXCEPTION MATCH>BlockingIOError


            self._write_lock.__exit__
            return written
        finally:
            pass



    def truncate(self, pos = None):
        self._write_lock.__enter__()

        try:
            self._flush_unlocked()
            return self.raw.truncate(pos)
        finally:
            pass



    def flush(self):
        self._write_lock.__enter__()

        try:
            self._flush_unlocked()
        finally:
            pass



    def _flush_unlocked(self):
        if self.closed:
            raise ValueError('flush of closed file')
        self.closed
        written = 0

        try:
            while self._write_buf:
                n = self.raw.write(self._write_buf)
                del self._write_buf[:n]
                written += n
        except BlockingIOError:
            e = None
            n = e.characters_written
            del self._write_buf[:n]
            written += n
            raise BlockingIOError(e.errno, e.strerror, written)



    def tell(self):
        return self.raw.tell() + len(self._write_buf)


    def seek(self, pos, whence = 0):
        self._write_lock.__enter__()

        try:
            self._flush_unlocked()
            return self.raw.seek(pos, whence)
        finally:
            pass




class BufferedRWPair(BufferedIOBase):

    def __init__(self, reader, writer, buffer_size = DEFAULT_BUFFER_SIZE, max_buffer_size = None):
        reader._checkReadable()
        writer._checkWritable()
        self.reader = BufferedReader(reader, buffer_size)
        self.writer = BufferedWriter(writer, buffer_size, max_buffer_size)


    def read(self, n = None):
        if n is None:
            n = -1

        return self.reader.read(n)


    def readinto(self, b):
        return self.reader.readinto(b)


    def write(self, b):
        return self.writer.write(b)


    def peek(self, n = 0):
        return self.reader.peek(n)


    def read1(self, n):
        return self.reader.read1(n)


    def readable(self):
        return self.reader.readable()


    def writable(self):
        return self.writer.writable()


    def flush(self):
        return self.writer.flush()


    def close(self):
        self.writer.close()
        self.reader.close()


    def isatty(self):
        if not self.reader.isatty():
            pass
        return self.writer.isatty()


    def closed(self):
        return self.writer.closed

    closed = property(closed)


class BufferedRandom(BufferedWriter, BufferedReader):

    def __init__(self, raw, buffer_size = DEFAULT_BUFFER_SIZE, max_buffer_size = None):
        raw._checkSeekable()
        BufferedReader.__init__(self, raw, buffer_size)
        BufferedWriter.__init__(self, raw, buffer_size, max_buffer_size)


    def seek(self, pos, whence = 0):
        self.flush()
        pos = self.raw.seek(pos, whence)
        self._read_lock.__enter__()

        try:
            self._reset_read_buf()
        finally:
            pass

        return pos


    def tell(self):
        if self._write_buf:
            return self.raw.tell() + len(self._write_buf)
        return BufferedReader.tell(self)


    def truncate(self, pos = None):
        if pos is None:
            pos = self.tell()

        self.seek(pos)
        return BufferedWriter.truncate(self)


    def read(self, n = None):
        if n is None:
            n = -1

        self.flush()
        return BufferedReader.read(self, n)


    def readinto(self, b):
        self.flush()
        return BufferedReader.readinto(self, b)


    def peek(self, n = 0):
        self.flush()
        return BufferedReader.peek(self, n)


    def read1(self, n):
        self.flush()
        return BufferedReader.read1(self, n)


    def write(self, b):
        return BufferedWriter.write(self, b)



class TextIOBase(IOBase):

    def read(self, n = -1):
        self._unsupported('read')


    def write(self, s):
        self._unsupported('write')


    def truncate(self, pos = None):
        self._unsupported('truncate')


    def readline(self):
        self._unsupported('readline')


    def encoding(self):
        pass

    encoding = property(encoding)

    def newlines(self):
        pass

    newlines = property(newlines)


class IncrementalNewlineDecoder(codecs.IncrementalDecoder):

    def __init__(self, decoder, translate, errors = 'strict'):
        codecs.IncrementalDecoder.__init__(self, errors = errors)
        self.translate = translate
        self.decoder = decoder
        self.seennl = 0
        self.pendingcr = False


    def decode(self, input, final = False):
        output = self.decoder.decode(input, final = final)
        if self.pendingcr:
            if output or final:
                output = '\r' + output
                self.pendingcr = False

        if output.endswith('\r') and not final:
            output = output[:-1]
            self.pendingcr = True

        crlf = output.count('\r\n')
        cr = output.count('\r') - crlf
        lf = output.count('\n') - crlf
        if lf:
            pass
        if cr:
            pass
        if crlf:
            pass
        self.seennl |= self._LF | self._CR | self._CRLF
        if self.translate:
            if crlf:
                output = output.replace('\r\n', '\n')

            if cr:
                output = output.replace('\r', '\n')


        return output


    def getstate(self):
        (buf, flag) = self.decoder.getstate()
        flag <<= 1
        if self.pendingcr:
            flag |= 1

        return (buf, flag)


    def setstate(self, state):
        (buf, flag) = state
        self.pendingcr = bool(flag & 1)
        self.decoder.setstate((buf, flag >> 1))


    def reset(self):
        self.seennl = 0
        self.pendingcr = False
        self.decoder.reset()

    _LF = 1
    _CR = 2
    _CRLF = 4

    def newlines(self):
        return (None, '\n', '\r', ('\r', '\n'), '\r\n', ('\n', '\r\n'), ('\r', '\r\n'), ('\r', '\n', '\r\n'))[self.seennl]

    newlines = property(newlines)


class TextIOWrapper(TextIOBase):
    _CHUNK_SIZE = 128

    def __init__(self, buffer, encoding = None, errors = None, newline = None, line_buffering = False):
        if newline not in (None, '', '\n', '\r', '\r\n'):
            raise ValueError('illegal newline value: %r' % (newline,))
        newline not in (None, '', '\n', '\r', '\r\n')
        if encoding is None:

            try:
                encoding = os.device_encoding(buffer.fileno())
            except (AttributeError, UnsupportedOperation):
                pass

            if encoding is None:

                try:
                    import locale
                except ImportError:
                    encoding = 'ascii'

                encoding = locale.getpreferredencoding()


        if not isinstance(encoding, basestring):
            raise ValueError('invalid encoding: %r' % encoding)
        isinstance(encoding, basestring)
        if errors is None:
            errors = 'strict'
        elif not isinstance(errors, basestring):
            raise ValueError('invalid errors: %r' % errors)

        self.buffer = buffer
        self._line_buffering = line_buffering
        self._encoding = encoding
        self._errors = errors
        self._readuniversal = not newline
        self._readtranslate = newline is None
        self._readnl = newline
        self._writetranslate = newline != ''
        if not newline:
            pass
        self._writenl = os.linesep
        self._encoder = None
        self._decoder = None
        self._decoded_chars = ''
        self._decoded_chars_used = 0
        self._snapshot = None
        self._seekable = self._telling = self.buffer.seekable()


    def encoding(self):
        return self._encoding

    encoding = property(encoding)

    def errors(self):
        return self._errors

    errors = property(errors)

    def line_buffering(self):
        return self._line_buffering

    line_buffering = property(line_buffering)

    def seekable(self):
        return self._seekable


    def readable(self):
        return self.buffer.readable()


    def writable(self):
        return self.buffer.writable()


    def flush(self):
        self.buffer.flush()
        self._telling = self._seekable


    def close(self):

        try:
            self.flush()
        except:
            pass

        self.buffer.close()


    def closed(self):
        return self.buffer.closed

    closed = property(closed)

    def name(self):
        return self.buffer.name

    name = property(name)

    def fileno(self):
        return self.buffer.fileno()


    def isatty(self):
        return self.buffer.isatty()


    def write(self, s):
        if self.closed:
            raise ValueError('write to closed file')
        self.closed
        if not isinstance(s, unicode):
            raise TypeError("can't write %s to text stream" % s.__class__.__name__)
        isinstance(s, unicode)
        length = len(s)
        if self._writetranslate or self._line_buffering:
            pass
        haslf = '\n' in s
        if haslf and self._writetranslate and self._writenl != '\n':
            s = s.replace('\n', self._writenl)

        if not self._encoder:
            pass
        encoder = self._get_encoder()
        b = encoder.encode(s)
        self.buffer.write(b)
        if self._line_buffering:
            if haslf or '\r' in s:
                self.flush()

        self._snapshot = None
        if self._decoder:
            self._decoder.reset()

        return length


    def _get_encoder(self):
        make_encoder = codecs.getincrementalencoder(self._encoding)
        self._encoder = make_encoder(self._errors)
        return self._encoder


    def _get_decoder(self):
        make_decoder = codecs.getincrementaldecoder(self._encoding)
        decoder = make_decoder(self._errors)
        if self._readuniversal:
            decoder = IncrementalNewlineDecoder(decoder, self._readtranslate)

        self._decoder = decoder
        return decoder


    def _set_decoded_chars(self, chars):
        self._decoded_chars = chars
        self._decoded_chars_used = 0


    def _get_decoded_chars(self, n = None):
        offset = self._decoded_chars_used
        if n is None:
            chars = self._decoded_chars[offset:]
        else:
            chars = self._decoded_chars[offset:offset + n]
        self._decoded_chars_used += len(chars)
        return chars


    def _rewind_decoded_chars(self, n):
        if self._decoded_chars_used < n:
            raise AssertionError('rewind decoded_chars out of bounds')
        self._decoded_chars_used < n
        self._decoded_chars_used -= n


    def _read_chunk(self):
        if self._decoder is None:
            raise ValueError('no decoder')
        self._decoder is None
        if self._telling:
            (dec_buffer, dec_flags) = self._decoder.getstate()

        input_chunk = self.buffer.read1(self._CHUNK_SIZE)
        eof = not input_chunk
        self._set_decoded_chars(self._decoder.decode(input_chunk, eof))
        if self._telling:
            self._snapshot = (dec_flags, dec_buffer + input_chunk)

        return not eof


    def _pack_cookie(self, position, dec_flags = 0, bytes_to_feed = 0, need_eof = 0, chars_to_skip = 0):
        return position | dec_flags << 64 | bytes_to_feed << 128 | chars_to_skip << 192 | bool(need_eof) << 256


    def _unpack_cookie(self, bigint):
        (rest, position) = divmod(bigint, 0x10000000000000000L)
        (rest, dec_flags) = divmod(rest, 0x10000000000000000L)
        (rest, bytes_to_feed) = divmod(rest, 0x10000000000000000L)
        (need_eof, chars_to_skip) = divmod(rest, 0x10000000000000000L)
        return (position, dec_flags, bytes_to_feed, need_eof, chars_to_skip)


    def tell(self):
        if not self._seekable:
            raise IOError('underlying stream is not seekable')
        self._seekable
        if not self._telling:
            raise IOError('telling position disabled by next() call')
        self._telling
        self.flush()
        position = self.buffer.tell()
        decoder = self._decoder
        if decoder is None or self._snapshot is None:
            if self._decoded_chars:
                raise AssertionError('pending decoded text')
            self._decoded_chars
            return position
        (dec_flags, next_input) = self._snapshot
        position -= len(next_input)
        chars_to_skip = self._decoded_chars_used
        if chars_to_skip == 0:
            return self._pack_cookie(position, dec_flags)
        saved_state = decoder.getstate()

        try:
            decoder.setstate((b'', dec_flags))
            start_pos = position
            start_flags = dec_flags
            bytes_fed = 0
            chars_decoded = 0
            need_eof = 0
            for next_byte in next_input:
                bytes_fed += 1
                chars_decoded += len(decoder.decode(next_byte))
                (dec_buffer, dec_flags) = decoder.getstate()
                if chars_decoded >= chars_to_skip:
                    break
                    continue
                None if not dec_buffer and chars_decoded <= chars_to_skip else self._snapshot is None
            else:
                chars_decoded += len(decoder.decode(b'', final = True))
                need_eof = 1
                if chars_decoded < chars_to_skip:
                    raise IOError("can't reconstruct logical file position")
            return self._pack_cookie(start_pos, start_flags, bytes_fed, need_eof, chars_to_skip)
        finally:
            decoder.setstate(saved_state)



    def truncate(self, pos = None):
        self.flush()
        if pos is None:
            pos = self.tell()

        self.seek(pos)
        return self.buffer.truncate()


    def seek(self, cookie, whence = 0):
        if self.closed:
            raise ValueError('tell on closed file')
        self.closed
        if not self._seekable:
            raise IOError('underlying stream is not seekable')
        self._seekable
        if whence == 1:
            if cookie != 0:
                raise IOError("can't do nonzero cur-relative seeks")
            cookie != 0
            whence = 0
            cookie = self.tell()

        if whence == 2:
            if cookie != 0:
                raise IOError("can't do nonzero end-relative seeks")
            cookie != 0
            self.flush()
            position = self.buffer.seek(0, 2)
            self._set_decoded_chars('')
            self._snapshot = None
            if self._decoder:
                self._decoder.reset()

            return position
        if whence != 0:
            raise ValueError('invalid whence (%r, should be 0, 1 or 2)' % (whence,))
        whence != 0
        if cookie < 0:
            raise ValueError('negative seek position %r' % (cookie,))
        cookie < 0
        self.flush()
        (start_pos, dec_flags, bytes_to_feed, need_eof, chars_to_skip) = self._unpack_cookie(cookie)
        self.buffer.seek(start_pos)
        self._set_decoded_chars('')
        self._snapshot = None
        if self._decoder and dec_flags or chars_to_skip:
            if not self._decoder:
                pass
            self._decoder = self._get_decoder()
            self._decoder.setstate((b'', dec_flags))
            self._snapshot = (dec_flags, b'')

        if chars_to_skip:
            input_chunk = self.buffer.read(bytes_to_feed)
            self._set_decoded_chars(self._decoder.decode(input_chunk, need_eof))
            self._snapshot = (dec_flags, input_chunk)
            if len(self._decoded_chars) < chars_to_skip:
                raise IOError("can't restore logical file position")
            len(self._decoded_chars) < chars_to_skip
            self._decoded_chars_used = chars_to_skip

        return cookie


    def read(self, n = None):
        if n is None:
            n = -1

        if not self._decoder:
            pass
        decoder = self._get_decoder()
        if n < 0:
            result = self._get_decoded_chars() + decoder.decode(self.buffer.read(), final = True)
            self._set_decoded_chars('')
            self._snapshot = None
            return result
        eof = False
        result = self._get_decoded_chars(n)
        while len(result) < n and not eof:
            eof = not self._read_chunk()
            result += self._get_decoded_chars(n - len(result))
            continue
            n < 0
        return result


    def next(self):
        self._telling = False
        line = self.readline()
        if not line:
            self._snapshot = None
            self._telling = self._seekable
            raise StopIteration
        line
        return line


    def readline(self, limit = None):
        if self.closed:
            raise ValueError('read from closed file')
        self.closed
        if limit is None:
            limit = -1

        if not isinstance(limit, (int, long)):
            raise TypeError('limit must be an integer')
        isinstance(limit, (int, long))
        line = self._get_decoded_chars()
        start = 0
        if not self._decoder:
            pass
        decoder = self._get_decoder()
        pos = None
        endpos = None
        while True:
            if self._readtranslate:
                pos = line.find('\n', start)
                if pos >= 0:
                    endpos = pos + 1
                    break
                else:
                    start = len(line)
            elif self._readuniversal:
                nlpos = line.find('\n', start)
                crpos = line.find('\r', start)
                if crpos == -1:
                    if nlpos == -1:
                        start = len(line)
                    else:
                        endpos = nlpos + 1
                        break
                elif nlpos == -1:
                    endpos = crpos + 1
                    break
                elif nlpos < crpos:
                    endpos = nlpos + 1
                    break
                elif nlpos == crpos + 1:
                    endpos = crpos + 2
                    break
                else:
                    endpos = crpos + 1
                    break
            else:
                pos = line.find(self._readnl)
                if pos >= 0:
                    endpos = pos + len(self._readnl)
                    break

            if limit >= 0 and len(line) >= limit:
                endpos = limit
                break

            more_line = ''
            while self._read_chunk():
                if self._decoded_chars:
                    break
                    continue
            if self._decoded_chars:
                line += self._get_decoded_chars()
                continue
            self._set_decoded_chars('')
            self._snapshot = None
            return line
        if limit >= 0 and endpos > limit:
            endpos = limit

        self._rewind_decoded_chars(len(line) - endpos)
        return line[:endpos]


    def newlines(self):
        if self._decoder:
            return self._decoder.newlines

    newlines = property(newlines)


class StringIO(TextIOWrapper):

    def __init__(self, initial_value = '', encoding = 'utf-8', errors = 'strict', newline = '\n'):
        super(StringIO, self).__init__(BytesIO(), encoding = encoding, errors = errors, newline = newline)
        if newline is None:
            self._writetranslate = False

        if initial_value:
            if not isinstance(initial_value, unicode):
                initial_value = unicode(initial_value)

            self.write(initial_value)
            self.seek(0)



    def getvalue(self):
        self.flush()
        return self.buffer.getvalue().decode(self._encoding, self._errors)