+++ /dev/null
-"""\r
-Python implementation of the io module.\r
-"""\r
-\r
-from __future__ import (print_function, unicode_literals)\r
-\r
-import os\r
-import abc\r
-import codecs\r
-import warnings\r
-# Import thread instead of threading to reduce startup cost\r
-try:\r
- from thread import allocate_lock as Lock\r
-except ImportError:\r
- from dummy_thread import allocate_lock as Lock\r
-\r
-import io\r
-from io import (__all__, SEEK_SET, SEEK_CUR, SEEK_END)\r
-from errno import EINTR\r
-\r
-__metaclass__ = type\r
-\r
-# open() uses st_blksize whenever we can\r
-DEFAULT_BUFFER_SIZE = 8 * 1024 # bytes\r
-\r
-# NOTE: Base classes defined here are registered with the "official" ABCs\r
-# defined in io.py. We don't use real inheritance though, because we don't\r
-# want to inherit the C implementations.\r
-\r
-\r
-class BlockingIOError(IOError):\r
-\r
- """Exception raised when I/O would block on a non-blocking I/O stream."""\r
-\r
- def __init__(self, errno, strerror, characters_written=0):\r
- super(IOError, self).__init__(errno, strerror)\r
- if not isinstance(characters_written, (int, long)):\r
- raise TypeError("characters_written must be a integer")\r
- self.characters_written = characters_written\r
-\r
-\r
-def open(file, mode="r", buffering=-1,\r
- encoding=None, errors=None,\r
- newline=None, closefd=True):\r
-\r
- r"""Open file and return a stream. Raise IOError upon failure.\r
-\r
- file is either a text or byte string giving the name (and the path\r
- if the file isn't in the current working directory) of the file to\r
- be opened or an integer file descriptor of the file to be\r
- wrapped. (If a file descriptor is given, it is closed when the\r
- returned I/O object is closed, unless closefd is set to False.)\r
-\r
- mode is an optional string that specifies the mode in which the file\r
- is opened. It defaults to 'r' which means open for reading in text\r
- mode. Other common values are 'w' for writing (truncating the file if\r
- it already exists), and 'a' for appending (which on some Unix systems,\r
- means that all writes append to the end of the file regardless of the\r
- current seek position). In text mode, if encoding is not specified the\r
- encoding used is platform dependent. (For reading and writing raw\r
- bytes use binary mode and leave encoding unspecified.) The available\r
- modes are:\r
-\r
- ========= ===============================================================\r
- Character Meaning\r
- --------- ---------------------------------------------------------------\r
- 'r' open for reading (default)\r
- 'w' open for writing, truncating the file first\r
- 'a' open for writing, appending to the end of the file if it exists\r
- 'b' binary mode\r
- 't' text mode (default)\r
- '+' open a disk file for updating (reading and writing)\r
- 'U' universal newline mode (for backwards compatibility; unneeded\r
- for new code)\r
- ========= ===============================================================\r
-\r
- The default mode is 'rt' (open for reading text). For binary random\r
- access, the mode 'w+b' opens and truncates the file to 0 bytes, while\r
- 'r+b' opens the file without truncation.\r
-\r
- Python distinguishes between files opened in binary and text modes,\r
- even when the underlying operating system doesn't. Files opened in\r
- binary mode (appending 'b' to the mode argument) return contents as\r
- bytes objects without any decoding. In text mode (the default, or when\r
- 't' is appended to the mode argument), the contents of the file are\r
- returned as strings, the bytes having been first decoded using a\r
- platform-dependent encoding or using the specified encoding if given.\r
-\r
- buffering is an optional integer used to set the buffering policy.\r
- Pass 0 to switch buffering off (only allowed in binary mode), 1 to select\r
- line buffering (only usable in text mode), and an integer > 1 to indicate\r
- the size of a fixed-size chunk buffer. When no buffering argument is\r
- given, the default buffering policy works as follows:\r
-\r
- * Binary files are buffered in fixed-size chunks; the size of the buffer\r
- is chosen using a heuristic trying to determine the underlying device's\r
- "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.\r
- On many systems, the buffer will typically be 4096 or 8192 bytes long.\r
-\r
- * "Interactive" text files (files for which isatty() returns True)\r
- use line buffering. Other text files use the policy described above\r
- for binary files.\r
-\r
- encoding is the name of the encoding used to decode or encode the\r
- file. This should only be used in text mode. The default encoding is\r
- platform dependent, but any encoding supported by Python can be\r
- passed. See the codecs module for the list of supported encodings.\r
-\r
- errors is an optional string that specifies how encoding errors are to\r
- be handled---this argument should not be used in binary mode. Pass\r
- 'strict' to raise a ValueError exception if there is an encoding error\r
- (the default of None has the same effect), or pass 'ignore' to ignore\r
- errors. (Note that ignoring encoding errors can lead to data loss.)\r
- See the documentation for codecs.register for a list of the permitted\r
- encoding error strings.\r
-\r
- newline controls how universal newlines works (it only applies to text\r
- mode). It can be None, '', '\n', '\r', and '\r\n'. It works as\r
- follows:\r
-\r
- * On input, if newline is None, universal newlines mode is\r
- enabled. Lines in the input can end in '\n', '\r', or '\r\n', and\r
- these are translated into '\n' before being returned to the\r
- caller. If it is '', universal newline mode is enabled, but line\r
- endings are returned to the caller untranslated. If it has any of\r
- the other legal values, input lines are only terminated by the given\r
- string, and the line ending is returned to the caller untranslated.\r
-\r
- * On output, if newline is None, any '\n' characters written are\r
- translated to the system default line separator, os.linesep. If\r
- newline is '', no translation takes place. If newline is any of the\r
- other legal values, any '\n' characters written are translated to\r
- the given string.\r
-\r
- If closefd is False, the underlying file descriptor will be kept open\r
- when the file is closed. This does not work when a file name is given\r
- and must be True in that case.\r
-\r
- open() returns a file object whose type depends on the mode, and\r
- through which the standard file operations such as reading and writing\r
- are performed. When open() is used to open a file in a text mode ('w',\r
- 'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\r
- a file in a binary mode, the returned class varies: in read binary\r
- mode, it returns a BufferedReader; in write binary and append binary\r
- modes, it returns a BufferedWriter, and in read/write mode, it returns\r
- a BufferedRandom.\r
-\r
- It is also possible to use a string or bytearray as a file for both\r
- reading and writing. For strings StringIO can be used like a file\r
- opened in a text mode, and for bytes a BytesIO can be used like a file\r
- opened in a binary mode.\r
- """\r
- if not isinstance(file, (basestring, int, long)):\r
- raise TypeError("invalid file: %r" % file)\r
- if not isinstance(mode, basestring):\r
- raise TypeError("invalid mode: %r" % mode)\r
- if not isinstance(buffering, (int, long)):\r
- raise TypeError("invalid buffering: %r" % buffering)\r
- if encoding is not None and not isinstance(encoding, basestring):\r
- raise TypeError("invalid encoding: %r" % encoding)\r
- if errors is not None and not isinstance(errors, basestring):\r
- raise TypeError("invalid errors: %r" % errors)\r
- modes = set(mode)\r
- if modes - set("arwb+tU") or len(mode) > len(modes):\r
- raise ValueError("invalid mode: %r" % mode)\r
- reading = "r" in modes\r
- writing = "w" in modes\r
- appending = "a" in modes\r
- updating = "+" in modes\r
- text = "t" in modes\r
- binary = "b" in modes\r
- if "U" in modes:\r
- if writing or appending:\r
- raise ValueError("can't use U and writing mode at once")\r
- reading = True\r
- if text and binary:\r
- raise ValueError("can't have text and binary mode at once")\r
- if reading + writing + appending > 1:\r
- raise ValueError("can't have read/write/append mode at once")\r
- if not (reading or writing or appending):\r
- raise ValueError("must have exactly one of read/write/append mode")\r
- if binary and encoding is not None:\r
- raise ValueError("binary mode doesn't take an encoding argument")\r
- if binary and errors is not None:\r
- raise ValueError("binary mode doesn't take an errors argument")\r
- if binary and newline is not None:\r
- raise ValueError("binary mode doesn't take a newline argument")\r
- raw = FileIO(file,\r
- (reading and "r" or "") +\r
- (writing and "w" or "") +\r
- (appending and "a" or "") +\r
- (updating and "+" or ""),\r
- closefd)\r
- line_buffering = False\r
- if buffering == 1 or buffering < 0 and raw.isatty():\r
- buffering = -1\r
- line_buffering = True\r
- if buffering < 0:\r
- buffering = DEFAULT_BUFFER_SIZE\r
- try:\r
- bs = os.fstat(raw.fileno()).st_blksize\r
- except (os.error, AttributeError):\r
- pass\r
- else:\r
- if bs > 1:\r
- buffering = bs\r
- if buffering < 0:\r
- raise ValueError("invalid buffering size")\r
- if buffering == 0:\r
- if binary:\r
- return raw\r
- raise ValueError("can't have unbuffered text I/O")\r
- if updating:\r
- buffer = BufferedRandom(raw, buffering)\r
- elif writing or appending:\r
- buffer = BufferedWriter(raw, buffering)\r
- elif reading:\r
- buffer = BufferedReader(raw, buffering)\r
- else:\r
- raise ValueError("unknown mode: %r" % mode)\r
- if binary:\r
- return buffer\r
- text = TextIOWrapper(buffer, encoding, errors, newline, line_buffering)\r
- text.mode = mode\r
- return text\r
-\r
-\r
-class DocDescriptor:\r
- """Helper for builtins.open.__doc__\r
- """\r
- def __get__(self, obj, typ):\r
- return (\r
- "open(file, mode='r', buffering=-1, encoding=None, "\r
- "errors=None, newline=None, closefd=True)\n\n" +\r
- open.__doc__)\r
-\r
-class OpenWrapper:\r
- """Wrapper for builtins.open\r
-\r
- Trick so that open won't become a bound method when stored\r
- as a class variable (as dbm.dumb does).\r
-\r
- See initstdio() in Python/pythonrun.c.\r
- """\r
- __doc__ = DocDescriptor()\r
-\r
- def __new__(cls, *args, **kwargs):\r
- return open(*args, **kwargs)\r
-\r
-\r
-class UnsupportedOperation(ValueError, IOError):\r
- pass\r
-\r
-\r
-class IOBase:\r
- __metaclass__ = abc.ABCMeta\r
-\r
- """The abstract base class for all I/O classes, acting on streams of\r
- bytes. There is no public constructor.\r
-\r
- This class provides dummy implementations for many methods that\r
- derived classes can override selectively; the default implementations\r
- represent a file that cannot be read, written or seeked.\r
-\r
- Even though IOBase does not declare read, readinto, or write because\r
- their signatures will vary, implementations and clients should\r
- consider those methods part of the interface. Also, implementations\r
- may raise a IOError when operations they do not support are called.\r
-\r
- The basic type used for binary data read from or written to a file is\r
- bytes. bytearrays are accepted too, and in some cases (such as\r
- readinto) needed. Text I/O classes work with str data.\r
-\r
- Note that calling any method (even inquiries) on a closed stream is\r
- undefined. Implementations may raise IOError in this case.\r
-\r
- IOBase (and its subclasses) support the iterator protocol, meaning\r
- that an IOBase object can be iterated over yielding the lines in a\r
- stream.\r
-\r
- IOBase also supports the :keyword:`with` statement. In this example,\r
- fp is closed after the suite of the with statement is complete:\r
-\r
- with open('spam.txt', 'r') as fp:\r
- fp.write('Spam and eggs!')\r
- """\r
-\r
- ### Internal ###\r
-\r
- def _unsupported(self, name):\r
- """Internal: raise an exception for unsupported operations."""\r
- raise UnsupportedOperation("%s.%s() not supported" %\r
- (self.__class__.__name__, name))\r
-\r
- ### Positioning ###\r
-\r
- def seek(self, pos, whence=0):\r
- """Change stream position.\r
-\r
- Change the stream position to byte offset offset. offset is\r
- interpreted relative to the position indicated by whence. Values\r
- for whence are:\r
-\r
- * 0 -- start of stream (the default); offset should be zero or positive\r
- * 1 -- current stream position; offset may be negative\r
- * 2 -- end of stream; offset is usually negative\r
-\r
- Return the new absolute position.\r
- """\r
- self._unsupported("seek")\r
-\r
- def tell(self):\r
- """Return current stream position."""\r
- return self.seek(0, 1)\r
-\r
- def truncate(self, pos=None):\r
- """Truncate file to size bytes.\r
-\r
- Size defaults to the current IO position as reported by tell(). Return\r
- the new size.\r
- """\r
- self._unsupported("truncate")\r
-\r
- ### Flush and close ###\r
-\r
- def flush(self):\r
- """Flush write buffers, if applicable.\r
-\r
- This is not implemented for read-only and non-blocking streams.\r
- """\r
- self._checkClosed()\r
- # XXX Should this return the number of bytes written???\r
-\r
- __closed = False\r
-\r
- def close(self):\r
- """Flush and close the IO object.\r
-\r
- This method has no effect if the file is already closed.\r
- """\r
- if not self.__closed:\r
- self.flush()\r
- self.__closed = True\r
-\r
- def __del__(self):\r
- """Destructor. Calls close()."""\r
- # The try/except block is in case this is called at program\r
- # exit time, when it's possible that globals have already been\r
- # deleted, and then the close() call might fail. Since\r
- # there's nothing we can do about such failures and they annoy\r
- # the end users, we suppress the traceback.\r
- try:\r
- self.close()\r
- except:\r
- pass\r
-\r
- ### Inquiries ###\r
-\r
- def seekable(self):\r
- """Return whether object supports random access.\r
-\r
- If False, seek(), tell() and truncate() will raise IOError.\r
- This method may need to do a test seek().\r
- """\r
- return False\r
-\r
- def _checkSeekable(self, msg=None):\r
- """Internal: raise an IOError if file is not seekable\r
- """\r
- if not self.seekable():\r
- raise IOError("File or stream is not seekable."\r
- if msg is None else msg)\r
-\r
-\r
- def readable(self):\r
- """Return whether object was opened for reading.\r
-\r
- If False, read() will raise IOError.\r
- """\r
- return False\r
-\r
- def _checkReadable(self, msg=None):\r
- """Internal: raise an IOError if file is not readable\r
- """\r
- if not self.readable():\r
- raise IOError("File or stream is not readable."\r
- if msg is None else msg)\r
-\r
- def writable(self):\r
- """Return whether object was opened for writing.\r
-\r
- If False, write() and truncate() will raise IOError.\r
- """\r
- return False\r
-\r
- def _checkWritable(self, msg=None):\r
- """Internal: raise an IOError if file is not writable\r
- """\r
- if not self.writable():\r
- raise IOError("File or stream is not writable."\r
- if msg is None else msg)\r
-\r
- @property\r
- def closed(self):\r
- """closed: bool. True iff the file has been closed.\r
-\r
- For backwards compatibility, this is a property, not a predicate.\r
- """\r
- return self.__closed\r
-\r
- def _checkClosed(self, msg=None):\r
- """Internal: raise an ValueError if file is closed\r
- """\r
- if self.closed:\r
- raise ValueError("I/O operation on closed file."\r
- if msg is None else msg)\r
-\r
- ### Context manager ###\r
-\r
- def __enter__(self):\r
- """Context management protocol. Returns self."""\r
- self._checkClosed()\r
- return self\r
-\r
- def __exit__(self, *args):\r
- """Context management protocol. Calls close()"""\r
- self.close()\r
-\r
- ### Lower-level APIs ###\r
-\r
- # XXX Should these be present even if unimplemented?\r
-\r
- def fileno(self):\r
- """Returns underlying file descriptor if one exists.\r
-\r
- An IOError is raised if the IO object does not use a file descriptor.\r
- """\r
- self._unsupported("fileno")\r
-\r
- def isatty(self):\r
- """Return whether this is an 'interactive' stream.\r
-\r
- Return False if it can't be determined.\r
- """\r
- self._checkClosed()\r
- return False\r
-\r
- ### Readline[s] and writelines ###\r
-\r
- def readline(self, limit=-1):\r
- r"""Read and return a line from the stream.\r
-\r
- If limit is specified, at most limit bytes will be read.\r
-\r
- The line terminator is always b'\n' for binary files; for text\r
- files, the newlines argument to open can be used to select the line\r
- terminator(s) recognized.\r
- """\r
- # For backwards compatibility, a (slowish) readline().\r
- if hasattr(self, "peek"):\r
- def nreadahead():\r
- readahead = self.peek(1)\r
- if not readahead:\r
- return 1\r
- n = (readahead.find(b"\n") + 1) or len(readahead)\r
- if limit >= 0:\r
- n = min(n, limit)\r
- return n\r
- else:\r
- def nreadahead():\r
- return 1\r
- if limit is None:\r
- limit = -1\r
- elif not isinstance(limit, (int, long)):\r
- raise TypeError("limit must be an integer")\r
- res = bytearray()\r
- while limit < 0 or len(res) < limit:\r
- b = self.read(nreadahead())\r
- if not b:\r
- break\r
- res += b\r
- if res.endswith(b"\n"):\r
- break\r
- return bytes(res)\r
-\r
- def __iter__(self):\r
- self._checkClosed()\r
- return self\r
-\r
- def next(self):\r
- line = self.readline()\r
- if not line:\r
- raise StopIteration\r
- return line\r
-\r
- def readlines(self, hint=None):\r
- """Return a list of lines from the stream.\r
-\r
- hint can be specified to control the number of lines read: no more\r
- lines will be read if the total size (in bytes/characters) of all\r
- lines so far exceeds hint.\r
- """\r
- if hint is not None and not isinstance(hint, (int, long)):\r
- raise TypeError("integer or None expected")\r
- if hint is None or hint <= 0:\r
- return list(self)\r
- n = 0\r
- lines = []\r
- for line in self:\r
- lines.append(line)\r
- n += len(line)\r
- if n >= hint:\r
- break\r
- return lines\r
-\r
- def writelines(self, lines):\r
- self._checkClosed()\r
- for line in lines:\r
- self.write(line)\r
-\r
-io.IOBase.register(IOBase)\r
-\r
-\r
-class RawIOBase(IOBase):\r
-\r
- """Base class for raw binary I/O."""\r
-\r
- # The read() method is implemented by calling readinto(); derived\r
- # classes that want to support read() only need to implement\r
- # readinto() as a primitive operation. In general, readinto() can be\r
- # more efficient than read().\r
-\r
- # (It would be tempting to also provide an implementation of\r
- # readinto() in terms of read(), in case the latter is a more suitable\r
- # primitive operation, but that would lead to nasty recursion in case\r
- # a subclass doesn't implement either.)\r
-\r
- def read(self, n=-1):\r
- """Read and return up to n bytes.\r
-\r
- Returns an empty bytes object on EOF, or None if the object is\r
- set not to block and has no data to read.\r
- """\r
- if n is None:\r
- n = -1\r
- if n < 0:\r
- return self.readall()\r
- b = bytearray(n.__index__())\r
- n = self.readinto(b)\r
- if n is None:\r
- return None\r
- del b[n:]\r
- return bytes(b)\r
-\r
- def readall(self):\r
- """Read until EOF, using multiple read() call."""\r
- res = bytearray()\r
- while True:\r
- data = self.read(DEFAULT_BUFFER_SIZE)\r
- if not data:\r
- break\r
- res += data\r
- if res:\r
- return bytes(res)\r
- else:\r
- # b'' or None\r
- return data\r
-\r
- def readinto(self, b):\r
- """Read up to len(b) bytes into b.\r
-\r
- Returns number of bytes read (0 for EOF), or None if the object\r
- is set not to block and has no data to read.\r
- """\r
- self._unsupported("readinto")\r
-\r
- def write(self, b):\r
- """Write the given buffer to the IO stream.\r
-\r
- Returns the number of bytes written, which may be less than len(b).\r
- """\r
- self._unsupported("write")\r
-\r
-io.RawIOBase.register(RawIOBase)\r
-from _io import FileIO\r
-RawIOBase.register(FileIO)\r
-\r
-\r
-class BufferedIOBase(IOBase):\r
-\r
- """Base class for buffered IO objects.\r
-\r
- The main difference with RawIOBase is that the read() method\r
- supports omitting the size argument, and does not have a default\r
- implementation that defers to readinto().\r
-\r
- In addition, read(), readinto() and write() may raise\r
- BlockingIOError if the underlying raw stream is in non-blocking\r
- mode and not ready; unlike their raw counterparts, they will never\r
- return None.\r
-\r
- A typical implementation should not inherit from a RawIOBase\r
- implementation, but wrap one.\r
- """\r
-\r
- def read(self, n=None):\r
- """Read and return up to n bytes.\r
-\r
- If the argument is omitted, None, or negative, reads and\r
- returns all data until EOF.\r
-\r
- If the argument is positive, and the underlying raw stream is\r
- not 'interactive', multiple raw reads may be issued to satisfy\r
- the byte count (unless EOF is reached first). But for\r
- interactive raw streams (XXX and for pipes?), at most one raw\r
- read will be issued, and a short result does not imply that\r
- EOF is imminent.\r
-\r
- Returns an empty bytes array on EOF.\r
-\r
- Raises BlockingIOError if the underlying raw stream has no\r
- data at the moment.\r
- """\r
- self._unsupported("read")\r
-\r
- def read1(self, n=None):\r
- """Read up to n bytes with at most one read() system call."""\r
- self._unsupported("read1")\r
-\r
- def readinto(self, b):\r
- """Read up to len(b) bytes into b.\r
-\r
- Like read(), this may issue multiple reads to the underlying raw\r
- stream, unless the latter is 'interactive'.\r
-\r
- Returns the number of bytes read (0 for EOF).\r
-\r
- Raises BlockingIOError if the underlying raw stream has no\r
- data at the moment.\r
- """\r
- # XXX This ought to work with anything that supports the buffer API\r
- data = self.read(len(b))\r
- n = len(data)\r
- try:\r
- b[:n] = data\r
- except TypeError as err:\r
- import array\r
- if not isinstance(b, array.array):\r
- raise err\r
- b[:n] = array.array(b'b', data)\r
- return n\r
-\r
- def write(self, b):\r
- """Write the given buffer to the IO stream.\r
-\r
- Return the number of bytes written, which is never less than\r
- len(b).\r
-\r
- Raises BlockingIOError if the buffer is full and the\r
- underlying raw stream cannot accept more data at the moment.\r
- """\r
- self._unsupported("write")\r
-\r
- def detach(self):\r
- """\r
- Separate the underlying raw stream from the buffer and return it.\r
-\r
- After the raw stream has been detached, the buffer is in an unusable\r
- state.\r
- """\r
- self._unsupported("detach")\r
-\r
-io.BufferedIOBase.register(BufferedIOBase)\r
-\r
-\r
-class _BufferedIOMixin(BufferedIOBase):\r
-\r
- """A mixin implementation of BufferedIOBase with an underlying raw stream.\r
-\r
- This passes most requests on to the underlying raw stream. It\r
- does *not* provide implementations of read(), readinto() or\r
- write().\r
- """\r
-\r
- def __init__(self, raw):\r
- self._raw = raw\r
-\r
- ### Positioning ###\r
-\r
- def seek(self, pos, whence=0):\r
- new_position = self.raw.seek(pos, whence)\r
- if new_position < 0:\r
- raise IOError("seek() returned an invalid position")\r
- return new_position\r
-\r
- def tell(self):\r
- pos = self.raw.tell()\r
- if pos < 0:\r
- raise IOError("tell() returned an invalid position")\r
- return pos\r
-\r
- def truncate(self, pos=None):\r
- # Flush the stream. We're mixing buffered I/O with lower-level I/O,\r
- # and a flush may be necessary to synch both views of the current\r
- # file state.\r
- self.flush()\r
-\r
- if pos is None:\r
- pos = self.tell()\r
- # XXX: Should seek() be used, instead of passing the position\r
- # XXX directly to truncate?\r
- return self.raw.truncate(pos)\r
-\r
- ### Flush and close ###\r
-\r
- def flush(self):\r
- if self.closed:\r
- raise ValueError("flush of closed file")\r
- self.raw.flush()\r
-\r
- def close(self):\r
- if self.raw is not None and not self.closed:\r
- self.flush()\r
- self.raw.close()\r
-\r
- def detach(self):\r
- if self.raw is None:\r
- raise ValueError("raw stream already detached")\r
- self.flush()\r
- raw = self._raw\r
- self._raw = None\r
- return raw\r
-\r
- ### Inquiries ###\r
-\r
- def seekable(self):\r
- return self.raw.seekable()\r
-\r
- def readable(self):\r
- return self.raw.readable()\r
-\r
- def writable(self):\r
- return self.raw.writable()\r
-\r
- @property\r
- def raw(self):\r
- return self._raw\r
-\r
- @property\r
- def closed(self):\r
- return self.raw.closed\r
-\r
- @property\r
- def name(self):\r
- return self.raw.name\r
-\r
- @property\r
- def mode(self):\r
- return self.raw.mode\r
-\r
- def __repr__(self):\r
- clsname = self.__class__.__name__\r
- try:\r
- name = self.name\r
- except AttributeError:\r
- return "<_pyio.{0}>".format(clsname)\r
- else:\r
- return "<_pyio.{0} name={1!r}>".format(clsname, name)\r
-\r
- ### Lower-level APIs ###\r
-\r
- def fileno(self):\r
- return self.raw.fileno()\r
-\r
- def isatty(self):\r
- return self.raw.isatty()\r
-\r
-\r
-class BytesIO(BufferedIOBase):\r
-\r
- """Buffered I/O implementation using an in-memory bytes buffer."""\r
-\r
- def __init__(self, initial_bytes=None):\r
- buf = bytearray()\r
- if initial_bytes is not None:\r
- buf.extend(initial_bytes)\r
- self._buffer = buf\r
- self._pos = 0\r
-\r
- def __getstate__(self):\r
- if self.closed:\r
- raise ValueError("__getstate__ on closed file")\r
- return self.__dict__.copy()\r
-\r
- def getvalue(self):\r
- """Return the bytes value (contents) of the buffer\r
- """\r
- if self.closed:\r
- raise ValueError("getvalue on closed file")\r
- return bytes(self._buffer)\r
-\r
- def read(self, n=None):\r
- if self.closed:\r
- raise ValueError("read from closed file")\r
- if n is None:\r
- n = -1\r
- if not isinstance(n, (int, long)):\r
- raise TypeError("integer argument expected, got {0!r}".format(\r
- type(n)))\r
- if n < 0:\r
- n = len(self._buffer)\r
- if len(self._buffer) <= self._pos:\r
- return b""\r
- newpos = min(len(self._buffer), self._pos + n)\r
- b = self._buffer[self._pos : newpos]\r
- self._pos = newpos\r
- return bytes(b)\r
-\r
- def read1(self, n):\r
- """This is the same as read.\r
- """\r
- return self.read(n)\r
-\r
- def write(self, b):\r
- if self.closed:\r
- raise ValueError("write to closed file")\r
- if isinstance(b, unicode):\r
- raise TypeError("can't write unicode to binary stream")\r
- n = len(b)\r
- if n == 0:\r
- return 0\r
- pos = self._pos\r
- if pos > len(self._buffer):\r
- # Inserts null bytes between the current end of the file\r
- # and the new write position.\r
- padding = b'\x00' * (pos - len(self._buffer))\r
- self._buffer += padding\r
- self._buffer[pos:pos + n] = b\r
- self._pos += n\r
- return n\r
-\r
- def seek(self, pos, whence=0):\r
- if self.closed:\r
- raise ValueError("seek on closed file")\r
- try:\r
- pos.__index__\r
- except AttributeError:\r
- raise TypeError("an integer is required")\r
- if whence == 0:\r
- if pos < 0:\r
- raise ValueError("negative seek position %r" % (pos,))\r
- self._pos = pos\r
- elif whence == 1:\r
- self._pos = max(0, self._pos + pos)\r
- elif whence == 2:\r
- self._pos = max(0, len(self._buffer) + pos)\r
- else:\r
- raise ValueError("invalid whence value")\r
- return self._pos\r
-\r
- def tell(self):\r
- if self.closed:\r
- raise ValueError("tell on closed file")\r
- return self._pos\r
-\r
- def truncate(self, pos=None):\r
- if self.closed:\r
- raise ValueError("truncate on closed file")\r
- if pos is None:\r
- pos = self._pos\r
- else:\r
- try:\r
- pos.__index__\r
- except AttributeError:\r
- raise TypeError("an integer is required")\r
- if pos < 0:\r
- raise ValueError("negative truncate position %r" % (pos,))\r
- del self._buffer[pos:]\r
- return pos\r
-\r
- def readable(self):\r
- return True\r
-\r
- def writable(self):\r
- return True\r
-\r
- def seekable(self):\r
- return True\r
-\r
-\r
-class BufferedReader(_BufferedIOMixin):\r
-\r
- """BufferedReader(raw[, buffer_size])\r
-\r
- A buffer for a readable, sequential BaseRawIO object.\r
-\r
- The constructor creates a BufferedReader for the given readable raw\r
- stream and buffer_size. If buffer_size is omitted, DEFAULT_BUFFER_SIZE\r
- is used.\r
- """\r
-\r
- def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):\r
- """Create a new buffered reader using the given readable raw IO object.\r
- """\r
- if not raw.readable():\r
- raise IOError('"raw" argument must be readable.')\r
-\r
- _BufferedIOMixin.__init__(self, raw)\r
- if buffer_size <= 0:\r
- raise ValueError("invalid buffer size")\r
- self.buffer_size = buffer_size\r
- self._reset_read_buf()\r
- self._read_lock = Lock()\r
-\r
- def _reset_read_buf(self):\r
- self._read_buf = b""\r
- self._read_pos = 0\r
-\r
- def read(self, n=None):\r
- """Read n bytes.\r
-\r
- Returns exactly n bytes of data unless the underlying raw IO\r
- stream reaches EOF or if the call would block in non-blocking\r
- mode. If n is negative, read until EOF or until read() would\r
- block.\r
- """\r
- if n is not None and n < -1:\r
- raise ValueError("invalid number of bytes to read")\r
- with self._read_lock:\r
- return self._read_unlocked(n)\r
-\r
- def _read_unlocked(self, n=None):\r
- nodata_val = b""\r
- empty_values = (b"", None)\r
- buf = self._read_buf\r
- pos = self._read_pos\r
-\r
- # Special case for when the number of bytes to read is unspecified.\r
- if n is None or n == -1:\r
- self._reset_read_buf()\r
- chunks = [buf[pos:]] # Strip the consumed bytes.\r
- current_size = 0\r
- while True:\r
- # Read until EOF or until read() would block.\r
- try:\r
- chunk = self.raw.read()\r
- except IOError as e:\r
- if e.errno != EINTR:\r
- raise\r
- continue\r
- if chunk in empty_values:\r
- nodata_val = chunk\r
- break\r
- current_size += len(chunk)\r
- chunks.append(chunk)\r
- return b"".join(chunks) or nodata_val\r
-\r
- # The number of bytes to read is specified, return at most n bytes.\r
- avail = len(buf) - pos # Length of the available buffered data.\r
- if n <= avail:\r
- # Fast path: the data to read is fully buffered.\r
- self._read_pos += n\r
- return buf[pos:pos+n]\r
- # Slow path: read from the stream until enough bytes are read,\r
- # or until an EOF occurs or until read() would block.\r
- chunks = [buf[pos:]]\r
- wanted = max(self.buffer_size, n)\r
- while avail < n:\r
- try:\r
- chunk = self.raw.read(wanted)\r
- except IOError as e:\r
- if e.errno != EINTR:\r
- raise\r
- continue\r
- if chunk in empty_values:\r
- nodata_val = chunk\r
- break\r
- avail += len(chunk)\r
- chunks.append(chunk)\r
- # n is more then avail only when an EOF occurred or when\r
- # read() would have blocked.\r
- n = min(n, avail)\r
- out = b"".join(chunks)\r
- self._read_buf = out[n:] # Save the extra data in the buffer.\r
- self._read_pos = 0\r
- return out[:n] if out else nodata_val\r
-\r
- def peek(self, n=0):\r
- """Returns buffered bytes without advancing the position.\r
-\r
- The argument indicates a desired minimal number of bytes; we\r
- do at most one raw read to satisfy it. We never return more\r
- than self.buffer_size.\r
- """\r
- with self._read_lock:\r
- return self._peek_unlocked(n)\r
-\r
- def _peek_unlocked(self, n=0):\r
- want = min(n, self.buffer_size)\r
- have = len(self._read_buf) - self._read_pos\r
- if have < want or have <= 0:\r
- to_read = self.buffer_size - have\r
- while True:\r
- try:\r
- current = self.raw.read(to_read)\r
- except IOError as e:\r
- if e.errno != EINTR:\r
- raise\r
- continue\r
- break\r
- if current:\r
- self._read_buf = self._read_buf[self._read_pos:] + current\r
- self._read_pos = 0\r
- return self._read_buf[self._read_pos:]\r
-\r
- def read1(self, n):\r
- """Reads up to n bytes, with at most one read() system call."""\r
- # Returns up to n bytes. If at least one byte is buffered, we\r
- # only return buffered bytes. Otherwise, we do one raw read.\r
- if n < 0:\r
- raise ValueError("number of bytes to read must be positive")\r
- if n == 0:\r
- return b""\r
- with self._read_lock:\r
- self._peek_unlocked(1)\r
- return self._read_unlocked(\r
- min(n, len(self._read_buf) - self._read_pos))\r
-\r
- def tell(self):\r
- return _BufferedIOMixin.tell(self) - len(self._read_buf) + self._read_pos\r
-\r
- def seek(self, pos, whence=0):\r
- if not (0 <= whence <= 2):\r
- raise ValueError("invalid whence value")\r
- with self._read_lock:\r
- if whence == 1:\r
- pos -= len(self._read_buf) - self._read_pos\r
- pos = _BufferedIOMixin.seek(self, pos, whence)\r
- self._reset_read_buf()\r
- return pos\r
-\r
-class BufferedWriter(_BufferedIOMixin):\r
-\r
- """A buffer for a writeable sequential RawIO object.\r
-\r
- The constructor creates a BufferedWriter for the given writeable raw\r
- stream. If the buffer_size is not given, it defaults to\r
- DEFAULT_BUFFER_SIZE.\r
- """\r
-\r
- _warning_stack_offset = 2\r
-\r
- def __init__(self, raw,\r
- buffer_size=DEFAULT_BUFFER_SIZE, max_buffer_size=None):\r
- if not raw.writable():\r
- raise IOError('"raw" argument must be writable.')\r
-\r
- _BufferedIOMixin.__init__(self, raw)\r
- if buffer_size <= 0:\r
- raise ValueError("invalid buffer size")\r
- if max_buffer_size is not None:\r
- warnings.warn("max_buffer_size is deprecated", DeprecationWarning,\r
- self._warning_stack_offset)\r
- self.buffer_size = buffer_size\r
- self._write_buf = bytearray()\r
- self._write_lock = Lock()\r
-\r
- def write(self, b):\r
- if self.closed:\r
- raise ValueError("write to closed file")\r
- if isinstance(b, unicode):\r
- raise TypeError("can't write unicode to binary stream")\r
- with self._write_lock:\r
- # XXX we can implement some more tricks to try and avoid\r
- # partial writes\r
- if len(self._write_buf) > self.buffer_size:\r
- # We're full, so let's pre-flush the buffer\r
- try:\r
- self._flush_unlocked()\r
- except BlockingIOError as e:\r
- # We can't accept anything else.\r
- # XXX Why not just let the exception pass through?\r
- raise BlockingIOError(e.errno, e.strerror, 0)\r
- before = len(self._write_buf)\r
- self._write_buf.extend(b)\r
- written = len(self._write_buf) - before\r
- if len(self._write_buf) > self.buffer_size:\r
- try:\r
- self._flush_unlocked()\r
- except BlockingIOError as e:\r
- if len(self._write_buf) > self.buffer_size:\r
- # We've hit the buffer_size. We have to accept a partial\r
- # write and cut back our buffer.\r
- overage = len(self._write_buf) - self.buffer_size\r
- written -= overage\r
- self._write_buf = self._write_buf[:self.buffer_size]\r
- raise BlockingIOError(e.errno, e.strerror, written)\r
- return written\r
-\r
- def truncate(self, pos=None):\r
- with self._write_lock:\r
- self._flush_unlocked()\r
- if pos is None:\r
- pos = self.raw.tell()\r
- return self.raw.truncate(pos)\r
-\r
- def flush(self):\r
- with self._write_lock:\r
- self._flush_unlocked()\r
-\r
- def _flush_unlocked(self):\r
- if self.closed:\r
- raise ValueError("flush of closed file")\r
- written = 0\r
- try:\r
- while self._write_buf:\r
- try:\r
- n = self.raw.write(self._write_buf)\r
- except IOError as e:\r
- if e.errno != EINTR:\r
- raise\r
- continue\r
- if n > len(self._write_buf) or n < 0:\r
- raise IOError("write() returned incorrect number of bytes")\r
- del self._write_buf[:n]\r
- written += n\r
- except BlockingIOError as e:\r
- n = e.characters_written\r
- del self._write_buf[:n]\r
- written += n\r
- raise BlockingIOError(e.errno, e.strerror, written)\r
-\r
- def tell(self):\r
- return _BufferedIOMixin.tell(self) + len(self._write_buf)\r
-\r
- def seek(self, pos, whence=0):\r
- if not (0 <= whence <= 2):\r
- raise ValueError("invalid whence")\r
- with self._write_lock:\r
- self._flush_unlocked()\r
- return _BufferedIOMixin.seek(self, pos, whence)\r
-\r
-\r
-class BufferedRWPair(BufferedIOBase):\r
-\r
- """A buffered reader and writer object together.\r
-\r
- A buffered reader object and buffered writer object put together to\r
- form a sequential IO object that can read and write. This is typically\r
- used with a socket or two-way pipe.\r
-\r
- reader and writer are RawIOBase objects that are readable and\r
- writeable respectively. If the buffer_size is omitted it defaults to\r
- DEFAULT_BUFFER_SIZE.\r
- """\r
-\r
- # XXX The usefulness of this (compared to having two separate IO\r
- # objects) is questionable.\r
-\r
- def __init__(self, reader, writer,\r
- buffer_size=DEFAULT_BUFFER_SIZE, max_buffer_size=None):\r
- """Constructor.\r
-\r
- The arguments are two RawIO instances.\r
- """\r
- if max_buffer_size is not None:\r
- warnings.warn("max_buffer_size is deprecated", DeprecationWarning, 2)\r
-\r
- if not reader.readable():\r
- raise IOError('"reader" argument must be readable.')\r
-\r
- if not writer.writable():\r
- raise IOError('"writer" argument must be writable.')\r
-\r
- self.reader = BufferedReader(reader, buffer_size)\r
- self.writer = BufferedWriter(writer, buffer_size)\r
-\r
- def read(self, n=None):\r
- if n is None:\r
- n = -1\r
- return self.reader.read(n)\r
-\r
- def readinto(self, b):\r
- return self.reader.readinto(b)\r
-\r
- def write(self, b):\r
- return self.writer.write(b)\r
-\r
- def peek(self, n=0):\r
- return self.reader.peek(n)\r
-\r
- def read1(self, n):\r
- return self.reader.read1(n)\r
-\r
- def readable(self):\r
- return self.reader.readable()\r
-\r
- def writable(self):\r
- return self.writer.writable()\r
-\r
- def flush(self):\r
- return self.writer.flush()\r
-\r
- def close(self):\r
- self.writer.close()\r
- self.reader.close()\r
-\r
- def isatty(self):\r
- return self.reader.isatty() or self.writer.isatty()\r
-\r
- @property\r
- def closed(self):\r
- return self.writer.closed\r
-\r
-\r
-class BufferedRandom(BufferedWriter, BufferedReader):\r
-\r
- """A buffered interface to random access streams.\r
-\r
- The constructor creates a reader and writer for a seekable stream,\r
- raw, given in the first argument. If the buffer_size is omitted it\r
- defaults to DEFAULT_BUFFER_SIZE.\r
- """\r
-\r
- _warning_stack_offset = 3\r
-\r
- def __init__(self, raw,\r
- buffer_size=DEFAULT_BUFFER_SIZE, max_buffer_size=None):\r
- raw._checkSeekable()\r
- BufferedReader.__init__(self, raw, buffer_size)\r
- BufferedWriter.__init__(self, raw, buffer_size, max_buffer_size)\r
-\r
- def seek(self, pos, whence=0):\r
- if not (0 <= whence <= 2):\r
- raise ValueError("invalid whence")\r
- self.flush()\r
- if self._read_buf:\r
- # Undo read ahead.\r
- with self._read_lock:\r
- self.raw.seek(self._read_pos - len(self._read_buf), 1)\r
- # First do the raw seek, then empty the read buffer, so that\r
- # if the raw seek fails, we don't lose buffered data forever.\r
- pos = self.raw.seek(pos, whence)\r
- with self._read_lock:\r
- self._reset_read_buf()\r
- if pos < 0:\r
- raise IOError("seek() returned invalid position")\r
- return pos\r
-\r
- def tell(self):\r
- if self._write_buf:\r
- return BufferedWriter.tell(self)\r
- else:\r
- return BufferedReader.tell(self)\r
-\r
- def truncate(self, pos=None):\r
- if pos is None:\r
- pos = self.tell()\r
- # Use seek to flush the read buffer.\r
- return BufferedWriter.truncate(self, pos)\r
-\r
- def read(self, n=None):\r
- if n is None:\r
- n = -1\r
- self.flush()\r
- return BufferedReader.read(self, n)\r
-\r
- def readinto(self, b):\r
- self.flush()\r
- return BufferedReader.readinto(self, b)\r
-\r
- def peek(self, n=0):\r
- self.flush()\r
- return BufferedReader.peek(self, n)\r
-\r
- def read1(self, n):\r
- self.flush()\r
- return BufferedReader.read1(self, n)\r
-\r
- def write(self, b):\r
- if self._read_buf:\r
- # Undo readahead\r
- with self._read_lock:\r
- self.raw.seek(self._read_pos - len(self._read_buf), 1)\r
- self._reset_read_buf()\r
- return BufferedWriter.write(self, b)\r
-\r
-\r
-class TextIOBase(IOBase):\r
-\r
- """Base class for text I/O.\r
-\r
- This class provides a character and line based interface to stream\r
- I/O. There is no readinto method because Python's character strings\r
- are immutable. There is no public constructor.\r
- """\r
-\r
- def read(self, n=-1):\r
- """Read at most n characters from stream.\r
-\r
- Read from underlying buffer until we have n characters or we hit EOF.\r
- If n is negative or omitted, read until EOF.\r
- """\r
- self._unsupported("read")\r
-\r
- def write(self, s):\r
- """Write string s to stream."""\r
- self._unsupported("write")\r
-\r
- def truncate(self, pos=None):\r
- """Truncate size to pos."""\r
- self._unsupported("truncate")\r
-\r
- def readline(self):\r
- """Read until newline or EOF.\r
-\r
- Returns an empty string if EOF is hit immediately.\r
- """\r
- self._unsupported("readline")\r
-\r
- def detach(self):\r
- """\r
- Separate the underlying buffer from the TextIOBase and return it.\r
-\r
- After the underlying buffer has been detached, the TextIO is in an\r
- unusable state.\r
- """\r
- self._unsupported("detach")\r
-\r
- @property\r
- def encoding(self):\r
- """Subclasses should override."""\r
- return None\r
-\r
- @property\r
- def newlines(self):\r
- """Line endings translated so far.\r
-\r
- Only line endings translated during reading are considered.\r
-\r
- Subclasses should override.\r
- """\r
- return None\r
-\r
- @property\r
- def errors(self):\r
- """Error setting of the decoder or encoder.\r
-\r
- Subclasses should override."""\r
- return None\r
-\r
-io.TextIOBase.register(TextIOBase)\r
-\r
-\r
-class IncrementalNewlineDecoder(codecs.IncrementalDecoder):\r
- r"""Codec used when reading a file in universal newlines mode. It wraps\r
- another incremental decoder, translating \r\n and \r into \n. It also\r
- records the types of newlines encountered. When used with\r
- translate=False, it ensures that the newline sequence is returned in\r
- one piece.\r
- """\r
- def __init__(self, decoder, translate, errors='strict'):\r
- codecs.IncrementalDecoder.__init__(self, errors=errors)\r
- self.translate = translate\r
- self.decoder = decoder\r
- self.seennl = 0\r
- self.pendingcr = False\r
-\r
- def decode(self, input, final=False):\r
- # decode input (with the eventual \r from a previous pass)\r
- if self.decoder is None:\r
- output = input\r
- else:\r
- output = self.decoder.decode(input, final=final)\r
- if self.pendingcr and (output or final):\r
- output = "\r" + output\r
- self.pendingcr = False\r
-\r
- # retain last \r even when not translating data:\r
- # then readline() is sure to get \r\n in one pass\r
- if output.endswith("\r") and not final:\r
- output = output[:-1]\r
- self.pendingcr = True\r
-\r
- # Record which newlines are read\r
- crlf = output.count('\r\n')\r
- cr = output.count('\r') - crlf\r
- lf = output.count('\n') - crlf\r
- self.seennl |= (lf and self._LF) | (cr and self._CR) \\r
- | (crlf and self._CRLF)\r
-\r
- if self.translate:\r
- if crlf:\r
- output = output.replace("\r\n", "\n")\r
- if cr:\r
- output = output.replace("\r", "\n")\r
-\r
- return output\r
-\r
- def getstate(self):\r
- if self.decoder is None:\r
- buf = b""\r
- flag = 0\r
- else:\r
- buf, flag = self.decoder.getstate()\r
- flag <<= 1\r
- if self.pendingcr:\r
- flag |= 1\r
- return buf, flag\r
-\r
- def setstate(self, state):\r
- buf, flag = state\r
- self.pendingcr = bool(flag & 1)\r
- if self.decoder is not None:\r
- self.decoder.setstate((buf, flag >> 1))\r
-\r
- def reset(self):\r
- self.seennl = 0\r
- self.pendingcr = False\r
- if self.decoder is not None:\r
- self.decoder.reset()\r
-\r
- _LF = 1\r
- _CR = 2\r
- _CRLF = 4\r
-\r
- @property\r
- def newlines(self):\r
- return (None,\r
- "\n",\r
- "\r",\r
- ("\r", "\n"),\r
- "\r\n",\r
- ("\n", "\r\n"),\r
- ("\r", "\r\n"),\r
- ("\r", "\n", "\r\n")\r
- )[self.seennl]\r
-\r
-\r
-class TextIOWrapper(TextIOBase):\r
-\r
- r"""Character and line based layer over a BufferedIOBase object, buffer.\r
-\r
- encoding gives the name of the encoding that the stream will be\r
- decoded or encoded with. It defaults to locale.getpreferredencoding.\r
-\r
- errors determines the strictness of encoding and decoding (see the\r
- codecs.register) and defaults to "strict".\r
-\r
- newline can be None, '', '\n', '\r', or '\r\n'. It controls the\r
- handling of line endings. If it is None, universal newlines is\r
- enabled. With this enabled, on input, the lines endings '\n', '\r',\r
- or '\r\n' are translated to '\n' before being returned to the\r
- caller. Conversely, on output, '\n' is translated to the system\r
- default line seperator, os.linesep. If newline is any other of its\r
- legal values, that newline becomes the newline when the file is read\r
- and it is returned untranslated. On output, '\n' is converted to the\r
- newline.\r
-\r
- If line_buffering is True, a call to flush is implied when a call to\r
- write contains a newline character.\r
- """\r
-\r
- _CHUNK_SIZE = 2048\r
-\r
- def __init__(self, buffer, encoding=None, errors=None, newline=None,\r
- line_buffering=False):\r
- if newline is not None and not isinstance(newline, basestring):\r
- raise TypeError("illegal newline type: %r" % (type(newline),))\r
- if newline not in (None, "", "\n", "\r", "\r\n"):\r
- raise ValueError("illegal newline value: %r" % (newline,))\r
- if encoding is None:\r
- try:\r
- import locale\r
- except ImportError:\r
- # Importing locale may fail if Python is being built\r
- encoding = "ascii"\r
- else:\r
- encoding = locale.getpreferredencoding()\r
-\r
- if not isinstance(encoding, basestring):\r
- raise ValueError("invalid encoding: %r" % encoding)\r
-\r
- if errors is None:\r
- errors = "strict"\r
- else:\r
- if not isinstance(errors, basestring):\r
- raise ValueError("invalid errors: %r" % errors)\r
-\r
- self._buffer = buffer\r
- self._line_buffering = line_buffering\r
- self._encoding = encoding\r
- self._errors = errors\r
- self._readuniversal = not newline\r
- self._readtranslate = newline is None\r
- self._readnl = newline\r
- self._writetranslate = newline != ''\r
- self._writenl = newline or os.linesep\r
- self._encoder = None\r
- self._decoder = None\r
- self._decoded_chars = '' # buffer for text returned from decoder\r
- self._decoded_chars_used = 0 # offset into _decoded_chars for read()\r
- self._snapshot = None # info for reconstructing decoder state\r
- self._seekable = self._telling = self.buffer.seekable()\r
-\r
- if self._seekable and self.writable():\r
- position = self.buffer.tell()\r
- if position != 0:\r
- try:\r
- self._get_encoder().setstate(0)\r
- except LookupError:\r
- # Sometimes the encoder doesn't exist\r
- pass\r
-\r
- # self._snapshot is either None, or a tuple (dec_flags, next_input)\r
- # where dec_flags is the second (integer) item of the decoder state\r
- # and next_input is the chunk of input bytes that comes next after the\r
- # snapshot point. We use this to reconstruct decoder states in tell().\r
-\r
- # Naming convention:\r
- # - "bytes_..." for integer variables that count input bytes\r
- # - "chars_..." for integer variables that count decoded characters\r
-\r
- def __repr__(self):\r
- try:\r
- name = self.name\r
- except AttributeError:\r
- return "<_pyio.TextIOWrapper encoding='{0}'>".format(self.encoding)\r
- else:\r
- return "<_pyio.TextIOWrapper name={0!r} encoding='{1}'>".format(\r
- name, self.encoding)\r
-\r
- @property\r
- def encoding(self):\r
- return self._encoding\r
-\r
- @property\r
- def errors(self):\r
- return self._errors\r
-\r
- @property\r
- def line_buffering(self):\r
- return self._line_buffering\r
-\r
- @property\r
- def buffer(self):\r
- return self._buffer\r
-\r
- def seekable(self):\r
- return self._seekable\r
-\r
- def readable(self):\r
- return self.buffer.readable()\r
-\r
- def writable(self):\r
- return self.buffer.writable()\r
-\r
- def flush(self):\r
- self.buffer.flush()\r
- self._telling = self._seekable\r
-\r
- def close(self):\r
- if self.buffer is not None and not self.closed:\r
- self.flush()\r
- self.buffer.close()\r
-\r
- @property\r
- def closed(self):\r
- return self.buffer.closed\r
-\r
- @property\r
- def name(self):\r
- return self.buffer.name\r
-\r
- def fileno(self):\r
- return self.buffer.fileno()\r
-\r
- def isatty(self):\r
- return self.buffer.isatty()\r
-\r
- def write(self, s):\r
- if self.closed:\r
- raise ValueError("write to closed file")\r
- if not isinstance(s, unicode):\r
- raise TypeError("can't write %s to text stream" %\r
- s.__class__.__name__)\r
- length = len(s)\r
- haslf = (self._writetranslate or self._line_buffering) and "\n" in s\r
- if haslf and self._writetranslate and self._writenl != "\n":\r
- s = s.replace("\n", self._writenl)\r
- encoder = self._encoder or self._get_encoder()\r
- # XXX What if we were just reading?\r
- b = encoder.encode(s)\r
- self.buffer.write(b)\r
- if self._line_buffering and (haslf or "\r" in s):\r
- self.flush()\r
- self._snapshot = None\r
- if self._decoder:\r
- self._decoder.reset()\r
- return length\r
-\r
- def _get_encoder(self):\r
- make_encoder = codecs.getincrementalencoder(self._encoding)\r
- self._encoder = make_encoder(self._errors)\r
- return self._encoder\r
-\r
- def _get_decoder(self):\r
- make_decoder = codecs.getincrementaldecoder(self._encoding)\r
- decoder = make_decoder(self._errors)\r
- if self._readuniversal:\r
- decoder = IncrementalNewlineDecoder(decoder, self._readtranslate)\r
- self._decoder = decoder\r
- return decoder\r
-\r
- # The following three methods implement an ADT for _decoded_chars.\r
- # Text returned from the decoder is buffered here until the client\r
- # requests it by calling our read() or readline() method.\r
- def _set_decoded_chars(self, chars):\r
- """Set the _decoded_chars buffer."""\r
- self._decoded_chars = chars\r
- self._decoded_chars_used = 0\r
-\r
- def _get_decoded_chars(self, n=None):\r
- """Advance into the _decoded_chars buffer."""\r
- offset = self._decoded_chars_used\r
- if n is None:\r
- chars = self._decoded_chars[offset:]\r
- else:\r
- chars = self._decoded_chars[offset:offset + n]\r
- self._decoded_chars_used += len(chars)\r
- return chars\r
-\r
- def _rewind_decoded_chars(self, n):\r
- """Rewind the _decoded_chars buffer."""\r
- if self._decoded_chars_used < n:\r
- raise AssertionError("rewind decoded_chars out of bounds")\r
- self._decoded_chars_used -= n\r
-\r
- def _read_chunk(self):\r
- """\r
- Read and decode the next chunk of data from the BufferedReader.\r
- """\r
-\r
- # The return value is True unless EOF was reached. The decoded\r
- # string is placed in self._decoded_chars (replacing its previous\r
- # value). The entire input chunk is sent to the decoder, though\r
- # some of it may remain buffered in the decoder, yet to be\r
- # converted.\r
-\r
- if self._decoder is None:\r
- raise ValueError("no decoder")\r
-\r
- if self._telling:\r
- # To prepare for tell(), we need to snapshot a point in the\r
- # file where the decoder's input buffer is empty.\r
-\r
- dec_buffer, dec_flags = self._decoder.getstate()\r
- # Given this, we know there was a valid snapshot point\r
- # len(dec_buffer) bytes ago with decoder state (b'', dec_flags).\r
-\r
- # Read a chunk, decode it, and put the result in self._decoded_chars.\r
- input_chunk = self.buffer.read1(self._CHUNK_SIZE)\r
- eof = not input_chunk\r
- self._set_decoded_chars(self._decoder.decode(input_chunk, eof))\r
-\r
- if self._telling:\r
- # At the snapshot point, len(dec_buffer) bytes before the read,\r
- # the next input to be decoded is dec_buffer + input_chunk.\r
- self._snapshot = (dec_flags, dec_buffer + input_chunk)\r
-\r
- return not eof\r
-\r
- def _pack_cookie(self, position, dec_flags=0,\r
- bytes_to_feed=0, need_eof=0, chars_to_skip=0):\r
- # The meaning of a tell() cookie is: seek to position, set the\r
- # decoder flags to dec_flags, read bytes_to_feed bytes, feed them\r
- # into the decoder with need_eof as the EOF flag, then skip\r
- # chars_to_skip characters of the decoded result. For most simple\r
- # decoders, tell() will often just give a byte offset in the file.\r
- return (position | (dec_flags<<64) | (bytes_to_feed<<128) |\r
- (chars_to_skip<<192) | bool(need_eof)<<256)\r
-\r
- def _unpack_cookie(self, bigint):\r
- rest, position = divmod(bigint, 1<<64)\r
- rest, dec_flags = divmod(rest, 1<<64)\r
- rest, bytes_to_feed = divmod(rest, 1<<64)\r
- need_eof, chars_to_skip = divmod(rest, 1<<64)\r
- return position, dec_flags, bytes_to_feed, need_eof, chars_to_skip\r
-\r
- def tell(self):\r
- if not self._seekable:\r
- raise IOError("underlying stream is not seekable")\r
- if not self._telling:\r
- raise IOError("telling position disabled by next() call")\r
- self.flush()\r
- position = self.buffer.tell()\r
- decoder = self._decoder\r
- if decoder is None or self._snapshot is None:\r
- if self._decoded_chars:\r
- # This should never happen.\r
- raise AssertionError("pending decoded text")\r
- return position\r
-\r
- # Skip backward to the snapshot point (see _read_chunk).\r
- dec_flags, next_input = self._snapshot\r
- position -= len(next_input)\r
-\r
- # How many decoded characters have been used up since the snapshot?\r
- chars_to_skip = self._decoded_chars_used\r
- if chars_to_skip == 0:\r
- # We haven't moved from the snapshot point.\r
- return self._pack_cookie(position, dec_flags)\r
-\r
- # Starting from the snapshot position, we will walk the decoder\r
- # forward until it gives us enough decoded characters.\r
- saved_state = decoder.getstate()\r
- try:\r
- # Note our initial start point.\r
- decoder.setstate((b'', dec_flags))\r
- start_pos = position\r
- start_flags, bytes_fed, chars_decoded = dec_flags, 0, 0\r
- need_eof = 0\r
-\r
- # Feed the decoder one byte at a time. As we go, note the\r
- # nearest "safe start point" before the current location\r
- # (a point where the decoder has nothing buffered, so seek()\r
- # can safely start from there and advance to this location).\r
- for next_byte in next_input:\r
- bytes_fed += 1\r
- chars_decoded += len(decoder.decode(next_byte))\r
- dec_buffer, dec_flags = decoder.getstate()\r
- if not dec_buffer and chars_decoded <= chars_to_skip:\r
- # Decoder buffer is empty, so this is a safe start point.\r
- start_pos += bytes_fed\r
- chars_to_skip -= chars_decoded\r
- start_flags, bytes_fed, chars_decoded = dec_flags, 0, 0\r
- if chars_decoded >= chars_to_skip:\r
- break\r
- else:\r
- # We didn't get enough decoded data; signal EOF to get more.\r
- chars_decoded += len(decoder.decode(b'', final=True))\r
- need_eof = 1\r
- if chars_decoded < chars_to_skip:\r
- raise IOError("can't reconstruct logical file position")\r
-\r
- # The returned cookie corresponds to the last safe start point.\r
- return self._pack_cookie(\r
- start_pos, start_flags, bytes_fed, need_eof, chars_to_skip)\r
- finally:\r
- decoder.setstate(saved_state)\r
-\r
- def truncate(self, pos=None):\r
- self.flush()\r
- if pos is None:\r
- pos = self.tell()\r
- return self.buffer.truncate(pos)\r
-\r
- def detach(self):\r
- if self.buffer is None:\r
- raise ValueError("buffer is already detached")\r
- self.flush()\r
- buffer = self._buffer\r
- self._buffer = None\r
- return buffer\r
-\r
- def seek(self, cookie, whence=0):\r
- if self.closed:\r
- raise ValueError("tell on closed file")\r
- if not self._seekable:\r
- raise IOError("underlying stream is not seekable")\r
- if whence == 1: # seek relative to current position\r
- if cookie != 0:\r
- raise IOError("can't do nonzero cur-relative seeks")\r
- # Seeking to the current position should attempt to\r
- # sync the underlying buffer with the current position.\r
- whence = 0\r
- cookie = self.tell()\r
- if whence == 2: # seek relative to end of file\r
- if cookie != 0:\r
- raise IOError("can't do nonzero end-relative seeks")\r
- self.flush()\r
- position = self.buffer.seek(0, 2)\r
- self._set_decoded_chars('')\r
- self._snapshot = None\r
- if self._decoder:\r
- self._decoder.reset()\r
- return position\r
- if whence != 0:\r
- raise ValueError("invalid whence (%r, should be 0, 1 or 2)" %\r
- (whence,))\r
- if cookie < 0:\r
- raise ValueError("negative seek position %r" % (cookie,))\r
- self.flush()\r
-\r
- # The strategy of seek() is to go back to the safe start point\r
- # and replay the effect of read(chars_to_skip) from there.\r
- start_pos, dec_flags, bytes_to_feed, need_eof, chars_to_skip = \\r
- self._unpack_cookie(cookie)\r
-\r
- # Seek back to the safe start point.\r
- self.buffer.seek(start_pos)\r
- self._set_decoded_chars('')\r
- self._snapshot = None\r
-\r
- # Restore the decoder to its state from the safe start point.\r
- if cookie == 0 and self._decoder:\r
- self._decoder.reset()\r
- elif self._decoder or dec_flags or chars_to_skip:\r
- self._decoder = self._decoder or self._get_decoder()\r
- self._decoder.setstate((b'', dec_flags))\r
- self._snapshot = (dec_flags, b'')\r
-\r
- if chars_to_skip:\r
- # Just like _read_chunk, feed the decoder and save a snapshot.\r
- input_chunk = self.buffer.read(bytes_to_feed)\r
- self._set_decoded_chars(\r
- self._decoder.decode(input_chunk, need_eof))\r
- self._snapshot = (dec_flags, input_chunk)\r
-\r
- # Skip chars_to_skip of the decoded characters.\r
- if len(self._decoded_chars) < chars_to_skip:\r
- raise IOError("can't restore logical file position")\r
- self._decoded_chars_used = chars_to_skip\r
-\r
- # Finally, reset the encoder (merely useful for proper BOM handling)\r
- try:\r
- encoder = self._encoder or self._get_encoder()\r
- except LookupError:\r
- # Sometimes the encoder doesn't exist\r
- pass\r
- else:\r
- if cookie != 0:\r
- encoder.setstate(0)\r
- else:\r
- encoder.reset()\r
- return cookie\r
-\r
- def read(self, n=None):\r
- self._checkReadable()\r
- if n is None:\r
- n = -1\r
- decoder = self._decoder or self._get_decoder()\r
- try:\r
- n.__index__\r
- except AttributeError:\r
- raise TypeError("an integer is required")\r
- if n < 0:\r
- # Read everything.\r
- result = (self._get_decoded_chars() +\r
- decoder.decode(self.buffer.read(), final=True))\r
- self._set_decoded_chars('')\r
- self._snapshot = None\r
- return result\r
- else:\r
- # Keep reading chunks until we have n characters to return.\r
- eof = False\r
- result = self._get_decoded_chars(n)\r
- while len(result) < n and not eof:\r
- eof = not self._read_chunk()\r
- result += self._get_decoded_chars(n - len(result))\r
- return result\r
-\r
- def next(self):\r
- self._telling = False\r
- line = self.readline()\r
- if not line:\r
- self._snapshot = None\r
- self._telling = self._seekable\r
- raise StopIteration\r
- return line\r
-\r
- def readline(self, limit=None):\r
- if self.closed:\r
- raise ValueError("read from closed file")\r
- if limit is None:\r
- limit = -1\r
- elif not isinstance(limit, (int, long)):\r
- raise TypeError("limit must be an integer")\r
-\r
- # Grab all the decoded text (we will rewind any extra bits later).\r
- line = self._get_decoded_chars()\r
-\r
- start = 0\r
- # Make the decoder if it doesn't already exist.\r
- if not self._decoder:\r
- self._get_decoder()\r
-\r
- pos = endpos = None\r
- while True:\r
- if self._readtranslate:\r
- # Newlines are already translated, only search for \n\r
- pos = line.find('\n', start)\r
- if pos >= 0:\r
- endpos = pos + 1\r
- break\r
- else:\r
- start = len(line)\r
-\r
- elif self._readuniversal:\r
- # Universal newline search. Find any of \r, \r\n, \n\r
- # The decoder ensures that \r\n are not split in two pieces\r
-\r
- # In C we'd look for these in parallel of course.\r
- nlpos = line.find("\n", start)\r
- crpos = line.find("\r", start)\r
- if crpos == -1:\r
- if nlpos == -1:\r
- # Nothing found\r
- start = len(line)\r
- else:\r
- # Found \n\r
- endpos = nlpos + 1\r
- break\r
- elif nlpos == -1:\r
- # Found lone \r\r
- endpos = crpos + 1\r
- break\r
- elif nlpos < crpos:\r
- # Found \n\r
- endpos = nlpos + 1\r
- break\r
- elif nlpos == crpos + 1:\r
- # Found \r\n\r
- endpos = crpos + 2\r
- break\r
- else:\r
- # Found \r\r
- endpos = crpos + 1\r
- break\r
- else:\r
- # non-universal\r
- pos = line.find(self._readnl)\r
- if pos >= 0:\r
- endpos = pos + len(self._readnl)\r
- break\r
-\r
- if limit >= 0 and len(line) >= limit:\r
- endpos = limit # reached length limit\r
- break\r
-\r
- # No line ending seen yet - get more data'\r
- while self._read_chunk():\r
- if self._decoded_chars:\r
- break\r
- if self._decoded_chars:\r
- line += self._get_decoded_chars()\r
- else:\r
- # end of file\r
- self._set_decoded_chars('')\r
- self._snapshot = None\r
- return line\r
-\r
- if limit >= 0 and endpos > limit:\r
- endpos = limit # don't exceed limit\r
-\r
- # Rewind _decoded_chars to just after the line ending we found.\r
- self._rewind_decoded_chars(len(line) - endpos)\r
- return line[:endpos]\r
-\r
- @property\r
- def newlines(self):\r
- return self._decoder.newlines if self._decoder else None\r
-\r
-\r
-class StringIO(TextIOWrapper):\r
- """Text I/O implementation using an in-memory buffer.\r
-\r
- The initial_value argument sets the value of object. The newline\r
- argument is like the one of TextIOWrapper's constructor.\r
- """\r
-\r
- def __init__(self, initial_value="", newline="\n"):\r
- super(StringIO, self).__init__(BytesIO(),\r
- encoding="utf-8",\r
- errors="strict",\r
- newline=newline)\r
- # Issue #5645: make universal newlines semantics the same as in the\r
- # C version, even under Windows.\r
- if newline is None:\r
- self._writetranslate = False\r
- if initial_value:\r
- if not isinstance(initial_value, unicode):\r
- initial_value = unicode(initial_value)\r
- self.write(initial_value)\r
- self.seek(0)\r
-\r
- def getvalue(self):\r
- self.flush()\r
- return self.buffer.getvalue().decode(self._encoding, self._errors)\r
-\r
- def __repr__(self):\r
- # TextIOWrapper tells the encoding in its repr. In StringIO,\r
- # that's a implementation detail.\r
- return object.__repr__(self)\r
-\r
- @property\r
- def errors(self):\r
- return None\r
-\r
- @property\r
- def encoding(self):\r
- return None\r
-\r
- def detach(self):\r
- # This doesn't make sense on StringIO.\r
- self._unsupported("detach")\r
projects / mirror_edk2.git / blobdiff