You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
173 lines
6.5 KiB
173 lines
6.5 KiB
# Copyright (c) 2000 David Abrahams. Permission to copy, use, modify, sell
|
|
# and distribute this software is granted provided this copyright
|
|
# notice appears in all copies. This software is provided "as is" without
|
|
# express or implied warranty, and with no claim as to its suitability for
|
|
# any purpose.
|
|
"""Provides a class Stdin which can be used to emulate the regular old
|
|
sys.stdin for the PythonWin interactive window. Right now it just pops
|
|
up a raw_input() dialog. With luck, someone will integrate it into the
|
|
actual PythonWin interactive window someday.
|
|
|
|
WARNING: Importing this file automatically replaces sys.stdin with an
|
|
instance of Stdin (below). This is useful because you can just open
|
|
Stdin.py in PythonWin and hit the import button to get it set up right
|
|
if you don't feel like changing PythonWin's source. To put things back
|
|
the way they were, simply use this magic incantation:
|
|
import sys
|
|
sys.stdin = sys.stdin.real_file
|
|
"""
|
|
import sys
|
|
|
|
try:
|
|
get_input_line = raw_input # py2x
|
|
except NameError:
|
|
get_input_line = input # py3k
|
|
|
|
class Stdin:
|
|
def __init__(self):
|
|
self.real_file = sys.stdin # NOTE: Likely to be None in py3k
|
|
self.buffer = ""
|
|
self.closed = False
|
|
|
|
def __getattr__(self, name):
|
|
"""Forward most functions to the real sys.stdin for absolute realism.
|
|
"""
|
|
if self.real_file is None:
|
|
raise AttributeError(name)
|
|
return getattr(self.real_file, name)
|
|
|
|
def isatty(self):
|
|
"""Return 1 if the file is connected to a tty(-like) device, else 0.
|
|
"""
|
|
return 1
|
|
|
|
def read(self, size = -1):
|
|
"""Read at most size bytes from the file (less if the read
|
|
hits EOF or no more data is immediately available on a pipe,
|
|
tty or similar device). If the size argument is negative or
|
|
omitted, read all data until EOF is reached. The bytes are
|
|
returned as a string object. An empty string is returned when
|
|
EOF is encountered immediately. (For certain files, like ttys,
|
|
it makes sense to continue reading after an EOF is hit.)"""
|
|
result_size = self.__get_lines(size)
|
|
return self.__extract_from_buffer(result_size)
|
|
|
|
def readline(self, size = -1):
|
|
"""Read one entire line from the file. A trailing newline
|
|
character is kept in the string2.6 (but may be absent when a file ends
|
|
with an incomplete line). If the size argument is present and
|
|
non-negative, it is a maximum byte count (including the trailing
|
|
newline) and an incomplete line may be returned. An empty string is
|
|
returned when EOF is hit immediately. Note: unlike stdio's fgets(),
|
|
the returned string contains null characters ('\0') if they occurred
|
|
in the input.
|
|
"""
|
|
maximum_result_size = self.__get_lines(size, lambda buffer: '\n' in buffer)
|
|
|
|
if '\n' in self.buffer[:maximum_result_size]:
|
|
result_size = self.buffer.find('\n', 0, maximum_result_size) + 1
|
|
assert(result_size > 0)
|
|
else:
|
|
result_size = maximum_result_size
|
|
|
|
return self.__extract_from_buffer(result_size)
|
|
|
|
def __extract_from_buffer(self, character_count):
|
|
"""Remove the first character_count characters from the internal buffer and
|
|
return them.
|
|
"""
|
|
result = self.buffer[:character_count]
|
|
self.buffer = self.buffer[character_count:]
|
|
return result
|
|
|
|
def __get_lines(self, desired_size, done_reading = lambda buffer: False):
|
|
"""Keep adding lines to our internal buffer until done_reading(self.buffer)
|
|
is true or EOF has been reached or we have desired_size bytes in the buffer.
|
|
If desired_size < 0, we are never satisfied until we reach EOF. If done_reading
|
|
is not supplied, it is not consulted.
|
|
|
|
If desired_size < 0, returns the length of the internal buffer. Otherwise,
|
|
returns desired_size.
|
|
"""
|
|
while not done_reading(self.buffer) and (desired_size < 0
|
|
or len(self.buffer) < desired_size):
|
|
try:
|
|
self.__get_line()
|
|
except (EOFError, KeyboardInterrupt): # deal with cancellation of get_input_line dialog
|
|
desired_size = len(self.buffer) # Be satisfied!
|
|
|
|
if desired_size < 0:
|
|
return len(self.buffer)
|
|
else:
|
|
return desired_size
|
|
|
|
def __get_line(self):
|
|
"""Grab one line from get_input_line() and append it to the buffer.
|
|
"""
|
|
line = get_input_line()
|
|
print('>>>',line) # echo input to console
|
|
self.buffer = self.buffer + line + '\n'
|
|
|
|
def readlines(self, *sizehint):
|
|
"""Read until EOF using readline() and return a list containing the lines
|
|
thus read. If the optional sizehint argument is present, instead of
|
|
reading up to EOF, whole lines totalling approximately sizehint bytes
|
|
(possibly after rounding up to an internal buffer size) are read.
|
|
"""
|
|
result = []
|
|
total_read = 0
|
|
while sizehint == () or total_read < sizehint[0]:
|
|
line = self.readline()
|
|
if line == '':
|
|
break
|
|
total_read = total_read + len(line)
|
|
result.append(line)
|
|
return result
|
|
|
|
if __name__ == "__main__":
|
|
test_input = r"""this is some test
|
|
input that I am hoping
|
|
~
|
|
will be very instructive
|
|
and when I am done
|
|
I will have tested everything.
|
|
Twelve and twenty blackbirds
|
|
baked in a pie. Patty cake
|
|
patty cake so am I.
|
|
~
|
|
Thirty-five niggling idiots!
|
|
Sell you soul to the devil, baby
|
|
"""
|
|
|
|
def fake_raw_input(prompt=None):
|
|
"""Replacement for raw_input() which pulls lines out of global test_input.
|
|
For testing only!
|
|
"""
|
|
global test_input
|
|
if '\n' not in test_input:
|
|
end_of_line_pos = len(test_input)
|
|
else:
|
|
end_of_line_pos = test_input.find('\n')
|
|
result = test_input[:end_of_line_pos]
|
|
test_input = test_input[end_of_line_pos + 1:]
|
|
if len(result) == 0 or result[0] == '~':
|
|
raise EOFError()
|
|
return result
|
|
|
|
get_input_line = fake_raw_input
|
|
|
|
# Some completely inadequate tests, just to make sure the code's not totally broken
|
|
try:
|
|
x = Stdin()
|
|
print(x.read())
|
|
print(x.readline())
|
|
print(x.read(12))
|
|
print(x.readline(47))
|
|
print(x.readline(3))
|
|
print(x.readlines())
|
|
finally:
|
|
get_input_line = raw_input
|
|
else:
|
|
import sys
|
|
sys.stdin = Stdin()
|
|
|