bpython
diff --git a/‎bpython/curtsiesfrontend/repl.py‎
Lines changed: 55 additions & 11 deletions b/‎bpython/curtsiesfrontend/repl.py‎
Lines changed: 55 additions & 11 deletions
diff --git a/‎bpython/test/test_curtsies_repl.py‎
Lines changed: 2 additions & 0 deletions b/‎bpython/test/test_curtsies_repl.py‎
Lines changed: 2 additions & 0 deletions
@@ -20,6 +20,7 @@
 from pygments.formatters import TerminalFormatter
 
 from wcwidth import wcswidth
+from math import ceil
 
 import blessings
 
@@ -395,14 +396,22 @@ def __init__(
         # current line of output - stdout and stdin go here
         self.current_stdouterr_line = ""
 
-        # lines separated whenever logical line
-        # length goes over what the terminal width
-        # was at the time of original output
+
+        # this is every line that's been displayed (input and output)
+        # as with formatting applied. Logical lines that exceeded the terminal width
+        # at the time of output are split across multiple entries in this list.
         self.display_lines = []
 
         # this is every line that's been executed; it gets smaller on rewind
         self.history = []
 
+        # This is every logical line that's been displayed, both input and output. 
+        # Like self.history, lines are unwrapped, uncolored, and without prompt.
+        # Entries are tuples, where
+        #   the first element a string of the line
+        #   the second element is one of 2 strings: "input" or "output".
+        self.all_logical_lines = []
+
         # formatted version of lines in the buffer kept around so we can
         # unhighlight parens using self.reprint_line as called by bpython.Repl
         self.display_buffer = []
@@ -411,7 +420,7 @@ def __init__(
         # because there wasn't room to display everything
         self.scroll_offset = 0
 
-        # from the left, 0 means first char
+        # cursor position relative to start of current_line, 0 is first char
         self._cursor_offset = 0
 
         self.orig_tcattrs = orig_tcattrs
@@ -872,8 +881,10 @@ def on_enter(self, new_code=True, reset_rl_history=True):
             self.rl_history.reset()
 
         self.history.append(self.current_line)
+        self.all_logical_lines.append((self.current_line, "input"))
         self.push(self.current_line, insert_into_history=new_code)
 
+
     def on_tab(self, back=False):
         """Do something on tab key
         taken from bpython.cli
@@ -982,6 +993,9 @@ def process_simple_keypress(self, e):
             self.add_normal_character(e)
 
     def send_current_block_to_external_editor(self, filename=None):
+        """"
+        Sends the current code block to external editor to be edited. Usually bound to C-x.
+        """
         text = self.send_to_external_editor(self.get_current_block())
         lines = [line for line in text.split("\n")]
         while lines and not lines[-1].split():
@@ -994,15 +1008,20 @@ def send_current_block_to_external_editor(self, filename=None):
         self.cursor_offset = len(self.current_line)
 
     def send_session_to_external_editor(self, filename=None):
+        """
+        Sends entire bpython session to external editor to be edited. Usually bound to F7. 
+
+        Loops through self.all_logical_lines so that lines aren't wrapped in the editor.
+        
+        """
         for_editor = EDIT_SESSION_HEADER
         for_editor += "\n".join(
-            line[len(self.ps1) :]
-            if line.startswith(self.ps1)
-            else line[len(self.ps2) :]
-            if line.startswith(self.ps2)
-            else "### " + line
-            for line in self.getstdout().split("\n")
+            line[0] if line[1] == "input"
+            else "### " + line[0] 
+            for line in self.all_logical_lines
         )
+        for_editor += "\n" + "### " + self.current_line
+
         text = self.send_to_external_editor(for_editor)
         if text == for_editor:
             self.status_bar.message(
@@ -1170,7 +1189,9 @@ def push(self, line, insert_into_history=True):
         if c:
             logger.debug("finished - buffer cleared")
             self.cursor_offset = 0
+
             self.display_lines.extend(self.display_buffer_lines)
+            
             self.display_buffer = []
             self.buffer = []
 
@@ -1237,13 +1258,17 @@ def clear_current_block(self, remove_from_history=True):
         if remove_from_history:
             for unused in self.buffer:
                 self.history.pop()
+                self.all_logical_lines.pop()
         self.buffer = []
         self.cursor_offset = 0
         self.saved_indent = 0
         self.current_line = ""
         self.cursor_offset = len(self.current_line)
 
     def get_current_block(self):
+        """
+        Returns the current code block as string (without prompts)
+        """
         return "\n".join(self.buffer + [self.current_line])
 
     def send_to_stdouterr(self, output):
@@ -1271,6 +1296,15 @@ def send_to_stdouterr(self, output):
                     [],
                 )
             )
+
+            # These can be FmtStrs, but self.all_logical_lines only wants strings
+            for line in [self.current_stdouterr_line] + lines[1:-1]:
+                if isinstance(line, FmtStr):
+                    self.all_logical_lines.append((line.s, "output"))
+                else:
+                    self.all_logical_lines.append((line, "output"))
+
+
             self.current_stdouterr_line = lines[-1]
         logger.debug("display_lines: %r", self.display_lines)
 
@@ -1804,11 +1838,15 @@ def take_back_buffer_line(self):
         self.display_buffer.pop()
         self.buffer.pop()
         self.history.pop()
+        self.all_logical_lines.pop()
 
     def take_back_empty_line(self):
         assert self.history and not self.history[-1]
         self.history.pop()
         self.display_lines.pop()
+        self.all_logical_lines.pop()
+ 
+
 
     def prompt_undo(self):
         if self.buffer:
@@ -1826,8 +1864,9 @@ def prompt_for_undo():
     def redo(self):
         if (self.redo_stack):
             temp = self.redo_stack.pop()
-            self.push(temp)
             self.history.append(temp)
+            self.all_logical_lines.append((temp, "input"))
+            self.push(temp)
         else:
             self.status_bar.message("Nothing to redo.")
 
@@ -1839,6 +1878,7 @@ def reevaluate(self, new_code=False):
         old_display_lines = self.display_lines
         self.history = []
         self.display_lines = []
+        self.all_logical_lines = []
 
         if not self.weak_rewind:
             self.interp = self.interp.__class__()
@@ -1903,6 +1943,9 @@ def initialize_interp(self):
         del self.coderunner.interp.locals["_Helper"]
 
     def getstdout(self):
+        """
+        Returns a string of the current bpython session, formatted and wrapped.
+        """
         lines = self.lines_for_display + [self.current_line_formatted]
         s = (
             "\n".join(x.s if isinstance(x, FmtStr) else x for x in lines)
@@ -1911,6 +1954,7 @@ def getstdout(self):
         )
         return s
 
+
     def focus_on_subprocess(self, args):
         prev_sigwinch_handler = signal.getsignal(signal.SIGWINCH)
         try:
 
@@ -78,6 +78,8 @@ def test_external_communication(self):
     def test_external_communication_encoding(self):
         with captured_output():
             self.repl.display_lines.append('>>> "åß∂ƒ"')
+            self.repl.history.append('"åß∂ƒ"')
+            self.repl.all_logical_lines.append(('"åß∂ƒ"',"input"))
             self.repl.send_session_to_external_editor()
 
     def test_get_last_word(self):