2 Python implementation of the io module.
9 # Import _thread instead of threading to reduce startup cost
11 from _thread
import allocate_lock
as Lock
13 from _dummy_thread
import allocate_lock
as Lock
16 from io
import __all__
17 from io
import SEEK_SET
, SEEK_CUR
, SEEK_END
19 # open() uses st_blksize whenever we can
20 DEFAULT_BUFFER_SIZE
= 8 * 1024 # bytes
22 # NOTE: Base classes defined here are registered with the "official" ABCs
23 # defined in io.py. We don't use real inheritance though, because we don't
24 # want to inherit the C implementations.
27 class BlockingIOError(IOError):
29 """Exception raised when I/O would block on a non-blocking I/O stream."""
31 def __init__(self
, errno
, strerror
, characters_written
=0):
32 super().__init
__(errno
, strerror
)
33 if not isinstance(characters_written
, int):
34 raise TypeError("characters_written must be a integer")
35 self
.characters_written
= characters_written
38 def open(file: (str, bytes
), mode
: str = "r", buffering
: int = None,
39 encoding
: str = None, errors
: str = None,
40 newline
: str = None, closefd
: bool = True) -> "IOBase":
42 r
"""Open file and return a stream. Raise IOError upon failure.
44 file is either a text or byte string giving the name (and the path
45 if the file isn't in the current working directory) of the file to
46 be opened or an integer file descriptor of the file to be
47 wrapped. (If a file descriptor is given, it is closed when the
48 returned I/O object is closed, unless closefd is set to False.)
50 mode is an optional string that specifies the mode in which the file
51 is opened. It defaults to 'r' which means open for reading in text
52 mode. Other common values are 'w' for writing (truncating the file if
53 it already exists), and 'a' for appending (which on some Unix systems,
54 means that all writes append to the end of the file regardless of the
55 current seek position). In text mode, if encoding is not specified the
56 encoding used is platform dependent. (For reading and writing raw
57 bytes use binary mode and leave encoding unspecified.) The available
60 ========= ===============================================================
62 --------- ---------------------------------------------------------------
63 'r' open for reading (default)
64 'w' open for writing, truncating the file first
65 'a' open for writing, appending to the end of the file if it exists
67 't' text mode (default)
68 '+' open a disk file for updating (reading and writing)
69 'U' universal newline mode (for backwards compatibility; unneeded
71 ========= ===============================================================
73 The default mode is 'rt' (open for reading text). For binary random
74 access, the mode 'w+b' opens and truncates the file to 0 bytes, while
75 'r+b' opens the file without truncation.
77 Python distinguishes between files opened in binary and text modes,
78 even when the underlying operating system doesn't. Files opened in
79 binary mode (appending 'b' to the mode argument) return contents as
80 bytes objects without any decoding. In text mode (the default, or when
81 't' is appended to the mode argument), the contents of the file are
82 returned as strings, the bytes having been first decoded using a
83 platform-dependent encoding or using the specified encoding if given.
85 buffering is an optional integer used to set the buffering policy. By
86 default full buffering is on. Pass 0 to switch buffering off (only
87 allowed in binary mode), 1 to set line buffering, and an integer > 1
90 encoding is the name of the encoding used to decode or encode the
91 file. This should only be used in text mode. The default encoding is
92 platform dependent, but any encoding supported by Python can be
93 passed. See the codecs module for the list of supported encodings.
95 errors is an optional string that specifies how encoding errors are to
96 be handled---this argument should not be used in binary mode. Pass
97 'strict' to raise a ValueError exception if there is an encoding error
98 (the default of None has the same effect), or pass 'ignore' to ignore
99 errors. (Note that ignoring encoding errors can lead to data loss.)
100 See the documentation for codecs.register for a list of the permitted
101 encoding error strings.
103 newline controls how universal newlines works (it only applies to text
104 mode). It can be None, '', '\n', '\r', and '\r\n'. It works as
107 * On input, if newline is None, universal newlines mode is
108 enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
109 these are translated into '\n' before being returned to the
110 caller. If it is '', universal newline mode is enabled, but line
111 endings are returned to the caller untranslated. If it has any of
112 the other legal values, input lines are only terminated by the given
113 string, and the line ending is returned to the caller untranslated.
115 * On output, if newline is None, any '\n' characters written are
116 translated to the system default line separator, os.linesep. If
117 newline is '', no translation takes place. If newline is any of the
118 other legal values, any '\n' characters written are translated to
121 If closefd is False, the underlying file descriptor will be kept open
122 when the file is closed. This does not work when a file name is given
123 and must be True in that case.
125 open() returns a file object whose type depends on the mode, and
126 through which the standard file operations such as reading and writing
127 are performed. When open() is used to open a file in a text mode ('w',
128 'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
129 a file in a binary mode, the returned class varies: in read binary
130 mode, it returns a BufferedReader; in write binary and append binary
131 modes, it returns a BufferedWriter, and in read/write mode, it returns
134 It is also possible to use a string or bytearray as a file for both
135 reading and writing. For strings StringIO can be used like a file
136 opened in a text mode, and for bytes a BytesIO can be used like a file
137 opened in a binary mode.
139 if not isinstance(file, (str, bytes
, int)):
140 raise TypeError("invalid file: %r" % file)
141 if not isinstance(mode
, str):
142 raise TypeError("invalid mode: %r" % mode
)
143 if buffering
is not None and not isinstance(buffering
, int):
144 raise TypeError("invalid buffering: %r" % buffering
)
145 if encoding
is not None and not isinstance(encoding
, str):
146 raise TypeError("invalid encoding: %r" % encoding
)
147 if errors
is not None and not isinstance(errors
, str):
148 raise TypeError("invalid errors: %r" % errors
)
150 if modes
- set("arwb+tU") or len(mode
) > len(modes
):
151 raise ValueError("invalid mode: %r" % mode
)
152 reading
= "r" in modes
153 writing
= "w" in modes
154 appending
= "a" in modes
155 updating
= "+" in modes
157 binary
= "b" in modes
159 if writing
or appending
:
160 raise ValueError("can't use U and writing mode at once")
163 raise ValueError("can't have text and binary mode at once")
164 if reading
+ writing
+ appending
> 1:
165 raise ValueError("can't have read/write/append mode at once")
166 if not (reading
or writing
or appending
):
167 raise ValueError("must have exactly one of read/write/append mode")
168 if binary
and encoding
is not None:
169 raise ValueError("binary mode doesn't take an encoding argument")
170 if binary
and errors
is not None:
171 raise ValueError("binary mode doesn't take an errors argument")
172 if binary
and newline
is not None:
173 raise ValueError("binary mode doesn't take a newline argument")
175 (reading
and "r" or "") +
176 (writing
and "w" or "") +
177 (appending
and "a" or "") +
178 (updating
and "+" or ""),
180 if buffering
is None:
182 line_buffering
= False
183 if buffering
== 1 or buffering
< 0 and raw
.isatty():
185 line_buffering
= True
187 buffering
= DEFAULT_BUFFER_SIZE
189 bs
= os
.fstat(raw
.fileno()).st_blksize
190 except (os
.error
, AttributeError):
196 raise ValueError("invalid buffering size")
200 raise ValueError("can't have unbuffered text I/O")
202 buffer = BufferedRandom(raw
, buffering
)
203 elif writing
or appending
:
204 buffer = BufferedWriter(raw
, buffering
)
206 buffer = BufferedReader(raw
, buffering
)
208 raise ValueError("unknown mode: %r" % mode
)
211 text
= TextIOWrapper(buffer, encoding
, errors
, newline
, line_buffering
)
217 """Helper for builtins.open.__doc__
219 def __get__(self
, obj
, typ
):
221 "open(file, mode='r', buffering=None, encoding=None, "
222 "errors=None, newline=None, closefd=True)\n\n" +
226 """Wrapper for builtins.open
228 Trick so that open won't become a bound method when stored
229 as a class variable (as dbm.dumb does).
231 See initstdio() in Python/pythonrun.c.
233 __doc__
= DocDescriptor()
235 def __new__(cls
, *args
, **kwargs
):
236 return open(*args
, **kwargs
)
239 class UnsupportedOperation(ValueError, IOError):
243 class IOBase(metaclass
=abc
.ABCMeta
):
245 """The abstract base class for all I/O classes, acting on streams of
246 bytes. There is no public constructor.
248 This class provides dummy implementations for many methods that
249 derived classes can override selectively; the default implementations
250 represent a file that cannot be read, written or seeked.
252 Even though IOBase does not declare read, readinto, or write because
253 their signatures will vary, implementations and clients should
254 consider those methods part of the interface. Also, implementations
255 may raise a IOError when operations they do not support are called.
257 The basic type used for binary data read from or written to a file is
258 bytes. bytearrays are accepted too, and in some cases (such as
259 readinto) needed. Text I/O classes work with str data.
261 Note that calling any method (even inquiries) on a closed stream is
262 undefined. Implementations may raise IOError in this case.
264 IOBase (and its subclasses) support the iterator protocol, meaning
265 that an IOBase object can be iterated over yielding the lines in a
268 IOBase also supports the :keyword:`with` statement. In this example,
269 fp is closed after the suite of the with statement is complete:
271 with open('spam.txt', 'r') as fp:
272 fp.write('Spam and eggs!')
277 def _unsupported(self
, name
: str) -> IOError:
278 """Internal: raise an exception for unsupported operations."""
279 raise UnsupportedOperation("%s.%s() not supported" %
280 (self
.__class
__.__name
__, name
))
284 def seek(self
, pos
: int, whence
: int = 0) -> int:
285 """Change stream position.
287 Change the stream position to byte offset offset. offset is
288 interpreted relative to the position indicated by whence. Values
291 * 0 -- start of stream (the default); offset should be zero or positive
292 * 1 -- current stream position; offset may be negative
293 * 2 -- end of stream; offset is usually negative
295 Return the new absolute position.
297 self
._unsupported
("seek")
299 def tell(self
) -> int:
300 """Return current stream position."""
301 return self
.seek(0, 1)
303 def truncate(self
, pos
: int = None) -> int:
304 """Truncate file to size bytes.
306 Size defaults to the current IO position as reported by tell(). Return
309 self
._unsupported
("truncate")
311 ### Flush and close ###
313 def flush(self
) -> None:
314 """Flush write buffers, if applicable.
316 This is not implemented for read-only and non-blocking streams.
318 # XXX Should this return the number of bytes written???
322 def close(self
) -> None:
323 """Flush and close the IO object.
325 This method has no effect if the file is already closed.
327 if not self
.__closed
:
331 pass # If flush() fails, just give up
334 def __del__(self
) -> None:
335 """Destructor. Calls close()."""
336 # The try/except block is in case this is called at program
337 # exit time, when it's possible that globals have already been
338 # deleted, and then the close() call might fail. Since
339 # there's nothing we can do about such failures and they annoy
340 # the end users, we suppress the traceback.
348 def seekable(self
) -> bool:
349 """Return whether object supports random access.
351 If False, seek(), tell() and truncate() will raise IOError.
352 This method may need to do a test seek().
356 def _checkSeekable(self
, msg
=None):
357 """Internal: raise an IOError if file is not seekable
359 if not self
.seekable():
360 raise IOError("File or stream is not seekable."
361 if msg
is None else msg
)
364 def readable(self
) -> bool:
365 """Return whether object was opened for reading.
367 If False, read() will raise IOError.
371 def _checkReadable(self
, msg
=None):
372 """Internal: raise an IOError if file is not readable
374 if not self
.readable():
375 raise IOError("File or stream is not readable."
376 if msg
is None else msg
)
378 def writable(self
) -> bool:
379 """Return whether object was opened for writing.
381 If False, write() and truncate() will raise IOError.
385 def _checkWritable(self
, msg
=None):
386 """Internal: raise an IOError if file is not writable
388 if not self
.writable():
389 raise IOError("File or stream is not writable."
390 if msg
is None else msg
)
394 """closed: bool. True iff the file has been closed.
396 For backwards compatibility, this is a property, not a predicate.
400 def _checkClosed(self
, msg
=None):
401 """Internal: raise an ValueError if file is closed
404 raise ValueError("I/O operation on closed file."
405 if msg
is None else msg
)
407 ### Context manager ###
409 def __enter__(self
) -> "IOBase": # That's a forward reference
410 """Context management protocol. Returns self."""
414 def __exit__(self
, *args
) -> None:
415 """Context management protocol. Calls close()"""
418 ### Lower-level APIs ###
420 # XXX Should these be present even if unimplemented?
422 def fileno(self
) -> int:
423 """Returns underlying file descriptor if one exists.
425 An IOError is raised if the IO object does not use a file descriptor.
427 self
._unsupported
("fileno")
429 def isatty(self
) -> bool:
430 """Return whether this is an 'interactive' stream.
432 Return False if it can't be determined.
437 ### Readline[s] and writelines ###
439 def readline(self
, limit
: int = -1) -> bytes
:
440 r
"""Read and return a line from the stream.
442 If limit is specified, at most limit bytes will be read.
444 The line terminator is always b'\n' for binary files; for text
445 files, the newlines argument to open can be used to select the line
446 terminator(s) recognized.
448 # For backwards compatibility, a (slowish) readline().
449 if hasattr(self
, "peek"):
451 readahead
= self
.peek(1)
454 n
= (readahead
.find(b
"\n") + 1) or len(readahead
)
463 elif not isinstance(limit
, int):
464 raise TypeError("limit must be an integer")
466 while limit
< 0 or len(res
) < limit
:
467 b
= self
.read(nreadahead())
471 if res
.endswith(b
"\n"):
480 line
= self
.readline()
485 def readlines(self
, hint
=None):
486 """Return a list of lines from the stream.
488 hint can be specified to control the number of lines read: no more
489 lines will be read if the total size (in bytes/characters) of all
490 lines so far exceeds hint.
492 if hint
is None or hint
<= 0:
503 def writelines(self
, lines
):
508 io
.IOBase
.register(IOBase
)
511 class RawIOBase(IOBase
):
513 """Base class for raw binary I/O."""
515 # The read() method is implemented by calling readinto(); derived
516 # classes that want to support read() only need to implement
517 # readinto() as a primitive operation. In general, readinto() can be
518 # more efficient than read().
520 # (It would be tempting to also provide an implementation of
521 # readinto() in terms of read(), in case the latter is a more suitable
522 # primitive operation, but that would lead to nasty recursion in case
523 # a subclass doesn't implement either.)
525 def read(self
, n
: int = -1) -> bytes
:
526 """Read and return up to n bytes.
528 Returns an empty bytes object on EOF, or None if the object is
529 set not to block and has no data to read.
534 return self
.readall()
535 b
= bytearray(n
.__index
__())
541 """Read until EOF, using multiple read() call."""
544 data
= self
.read(DEFAULT_BUFFER_SIZE
)
550 def readinto(self
, b
: bytearray
) -> int:
551 """Read up to len(b) bytes into b.
553 Returns number of bytes read (0 for EOF), or None if the object
554 is set not to block as has no data to read.
556 self
._unsupported
("readinto")
558 def write(self
, b
: bytes
) -> int:
559 """Write the given buffer to the IO stream.
561 Returns the number of bytes written, which may be less than len(b).
563 self
._unsupported
("write")
565 io
.RawIOBase
.register(RawIOBase
)
566 from _io
import FileIO
567 RawIOBase
.register(FileIO
)
570 class BufferedIOBase(IOBase
):
572 """Base class for buffered IO objects.
574 The main difference with RawIOBase is that the read() method
575 supports omitting the size argument, and does not have a default
576 implementation that defers to readinto().
578 In addition, read(), readinto() and write() may raise
579 BlockingIOError if the underlying raw stream is in non-blocking
580 mode and not ready; unlike their raw counterparts, they will never
583 A typical implementation should not inherit from a RawIOBase
584 implementation, but wrap one.
587 def read(self
, n
: int = None) -> bytes
:
588 """Read and return up to n bytes.
590 If the argument is omitted, None, or negative, reads and
591 returns all data until EOF.
593 If the argument is positive, and the underlying raw stream is
594 not 'interactive', multiple raw reads may be issued to satisfy
595 the byte count (unless EOF is reached first). But for
596 interactive raw streams (XXX and for pipes?), at most one raw
597 read will be issued, and a short result does not imply that
600 Returns an empty bytes array on EOF.
602 Raises BlockingIOError if the underlying raw stream has no
605 self
._unsupported
("read")
607 def read1(self
, n
: int=None) -> bytes
:
608 """Read up to n bytes with at most one read() system call."""
609 self
._unsupported
("read1")
611 def readinto(self
, b
: bytearray
) -> int:
612 """Read up to len(b) bytes into b.
614 Like read(), this may issue multiple reads to the underlying raw
615 stream, unless the latter is 'interactive'.
617 Returns the number of bytes read (0 for EOF).
619 Raises BlockingIOError if the underlying raw stream has no
622 # XXX This ought to work with anything that supports the buffer API
623 data
= self
.read(len(b
))
627 except TypeError as err
:
629 if not isinstance(b
, array
.array
):
631 b
[:n
] = array
.array('b', data
)
634 def write(self
, b
: bytes
) -> int:
635 """Write the given buffer to the IO stream.
637 Return the number of bytes written, which is never less than
640 Raises BlockingIOError if the buffer is full and the
641 underlying raw stream cannot accept more data at the moment.
643 self
._unsupported
("write")
645 def detach(self
) -> None:
647 Separate the underlying raw stream from the buffer and return it.
649 After the raw stream has been detached, the buffer is in an unusable
652 self
._unsupported
("detach")
654 io
.BufferedIOBase
.register(BufferedIOBase
)
657 class _BufferedIOMixin(BufferedIOBase
):
659 """A mixin implementation of BufferedIOBase with an underlying raw stream.
661 This passes most requests on to the underlying raw stream. It
662 does *not* provide implementations of read(), readinto() or
666 def __init__(self
, raw
):
671 def seek(self
, pos
, whence
=0):
672 new_position
= self
.raw
.seek(pos
, whence
)
674 raise IOError("seek() returned an invalid position")
678 pos
= self
.raw
.tell()
680 raise IOError("tell() returned an invalid position")
683 def truncate(self
, pos
=None):
684 # Flush the stream. We're mixing buffered I/O with lower-level I/O,
685 # and a flush may be necessary to synch both views of the current
691 # XXX: Should seek() be used, instead of passing the position
692 # XXX directly to truncate?
693 return self
.raw
.truncate(pos
)
695 ### Flush and close ###
701 if not self
.closed
and self
.raw
is not None:
705 pass # If flush() fails, just give up
710 raise ValueError("raw stream already detached")
719 return self
.raw
.seekable()
722 return self
.raw
.readable()
725 return self
.raw
.writable()
729 return self
.raw
.closed
740 clsname
= self
.__class
__.__name
__
743 except AttributeError:
744 return "<_pyio.{0}>".format(clsname
)
746 return "<_pyio.{0} name={1!r}>".format(clsname
, name
)
748 ### Lower-level APIs ###
751 return self
.raw
.fileno()
754 return self
.raw
.isatty()
757 class BytesIO(BufferedIOBase
):
759 """Buffered I/O implementation using an in-memory bytes buffer."""
761 def __init__(self
, initial_bytes
=None):
763 if initial_bytes
is not None:
769 """Return the bytes value (contents) of the buffer
772 raise ValueError("getvalue on closed file")
773 return bytes(self
._buffer
)
775 def read(self
, n
=None):
777 raise ValueError("read from closed file")
781 n
= len(self
._buffer
)
782 if len(self
._buffer
) <= self
._pos
:
784 newpos
= min(len(self
._buffer
), self
._pos
+ n
)
785 b
= self
._buffer
[self
._pos
: newpos
]
790 """This is the same as read.
796 raise ValueError("write to closed file")
797 if isinstance(b
, str):
798 raise TypeError("can't write str to binary stream")
803 if pos
> len(self
._buffer
):
804 # Inserts null bytes between the current end of the file
805 # and the new write position.
806 padding
= b
'\x00' * (pos
- len(self
._buffer
))
807 self
._buffer
+= padding
808 self
._buffer
[pos
:pos
+ n
] = b
812 def seek(self
, pos
, whence
=0):
814 raise ValueError("seek on closed file")
816 pos
= pos
.__index
__()
817 except AttributeError as err
:
818 raise TypeError("an integer is required") from err
821 raise ValueError("negative seek position %r" % (pos
,))
824 self
._pos
= max(0, self
._pos
+ pos
)
826 self
._pos
= max(0, len(self
._buffer
) + pos
)
828 raise ValueError("invalid whence value")
833 raise ValueError("tell on closed file")
836 def truncate(self
, pos
=None):
838 raise ValueError("truncate on closed file")
842 raise ValueError("negative truncate position %r" % (pos
,))
843 del self
._buffer
[pos
:]
844 return self
.seek(pos
)
856 class BufferedReader(_BufferedIOMixin
):
858 """BufferedReader(raw[, buffer_size])
860 A buffer for a readable, sequential BaseRawIO object.
862 The constructor creates a BufferedReader for the given readable raw
863 stream and buffer_size. If buffer_size is omitted, DEFAULT_BUFFER_SIZE
867 def __init__(self
, raw
, buffer_size
=DEFAULT_BUFFER_SIZE
):
868 """Create a new buffered reader using the given readable raw IO object.
870 if not raw
.readable():
871 raise IOError('"raw" argument must be readable.')
873 _BufferedIOMixin
.__init
__(self
, raw
)
875 raise ValueError("invalid buffer size")
876 self
.buffer_size
= buffer_size
877 self
._reset
_read
_buf
()
878 self
._read
_lock
= Lock()
880 def _reset_read_buf(self
):
884 def read(self
, n
=None):
887 Returns exactly n bytes of data unless the underlying raw IO
888 stream reaches EOF or if the call would block in non-blocking
889 mode. If n is negative, read until EOF or until read() would
892 if n
is not None and n
< -1:
893 raise ValueError("invalid number of bytes to read")
894 with self
._read
_lock
:
895 return self
._read
_unlocked
(n
)
897 def _read_unlocked(self
, n
=None):
899 empty_values
= (b
"", None)
903 # Special case for when the number of bytes to read is unspecified.
904 if n
is None or n
== -1:
905 self
._reset
_read
_buf
()
906 chunks
= [buf
[pos
:]] # Strip the consumed bytes.
909 # Read until EOF or until read() would block.
910 chunk
= self
.raw
.read()
911 if chunk
in empty_values
:
914 current_size
+= len(chunk
)
916 return b
"".join(chunks
) or nodata_val
918 # The number of bytes to read is specified, return at most n bytes.
919 avail
= len(buf
) - pos
# Length of the available buffered data.
921 # Fast path: the data to read is fully buffered.
923 return buf
[pos
:pos
+n
]
924 # Slow path: read from the stream until enough bytes are read,
925 # or until an EOF occurs or until read() would block.
927 wanted
= max(self
.buffer_size
, n
)
929 chunk
= self
.raw
.read(wanted
)
930 if chunk
in empty_values
:
935 # n is more then avail only when an EOF occurred or when
936 # read() would have blocked.
938 out
= b
"".join(chunks
)
939 self
._read
_buf
= out
[n
:] # Save the extra data in the buffer.
941 return out
[:n
] if out
else nodata_val
944 """Returns buffered bytes without advancing the position.
946 The argument indicates a desired minimal number of bytes; we
947 do at most one raw read to satisfy it. We never return more
948 than self.buffer_size.
950 with self
._read
_lock
:
951 return self
._peek
_unlocked
(n
)
953 def _peek_unlocked(self
, n
=0):
954 want
= min(n
, self
.buffer_size
)
955 have
= len(self
._read
_buf
) - self
._read
_pos
956 if have
< want
or have
<= 0:
957 to_read
= self
.buffer_size
- have
958 current
= self
.raw
.read(to_read
)
960 self
._read
_buf
= self
._read
_buf
[self
._read
_pos
:] + current
962 return self
._read
_buf
[self
._read
_pos
:]
965 """Reads up to n bytes, with at most one read() system call."""
966 # Returns up to n bytes. If at least one byte is buffered, we
967 # only return buffered bytes. Otherwise, we do one raw read.
969 raise ValueError("number of bytes to read must be positive")
972 with self
._read
_lock
:
973 self
._peek
_unlocked
(1)
974 return self
._read
_unlocked
(
975 min(n
, len(self
._read
_buf
) - self
._read
_pos
))
978 return _BufferedIOMixin
.tell(self
) - len(self
._read
_buf
) + self
._read
_pos
980 def seek(self
, pos
, whence
=0):
981 if not (0 <= whence
<= 2):
982 raise ValueError("invalid whence value")
983 with self
._read
_lock
:
985 pos
-= len(self
._read
_buf
) - self
._read
_pos
986 pos
= _BufferedIOMixin
.seek(self
, pos
, whence
)
987 self
._reset
_read
_buf
()
990 class BufferedWriter(_BufferedIOMixin
):
992 """A buffer for a writeable sequential RawIO object.
994 The constructor creates a BufferedWriter for the given writeable raw
995 stream. If the buffer_size is not given, it defaults to
999 _warning_stack_offset
= 2
1001 def __init__(self
, raw
,
1002 buffer_size
=DEFAULT_BUFFER_SIZE
, max_buffer_size
=None):
1003 if not raw
.writable():
1004 raise IOError('"raw" argument must be writable.')
1006 _BufferedIOMixin
.__init
__(self
, raw
)
1007 if buffer_size
<= 0:
1008 raise ValueError("invalid buffer size")
1009 if max_buffer_size
is not None:
1010 warnings
.warn("max_buffer_size is deprecated", DeprecationWarning,
1011 self
._warning
_stack
_offset
)
1012 self
.buffer_size
= buffer_size
1013 self
._write
_buf
= bytearray()
1014 self
._write
_lock
= Lock()
1018 raise ValueError("write to closed file")
1019 if isinstance(b
, str):
1020 raise TypeError("can't write str to binary stream")
1021 with self
._write
_lock
:
1022 # XXX we can implement some more tricks to try and avoid
1024 if len(self
._write
_buf
) > self
.buffer_size
:
1025 # We're full, so let's pre-flush the buffer
1027 self
._flush
_unlocked
()
1028 except BlockingIOError
as e
:
1029 # We can't accept anything else.
1030 # XXX Why not just let the exception pass through?
1031 raise BlockingIOError(e
.errno
, e
.strerror
, 0)
1032 before
= len(self
._write
_buf
)
1033 self
._write
_buf
.extend(b
)
1034 written
= len(self
._write
_buf
) - before
1035 if len(self
._write
_buf
) > self
.buffer_size
:
1037 self
._flush
_unlocked
()
1038 except BlockingIOError
as e
:
1039 if len(self
._write
_buf
) > self
.buffer_size
:
1040 # We've hit the buffer_size. We have to accept a partial
1041 # write and cut back our buffer.
1042 overage
= len(self
._write
_buf
) - self
.buffer_size
1044 self
._write
_buf
= self
._write
_buf
[:self
.buffer_size
]
1045 raise BlockingIOError(e
.errno
, e
.strerror
, written
)
1048 def truncate(self
, pos
=None):
1049 with self
._write
_lock
:
1050 self
._flush
_unlocked
()
1052 pos
= self
.raw
.tell()
1053 return self
.raw
.truncate(pos
)
1056 with self
._write
_lock
:
1057 self
._flush
_unlocked
()
1059 def _flush_unlocked(self
):
1061 raise ValueError("flush of closed file")
1064 while self
._write
_buf
:
1065 n
= self
.raw
.write(self
._write
_buf
)
1066 if n
> len(self
._write
_buf
) or n
< 0:
1067 raise IOError("write() returned incorrect number of bytes")
1068 del self
._write
_buf
[:n
]
1070 except BlockingIOError
as e
:
1071 n
= e
.characters_written
1072 del self
._write
_buf
[:n
]
1074 raise BlockingIOError(e
.errno
, e
.strerror
, written
)
1077 return _BufferedIOMixin
.tell(self
) + len(self
._write
_buf
)
1079 def seek(self
, pos
, whence
=0):
1080 if not (0 <= whence
<= 2):
1081 raise ValueError("invalid whence")
1082 with self
._write
_lock
:
1083 self
._flush
_unlocked
()
1084 return _BufferedIOMixin
.seek(self
, pos
, whence
)
1087 class BufferedRWPair(BufferedIOBase
):
1089 """A buffered reader and writer object together.
1091 A buffered reader object and buffered writer object put together to
1092 form a sequential IO object that can read and write. This is typically
1093 used with a socket or two-way pipe.
1095 reader and writer are RawIOBase objects that are readable and
1096 writeable respectively. If the buffer_size is omitted it defaults to
1097 DEFAULT_BUFFER_SIZE.
1100 # XXX The usefulness of this (compared to having two separate IO
1101 # objects) is questionable.
1103 def __init__(self
, reader
, writer
,
1104 buffer_size
=DEFAULT_BUFFER_SIZE
, max_buffer_size
=None):
1107 The arguments are two RawIO instances.
1109 if max_buffer_size
is not None:
1110 warnings
.warn("max_buffer_size is deprecated", DeprecationWarning, 2)
1112 if not reader
.readable():
1113 raise IOError('"reader" argument must be readable.')
1115 if not writer
.writable():
1116 raise IOError('"writer" argument must be writable.')
1118 self
.reader
= BufferedReader(reader
, buffer_size
)
1119 self
.writer
= BufferedWriter(writer
, buffer_size
)
1121 def read(self
, n
=None):
1124 return self
.reader
.read(n
)
1126 def readinto(self
, b
):
1127 return self
.reader
.readinto(b
)
1130 return self
.writer
.write(b
)
1132 def peek(self
, n
=0):
1133 return self
.reader
.peek(n
)
1136 return self
.reader
.read1(n
)
1139 return self
.reader
.readable()
1142 return self
.writer
.writable()
1145 return self
.writer
.flush()
1152 return self
.reader
.isatty() or self
.writer
.isatty()
1156 return self
.writer
.closed
1159 class BufferedRandom(BufferedWriter
, BufferedReader
):
1161 """A buffered interface to random access streams.
1163 The constructor creates a reader and writer for a seekable stream,
1164 raw, given in the first argument. If the buffer_size is omitted it
1165 defaults to DEFAULT_BUFFER_SIZE.
1168 _warning_stack_offset
= 3
1170 def __init__(self
, raw
,
1171 buffer_size
=DEFAULT_BUFFER_SIZE
, max_buffer_size
=None):
1172 raw
._checkSeekable
()
1173 BufferedReader
.__init
__(self
, raw
, buffer_size
)
1174 BufferedWriter
.__init
__(self
, raw
, buffer_size
, max_buffer_size
)
1176 def seek(self
, pos
, whence
=0):
1177 if not (0 <= whence
<= 2):
1178 raise ValueError("invalid whence")
1182 with self
._read
_lock
:
1183 self
.raw
.seek(self
._read
_pos
- len(self
._read
_buf
), 1)
1184 # First do the raw seek, then empty the read buffer, so that
1185 # if the raw seek fails, we don't lose buffered data forever.
1186 pos
= self
.raw
.seek(pos
, whence
)
1187 with self
._read
_lock
:
1188 self
._reset
_read
_buf
()
1190 raise IOError("seek() returned invalid position")
1195 return BufferedWriter
.tell(self
)
1197 return BufferedReader
.tell(self
)
1199 def truncate(self
, pos
=None):
1202 # Use seek to flush the read buffer.
1204 return BufferedWriter
.truncate(self
)
1206 def read(self
, n
=None):
1210 return BufferedReader
.read(self
, n
)
1212 def readinto(self
, b
):
1214 return BufferedReader
.readinto(self
, b
)
1216 def peek(self
, n
=0):
1218 return BufferedReader
.peek(self
, n
)
1222 return BufferedReader
.read1(self
, n
)
1227 with self
._read
_lock
:
1228 self
.raw
.seek(self
._read
_pos
- len(self
._read
_buf
), 1)
1229 self
._reset
_read
_buf
()
1230 return BufferedWriter
.write(self
, b
)
1233 class TextIOBase(IOBase
):
1235 """Base class for text I/O.
1237 This class provides a character and line based interface to stream
1238 I/O. There is no readinto method because Python's character strings
1239 are immutable. There is no public constructor.
1242 def read(self
, n
: int = -1) -> str:
1243 """Read at most n characters from stream.
1245 Read from underlying buffer until we have n characters or we hit EOF.
1246 If n is negative or omitted, read until EOF.
1248 self
._unsupported
("read")
1250 def write(self
, s
: str) -> int:
1251 """Write string s to stream."""
1252 self
._unsupported
("write")
1254 def truncate(self
, pos
: int = None) -> int:
1255 """Truncate size to pos."""
1256 self
._unsupported
("truncate")
1258 def readline(self
) -> str:
1259 """Read until newline or EOF.
1261 Returns an empty string if EOF is hit immediately.
1263 self
._unsupported
("readline")
1265 def detach(self
) -> None:
1267 Separate the underlying buffer from the TextIOBase and return it.
1269 After the underlying buffer has been detached, the TextIO is in an
1272 self
._unsupported
("detach")
1276 """Subclasses should override."""
1281 """Line endings translated so far.
1283 Only line endings translated during reading are considered.
1285 Subclasses should override.
1291 """Error setting of the decoder or encoder.
1293 Subclasses should override."""
1296 io
.TextIOBase
.register(TextIOBase
)
1299 class IncrementalNewlineDecoder(codecs
.IncrementalDecoder
):
1300 r
"""Codec used when reading a file in universal newlines mode. It wraps
1301 another incremental decoder, translating \r\n and \r into \n. It also
1302 records the types of newlines encountered. When used with
1303 translate=False, it ensures that the newline sequence is returned in
1306 def __init__(self
, decoder
, translate
, errors
='strict'):
1307 codecs
.IncrementalDecoder
.__init
__(self
, errors
=errors
)
1308 self
.translate
= translate
1309 self
.decoder
= decoder
1311 self
.pendingcr
= False
1313 def decode(self
, input, final
=False):
1314 # decode input (with the eventual \r from a previous pass)
1315 if self
.decoder
is None:
1318 output
= self
.decoder
.decode(input, final
=final
)
1319 if self
.pendingcr
and (output
or final
):
1320 output
= "\r" + output
1321 self
.pendingcr
= False
1323 # retain last \r even when not translating data:
1324 # then readline() is sure to get \r\n in one pass
1325 if output
.endswith("\r") and not final
:
1326 output
= output
[:-1]
1327 self
.pendingcr
= True
1329 # Record which newlines are read
1330 crlf
= output
.count('\r\n')
1331 cr
= output
.count('\r') - crlf
1332 lf
= output
.count('\n') - crlf
1333 self
.seennl |
= (lf
and self
._LF
) |
(cr
and self
._CR
) \
1334 |
(crlf
and self
._CRLF
)
1338 output
= output
.replace("\r\n", "\n")
1340 output
= output
.replace("\r", "\n")
1345 if self
.decoder
is None:
1349 buf
, flag
= self
.decoder
.getstate()
1355 def setstate(self
, state
):
1357 self
.pendingcr
= bool(flag
& 1)
1358 if self
.decoder
is not None:
1359 self
.decoder
.setstate((buf
, flag
>> 1))
1363 self
.pendingcr
= False
1364 if self
.decoder
is not None:
1365 self
.decoder
.reset()
1380 ("\r", "\n", "\r\n")
1384 class TextIOWrapper(TextIOBase
):
1386 r
"""Character and line based layer over a BufferedIOBase object, buffer.
1388 encoding gives the name of the encoding that the stream will be
1389 decoded or encoded with. It defaults to locale.getpreferredencoding.
1391 errors determines the strictness of encoding and decoding (see the
1392 codecs.register) and defaults to "strict".
1394 newline can be None, '', '\n', '\r', or '\r\n'. It controls the
1395 handling of line endings. If it is None, universal newlines is
1396 enabled. With this enabled, on input, the lines endings '\n', '\r',
1397 or '\r\n' are translated to '\n' before being returned to the
1398 caller. Conversely, on output, '\n' is translated to the system
1399 default line seperator, os.linesep. If newline is any other of its
1400 legal values, that newline becomes the newline when the file is read
1401 and it is returned untranslated. On output, '\n' is converted to the
1404 If line_buffering is True, a call to flush is implied when a call to
1405 write contains a newline character.
1410 def __init__(self
, buffer, encoding
=None, errors
=None, newline
=None,
1411 line_buffering
=False):
1412 if newline
is not None and not isinstance(newline
, str):
1413 raise TypeError("illegal newline type: %r" % (type(newline
),))
1414 if newline
not in (None, "", "\n", "\r", "\r\n"):
1415 raise ValueError("illegal newline value: %r" % (newline
,))
1416 if encoding
is None:
1418 encoding
= os
.device_encoding(buffer.fileno())
1419 except (AttributeError, UnsupportedOperation
):
1421 if encoding
is None:
1425 # Importing locale may fail if Python is being built
1428 encoding
= locale
.getpreferredencoding()
1430 if not isinstance(encoding
, str):
1431 raise ValueError("invalid encoding: %r" % encoding
)
1436 if not isinstance(errors
, str):
1437 raise ValueError("invalid errors: %r" % errors
)
1439 self
.buffer = buffer
1440 self
._line
_buffering
= line_buffering
1441 self
._encoding
= encoding
1442 self
._errors
= errors
1443 self
._readuniversal
= not newline
1444 self
._readtranslate
= newline
is None
1445 self
._readnl
= newline
1446 self
._writetranslate
= newline
!= ''
1447 self
._writenl
= newline
or os
.linesep
1448 self
._encoder
= None
1449 self
._decoder
= None
1450 self
._decoded
_chars
= '' # buffer for text returned from decoder
1451 self
._decoded
_chars
_used
= 0 # offset into _decoded_chars for read()
1452 self
._snapshot
= None # info for reconstructing decoder state
1453 self
._seekable
= self
._telling
= self
.buffer.seekable()
1455 if self
._seekable
and self
.writable():
1456 position
= self
.buffer.tell()
1459 self
._get
_encoder
().setstate(0)
1461 # Sometimes the encoder doesn't exist
1464 # self._snapshot is either None, or a tuple (dec_flags, next_input)
1465 # where dec_flags is the second (integer) item of the decoder state
1466 # and next_input is the chunk of input bytes that comes next after the
1467 # snapshot point. We use this to reconstruct decoder states in tell().
1469 # Naming convention:
1470 # - "bytes_..." for integer variables that count input bytes
1471 # - "chars_..." for integer variables that count decoded characters
1476 except AttributeError:
1477 return "<_pyio.TextIOWrapper encoding={0!r}>".format(self
.encoding
)
1479 return "<_pyio.TextIOWrapper name={0!r} encoding={1!r}>".format(
1480 name
, self
.encoding
)
1484 return self
._encoding
1491 def line_buffering(self
):
1492 return self
._line
_buffering
1495 return self
._seekable
1498 return self
.buffer.readable()
1501 return self
.buffer.writable()
1505 self
._telling
= self
._seekable
1508 if self
.buffer is not None:
1512 pass # If flush() fails, just give up
1517 return self
.buffer.closed
1521 return self
.buffer.name
1524 return self
.buffer.fileno()
1527 return self
.buffer.isatty()
1529 def write(self
, s
: str):
1531 raise ValueError("write to closed file")
1532 if not isinstance(s
, str):
1533 raise TypeError("can't write %s to text stream" %
1534 s
.__class
__.__name
__)
1536 haslf
= (self
._writetranslate
or self
._line
_buffering
) and "\n" in s
1537 if haslf
and self
._writetranslate
and self
._writenl
!= "\n":
1538 s
= s
.replace("\n", self
._writenl
)
1539 encoder
= self
._encoder
or self
._get
_encoder
()
1540 # XXX What if we were just reading?
1541 b
= encoder
.encode(s
)
1542 self
.buffer.write(b
)
1543 if self
._line
_buffering
and (haslf
or "\r" in s
):
1545 self
._snapshot
= None
1547 self
._decoder
.reset()
1550 def _get_encoder(self
):
1551 make_encoder
= codecs
.getincrementalencoder(self
._encoding
)
1552 self
._encoder
= make_encoder(self
._errors
)
1553 return self
._encoder
1555 def _get_decoder(self
):
1556 make_decoder
= codecs
.getincrementaldecoder(self
._encoding
)
1557 decoder
= make_decoder(self
._errors
)
1558 if self
._readuniversal
:
1559 decoder
= IncrementalNewlineDecoder(decoder
, self
._readtranslate
)
1560 self
._decoder
= decoder
1563 # The following three methods implement an ADT for _decoded_chars.
1564 # Text returned from the decoder is buffered here until the client
1565 # requests it by calling our read() or readline() method.
1566 def _set_decoded_chars(self
, chars
):
1567 """Set the _decoded_chars buffer."""
1568 self
._decoded
_chars
= chars
1569 self
._decoded
_chars
_used
= 0
1571 def _get_decoded_chars(self
, n
=None):
1572 """Advance into the _decoded_chars buffer."""
1573 offset
= self
._decoded
_chars
_used
1575 chars
= self
._decoded
_chars
[offset
:]
1577 chars
= self
._decoded
_chars
[offset
:offset
+ n
]
1578 self
._decoded
_chars
_used
+= len(chars
)
1581 def _rewind_decoded_chars(self
, n
):
1582 """Rewind the _decoded_chars buffer."""
1583 if self
._decoded
_chars
_used
< n
:
1584 raise AssertionError("rewind decoded_chars out of bounds")
1585 self
._decoded
_chars
_used
-= n
1587 def _read_chunk(self
):
1589 Read and decode the next chunk of data from the BufferedReader.
1592 # The return value is True unless EOF was reached. The decoded
1593 # string is placed in self._decoded_chars (replacing its previous
1594 # value). The entire input chunk is sent to the decoder, though
1595 # some of it may remain buffered in the decoder, yet to be
1598 if self
._decoder
is None:
1599 raise ValueError("no decoder")
1602 # To prepare for tell(), we need to snapshot a point in the
1603 # file where the decoder's input buffer is empty.
1605 dec_buffer
, dec_flags
= self
._decoder
.getstate()
1606 # Given this, we know there was a valid snapshot point
1607 # len(dec_buffer) bytes ago with decoder state (b'', dec_flags).
1609 # Read a chunk, decode it, and put the result in self._decoded_chars.
1610 input_chunk
= self
.buffer.read1(self
._CHUNK
_SIZE
)
1611 eof
= not input_chunk
1612 self
._set
_decoded
_chars
(self
._decoder
.decode(input_chunk
, eof
))
1615 # At the snapshot point, len(dec_buffer) bytes before the read,
1616 # the next input to be decoded is dec_buffer + input_chunk.
1617 self
._snapshot
= (dec_flags
, dec_buffer
+ input_chunk
)
1621 def _pack_cookie(self
, position
, dec_flags
=0,
1622 bytes_to_feed
=0, need_eof
=0, chars_to_skip
=0):
1623 # The meaning of a tell() cookie is: seek to position, set the
1624 # decoder flags to dec_flags, read bytes_to_feed bytes, feed them
1625 # into the decoder with need_eof as the EOF flag, then skip
1626 # chars_to_skip characters of the decoded result. For most simple
1627 # decoders, tell() will often just give a byte offset in the file.
1628 return (position |
(dec_flags
<<64) |
(bytes_to_feed
<<128) |
1629 (chars_to_skip
<<192) |
bool(need_eof
)<<256)
1631 def _unpack_cookie(self
, bigint
):
1632 rest
, position
= divmod(bigint
, 1<<64)
1633 rest
, dec_flags
= divmod(rest
, 1<<64)
1634 rest
, bytes_to_feed
= divmod(rest
, 1<<64)
1635 need_eof
, chars_to_skip
= divmod(rest
, 1<<64)
1636 return position
, dec_flags
, bytes_to_feed
, need_eof
, chars_to_skip
1639 if not self
._seekable
:
1640 raise IOError("underlying stream is not seekable")
1641 if not self
._telling
:
1642 raise IOError("telling position disabled by next() call")
1644 position
= self
.buffer.tell()
1645 decoder
= self
._decoder
1646 if decoder
is None or self
._snapshot
is None:
1647 if self
._decoded
_chars
:
1648 # This should never happen.
1649 raise AssertionError("pending decoded text")
1652 # Skip backward to the snapshot point (see _read_chunk).
1653 dec_flags
, next_input
= self
._snapshot
1654 position
-= len(next_input
)
1656 # How many decoded characters have been used up since the snapshot?
1657 chars_to_skip
= self
._decoded
_chars
_used
1658 if chars_to_skip
== 0:
1659 # We haven't moved from the snapshot point.
1660 return self
._pack
_cookie
(position
, dec_flags
)
1662 # Starting from the snapshot position, we will walk the decoder
1663 # forward until it gives us enough decoded characters.
1664 saved_state
= decoder
.getstate()
1666 # Note our initial start point.
1667 decoder
.setstate((b
'', dec_flags
))
1668 start_pos
= position
1669 start_flags
, bytes_fed
, chars_decoded
= dec_flags
, 0, 0
1672 # Feed the decoder one byte at a time. As we go, note the
1673 # nearest "safe start point" before the current location
1674 # (a point where the decoder has nothing buffered, so seek()
1675 # can safely start from there and advance to this location).
1676 next_byte
= bytearray(1)
1677 for next_byte
[0] in next_input
:
1679 chars_decoded
+= len(decoder
.decode(next_byte
))
1680 dec_buffer
, dec_flags
= decoder
.getstate()
1681 if not dec_buffer
and chars_decoded
<= chars_to_skip
:
1682 # Decoder buffer is empty, so this is a safe start point.
1683 start_pos
+= bytes_fed
1684 chars_to_skip
-= chars_decoded
1685 start_flags
, bytes_fed
, chars_decoded
= dec_flags
, 0, 0
1686 if chars_decoded
>= chars_to_skip
:
1689 # We didn't get enough decoded data; signal EOF to get more.
1690 chars_decoded
+= len(decoder
.decode(b
'', final
=True))
1692 if chars_decoded
< chars_to_skip
:
1693 raise IOError("can't reconstruct logical file position")
1695 # The returned cookie corresponds to the last safe start point.
1696 return self
._pack
_cookie
(
1697 start_pos
, start_flags
, bytes_fed
, need_eof
, chars_to_skip
)
1699 decoder
.setstate(saved_state
)
1701 def truncate(self
, pos
=None):
1706 return self
.buffer.truncate()
1709 if self
.buffer is None:
1710 raise ValueError("buffer is already detached")
1712 buffer = self
.buffer
1716 def seek(self
, cookie
, whence
=0):
1718 raise ValueError("tell on closed file")
1719 if not self
._seekable
:
1720 raise IOError("underlying stream is not seekable")
1721 if whence
== 1: # seek relative to current position
1723 raise IOError("can't do nonzero cur-relative seeks")
1724 # Seeking to the current position should attempt to
1725 # sync the underlying buffer with the current position.
1727 cookie
= self
.tell()
1728 if whence
== 2: # seek relative to end of file
1730 raise IOError("can't do nonzero end-relative seeks")
1732 position
= self
.buffer.seek(0, 2)
1733 self
._set
_decoded
_chars
('')
1734 self
._snapshot
= None
1736 self
._decoder
.reset()
1739 raise ValueError("invalid whence (%r, should be 0, 1 or 2)" %
1742 raise ValueError("negative seek position %r" % (cookie
,))
1745 # The strategy of seek() is to go back to the safe start point
1746 # and replay the effect of read(chars_to_skip) from there.
1747 start_pos
, dec_flags
, bytes_to_feed
, need_eof
, chars_to_skip
= \
1748 self
._unpack
_cookie
(cookie
)
1750 # Seek back to the safe start point.
1751 self
.buffer.seek(start_pos
)
1752 self
._set
_decoded
_chars
('')
1753 self
._snapshot
= None
1755 # Restore the decoder to its state from the safe start point.
1756 if cookie
== 0 and self
._decoder
:
1757 self
._decoder
.reset()
1758 elif self
._decoder
or dec_flags
or chars_to_skip
:
1759 self
._decoder
= self
._decoder
or self
._get
_decoder
()
1760 self
._decoder
.setstate((b
'', dec_flags
))
1761 self
._snapshot
= (dec_flags
, b
'')
1764 # Just like _read_chunk, feed the decoder and save a snapshot.
1765 input_chunk
= self
.buffer.read(bytes_to_feed
)
1766 self
._set
_decoded
_chars
(
1767 self
._decoder
.decode(input_chunk
, need_eof
))
1768 self
._snapshot
= (dec_flags
, input_chunk
)
1770 # Skip chars_to_skip of the decoded characters.
1771 if len(self
._decoded
_chars
) < chars_to_skip
:
1772 raise IOError("can't restore logical file position")
1773 self
._decoded
_chars
_used
= chars_to_skip
1775 # Finally, reset the encoder (merely useful for proper BOM handling)
1777 encoder
= self
._encoder
or self
._get
_encoder
()
1779 # Sometimes the encoder doesn't exist
1788 def read(self
, n
=None):
1789 self
._checkReadable
()
1792 decoder
= self
._decoder
or self
._get
_decoder
()
1795 result
= (self
._get
_decoded
_chars
() +
1796 decoder
.decode(self
.buffer.read(), final
=True))
1797 self
._set
_decoded
_chars
('')
1798 self
._snapshot
= None
1801 # Keep reading chunks until we have n characters to return.
1803 result
= self
._get
_decoded
_chars
(n
)
1804 while len(result
) < n
and not eof
:
1805 eof
= not self
._read
_chunk
()
1806 result
+= self
._get
_decoded
_chars
(n
- len(result
))
1810 self
._telling
= False
1811 line
= self
.readline()
1813 self
._snapshot
= None
1814 self
._telling
= self
._seekable
1818 def readline(self
, limit
=None):
1820 raise ValueError("read from closed file")
1823 elif not isinstance(limit
, int):
1824 raise TypeError("limit must be an integer")
1826 # Grab all the decoded text (we will rewind any extra bits later).
1827 line
= self
._get
_decoded
_chars
()
1830 # Make the decoder if it doesn't already exist.
1831 if not self
._decoder
:
1836 if self
._readtranslate
:
1837 # Newlines are already translated, only search for \n
1838 pos
= line
.find('\n', start
)
1845 elif self
._readuniversal
:
1846 # Universal newline search. Find any of \r, \r\n, \n
1847 # The decoder ensures that \r\n are not split in two pieces
1849 # In C we'd look for these in parallel of course.
1850 nlpos
= line
.find("\n", start
)
1851 crpos
= line
.find("\r", start
)
1868 elif nlpos
== crpos
+ 1:
1878 pos
= line
.find(self
._readnl
)
1880 endpos
= pos
+ len(self
._readnl
)
1883 if limit
>= 0 and len(line
) >= limit
:
1884 endpos
= limit
# reached length limit
1887 # No line ending seen yet - get more data'
1888 while self
._read
_chunk
():
1889 if self
._decoded
_chars
:
1891 if self
._decoded
_chars
:
1892 line
+= self
._get
_decoded
_chars
()
1895 self
._set
_decoded
_chars
('')
1896 self
._snapshot
= None
1899 if limit
>= 0 and endpos
> limit
:
1900 endpos
= limit
# don't exceed limit
1902 # Rewind _decoded_chars to just after the line ending we found.
1903 self
._rewind
_decoded
_chars
(len(line
) - endpos
)
1904 return line
[:endpos
]
1908 return self
._decoder
.newlines
if self
._decoder
else None
1911 class StringIO(TextIOWrapper
):
1912 """Text I/O implementation using an in-memory buffer.
1914 The initial_value argument sets the value of object. The newline
1915 argument is like the one of TextIOWrapper's constructor.
1918 def __init__(self
, initial_value
="", newline
="\n"):
1919 super(StringIO
, self
).__init
__(BytesIO(),
1923 # Issue #5645: make universal newlines semantics the same as in the
1924 # C version, even under Windows.
1926 self
._writetranslate
= False
1928 if not isinstance(initial_value
, str):
1929 initial_value
= str(initial_value
)
1930 self
.write(initial_value
)
1935 return self
.buffer.getvalue().decode(self
._encoding
, self
._errors
)
1938 # TextIOWrapper tells the encoding in its repr. In StringIO,
1939 # that's a implementation detail.
1940 return object.__repr
__(self
)
1951 # This doesn't make sense on StringIO.
1952 self
._unsupported
("detach")