# coding=utf-8

# Copyright (c) 2017, 2020, Oracle and/or its affiliates.

# Copyright (c) 2017, The PyPy Project

#

# The MIT License

# Permission is hereby granted, free of charge, to any person

# obtaining a copy of this software and associated documentation

# files (the "Software"), to deal in the Software without

# restriction, including without limitation the rights to use,

# copy, modify, merge, publish, distribute, sublicense, and/or

# sell copies of the Software, and to permit persons to whom the

# Software is furnished to do so, subject to the following conditions:

#

# The above copyright notice and this permission notice shall be included

# in all copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

# DEALINGS IN THE SOFTWARE.

import sys

_warn = sys.modules["_warnings"]._warn

_os = sys.modules.get("posix", sys.modules.get("nt"))

DEFAULT_BUFFER_SIZE = 8192

class BlockingIOError(OSError):

pass

class UnsupportedOperation(OSError, ValueError):

pass

class _IOBase(object):

def __init__(self, **kwargs):

self.__IOBase_closed = False

def __enter__(self):

self._checkClosed()

return self

def __exit__(self, *args):

self.close()

def __iter__(self):

self._checkClosed()

return self

def __next__(self):

line = self.readline()

if not line:

raise StopIteration

return line

def __getstate__(self):

raise TypeError("cannot serialize '%s' object" % type(self))

def close(self):

if not self.closed:

try:

self.flush()

finally:

self.__IOBase_closed = True

def flush(self):

self._checkClosed()

def seek(self, offset, whence=None):

raise UnsupportedOperation("seek")

def tell(self):

return self.seek(0, 1)

def truncate(self):

raise UnsupportedOperation("truncate")

def fileno(self):

raise UnsupportedOperation("fileno")

def isatty(self):

self._checkClosed()

return False

def readable(self):

return False

def writable(self):

return False

def seekable(self):

return False

def _checkReadable(self):

if not self.readable():

raise UnsupportedOperation("File or stream is not readable")

def _checkWritable(self):

if not self.writable():

raise UnsupportedOperation("File or stream is not writable")

def _checkSeekable(self):

if not self.seekable():

raise UnsupportedOperation("File or stream is not seekable")

def _checkClosed(self):

if self.closed:

raise ValueError("I/O operation on closed file")

@property

def closed(self):

return self.__IOBase_closed

def __del__(self):

if not self.closed:

try:

self._dealloc_warn(self)

self.close()

finally:

# Ignore all errors

return

def _dealloc_warn(self, source):

pass

def readline(self, limit=-1):

has_peek = hasattr(self, "peek")

builder = []

size = 0

while limit < 0 or size < limit:

nreadahead = 1

if has_peek:

readahead = self.peek(1)

if not isinstance(readahead, bytes):

raise IOError("peek() should have returned a bytes object, not '%s'", type(readahead))

length = len(readahead)

if length > 0:

n = 0

buf = readahead

if limit >= 0:

while True:

if n >= length or n >= limit:

break

n += 1

if buf[n-1] == '\n':

break

else:

while True:

if n >= length:

break

n += 1

if buf[n-1] == '\n':

break

nreadahead = n

read = self.read(nreadahead)

if not isinstance(read, bytes):

raise IOError("read() should have returned a bytes object, not '%s'" % type(read))

if not read:

break

size += len(read)

builder.append(read)

if read[-1] == b'\n'[0]:

break

return b"".join(builder)

def readlines(self, hint=-1):

if hint <= 0:

return [line for line in self]

lines = []

length = 0

while True:

line = self.readline()

line_length = len(line)

if line_length == 0:

break

lines.append(line)

length += line_length

if length > hint:

break

return lines

def writelines(self, lines):

self._checkClosed()

for line in lines:

self.write(line)

class _RawIOBase(_IOBase):

def read(self, size=-1):

if size < 0:

return self.readall()

buf = bytearray(size)

length = self.readinto(buf)

if length is None:

return length

del buf[length:-1]

return bytes(buf)

def readall(self):

builder = []

while True:

data = self.read(DEFAULT_BUFFER_SIZE)

if data is None:

if not builder:

return data

break

if not isinstance(data, str):

raise TypeError("read() should return bytes")

if not data:

break

builder.append(data)

return b"".join(builder)

class FileIO(_RawIOBase):

@staticmethod

def __isdir__(mode):

# We cannot import the stat module here

return (mode & 0o170000) == 0o040000

@staticmethod

def __decode_mode__(mode):

O_BINARY = getattr(_os, "O_BINARY", 0)

O_APPEND = getattr(_os, "O_APPEND", 0)

_bad_mode = ValueError("Must have exactly one of read/write/create/append mode")

flags = 0

rwa = False

readable = False

writable = False

created = False

append = False

plus = False

for s in mode:

if s == 'r':

if rwa:

raise _bad_mode

rwa = True

readable = True

elif s == 'w':

if rwa:

raise _bad_mode

rwa = True

writable = True

flags |= _os.O_CREAT | _os.O_TRUNC

elif s == 'x':

if rwa:

raise _bad_mode

rwa = True

created = True

writable = True

flags |= _os.O_EXCL | _os.O_CREAT

elif s == 'a':

if rwa:

raise _bad_mode

rwa = True

writable = True

append = True

flags |= O_APPEND | _os.O_CREAT

elif s == 'b':

pass

elif s == '+':

if plus:

raise _bad_mode

readable = writable = True

plus = True

else:

raise ValueError("invalid mode: %s" % mode)

if not rwa:

raise _bad_mode

if readable and writable:

flags |= _os.O_RDWR

elif readable:

flags |= _os.O_RDONLY

else:

flags |= _os.O_WRONLY

flags |= O_BINARY

return readable, writable, created, append, flags

def __init__(self, name, mode='r', closefd=True, opener=None):

_RawIOBase.__init__(self)

self.__fd__ = -1

self.__readable__ = False

self.__writable__ = False

self.__created__ = False

self.__appending__ = False

self.__seekable__ = -1

self.__closefd__ = True

self.name = None

if self.__fd__ >= 0:

if self.__closefd__:

self.close()

else:

self.__fd__ = -1

if isinstance(name, float):

raise TypeError("integer argument expected, got float")

fd = -1

try:

fd = int(name)

except:

pass

else:

if fd < 0:

raise ValueError("negative file descriptor")

self.__readable__, self.__writable__, self.__created__, self.__appending__, flags = FileIO.__decode_mode__(mode)

fd_is_own = False

try:

if fd >= 0:

self.__fd__ = fd

self.__closefd__ = bool(closefd)

else:

self.__closefd__ = True

if not closefd:

raise ValueError("Cannot use closefd=False with file name")

if opener is None:

self.__fd__ = _os.open(name, flags, 0o666)

fd_is_own = True

else:

fd = getattr(opener, name)(flags)

try:

self.__fd__ = int(fd)

if self.__fd__ < 0:

# The opener returned a negative result instead

# of raising an exception

raise ValueError("opener returned %d" % self.__fd__)

fd_is_own = True

except TypeError:

raise TypeError("expected integer from opener")

st = _os.fstat(self.__fd__)

# On Unix, fopen will succeed for directories.

# In Python, there should be no file objects referring to

# directories, so we need a check.

if FileIO.__isdir__(st.st_mode):

raise OSError(21) # EISDIR

self.__blksize__ = DEFAULT_BUFFER_SIZE

self.name = name

if self.__appending__:

# For consistent behaviour, we explicitly seek to the end of file

# (otherwise, it might be done only on the first write()).

_os.lseek(self.__fd__, 0, _os.SEEK_END)

except:

if not fd_is_own:

self.__fd__ = -1

raise

@property

def closefd(self):

return self.__closefd__

@property

def mode(self):

if self.__created__:

if self.__readable__:

return 'xb+'

else:

return 'xb'

if self.__appending__:

if self.__readable__:

return 'ab+'

else:

return 'ab'

elif self.__readable__:

if self.__writable__:

return 'rb+'

else:

return 'rb'

else:

return 'wb'

@property

def blksize(self):

return self.__blksize__

def _checkClosed(self, message=None):

if message is None:

message = "I/O operation on closed file"

if self.__fd__ < 0:

raise ValueError(message)

def _checkReadable(self):

if not self.readable():

raise UnsupportedOperation("File not open for reading")

def _checkWritable(self):

if not self.writable():

raise UnsupportedOperation("File not open for writing")

def close(self):

got_e = None

try:

_RawIOBase.close(self)

except Exception as e:

got_e = e

if not self.__closefd__:

self.__fd__ = -1

else:

if self.__fd__ >= 0:

fd = self.__fd__

self.__fd__ = -1

_os.close(fd)

if got_e:

raise got_e

def _dealloc_warn(self, source):

if self.__fd__ >= 0 and self.closefd:

_warn("unclosed file %s" % repr(source), ResourceWarning)

def seek(self, pos, whence=0):

self._checkClosed()

return _os.lseek(self.__fd__, pos, whence)

def tell(self):

self._checkClosed()

return _os.lseek(self.__fd__, 0, 1)

def readable(self):

self._checkClosed()

return self.__readable__

def writable(self):

self._checkClosed()

return self.__writable__

def seekable(self):

self._checkClosed()

if self.__seekable__ < 0:

try:

_os.lseek(self.__fd__, 0, _os.SEEK_CUR)

except OSError:

self.__seekable__ = 0

else:

self.__seekable__ = 1

return self.__seekable__ == 1

# ______________________________________________

def fileno(self):

self._checkClosed()

return self.__fd__

def isatty(self):

self._checkClosed()

return _os.isatty(self.__fd__)

def __repr__(self):

if self.__fd__ < 0:

return "<_io.FileIO [closed]>"

closefd = "True" if self.__closefd__ else "False"

if self.name is None:

return "<_io.FileIO fd=%d mode='%s' closefd=%s>" % (

self.__fd__, self.mode, closefd

)

else:

return "<_io.FileIO name=%s mode='%s' closefd=%s>" % (

repr(self.name), self.mode, closefd

)

# ______________________________________________

def write(self, data):

self._checkClosed()

self._checkWritable()

return _os.write(self.__fd__, data)

def read(self, size=-1):

self._checkClosed()

self._checkReadable()

if size < 0:

return self.readall()

return _os.read(self.__fd__, size)

def readinto(self, rwbuffer):

self._checkClosed()

self._checkReadable()

length = len(rwbuffer)

buf = _os.read(self.__fd__, length)

rwbuffer[:] = buf

return len(buf)

def readall(self):

self._checkClosed()

self._checkReadable()

total = 0

builder = []

while True:

newsize = 512 * 1024

chunk = _os.read(self.__fd__, newsize - total)

if len(chunk) == 0:

break

builder.append(chunk)

total += len(chunk)

return b"".join(builder)

if sys.platform == "win32":

def truncate(self, size):

self._checkClosed()

self._checkWritable()

if size < 0:

size = self.tell()

raise NotImplementedError("truncate on win32")

else:

def truncate(self, size=-1):

self._checkClosed()

self._checkWritable()

if size < 0:

size = self.tell()

_os.ftruncate(self.__fd__, size)

return size

sys.stdin = FileIO(0, mode='r', closefd=False)

sys.stdin.name = "<stdin>"

sys.__stdin__ = sys.stdin

sys.stdout = FileIO(1, mode='w', closefd=False)

sys.stdout.name = "<stdout>"

sys.__stdout__ = sys.stdout

sys.stderr = FileIO(2, mode='w', closefd=False)

sys.stderr.name = "<stderr>"

sys.__stderr__ = sys.stderr

# PEP 578 stub

def open_code(path):

return FileIO(path, 'rb')

# ----------------------------------------------------------------------------------------------------------------------

#

# following definitions: patched in the __builtins_patches__ module

#

# ----------------------------------------------------------------------------------------------------------------------

class _BufferedIOBase(_IOBase):

pass

class BytesIO(_BufferedIOBase):

pass

class _TextIOBase(_IOBase):

pass

class StringIO(_TextIOBase):

pass

class BufferedReader(_BufferedIOBase):

pass

class BufferedWriter(_BufferedIOBase):

pass

class BufferedRWPair(_BufferedIOBase):

pass

class BufferedRandom(_BufferedIOBase):

pass

class IncrementalNewlineDecoder(object):

pass

class TextIOWrapper(_TextIOBase):

pass

def open(*args, **kwargs):

raise NotImplementedError

# ----------------------------------------------------------------------------------------------------------------------

#

# needed for imports will be patched in the __builtins_patches__ module

#

# ----------------------------------------------------------------------------------------------------------------------

import builtins

setattr(builtins, 'open', open)

globals()['open'] = open