checkpoint: mid-refactor for interrupting running code to stdout.write

thomasballinger · thomasballinger · commit 8742987cb299 · 2013-10-21T00:25:53.000-04:00
raw_input is currently broken, but otherwise things are working.
Plan is to use the same pattern of coderunner + stdout for err and in

--HG--
branch : scroll-frontend
diff --git a/bpython/scroll.py b/bpython/scroll.py
@@ -22,7 +22,7 @@ def main(locals_=None, config=None, exec_args=None, options=None):
 
     with TerminalController() as tc:
         with Terminal(tc, keep_last_line=True, hide_cursor=False) as term:
-            with Repl(config=config, locals_=locals_) as repl:
+            with Repl(config=config, locals_=locals_, stuff_a_refresh_request=tc.stuff_a_refresh_request) as repl:
                 rows, columns = tc.get_screen_size()
                 repl.width = columns
                 repl.height = rows
diff --git a/bpython/scrollfrontend/coderunner.py b/bpython/scrollfrontend/coderunner.py
@@ -0,0 +1,74 @@
+import code
+import Queue
+import signal
+import sys
+import threading
+import logging
+
+class CodeRunner(object):
+    """Runs user code in an interpreter, taking care of stdout/in/err"""
+    def __init__(self, interp=None, stuff_a_refresh_request=lambda:None):
+        self.interp = interp or code.InteractiveInterpreter()
+        self.source = None
+        self.code_thread = None
+        self.requests_from_code_thread = Queue.Queue(maxsize=1)
+        self.responses_for_code_thread = Queue.Queue(maxsize=1)
+        self.stuff_a_refresh_request = stuff_a_refresh_request
+        self.code_is_waiting = False
+
+    def load_code(self, source):
+        self.source = source
+        self.code_thread = None
+
+    def run_code(self, input=None):
+        """Returns Truthy values if code finishes, False otherwise
+
+        if source code is complete, returns "done"
+        if source code is incomplete, returns "unfinished"
+        """
+        if self.code_thread is None:
+            assert self.source
+            self.code_thread = threading.Thread(target=self._blocking_run_code, name='codethread')
+            self.code_thread.daemon = True
+            self.code_thread.start()
+        else:
+            assert self.code_is_waiting
+            self.code_is_waiting = False
+            self.responses_for_code_thread.put(input)
+
+        request = self.requests_from_code_thread.get()
+        if request[0] == 'done':
+            return 'unfinished' if request[1] else 'done'
+        else:
+            method, args, kwargs = request
+            self.code_is_waiting = True
+            method(*args, **kwargs)
+            self.stuff_a_refresh_request()
+            return False
+
+    def _blocking_run_code(self):
+        unfinished = self.interp.runsource(self.source)
+        self.requests_from_code_thread.put(('done', unfinished))
+    def _blocking_wait_for(self, method, args, kwargs):
+        self.requests_from_code_thread.put((method, args, kwargs))
+        return self.responses_for_code_thread.get()
+
+class FakeOutput(object):
+    def __init__(self, coderunner, please):
+        self.coderunner = coderunner
+        self.please = please
+    def write(self, *args, **kwargs):
+        return self.coderunner._blocking_wait_for(self.please, args, kwargs)
+
+if __name__ == '__main__':
+    orig_stdout = sys.stdout
+    orig_stderr = sys.stderr
+    c = CodeRunner(stuff_a_refresh_request=lambda: orig_stdout.flush() or orig_stderr.flush())
+    stdout = FakeOutput(c, orig_stdout.write)
+    stderr = FakeOutput(c, orig_stderr.write)
+    sys.stdout = stdout
+    sys.stderr = stderr
+    c.load_code('1 + 1')
+    c.run_code()
+    c.run_code()
+    c.run_code()
diff --git a/bpython/scrollfrontend/repl.py b/bpython/scrollfrontend/repl.py
@@ -34,6 +34,7 @@
 import bpython.scrollfrontend.replpainter as paint
 import fmtstr.events as events
 from bpython.scrollfrontend.friendly import NotImplementedError
+from bpython.scrollfrontend.coderunner import CodeRunner, FakeOutput
 
 #TODO implement paste mode and figure out what the deal with config.paste_time is
 #TODO figure out how config.auto_display_list=False behaves and implement it
@@ -51,8 +52,6 @@
 class FakeStdout(object):
     def __init__(self):
         self.data = StringIO()
-    def seek(self, pos, mode=0): return self.data.seek(pos, mode)
-    def tell(self): return self.data.tell()
     def read(self, n=None):
         data = self.data.read()
         if isinstance(data, bytes):
@@ -76,7 +75,7 @@ def __init__(self, on_receive_tuple):
 
     def wait_for_request_or_finish(self):
         logging.debug('waiting for message from running code (stack depth %r)', len(traceback.format_stack()))
-        msg = self.request_from_executing_code.get(timeout=3)
+        msg = self.request_from_executing_code.get()
         logging.debug('FakeStdin received message %r', msg)
         self.process_request(msg)
 
@@ -112,7 +111,7 @@ def process_event(self, e):
 
     def readline(self):
         self.request_from_executing_code.put('can haz stdin line plz')
-        return self.response_queue.get(timeout=15)
+        return self.response_queue.get()
 
 
 class Repl(BpythonRepl):
@@ -134,7 +133,7 @@ class Repl(BpythonRepl):
     """
 
     ## initialization, cleanup
-    def __init__(self, locals_=None, config=None):
+    def __init__(self, locals_=None, config=None, stuff_a_refresh_request=None):
         logging.debug("starting init")
         interp = code.InteractiveInterpreter(locals=locals_)
 
@@ -171,6 +170,8 @@ def __init__(self, locals_=None, config=None):
         self.cursor_offset_in_line = 0 # from the left, 0 means first char
         self.done = True
 
+        self.coderunner = CodeRunner(self.interp, stuff_a_refresh_request)
+        self.stdout = FakeOutput(self.coderunner, self.send_to_stdout)
         self.stdin = FakeStdin(self.on_finish_running_code)
 
         self.paste_mode = False
@@ -186,7 +187,7 @@ def __enter__(self):
         self.orig_stdout = sys.stdout
         self.orig_stderr = sys.stderr
         self.orig_stdin = sys.stdin
-        sys.stdout = FakeStdout()
+        sys.stdout = self.stdout
         sys.stderr = StringIO()
         sys.stdin = self.stdin
         return self
@@ -218,9 +219,12 @@ def clean_up_current_line_for_exit(self):
     def process_event(self, e):
         """Returns True if shutting down, otherwise mutates state of Repl object"""
 
+        logging.debug("processing event %r", e)
+        if isinstance(e, events.RefreshRequestEvent):
+            self.run_runsource_part_2_when_finished()
+            return
         self.last_events.append(e)
         self.last_events.pop(0)
-        #logging.debug("processing event %r", e)
         if isinstance(e, events.WindowChangeEvent):
             logging.debug('window change to %d %d', e.width, e.height)
             self.width, self.height = e.width, e.height
@@ -311,9 +315,12 @@ def on_enter(self, insert_into_history=True):
         self.history.append(self._current_line)
         self.push(self._current_line, insert_into_history=insert_into_history)
 
+    def send_to_stdout(self, output):
+        self.display_lines.extend(sum([paint.display_linize(line, self.width) for line in output.split('\n')], []))
+
     def on_finish_running_code(self, output, error, done, indent):
-        if output:
-            self.display_lines.extend(sum([paint.display_linize(line, self.width) for line in output.split('\n')], []))
+        #if output:
+        #    self.display_lines.extend(sum([paint.display_linize(line, self.width) for line in output.split('\n')], []))
         if error:
             self.display_lines.extend([func_for_letter(self.config.color_scheme['error'])(line)
                                       for line in sum([paint.display_linize(line, self.width)
@@ -405,12 +412,7 @@ def push(self, line, insert_into_history=True):
         """
         if insert_into_history:
             self.insert_into_history(line)
-        t = threading.Thread(target=self.runsource, args=(line,))
-        t.daemon = True
-        t.start()
-        logging.debug('push() is now waiting')
-        self.stdin.wait_for_request_or_finish()
-        logging.debug('push() done waiting')
+        self.runsource(line)
 
     def runsource(self, line):
         """Push a line of code on to the buffer, run the buffer, clean up
@@ -429,20 +431,36 @@ def runsource(self, line):
             indent = max(0, indent - self.config.tab_length)
         elif line and ':' not in line and line.strip().startswith(('return', 'pass', 'raise', 'yield')):
             indent = max(0, indent - self.config.tab_length)
-        out_spot = sys.stdout.tell()
         err_spot = sys.stderr.tell()
         logging.debug('running %r in interpreter', self.buffer)
-        unfinished = self.interp.runsource('\n'.join(self.buffer))
+        self.coderunner.load_code('\n'.join(self.buffer))
+        self.saved_err_spot = err_spot
+        self.saved_indent = indent
+        self.saved_line = line
 
         #current line not added to display buffer if quitting
         if self.config.syntax:
             self.display_buffer.append(bpythonparse(format(self.tokenize(line), self.formatter)))
         else:
             self.display_buffer.append(fmtstr(line))
 
-        sys.stdout.seek(out_spot)
+        if code.compile_command('\n'.join(self.buffer)):
+            logging.debug('finished - buffer cleared')
+            self.display_lines.extend(self.display_buffer_lines)
+            self.display_buffer = []
+            self.buffer = []
+
+        self.run_runsource_part_2_when_finished()
+
+    def run_runsource_part_2_when_finished(self):
+        r = self.coderunner.run_code()
+        if r:
+            unfinished = r == 'unfinished'
+            self.runsource_part_2(self.saved_line, self.saved_err_spot, unfinished, self.saved_indent)
+            self.stdin.wait_for_request_or_finish()
+
+    def runsource_part_2(self, line, err_spot, unfinished, indent):
         sys.stderr.seek(err_spot)
-        out = sys.stdout.read()
         err = sys.stderr.read()
 
         # easier debugging: save only errors that aren't from this interpreter
@@ -455,14 +473,10 @@ def runsource(self, line):
             logging.debug('unfinished - line added to buffer')
             self.stdin.request_from_executing_code.put((None, None, False, indent))
         else:
-            logging.debug('finished - buffer cleared')
-            self.display_lines.extend(self.display_buffer_lines)
-            self.display_buffer = []
-            self.buffer = []
             if err:
                 indent = 0
             logging.debug('sending output info')
-            self.stdin.request_from_executing_code.put((out[:-1], err[:-1], True, indent))
+            self.stdin.request_from_executing_code.put((None, err[:-1], True, indent))
             logging.debug('sent output info')
 
     def unhighlight_paren(self):
