euporie 2.8.4__py3-none-any.whl → 2.8.6__py3-none-any.whl

euporie/console/_commands.py

@@ -0,0 +1,143 @@
+"""Contains commands for the console."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.filters.app import (
+    buffer_has_focus,
+    has_selection,
+)
+
+from euporie.core.commands import add_cmd
+from euporie.core.filters import (
+    buffer_is_code,
+    buffer_is_empty,
+    kernel_tab_has_focus,
+)
+from euporie.core.tabs.kernel import KernelTab
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+
+
+@add_cmd()
+async def _convert_to_notebook() -> None:
+    """Convert the current console session to a notebook."""
+    from prompt_toolkit.application.run_in_terminal import in_terminal
+
+    from euporie.console.app import get_app
+    from euporie.console.tabs.console import Console
+    from euporie.notebook.app import NotebookApp
+
+    app = get_app()
+    NotebookApp.config = app.config
+    NotebookApp.load_settings()
+    NotebookApp.config.__init__(app="notebook")  # type: ignore [misc]
+    nb_app = NotebookApp()
+    # Use same event loop
+    nb_app.loop = app.loop
+    for tab in app.tabs:
+        if isinstance(tab, Console):
+            from euporie.notebook.tabs.notebook import Notebook
+
+            nb = Notebook(
+                app=nb_app,
+                path=tab.path,
+                kernel=tab.kernel,
+                comms=tab.comms,
+                json=tab.json,
+            )
+            # Set the history to the console's history
+            nb.history = tab.history
+            # Add the current input
+            nb.add(len(nb.json["cells"]) + 1, source=tab.input_box.buffer.text)
+            # Add the new notebook to the notebook app
+            nb_app.tabs.append(nb)
+            # Tell notebook that the kernel has already started
+            nb.kernel_started()
+
+    async with in_terminal():
+        await nb_app.run_async()
+
+    app.exit()
+
+
+@add_cmd()
+def _accept_input() -> None:
+    """Accept the current console input."""
+    from euporie.console.app import get_app
+
+    buffer = get_app().current_buffer
+    if buffer:
+        buffer.validate_and_handle()
+
+
+@add_cmd(
+    filter=buffer_is_code & buffer_has_focus & ~has_selection & ~buffer_is_empty,
+)
+def _clear_input() -> None:
+    """Clear the console input."""
+    from euporie.console.app import get_app
+
+    buffer = get_app().current_buffer
+    buffer.reset()
+
+
+@add_cmd(
+    filter=buffer_is_code & buffer_has_focus,
+)
+def _run_input() -> None:
+    """Run the console input."""
+    from euporie.console.app import get_app
+    from euporie.console.tabs.console import Console
+
+    if isinstance(console := get_app().tab, Console):
+        console.run()
+
+
+@add_cmd(
+    name="cc-interrupt-kernel",
+    hidden=True,
+    filter=buffer_is_code & buffer_is_empty,
+)
+@add_cmd(filter=kernel_tab_has_focus)
+def _interrupt_kernel() -> None:
+    """Interrupt the notebook's kernel."""
+    from euporie.console.app import get_app
+
+    if isinstance(kt := get_app().tab, KernelTab):
+        kt.interrupt_kernel()
+
+
+@add_cmd(filter=kernel_tab_has_focus)
+def _restart_kernel() -> None:
+    """Restart the notebook's kernel."""
+    from euporie.console.app import get_app
+
+    if isinstance(kt := get_app().tab, KernelTab):
+        kt.restart_kernel()
+
+
+@add_cmd(
+    filter=buffer_is_code & buffer_is_empty,
+    hidden=True,
+    description="Signals the end of the input, causing the console to exit.",
+)
+def _end_of_file(event: KeyPressEvent) -> None:
+    """Exit when Control-D has been pressed."""
+    event.app.exit(exception=EOFError)
+
+
+@add_cmd()
+def _clear_screen() -> None:
+    """Clear the screen and the previous output."""
+    from euporie.console.app import get_app
+    from euporie.console.tabs.console import Console
+
+    app = get_app()
+    app.renderer.clear()
+
+    if isinstance(console := app.tab, Console):
+        console.reset()
+        app.layout.focus(console.input_box)

euporie/console/_settings.py

@@ -0,0 +1,58 @@
+"""Settings for the console app."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from upath import UPath
+
+from euporie.core.config import add_setting
+
+if TYPE_CHECKING:
+    from typing import TypeVar
+
+    _AppResult = TypeVar("_AppResult")
+
+add_setting(
+    name="mouse_support",
+    group="euporie.console.app",
+    flags=["--mouse-support"],
+    type_=bool,
+    help_="Enable or disable mouse support",
+    default=None,
+    description="""
+            When set to True, mouse support is enabled. When set to False, mouse
+            support is disabled.
+        """,
+)
+add_setting(
+    name="max_stored_outputs",
+    group="euporie.console.app",
+    flags=["--max-stored-outputs"],
+    type_=int,
+    help_="The number of inputs / outputs to store in an in-memory notebook",
+    default=100,
+    schema={
+        "minimum": 0,
+    },
+    description="""
+        Defines the maximum number of executed "cells" to store in case the console
+        session is saved to a file or converted into a notebook.
+    """,
+)
+
+add_setting(
+    name="connection_file",
+    group="euporie.console.app",
+    flags=["--connection-file", "--kernel-connection-file"],
+    type_=UPath,
+    help_="Attempt to connect to an existing kernel using a JSON connection info file",
+    default=None,
+    description="""
+        If the file does not exist, kernel connection information will be written
+        to the file path provided.
+
+        If the file exists, kernel connection info will be read from the file,
+        allowing euporie to connect to existing kernels.
+    """,
+)

euporie/console/app.py

@@ -6,7 +6,6 @@ import logging
 from typing import TYPE_CHECKING, cast
 
 from prompt_toolkit.application.current import get_app as ptk_get_app
-from prompt_toolkit.application.run_in_terminal import in_terminal
 from prompt_toolkit.filters.app import (
     has_completions,
     is_done,
@@ -15,6 +14,7 @@ from prompt_toolkit.filters.app import (
 )
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
+    Float,
     FloatContainer,
     HSplit,
     VSplit,
@@ -23,10 +23,11 @@ from prompt_toolkit.layout.containers import (
 from prompt_toolkit.layout.dimension import Dimension
 
 from euporie.console.tabs.console import Console
-from euporie.core import __logo__
-from euporie.core.app import BaseApp
-from euporie.core.commands import add_cmd
-from euporie.core.config import add_setting
+from euporie.core.app.app import BaseApp
+from euporie.core.bars.command import CommandBar
+from euporie.core.bars.menu import ToolbarCompletionsMenu
+from euporie.core.bars.search import SearchBar
+from euporie.core.bars.status import StatusBar
 from euporie.core.filters import has_dialog
 from euporie.core.layout.mouse import DisableMouseOnScroll
 from euporie.core.widgets.dialog import (
@@ -36,14 +37,15 @@ from euporie.core.widgets.dialog import (
     SelectKernelDialog,
     ShortcutsDialog,
 )
+from euporie.core.widgets.logo import Logo
 from euporie.core.widgets.pager import Pager
 from euporie.core.widgets.palette import CommandPalette
-from euporie.core.widgets.search import SearchBar
-from euporie.core.widgets.status import StatusBar
 
 if TYPE_CHECKING:
     from typing import Any, TypeVar
 
+    from prompt_toolkit.application.application import Application
+
     _AppResult = TypeVar("_AppResult")
 
 log = logging.getLogger(__name__)
@@ -63,7 +65,6 @@ class ConsoleApp(BaseApp):
     """
 
     name = "console"
-    log_stdout_level = "ERROR"
 
     def __init__(self, **kwargs: Any) -> None:
         """Create a new euporie text user interface application instance."""
@@ -72,16 +73,22 @@ class ConsoleApp(BaseApp):
         kwargs.setdefault("title", "euporie-console")
         kwargs.setdefault("full_screen", False)
         kwargs.setdefault("leave_graphics", True)
-        kwargs.setdefault("mouse_support", self.config.filter("mouse_support"))
+        kwargs.setdefault("mouse_support", self.config.filters.mouse_support)
 
         # Initialize the application
         super().__init__(**kwargs)
 
-        self.search_bar = SearchBar()
         self.bindings_to_load += ["euporie.console.app.ConsoleApp"]
 
         self.tabs = []
-        self.pager = Pager()
+
+    def pre_run(self, app: Application | None = None) -> None:
+        """Continue loading the app."""
+        super().pre_run(app)
+        # Add a toolbar completion menu
+        self.menus["toolbar_completions"] = Float(
+            content=ToolbarCompletionsMenu(), ycursor=True, transparent=True
+        )
 
     def _get_reserved_height(self) -> Dimension:
         if has_dialog():
@@ -95,9 +102,9 @@ class ConsoleApp(BaseApp):
         """Return a container with all opened tabs."""
         self.tabs = [Console(self)]
 
-        assert self.pager is not None
-        assert self.search_bar is not None
-        assert self.tab is not None
+        self.command_bar = CommandBar()
+        self.search_bar = SearchBar()
+        self.pager = Pager()
 
         self.dialogs["command-palette"] = CommandPalette(self)
         self.dialogs["about"] = AboutDialog(self)
@@ -110,7 +117,7 @@ class ConsoleApp(BaseApp):
             DisableMouseOnScroll(
                 HSplit(
                     [
-                        self.tab,
+                        self.tabs[0],
                         ConditionalContainer(
                             HSplit(
                                 [
@@ -120,17 +127,12 @@ class ConsoleApp(BaseApp):
                                         style="class:default",
                                     ),
                                     self.pager,
-                                    self.search_bar,
                                     ConditionalContainer(
                                         VSplit(
                                             [
-                                                Window(
-                                                    char=f" {__logo__} ",
-                                                    height=1,
-                                                    width=3,
-                                                    style="class:menu,logo",
-                                                    dont_extend_width=True,
-                                                ),
+                                                Logo(),
+                                                self.command_bar,
+                                                self.search_bar,
                                                 StatusBar(),
                                             ]
                                         ),
@@ -165,54 +167,6 @@ class ConsoleApp(BaseApp):
         else:
             super().exit()
 
-    # ################################### Commands ####################################
-
-    @staticmethod
-    @add_cmd()
-    async def _convert_to_notebook() -> None:
-        """Convert the current console session to a notebook."""
-        from euporie.notebook.app import NotebookApp
-        from euporie.notebook.tabs.notebook import Notebook
-
-        app = get_app()
-        nb_app = NotebookApp()
-        for tab in app.tabs:
-            if isinstance(tab, Console):
-                nb = Notebook(
-                    app=nb_app,
-                    path=tab.path,
-                    kernel=tab.kernel,
-                    comms=tab.comms,
-                    json=tab.json,
-                )
-                # Set the history to the console's history
-                nb.history = tab.history
-                # Add the current input
-                nb.add(len(nb.json["cells"]) + 1, source=tab.input_box.buffer.text)
-                # Add the new notebook to the notebook app
-                nb_app.tabs.append(nb)
-                # Tell notebook that the kernel has already started
-                nb.kernel_started()
-
-        async with in_terminal():
-            await nb_app.run_async()
-
-        app.exit()
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="mouse_support",
-        flags=["--mouse-support"],
-        type_=bool,
-        help_="Enable or disable mouse support",
-        default=None,
-        description="""
-            When set to True, mouse support is enabled. When set to False, mouse
-            support is disabled.
-        """,
-    )
-
     # ################################# Key Bindings ##################################
 
     # register_bindings({"euporie.console.app.ConsoleApp": {}})

euporie/console/tabs/console.py

@@ -31,7 +31,6 @@ from prompt_toolkit.utils import Event
 from upath import UPath
 
 from euporie.core.commands import add_cmd, get_cmd
-from euporie.core.config import add_setting
 from euporie.core.diagnostics import Report
 from euporie.core.filters import (
     at_end_of_buffer,
@@ -40,7 +39,8 @@ from euporie.core.filters import (
     kernel_tab_has_focus,
 )
 from euporie.core.format import LspFormatter
-from euporie.core.kernel import MsgCallbacks
+from euporie.core.io import edit_in_editor
+from euporie.core.kernel.client import MsgCallbacks
 from euporie.core.key_binding.registry import (
     load_registered_bindings,
     register_bindings,
@@ -48,23 +48,24 @@ from euporie.core.key_binding.registry import (
 from euporie.core.layout.print import PrintingContainer
 from euporie.core.lsp import LspCell
 from euporie.core.style import KERNEL_STATUS_REPR
-from euporie.core.tabs.base import KernelTab
-from euporie.core.terminal import edit_in_editor
+from euporie.core.tabs.kernel import KernelTab
 from euporie.core.validation import KernelValidator
 from euporie.core.widgets.cell_outputs import CellOutputArea
 from euporie.core.widgets.inputs import KernelInput, StdInput
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from pathlib import Path
-    from typing import Any, Callable, Sequence
+    from typing import Any, Callable
 
+    from nbformat.notebooknode import NotebookNode
     from prompt_toolkit.application.application import Application
     from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
     from prompt_toolkit.layout.containers import Container, Float
 
-    from euporie.core.app import BaseApp
+    from euporie.core.app.app import BaseApp
     from euporie.core.lsp import LspClient
 
 log = logging.getLogger(__name__)
@@ -77,8 +78,6 @@ class Console(KernelTab):
 
     """
 
-    bg_init = False
-
     def __init__(
         self,
         app: BaseApp,
@@ -134,6 +133,7 @@ class Console(KernelTab):
         self.json = nbformat.v4.new_notebook()
         self.json["metadata"] = self._metadata
         self.render_queue: list[dict[str, Any]] = []
+        self.last_rendered: NotebookNode | None = None
 
         self.container = self.load_container()
 
@@ -197,8 +197,7 @@ class Console(KernelTab):
         return not (
             not code.strip()
             or completeness_status == "incomplete"
-            or completeness_status == "unknown"
-            and code[-2:] != "\n\n"
+            or (completeness_status == "unknown" and code[-2:] != "\n\n")
         )
 
     def run(self, buffer: Buffer | None = None) -> None:
@@ -292,10 +291,30 @@ class Console(KernelTab):
             self.render_queue.append(cell)
 
         # Add widgets to the live output
-        if "application/vnd.jupyter.widget-view+json" in output_json.get("data", {}):
-            self.live_output.add_output(output_json)
+        if output_json.get("output_type") == "stream":
+            # Use live output to enable emulation of carriage returns
+            text = output_json.get("text", "")
+            tail = ""
+            _text, _, _tail = text.rpartition("\n")
+            if "\r" in _tail:  # or "\x1b[" in _tail:
+                text, tail = _text, _tail
+            if text:
+                # Partially Flush live output streams
+                cell["outputs"].extend(self.live_output.json)
+                self.live_output.reset()
+                output_json["text"] = text
+                cell["outputs"].append(output_json)
+            if tail:
+                self.live_output.add_output(
+                    nbformat.v4.new_output(**{**output_json, "text": tail})
+                )
         else:
-            cell["outputs"].append(output_json)
+            if "application/vnd.jupyter.widget-view+json" in output_json.get(
+                "data", {}
+            ):
+                self.live_output.add_output(output_json)
+            else:
+                cell["outputs"].append(output_json)
 
         # Invalidate the app so the output get printed
         self.app.invalidate()
@@ -331,7 +350,7 @@ class Console(KernelTab):
 
     def reset(self) -> None:
         """Reset the state of the tab."""
-        from euporie.core.widgets.search import stop_search
+        from euporie.core.bars.search import stop_search
 
         self.live_output.reset()
         stop_search()
@@ -349,7 +368,7 @@ class Console(KernelTab):
     ) -> StyleAndTextTuples:
         """Determine what should be displayed in the prompt of the cell."""
         if count is None:
-            count = self.execution_count
+            return [("", " " * (len(text) + 4 + len(str(self.execution_count))))]
         prompt = str(count + offset)
         if show_busy and self.kernel.status in ("busy", "queued"):
             prompt = "*".center(len(prompt))
@@ -420,12 +439,18 @@ class Console(KernelTab):
 
             # Outputs
             if outputs := cell.outputs:
-                children.append(
-                    Window(
-                        height=1,
-                        dont_extend_height=True,
+                # Add space before an output if last rendered cell did not have outputs
+                # or we are rendering a new output
+                if self.last_rendered is not None and (
+                    not self.last_rendered.outputs
+                    or cell.execution_count != self.last_rendered.execution_count
+                ):
+                    children.append(
+                        Window(
+                            height=1,
+                            dont_extend_height=True,
+                        )
                     )
-                )
 
                 def _flush(
                     buffer: list[dict[str, Any]], prompt: AnyFormattedText
@@ -450,21 +475,20 @@ class Console(KernelTab):
                         buffer.clear()
 
                 buffer: list[dict[str, Any]] = []
-                ec = cell.execution_count
+                # ec = cell.execution_count
                 prompt: AnyFormattedText = ""
                 next_prompt: AnyFormattedText
                 for output in outputs:
-                    if (next_ec := output.get("execution_count")) is None:
-                        next_prompt = " " * (len(str(ec)) + 7)
-                    else:
-                        next_prompt = self.prompt("Out", count=next_ec, show_busy=False)
-                        ec = next_ec
+                    next_ec = output.get("execution_count")
+                    next_prompt = self.prompt("Out", count=next_ec, show_busy=False)
                     if next_prompt != prompt:
                         _flush(buffer, prompt)
                         prompt = next_prompt
                     buffer.append(output)
                 _flush(buffer, prompt)
 
+            self.last_rendered = cell
+
         return Layout(
             FloatContainer(
                 PrintingContainer(children),
@@ -488,9 +512,9 @@ class Console(KernelTab):
                                 FormattedTextControl(
                                     lambda: self.prompt(
                                         "Out",
-                                        count=self.live_output.json[0][
-                                            "execution_count"
-                                        ],
+                                        count=self.live_output.json[0].get(
+                                            "execution_count",
+                                        ),
                                     )
                                 ),
                                 dont_extend_width=True,
@@ -602,7 +626,11 @@ class Console(KernelTab):
                 VSplit(
                     [
                         Window(
-                            FormattedTextControl(partial(self.prompt, "In ", offset=1)),
+                            FormattedTextControl(
+                                lambda: self.prompt(
+                                    "In ", self.execution_count, offset=1
+                                )
+                            ),
                             dont_extend_width=True,
                             style="class:cell,input,prompt",
                             height=1,
@@ -838,38 +866,6 @@ class Console(KernelTab):
             tab.reset()
             app.layout.focus(tab.input_box)
 
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="max_stored_outputs",
-        flags=["--max-stored-outputs"],
-        type_=int,
-        help_="The number of inputs / outputs to store in an in-memory notebook",
-        default=100,
-        schema={
-            "minimum": 0,
-        },
-        description="""
-            Defines the maximum number of executed "cells" to store in case the console
-            session is saved to a file or converted into a notebook.
-        """,
-    )
-
-    add_setting(
-        name="connection_file",
-        flags=["--connection-file", "--kernel-connection-file"],
-        type_=UPath,
-        help_="Attempt to connect to an existing kernel using a JSON connection info file",
-        default=None,
-        description="""
-            If the file does not exist, kernel connection information will be written
-            to the file path provided.
-
-            If the file exists, kernel connection info will be read from the file,
-            allowing euporie to connect to existing kernels.
-        """,
-    )
-
     # ################################# Key Bindings ##################################
 
     register_bindings(

euporie/core/__init__.py

@@ -1,7 +1,7 @@
 """This package defines the euporie application and its components."""
 
 __app_name__ = "euporie"
-__version__ = "2.8.4"
+__version__ = "2.8.6"
 __logo__ = "⚈"
 __strapline__ = "Jupyter in the terminal"
 __author__ = "Josiah Outram Halstead"

euporie/core/__main__.py

@@ -1,10 +1,33 @@
 """Main entry point into euporie.core."""
 
+from __future__ import annotations
 
-def main(name: "str" = "launch") -> "None":
-    """Load and launches the application."""
-    from importlib.metadata import entry_points
+from functools import cache
+from importlib.metadata import entry_points
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from importlib.metadata import EntryPoint, EntryPoints
+
+
+@cache
+def available_apps() -> dict[str, EntryPoint]:
+    """Return a list of loadable euporie apps."""
+    eps: dict | EntryPoints
+    try:
+        eps = entry_points(group="euporie.apps")
+    except TypeError:
+        eps = entry_points()
+    if isinstance(eps, dict):
+        points = eps.get("euporie.apps")
+    else:
+        points = eps.select(group="euporie.apps")
+    apps = {x.name: x for x in points} if points else {}
+    return apps
 
+
+def main(name: str = "launch") -> None:
+    """Load and launches the application."""
     # Register extensions to external packages
     from euporie.core import (
         path,  # noqa F401
@@ -14,17 +37,11 @@ def main(name: "str" = "launch") -> "None":
     # Monkey-patch prompt_toolkit
     from euporie.core.layout import containers  # noqa: F401
 
-    eps = entry_points()
-    if isinstance(eps, dict):
-        points = eps.get("euporie.apps")
-    else:
-        points = eps.select(group="euporie.apps")
-    apps = {x.name: x for x in points} if points else {}
-
+    apps = available_apps()
     if entry := apps.get(name):
         return entry.load().launch()
     else:
-        raise Exception(f"Euporie app `{name}` not installed")
+        raise ModuleNotFoundError(f"Euporie app `{name}` not installed")
 
 
 if __name__ == "__main__":