Lines Matching refs:self
365 def _unsupported(self, name):
368 (self.__class__.__name__, name))
372 def seek(self, pos, whence=0):
386 self._unsupported("seek")
388 def tell(self):
390 return self.seek(0, 1)
392 def truncate(self, pos=None):
398 self._unsupported("truncate")
402 def flush(self):
407 self._checkClosed()
412 def close(self):
417 if not self.__closed:
419 self.flush()
421 self.__closed = True
423 def __del__(self):
426 closed = self.closed
436 self.close()
444 self.close()
450 def seekable(self):
458 def _checkSeekable(self, msg=None):
461 if not self.seekable():
465 def readable(self):
472 def _checkReadable(self, msg=None):
475 if not self.readable():
479 def writable(self):
486 def _checkWritable(self, msg=None):
489 if not self.writable():
494 def closed(self):
499 return self.__closed
501 def _checkClosed(self, msg=None):
504 if self.closed:
510 def __enter__(self): # That's a forward reference
511 """Context management protocol. Returns self (an instance of IOBase)."""
512 self._checkClosed()
513 return self
515 def __exit__(self, *args):
517 self.close()
523 def fileno(self):
528 self._unsupported("fileno")
530 def isatty(self):
535 self._checkClosed()
540 def readline(self, size=-1):
551 if hasattr(self, "peek"):
553 readahead = self.peek(1)
574 b = self.read(nreadahead())
582 def __iter__(self):
583 self._checkClosed()
584 return self
586 def __next__(self):
587 line = self.readline()
592 def readlines(self, hint=None):
600 return list(self)
603 for line in self:
610 def writelines(self, lines):
616 self._checkClosed()
618 self.write(line)
637 def read(self, size=-1):
646 return self.readall()
648 n = self.readinto(b)
654 def readall(self):
658 data = self.read(DEFAULT_BUFFER_SIZE)
668 def readinto(self, b):
674 self._unsupported("readinto")
676 def write(self, b):
682 self._unsupported("write")
706 def read(self, size=-1):
724 self._unsupported("read")
726 def read1(self, size=-1):
730 self._unsupported("read1")
732 def readinto(self, b):
744 return self._readinto(b, read1=False)
746 def readinto1(self, b):
755 return self._readinto(b, read1=True)
757 def _readinto(self, b, read1):
763 data = self.read1(len(b))
765 data = self.read(len(b))
772 def write(self, b):
781 self._unsupported("write")
783 def detach(self):
790 self._unsupported("detach")
804 def __init__(self, raw):
805 self._raw = raw
809 def seek(self, pos, whence=0):
810 new_position = self.raw.seek(pos, whence)
815 def tell(self):
816 pos = self.raw.tell()
821 def truncate(self, pos=None):
822 self._checkClosed()
823 self._checkWritable()
828 self.flush()
831 pos = self.tell()
834 return self.raw.truncate(pos)
838 def flush(self):
839 if self.closed:
841 self.raw.flush()
843 def close(self):
844 if self.raw is not None and not self.closed:
847 self.flush()
849 self.raw.close()
851 def detach(self):
852 if self.raw is None:
854 self.flush()
855 raw = self._raw
856 self._raw = None
861 def seekable(self):
862 return self.raw.seekable()
865 def raw(self):
866 return self._raw
869 def closed(self):
870 return self.raw.closed
873 def name(self):
874 return self.raw.name
877 def mode(self):
878 return self.raw.mode
880 def __getstate__(self):
881 raise TypeError(f"cannot pickle {self.__class__.__name__!r} object")
883 def __repr__(self):
884 modname = self.__class__.__module__
885 clsname = self.__class__.__qualname__
887 name = self.name
895 def fileno(self):
896 return self.raw.fileno()
898 def isatty(self):
899 return self.raw.isatty()
910 def __init__(self, initial_bytes=None):
914 self._buffer = buf
915 self._pos = 0
917 def __getstate__(self):
918 if self.closed:
920 return self.__dict__.copy()
922 def getvalue(self):
925 if self.closed:
927 return bytes(self._buffer)
929 def getbuffer(self):
932 if self.closed:
934 return memoryview(self._buffer)
936 def close(self):
937 if self._buffer is not None:
938 self._buffer.clear()
941 def read(self, size=-1):
942 if self.closed:
954 size = len(self._buffer)
955 if len(self._buffer) <= self._pos:
957 newpos = min(len(self._buffer), self._pos + size)
958 b = self._buffer[self._pos : newpos]
959 self._pos = newpos
962 def read1(self, size=-1):
965 return self.read(size)
967 def write(self, b):
968 if self.closed:
976 pos = self._pos
977 if pos > len(self._buffer):
980 padding = b'\x00' * (pos - len(self._buffer))
981 self._buffer += padding
982 self._buffer[pos:pos + n] = b
983 self._pos += n
986 def seek(self, pos, whence=0):
987 if self.closed:
998 self._pos = pos
1000 self._pos = max(0, self._pos + pos)
1002 self._pos = max(0, len(self._buffer) + pos)
1005 return self._pos
1007 def tell(self):
1008 if self.closed:
1010 return self._pos
1012 def truncate(self, pos=None):
1013 if self.closed:
1016 pos = self._pos
1026 del self._buffer[pos:]
1029 def readable(self):
1030 if self.closed:
1034 def writable(self):
1035 if self.closed:
1039 def seekable(self):
1040 if self.closed:
1056 def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):
1062 _BufferedIOMixin.__init__(self, raw)
1065 self.buffer_size = buffer_size
1066 self._reset_read_buf()
1067 self._read_lock = Lock()
1069 def readable(self):
1070 return self.raw.readable()
1072 def _reset_read_buf(self):
1073 self._read_buf = b""
1074 self._read_pos = 0
1076 def read(self, size=None):
1086 with self._read_lock:
1087 return self._read_unlocked(size)
1089 def _read_unlocked(self, n=None):
1092 buf = self._read_buf
1093 pos = self._read_pos
1097 self._reset_read_buf()
1098 if hasattr(self.raw, 'readall'):
1099 chunk = self.raw.readall()
1108 chunk = self.raw.read()
1120 self._read_pos += n
1125 wanted = max(self.buffer_size, n)
1127 chunk = self.raw.read(wanted)
1137 self._read_buf = out[n:] # Save the extra data in the buffer.
1138 self._read_pos = 0
1141 def peek(self, size=0):
1146 than self.buffer_size.
1148 with self._read_lock:
1149 return self._peek_unlocked(size)
1151 def _peek_unlocked(self, n=0):
1152 want = min(n, self.buffer_size)
1153 have = len(self._read_buf) - self._read_pos
1155 to_read = self.buffer_size - have
1156 current = self.raw.read(to_read)
1158 self._read_buf = self._read_buf[self._read_pos:] + current
1159 self._read_pos = 0
1160 return self._read_buf[self._read_pos:]
1162 def read1(self, size=-1):
1167 size = self.buffer_size
1170 with self._read_lock:
1171 self._peek_unlocked(1)
1172 return self._read_unlocked(
1173 min(size, len(self._read_buf) - self._read_pos))
1180 def _readinto(self, buf, read1):
1193 with self._read_lock:
1197 avail = min(len(self._read_buf) - self._read_pos, len(buf))
1200 self._read_buf[self._read_pos:self._read_pos+avail]
1201 self._read_pos += avail
1208 if len(buf) - written > self.buffer_size:
1209 n = self.raw.readinto(buf[written:])
1217 if not self._peek_unlocked(1):
1226 def tell(self):
1227 return _BufferedIOMixin.tell(self) - len(self._read_buf) + self._read_pos
1229 def seek(self, pos, whence=0):
1232 with self._read_lock:
1234 pos -= len(self._read_buf) - self._read_pos
1235 pos = _BufferedIOMixin.seek(self, pos, whence)
1236 self._reset_read_buf()
1248 def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):
1252 _BufferedIOMixin.__init__(self, raw)
1255 self.buffer_size = buffer_size
1256 self._write_buf = bytearray()
1257 self._write_lock = Lock()
1259 def writable(self):
1260 return self.raw.writable()
1262 def write(self, b):
1265 with self._write_lock:
1266 if self.closed:
1270 if len(self._write_buf) > self.buffer_size:
1273 self._flush_unlocked()
1274 before = len(self._write_buf)
1275 self._write_buf.extend(b)
1276 written = len(self._write_buf) - before
1277 if len(self._write_buf) > self.buffer_size:
1279 self._flush_unlocked()
1281 if len(self._write_buf) > self.buffer_size:
1284 overage = len(self._write_buf) - self.buffer_size
1286 self._write_buf = self._write_buf[:self.buffer_size]
1290 def truncate(self, pos=None):
1291 with self._write_lock:
1292 self._flush_unlocked()
1294 pos = self.raw.tell()
1295 return self.raw.truncate(pos)
1297 def flush(self):
1298 with self._write_lock:
1299 self._flush_unlocked()
1301 def _flush_unlocked(self):
1302 if self.closed:
1304 while self._write_buf:
1306 n = self.raw.write(self._write_buf)
1308 raise RuntimeError("self.raw should implement RawIOBase: it "
1314 if n > len(self._write_buf) or n < 0:
1316 del self._write_buf[:n]
1318 def tell(self):
1319 return _BufferedIOMixin.tell(self) + len(self._write_buf)
1321 def seek(self, pos, whence=0):
1324 with self._write_lock:
1325 self._flush_unlocked()
1326 return _BufferedIOMixin.seek(self, pos, whence)
1328 def close(self):
1329 with self._write_lock:
1330 if self.raw is None or self.closed:
1332 # We have to release the lock and call self.flush() (which will
1334 # a subclass or the user set self.flush to something. This is the same
1338 self.flush()
1340 with self._write_lock:
1341 self.raw.close()
1360 def __init__(self, reader, writer, buffer_size=DEFAULT_BUFFER_SIZE):
1371 self.reader = BufferedReader(reader, buffer_size)
1372 self.writer = BufferedWriter(writer, buffer_size)
1374 def read(self, size=-1):
1377 return self.reader.read(size)
1379 def readinto(self, b):
1380 return self.reader.readinto(b)
1382 def write(self, b):
1383 return self.writer.write(b)
1385 def peek(self, size=0):
1386 return self.reader.peek(size)
1388 def read1(self, size=-1):
1389 return self.reader.read1(size)
1391 def readinto1(self, b):
1392 return self.reader.readinto1(b)
1394 def readable(self):
1395 return self.reader.readable()
1397 def writable(self):
1398 return self.writer.writable()
1400 def flush(self):
1401 return self.writer.flush()
1403 def close(self):
1405 self.writer.close()
1407 self.reader.close()
1409 def isatty(self):
1410 return self.reader.isatty() or self.writer.isatty()
1413 def closed(self):
1414 return self.writer.closed
1426 def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):
1428 BufferedReader.__init__(self, raw, buffer_size)
1429 BufferedWriter.__init__(self, raw, buffer_size)
1431 def seek(self, pos, whence=0):
1434 self.flush()
1435 if self._read_buf:
1437 with self._read_lock:
1438 self.raw.seek(self._read_pos - len(self._read_buf), 1)
1441 pos = self.raw.seek(pos, whence)
1442 with self._read_lock:
1443 self._reset_read_buf()
1448 def tell(self):
1449 if self._write_buf:
1450 return BufferedWriter.tell(self)
1452 return BufferedReader.tell(self)
1454 def truncate(self, pos=None):
1456 pos = self.tell()
1458 return BufferedWriter.truncate(self, pos)
1460 def read(self, size=None):
1463 self.flush()
1464 return BufferedReader.read(self, size)
1466 def readinto(self, b):
1467 self.flush()
1468 return BufferedReader.readinto(self, b)
1470 def peek(self, size=0):
1471 self.flush()
1472 return BufferedReader.peek(self, size)
1474 def read1(self, size=-1):
1475 self.flush()
1476 return BufferedReader.read1(self, size)
1478 def readinto1(self, b):
1479 self.flush()
1480 return BufferedReader.readinto1(self, b)
1482 def write(self, b):
1483 if self._read_buf:
1485 with self._read_lock:
1486 self.raw.seek(self._read_pos - len(self._read_buf), 1)
1487 self._reset_read_buf()
1488 return BufferedWriter.write(self, b)
1500 def __init__(self, file, mode='r', closefd=True, opener=None):
1513 if self._fd >= 0:
1516 if self._closefd:
1517 os.close(self._fd)
1519 self._fd = -1
1539 self._created = True
1540 self._writable = True
1543 self._readable = True
1546 self._writable = True
1549 self._writable = True
1550 self._appending = True
1554 self._readable = True
1555 self._writable = True
1557 if self._readable and self._writable:
1559 elif self._readable:
1587 self._closefd = closefd
1597 self._blksize = getattr(fdfstat, 'st_blksize', 0)
1598 if self._blksize <= 1:
1599 self._blksize = DEFAULT_BUFFER_SIZE
1605 self.name = file
1606 if self._appending:
1619 self._fd = fd
1621 def __del__(self):
1622 if self._fd >= 0 and self._closefd and not self.closed:
1624 warnings.warn('unclosed file %r' % (self,), ResourceWarning,
1625 stacklevel=2, source=self)
1626 self.close()
1628 def __getstate__(self):
1629 raise TypeError(f"cannot pickle {self.__class__.__name__!r} object")
1631 def __repr__(self):
1632 class_name = '%s.%s' % (self.__class__.__module__,
1633 self.__class__.__qualname__)
1634 if self.closed:
1637 name = self.name
1640 (class_name, self._fd, self.mode, self._closefd))
1643 (class_name, name, self.mode, self._closefd))
1645 def _checkReadable(self):
1646 if not self._readable:
1649 def _checkWritable(self, msg=None):
1650 if not self._writable:
1653 def read(self, size=None):
1660 self._checkClosed()
1661 self._checkReadable()
1663 return self.readall()
1665 return os.read(self._fd, size)
1669 def readall(self):
1675 self._checkClosed()
1676 self._checkReadable()
1679 pos = os.lseek(self._fd, 0, SEEK_CUR)
1680 end = os.fstat(self._fd).st_size
1693 chunk = os.read(self._fd, n)
1704 def readinto(self, b):
1707 data = self.read(len(m))
1712 def write(self, b):
1719 self._checkClosed()
1720 self._checkWritable()
1722 return os.write(self._fd, b)
1726 def seek(self, pos, whence=SEEK_SET):
1739 self._checkClosed()
1740 return os.lseek(self._fd, pos, whence)
1742 def tell(self):
1746 self._checkClosed()
1747 return os.lseek(self._fd, 0, SEEK_CUR)
1749 def truncate(self, size=None):
1755 self._checkClosed()
1756 self._checkWritable()
1758 size = self.tell()
1759 os.ftruncate(self._fd, size)
1762 def close(self):
1768 if not self.closed:
1770 if self._closefd:
1771 os.close(self._fd)
1775 def seekable(self):
1777 self._checkClosed()
1778 if self._seekable is None:
1780 self.tell()
1782 self._seekable = False
1784 self._seekable = True
1785 return self._seekable
1787 def readable(self):
1789 self._checkClosed()
1790 return self._readable
1792 def writable(self):
1794 self._checkClosed()
1795 return self._writable
1797 def fileno(self):
1799 self._checkClosed()
1800 return self._fd
1802 def isatty(self):
1804 self._checkClosed()
1805 return os.isatty(self._fd)
1808 def closefd(self):
1810 return self._closefd
1813 def mode(self):
1815 if self._created:
1816 if self._readable:
1820 elif self._appending:
1821 if self._readable:
1825 elif self._readable:
1826 if self._writable:
1842 def read(self, size=-1):
1850 self._unsupported("read")
1852 def write(self, s):
1854 self._unsupported("write")
1856 def truncate(self, pos=None):
1858 self._unsupported("truncate")
1860 def readline(self):
1865 self._unsupported("readline")
1867 def detach(self):
1874 self._unsupported("detach")
1877 def encoding(self):
1882 def newlines(self):
1892 def errors(self):
1908 def __init__(self, decoder, translate, errors='strict'):
1909 codecs.IncrementalDecoder.__init__(self, errors=errors)
1910 self.translate = translate
1911 self.decoder = decoder
1912 self.seennl = 0
1913 self.pendingcr = False
1915 def decode(self, input, final=False):
1917 if self.decoder is None:
1920 output = self.decoder.decode(input, final=final)
1921 if self.pendingcr and (output or final):
1923 self.pendingcr = False
1929 self.pendingcr = True
1935 self.seennl |= (lf and self._LF) | (cr and self._CR) \
1936 | (crlf and self._CRLF)
1938 if self.translate:
1946 def getstate(self):
1947 if self.decoder is None:
1951 buf, flag = self.decoder.getstate()
1953 if self.pendingcr:
1957 def setstate(self, state):
1959 self.pendingcr = bool(flag & 1)
1960 if self.decoder is not None:
1961 self.decoder.setstate((buf, flag >> 1))
1963 def reset(self):
1964 self.seennl = 0
1965 self.pendingcr = False
1966 if self.decoder is not None:
1967 self.decoder.reset()
1974 def newlines(self):
1983 )[self.seennl]
2019 def __init__(self, buffer, encoding=None, errors=None, newline=None,
2021 self._check_newline(newline)
2025 encoding = self._get_locale_encoding()
2043 self._buffer = buffer
2044 self._decoded_chars = '' # buffer for text returned from decoder
2045 self._decoded_chars_used = 0 # offset into _decoded_chars for read()
2046 self._snapshot = None # info for reconstructing decoder state
2047 self._seekable = self._telling = self.buffer.seekable()
2048 self._has_read1 = hasattr(self.buffer, 'read1')
2049 self._configure(encoding, errors, newline,
2052 def _check_newline(self, newline):
2058 def _configure(self, encoding=None, errors=None, newline=None,
2060 self._encoding = encoding
2061 self._errors = errors
2062 self._encoder = None
2063 self._decoder = None
2064 self._b2cratio = 0.0
2066 self._readuniversal = not newline
2067 self._readtranslate = newline is None
2068 self._readnl = newline
2069 self._writetranslate = newline != ''
2070 self._writenl = newline or os.linesep
2072 self._line_buffering = line_buffering
2073 self._write_through = write_through
2076 if self._seekable and self.writable():
2077 position = self.buffer.tell()
2080 self._get_encoder().setstate(0)
2085 # self._snapshot is either None, or a tuple (dec_flags, next_input)
2094 def __repr__(self):
2095 result = "<{}.{}".format(self.__class__.__module__,
2096 self.__class__.__qualname__)
2098 name = self.name
2104 mode = self.mode
2109 return result + " encoding={0!r}>".format(self.encoding)
2112 def encoding(self):
2113 return self._encoding
2116 def errors(self):
2117 return self._errors
2120 def line_buffering(self):
2121 return self._line_buffering
2124 def write_through(self):
2125 return self._write_through
2128 def buffer(self):
2129 return self._buffer
2131 def reconfigure(self, *,
2138 if (self._decoder is not None
2147 errors = self._errors
2154 encoding = self._encoding
2159 encoding = self._get_locale_encoding()
2162 newline = self._readnl
2163 self._check_newline(newline)
2166 line_buffering = self.line_buffering
2168 write_through = self.write_through
2170 self.flush()
2171 self._configure(encoding, errors, newline,
2174 def seekable(self):
2175 if self.closed:
2177 return self._seekable
2179 def readable(self):
2180 return self.buffer.readable()
2182 def writable(self):
2183 return self.buffer.writable()
2185 def flush(self):
2186 self.buffer.flush()
2187 self._telling = self._seekable
2189 def close(self):
2190 if self.buffer is not None and not self.closed:
2192 self.flush()
2194 self.buffer.close()
2197 def closed(self):
2198 return self.buffer.closed
2201 def name(self):
2202 return self.buffer.name
2204 def fileno(self):
2205 return self.buffer.fileno()
2207 def isatty(self):
2208 return self.buffer.isatty()
2210 def write(self, s):
2212 if self.closed:
2218 haslf = (self._writetranslate or self._line_buffering) and "\n" in s
2219 if haslf and self._writetranslate and self._writenl != "\n":
2220 s = s.replace("\n", self._writenl)
2221 encoder = self._encoder or self._get_encoder()
2224 self.buffer.write(b)
2225 if self._line_buffering and (haslf or "\r" in s):
2226 self.flush()
2227 self._set_decoded_chars('')
2228 self._snapshot = None
2229 if self._decoder:
2230 self._decoder.reset()
2233 def _get_encoder(self):
2234 make_encoder = codecs.getincrementalencoder(self._encoding)
2235 self._encoder = make_encoder(self._errors)
2236 return self._encoder
2238 def _get_decoder(self):
2239 make_decoder = codecs.getincrementaldecoder(self._encoding)
2240 decoder = make_decoder(self._errors)
2241 if self._readuniversal:
2242 decoder = IncrementalNewlineDecoder(decoder, self._readtranslate)
2243 self._decoder = decoder
2249 def _set_decoded_chars(self, chars):
2251 self._decoded_chars = chars
2252 self._decoded_chars_used = 0
2254 def _get_decoded_chars(self, n=None):
2256 offset = self._decoded_chars_used
2258 chars = self._decoded_chars[offset:]
2260 chars = self._decoded_chars[offset:offset + n]
2261 self._decoded_chars_used += len(chars)
2264 def _get_locale_encoding(self):
2273 def _rewind_decoded_chars(self, n):
2275 if self._decoded_chars_used < n:
2277 self._decoded_chars_used -= n
2279 def _read_chunk(self):
2285 # string is placed in self._decoded_chars (replacing its previous
2290 if self._decoder is None:
2293 if self._telling:
2297 dec_buffer, dec_flags = self._decoder.getstate()
2301 # Read a chunk, decode it, and put the result in self._decoded_chars.
2302 if self._has_read1:
2303 input_chunk = self.buffer.read1(self._CHUNK_SIZE)
2305 input_chunk = self.buffer.read(self._CHUNK_SIZE)
2307 decoded_chars = self._decoder.decode(input_chunk, eof)
2308 self._set_decoded_chars(decoded_chars)
2310 self._b2cratio = len(input_chunk) / len(self._decoded_chars)
2312 self._b2cratio = 0.0
2314 if self._telling:
2317 self._snapshot = (dec_flags, dec_buffer + input_chunk)
2321 def _pack_cookie(self, position, dec_flags=0,
2331 def _unpack_cookie(self, bigint):
2338 def tell(self):
2339 if not self._seekable:
2341 if not self._telling:
2343 self.flush()
2344 position = self.buffer.tell()
2345 decoder = self._decoder
2346 if decoder is None or self._snapshot is None:
2347 if self._decoded_chars:
2353 dec_flags, next_input = self._snapshot
2357 chars_to_skip = self._decoded_chars_used
2360 return self._pack_cookie(position, dec_flags)
2373 skip_bytes = int(self._b2cratio * chars_to_skip)
2403 return self._pack_cookie(start_pos, start_flags)
2432 return self._pack_cookie(
2437 def truncate(self, pos=None):
2438 self.flush()
2440 pos = self.tell()
2441 return self.buffer.truncate(pos)
2443 def detach(self):
2444 if self.buffer is None:
2446 self.flush()
2447 buffer = self._buffer
2448 self._buffer = None
2451 def seek(self, cookie, whence=0):
2455 encoder = self._encoder or self._get_encoder()
2465 if self.closed:
2467 if not self._seekable:
2475 cookie = self.tell()
2479 self.flush()
2480 position = self.buffer.seek(0, whence)
2481 self._set_decoded_chars('')
2482 self._snapshot = None
2483 if self._decoder:
2484 self._decoder.reset()
2491 self.flush()
2496 self._unpack_cookie(cookie)
2499 self.buffer.seek(start_pos)
2500 self._set_decoded_chars('')
2501 self._snapshot = None
2504 if cookie == 0 and self._decoder:
2505 self._decoder.reset()
2506 elif self._decoder or dec_flags or chars_to_skip:
2507 self._decoder = self._decoder or self._get_decoder()
2508 self._decoder.setstate((b'', dec_flags))
2509 self._snapshot = (dec_flags, b'')
2513 input_chunk = self.buffer.read(bytes_to_feed)
2514 self._set_decoded_chars(
2515 self._decoder.decode(input_chunk, need_eof))
2516 self._snapshot = (dec_flags, input_chunk)
2519 if len(self._decoded_chars) < chars_to_skip:
2521 self._decoded_chars_used = chars_to_skip
2526 def read(self, size=None):
2527 self._checkReadable()
2537 decoder = self._decoder or self._get_decoder()
2540 result = (self._get_decoded_chars() +
2541 decoder.decode(self.buffer.read(), final=True))
2542 self._set_decoded_chars('')
2543 self._snapshot = None
2548 result = self._get_decoded_chars(size)
2550 eof = not self._read_chunk()
2551 result += self._get_decoded_chars(size - len(result))
2554 def __next__(self):
2555 self._telling = False
2556 line = self.readline()
2558 self._snapshot = None
2559 self._telling = self._seekable
2563 def readline(self, size=None):
2564 if self.closed:
2577 line = self._get_decoded_chars()
2581 if not self._decoder:
2582 self._get_decoder()
2586 if self._readtranslate:
2595 elif self._readuniversal:
2628 pos = line.find(self._readnl)
2630 endpos = pos + len(self._readnl)
2638 while self._read_chunk():
2639 if self._decoded_chars:
2641 if self._decoded_chars:
2642 line += self._get_decoded_chars()
2645 self._set_decoded_chars('')
2646 self._snapshot = None
2653 self._rewind_decoded_chars(len(line) - endpos)
2657 def newlines(self):
2658 return self._decoder.newlines if self._decoder else None
2668 def __init__(self, initial_value="", newline="\n"):
2669 super(StringIO, self).__init__(BytesIO(),
2676 self._writetranslate = False
2681 self.write(initial_value)
2682 self.seek(0)
2684 def getvalue(self):
2685 self.flush()
2686 decoder = self._decoder or self._get_decoder()
2690 return decoder.decode(self.buffer.getvalue(), final=True)
2694 def __repr__(self):
2697 return object.__repr__(self)
2700 def errors(self):
2704 def encoding(self):
2707 def detach(self):
2709 self._unsupported("detach")