diff -r 4d5cb87230f4 Lib/idlelib/PyShell.py --- a/Lib/idlelib/PyShell.py Tue Oct 09 11:16:26 2012 -0400 +++ b/Lib/idlelib/PyShell.py Wed Oct 10 19:18:31 2012 +0300 @@ -411,10 +411,8 @@ except socket.timeout as err: self.display_no_subprocess_error() return None - # Can't regiter self.tkconsole.stdin, since run.py wants to - # call non-TextIO methods on it (such as getvar) - # XXX should be renamed to "console" - self.rpcclt.register("stdin", self.tkconsole) + self.rpcclt.register("console", self.tkconsole) + self.rpcclt.register("stdin", self.tkconsole.stdin) self.rpcclt.register("stdout", self.tkconsole.stdout) self.rpcclt.register("stderr", self.tkconsole.stderr) self.rpcclt.register("flist", self.tkconsole.flist) @@ -858,10 +856,10 @@ self.save_stderr = sys.stderr self.save_stdin = sys.stdin from idlelib import IOBinding - self.stdin = PseudoInputFile(self) - self.stdout = PseudoFile(self, "stdout", IOBinding.encoding) - self.stderr = PseudoFile(self, "stderr", IOBinding.encoding) - self.console = PseudoFile(self, "console", IOBinding.encoding) + self.stdin = PseudoInputFile(self, "stdin", IOBinding.encoding) + self.stdout = PseudoOutputFile(self, "stdout", IOBinding.encoding) + self.stderr = PseudoOutputFile(self, "stderr", IOBinding.encoding) + self.console = PseudoOutputFile(self, "console", IOBinding.encoding) if not use_subprocess: sys.stdout = self.stdout sys.stderr = self.stderr @@ -1256,36 +1254,82 @@ raise KeyboardInterrupt return count -class PseudoFile(object): +class PseudoFile(io.TextIOBase): def __init__(self, shell, tags, encoding=None): self.shell = shell self.tags = tags - self.encoding = encoding + self._encoding = encoding + + @property + def encoding(self): + return self._encoding + + @property + def name(self): + return '<%s>' % self.tags + + def isatty(self): + return True + + +class PseudoOutputFile(PseudoFile): + + def writable(self): + return True def write(self, s): + if self.closed: + raise ValueError("write to closed file") if not isinstance(s, str): raise TypeError('must be str, not ' + type(s).__name__) return self.shell.write(s, self.tags) - def writelines(self, lines): - for line in lines: - self.write(line) - def flush(self): - pass +class PseudoInputFile(PseudoFile): - def isatty(self): + def __init__(self, shell, tags, encoding=None): + PseudoFile.__init__(self, shell, tags, encoding) + self._line_buffer = '' + + def readable(self): return True -class PseudoInputFile(object): - def __init__(self, shell): - self.readline = shell.readline - self.isatty = shell.isatty + def read(self, n=-1): + if self.closed: + raise ValueError("read from closed file") + if n is None: + n = -1 + elif not isinstance(n, int): + raise TypeError('must be int, not ' + type(n).__name__) + result = self._line_buffer + self._line_buffer = '' + if n < 0: + while True: + line = self.shell.readline() + if not line: break + result += line + else: + while len(result) < n: + line = self.shell.readline() + if not line: break + result += line + self._line_buffer = result[n:] + result = result[:n] + return result - def write(self, s): - raise io.UnsupportedOperation("not writable") - writelines = write + def readline(self, limit=-1): + if self.closed: + raise ValueError("read from closed file") + if limit is None: + limit = -1 + elif not isinstance(limit, int): + raise TypeError('must be int, not ' + type(limit).__name__) + line = self._line_buffer or self.shell.readline() + if limit < 0: + limit = len(line) + self._line_buffer = line[limit:] + return line[:limit] usage_msg = """\ diff -r 4d5cb87230f4 Lib/idlelib/run.py --- a/Lib/idlelib/run.py Tue Oct 09 11:16:26 2012 -0400 +++ b/Lib/idlelib/run.py Wed Oct 10 19:18:31 2012 +0300 @@ -258,63 +258,25 @@ quitting = True thread.interrupt_main() -class _RPCFile(io.TextIOBase): - """Wrapper class for the RPC proxy to typecheck arguments - that may not support pickling. The base class is there only - to support type tests; all implementations come from the remote - object.""" - - def __init__(self, rpc): - super.__setattr__(self, 'rpc', rpc) - - def __getattribute__(self, name): - # When accessing the 'rpc' attribute, or 'write', use ours - if name in ('rpc', 'write', 'writelines'): - return io.TextIOBase.__getattribute__(self, name) - # Else only look into the remote object only - return getattr(self.rpc, name) - - def __setattr__(self, name, value): - return setattr(self.rpc, name, value) - - @staticmethod - def _ensure_string(func): - def f(self, s): - if not isinstance(s, str): - raise TypeError('must be str, not ' + type(s).__name__) - return func(self, s) - return f - -class _RPCOutputFile(_RPCFile): - @_RPCFile._ensure_string - def write(self, s): - if not isinstance(s, str): - raise TypeError('must be str, not ' + type(s).__name__) - return self.rpc.write(s) - -class _RPCInputFile(_RPCFile): - @_RPCFile._ensure_string - def write(self, s): - raise io.UnsupportedOperation("not writable") - writelines = write - class MyHandler(rpc.RPCHandler): def handle(self): """Override base method""" executive = Executive(self) self.register("exec", executive) - self.console = self.get_remote_proxy("stdin") - sys.stdin = _RPCInputFile(self.console) - sys.stdout = _RPCOutputFile(self.get_remote_proxy("stdout")) - sys.stderr = _RPCOutputFile(self.get_remote_proxy("stderr")) + self.console = self.get_remote_proxy("console") + from idlelib import PyShell, IOBinding + sys.stdin = PyShell.PseudoInputFile(self.console, "stdin", + IOBinding.encoding) + sys.stdout = PyShell.PseudoOutputFile(self.console, "stdout", + IOBinding.encoding) + sys.stderr = PyShell.PseudoOutputFile(self.console, "stderr", + IOBinding.encoding) + sys.displayhook = rpc.displayhook # page help() text to shell. import pydoc # import must be done here to capture i/o binding pydoc.pager = pydoc.plainpager - from idlelib import IOBinding - sys.stdin.encoding = sys.stdout.encoding = \ - sys.stderr.encoding = IOBinding.encoding self.interp = self.get_remote_proxy("interp") rpc.RPCHandler.getresponse(self, myseq=None, wait=0.05)