cool-RR
diff --git a/‎prompt_toolkit/buffer.py
Lines changed: 7 additions & 6 deletions b/‎prompt_toolkit/buffer.py
Lines changed: 7 additions & 6 deletions
diff --git a/‎prompt_toolkit/history.py
Lines changed: 59 additions & 49 deletions b/‎prompt_toolkit/history.py
Lines changed: 59 additions & 49 deletions
@@ -284,14 +284,15 @@ def __init__(self,
         # Reset other attributes.
         self.reset(document=document)
 
-        # Attach callback for new history entries.
-        def new_history_item(sender: History) -> None:
+        # Load the history.
+        def new_history_item(item: str) -> None:
+            # XXX: Keep in mind that this function can be called in a different
+            #      thread!
             # Insert the new string into `_working_lines`.
-            self._working_lines.insert(0, self.history.get_strings()[0])
-            self.__working_index += 1
+            self._working_lines.insert(0, item)
+            self.__working_index += 1  # Not entirely threadsafe, but probably good enough.
 
-        self.history.get_item_loaded_event().add_handler(new_history_item)
-        self.history.start_loading()
+        self.history.load(new_history_item)
 
     def __repr__(self) -> str:
         if len(self.text) < 15:
 
@@ -9,12 +9,8 @@
 import datetime
 import os
 from abc import ABCMeta, abstractmethod
-from typing import AsyncGenerator, Iterable, List
-
-from prompt_toolkit.application.current import get_app
-
-from .eventloop import generator_to_async_generator
-from .utils import Event
+from threading import Thread
+from typing import Iterable, List, Callable, Optional
 
 __all__ = [
     'History',
@@ -33,38 +29,48 @@ class History(metaclass=ABCMeta):
     """
     def __init__(self) -> None:
         # In memory storage for strings.
-        self._loading = False
+        self._loaded = False
         self._loaded_strings: List[str] = []
-        self._item_loaded: Event['History'] = Event(self)
-
-    async def _start_loading(self) -> None:
-        """
-        Consume the asynchronous generator: `load_history_strings_async`.
-
-        This is only called once, because once the history is loaded, we don't
-        have to load it again.
-        """
-        def add_string(string: str) -> None:
-            " Got one string from the asynchronous history generator. "
-            self._loaded_strings.insert(0, string)
-            self._item_loaded.fire()
-
-        async for item in self.load_history_strings_async():
-            add_string(item)
 
     #
     # Methods expected by `Buffer`.
     #
 
-    def start_loading(self) -> None:
-        " Start loading the history. "
-        if not self._loading:
-            self._loading = True
-            get_app().create_background_task(self._start_loading())
-
-    def get_item_loaded_event(self) -> Event['History']:
-        " Event which is triggered when a new item is loaded. "
-        return self._item_loaded
+    def load(self, item_loaded_callback: Callable[[str], None]) -> None:
+        """
+        Load the history and call the callback for every entry in the history.
+
+        XXX: The callback can be called from another thread, which happens in
+             case of `ThreadedHistory`.
+
+             We can't assume that an asyncio event loop is running, and
+             schedule the insertion into the `Buffer` using the event loop.
+
+             The reason is that the creation of the :class:`.History` object as
+             well as the start of the loading happens *before*
+             `Application.run()` is called, and it can continue even after
+             `Application.run()` terminates. (Which is useful to have a
+             complete history during the next prompt.)
+
+             Calling `get_event_loop()` right here is also not guaranteed to
+             return the same event loop which is used in `Application.run`,
+             because a new event loop can be created during the `run`. This is
+             useful in Python REPLs, where we want to use one event loop for
+             the prompt, and have another one active during the `eval` of the
+             commands. (Otherwise, the user can schedule a while/true loop and
+             freeze the UI.)
+        """
+        if self._loaded:
+            for item in self._loaded_strings[::-1]:
+                item_loaded_callback(item)
+            return
+
+        try:
+            for item in self.load_history_strings():
+                self._loaded_strings.insert(0, item)
+                item_loaded_callback(item)
+        finally:
+            self._loaded = True
 
     def get_strings(self) -> List[str]:
         """
@@ -93,16 +99,6 @@ def load_history_strings(self) -> Iterable[str]:
         while False:
             yield
 
-    async def load_history_strings_async(self) -> AsyncGenerator[str, None]:
-        """
-        Asynchronous generator for history strings. (Probably, you won't have
-        to override this.)
-
-        This is an asynchronous generator of `str` objects.
-        """
-        for item in self.load_history_strings():
-            yield item
-
     @abstractmethod
     def store_string(self, string: str) -> None:
         """
@@ -120,15 +116,29 @@ class ThreadedHistory(History):
     """
     def __init__(self, history: History) -> None:
         self.history = history
+        self._load_thread: Optional[Thread] = None
+        self._item_loaded_callbacks: List[Callable[[str], None]] = []
         super().__init__()
 
-    async def load_history_strings_async(self) -> AsyncGenerator[str, None]:
-        """
-        Asynchronous generator of completions.
-        This yields both Future and Completion objects.
-        """
-        async for item in generator_to_async_generator(self.history.load_history_strings):
-            yield item
+    def load(self, item_loaded_callback: Callable[[str], None]) -> None:
+        self._item_loaded_callbacks.append(item_loaded_callback)
+
+        # Start the load thread, if we don't have a thread yet.
+        if not self._load_thread:
+            def call_all_callbacks(item: str) -> None:
+                for cb in self._item_loaded_callbacks:
+                    cb(item)
+
+            self._load_thread = Thread(target=self.history.load, args=(call_all_callbacks, ))
+            print(self._load_thread.daemon)
+            self._load_thread.daemon = True
+            self._load_thread.start()
+
+    def get_strings(self) -> List[str]:
+        return self.history.get_strings()
+
+    def append_string(self, string: str) -> None:
+        self.history.append_string(string)
 
     # All of the following are proxied to `self.history`.