euporie 2.8.5__py3-none-any.whl → 2.8.7__py3-none-any.whl

euporie/console/app.py

@@ -32,6 +32,7 @@ from euporie.core.filters import has_dialog
 from euporie.core.layout.mouse import DisableMouseOnScroll
 from euporie.core.widgets.dialog import (
     AboutDialog,
+    ConfirmDialog,
     NoKernelsDialog,
     SaveAsDialog,
     SelectKernelDialog,
@@ -112,6 +113,7 @@ class ConsoleApp(BaseApp):
         self.dialogs["no-kernels"] = NoKernelsDialog(self)
         self.dialogs["change-kernel"] = SelectKernelDialog(self)
         self.dialogs["shortcuts"] = ShortcutsDialog(self)
+        self.dialogs["confirm"] = ConfirmDialog(self)
 
         return FloatContainer(
             DisableMouseOnScroll(

euporie/console/tabs/console.py

@@ -40,7 +40,7 @@ from euporie.core.filters import (
 )
 from euporie.core.format import LspFormatter
 from euporie.core.io import edit_in_editor
-from euporie.core.kernel.client import MsgCallbacks
+from euporie.core.kernel.base import MsgCallbacks
 from euporie.core.key_binding.registry import (
     load_registered_bindings,
     register_bindings,
@@ -137,10 +137,7 @@ class Console(KernelTab):
 
         self.container = self.load_container()
 
-        self.kernel.start(cb=self.kernel_started, wait=False)
-
         self.app.before_render += self.render_outputs
-
         self.on_advance = Event(self)
 
     async def load_lsps(self) -> None:
@@ -162,9 +159,26 @@ class Console(KernelTab):
 
             lsp.on_exit += lsp_unload
 
+    def post_init_kernel(self) -> None:
+        """Start the kernel after if has been loaded."""
+        # Load container
+        super().post_init_kernel()
+
+        # Start kernel
+        if self.kernel._status == "stopped":
+            self.kernel.start(cb=self.kernel_started, wait=False)
+
     def kernel_died(self) -> None:
-        """Call when the kernel dies."""
+        """Call if the kernel dies."""
         log.error("The kernel has died")
+        if confirm := self.app.dialogs.get("confirm"):
+            confirm.show(
+                title="Kernel connection lost",
+                message="The kernel appears to have died\n"
+                "as it can no longer be reached.\n\n"
+                "Do you want to restart the kernel?",
+                cb=self.kernel.restart,
+            )
 
     async def load_history(self) -> None:
         """Load kernel history."""
@@ -191,9 +205,7 @@ class Console(KernelTab):
     def validate_input(self, code: str) -> bool:
         """Determine if the entered code is ready to run."""
         assert self.kernel is not None
-        completeness_status = self.kernel.is_complete(code, wait=True).get(
-            "status", "unknown"
-        )
+        completeness_status = self.kernel.is_complete(code).get("status", "unknown")
         return not (
             not code.strip()
             or completeness_status == "incomplete"
@@ -404,12 +416,7 @@ class Console(KernelTab):
                 if ((json_cells and cell.id != json_cells[0].id) or i > 0) and (
                     (height_known and rows_above_layout > 0) or not height_known
                 ):
-                    children.append(
-                        Window(
-                            height=1,
-                            dont_extend_height=True,
-                        )
-                    )
+                    children.append(Window(height=1, dont_extend_height=True))
 
                 # Cell input
                 children.append(
@@ -441,9 +448,12 @@ class Console(KernelTab):
             if outputs := cell.outputs:
                 # 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
+                if self.last_rendered is None or (
+                    self.last_rendered is not None
+                    and (
+                        not self.last_rendered.outputs
+                        or cell.execution_count != self.last_rendered.execution_count
+                    )
                 ):
                     children.append(
                         Window(

euporie/core/__init__.py

@@ -1,10 +1,10 @@
 """This package defines the euporie application and its components."""
 
 __app_name__ = "euporie"
-__version__ = "2.8.5"
+__version__ = "2.8.7"
 __logo__ = "⚈"
 __strapline__ = "Jupyter in the terminal"
 __author__ = "Josiah Outram Halstead"
 __email__ = "josiah@halstead.email"
-__copyright__ = f"© 2024, {__author__}"
+__copyright__ = f"© 2025, {__author__}"
 __license__ = "MIT"

euporie/core/__main__.py

@@ -7,13 +7,13 @@ from importlib.metadata import entry_points
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from importlib.metadata import EntryPoint, EntryPoints, SelectableGroups
+    from importlib.metadata import EntryPoint, EntryPoints
 
 
 @cache
 def available_apps() -> dict[str, EntryPoint]:
     """Return a list of loadable euporie apps."""
-    eps: dict | SelectableGroups | EntryPoints
+    eps: dict | EntryPoints
     try:
         eps = entry_points(group="euporie.apps")
     except TypeError:

euporie/core/_settings.py

@@ -1,5 +1,7 @@
 """Defines core settings."""
 
+import json
+
 from euporie.core import __version__
 from euporie.core.config import add_setting
 
@@ -73,8 +75,11 @@ add_setting(
     name="log_config",
     group="euporie.core.log",
     flags=["--log-config"],
-    type_=str,
-    default="{}",
+    type_=json.loads,
+    default={},
+    schema={
+        "type": "object",
+    },
     title="additional logging configuration",
     help_="Additional logging configuration",
     description="""

euporie/core/app/_commands.py

@@ -8,7 +8,7 @@ from prompt_toolkit.filters import buffer_has_focus
 
 from euporie.core.app.current import get_app
 from euporie.core.commands import add_cmd
-from euporie.core.filters import tab_has_focus
+from euporie.core.filters import tab_has_focus, tab_type_has_focus
 
 if TYPE_CHECKING:
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
@@ -20,18 +20,12 @@ def _quit() -> None:
     get_app().exit()
 
 
-@add_cmd(aliases=["wq", "x"])
-def _save_and_quit(event: KeyPressEvent) -> None:
-    """Save the current tab then quits euporie."""
-    from upath import UPath
+@add_cmd(aliases=["q!"])
+def _force_quit() -> None:
+    """Quit euporie without saving any changes."""
+    from prompt_toolkit.application.application import Application
 
-    app = get_app()
-    if (tab := get_app().tab) is not None:
-        try:
-            tab._save(UPath(event._arg) if event._arg else None)
-        except NotImplementedError:
-            pass
-    app.exit()
+    Application.exit(get_app())
 
 
 @add_cmd(aliases=["bc"], filter=tab_has_focus, menu_title="Close File")
@@ -68,3 +62,17 @@ def _focus_previous() -> None:
 def _clear_screen() -> None:
     """Clear the screen."""
     get_app().renderer.clear()
+
+
+@add_cmd(hidden=True, aliases=[""])
+def _go_to(event: KeyPressEvent, index: int = 0) -> None:
+    """Go to a line or cell by number."""
+    index = max(0, index - 1)
+    if buffer_has_focus():
+        buffer = get_app().current_buffer
+        buffer.cursor_position = len("".join(buffer.text.splitlines(True)[:index]))
+    elif tab_type_has_focus("euporie.notebook.tabs.notebook:Notebook")():
+        from euporie.notebook.tabs.notebook import Notebook
+
+        if isinstance(nb := get_app().tab, Notebook):
+            nb.select(index)

euporie/core/app/_settings.py

@@ -140,6 +140,8 @@ add_setting(
 
         e.g.
 
+        .. code-block:: json
+
            [
              {"command": ["ruff", "format", "-"], "languages": ["python"]},
              {"command": ["black", "-"], "languages": ["python"]},
@@ -281,6 +283,30 @@ add_setting(
     """,
 )
 
+add_setting(
+    name="custom_styles",
+    group="euporie.core.style",
+    flags=["--custom-styles"],
+    type_=json.loads,
+    default={},
+    schema={
+        "type": "object",
+    },
+    help_="Additional style settings",
+    description="""
+        A JSON object mapping style names to prompt-toolkit style values.
+
+        The style keys used in euporie can be found in :py:func:`euporie.core.style.build_style`.
+
+        e.g.:
+
+        .. code-block:: json
+
+           { "cell input prompt":"fg:purple", "cell output prompt": "fg:green" }
+
+    """,
+)
+
 add_setting(
     name="key_bindings",
     group="euporie.core.app.app",
@@ -288,19 +314,19 @@ add_setting(
     type_=json.loads,
     help_="Additional key binding definitions",
     default={},
-    description="""
-        A mapping of component names to mappings of command name to key-binding lists.
-""",
     schema={
         "type": "object",
     },
+    description="""
+        A mapping of component names to mappings of command name to key-binding lists.
+""",
 )
 
 add_setting(
     name="graphics",
     group="euporie.core.app.app",
     flags=["--graphics"],
-    choices=["none", "sixel", "kitty", "iterm"],
+    choices=["none", "sixel", "kitty", "kitty-unicode", "iterm"],
     type_=str,
     default=None,
     help_="The preferred graphics protocol",
@@ -375,6 +401,8 @@ add_setting(
     description="""
         Additional language servers can be defined here, e.g.:
 
+        .. code-block:: json
+
            {
             "ruff": {"command": ["ruff-lsp"], "languages": ["python"]},
             "pylsp": {"command": ["pylsp"], "languages": ["python"]},
@@ -392,6 +420,8 @@ add_setting(
         empty dictionary. For example, the following would disable the awk language
         server:
 
+        .. code-block:: json
+
            {
              "awk-language-server": {},
            }

euporie/core/app/app.py

@@ -520,14 +520,17 @@ class BaseApp(ConfigurableApp, Application, ABC):
     @classmethod
     def launch(cls) -> None:
         """Launch the app."""
+        from prompt_toolkit.utils import in_main_thread
+
         super().launch()
         # Run the application
         with create_app_session(input=cls.load_input(), output=cls.load_output()):
             # Create an instance of the app and run it
             app = cls()
-            # Handle SIGTERM while the app is running
-            original_sigterm = signal.getsignal(signal.SIGTERM)
-            signal.signal(signal.SIGTERM, app.cleanup)
+            if in_main_thread():
+                # Handle SIGTERM while the app is running
+                original_sigterm = signal.getsignal(signal.SIGTERM)
+                signal.signal(signal.SIGTERM, app.cleanup)
             # Set and run the app
             with set_app(app):
                 try:
@@ -535,7 +538,8 @@ class BaseApp(ConfigurableApp, Application, ABC):
                 except (EOFError, KeyboardInterrupt):
                     result = None
                 finally:
-                    signal.signal(signal.SIGTERM, original_sigterm)
+                    if in_main_thread():
+                        signal.signal(signal.SIGTERM, original_sigterm)
                     # Shut down any remaining LSP clients at exit
                     app.shutdown_lsps()
         return result
@@ -582,14 +586,16 @@ class BaseApp(ConfigurableApp, Application, ABC):
         path_mime = get_mime(path) or "text/plain"
         log.debug("File %s has mime type: %s", path, path_mime)
 
-        tab_options: list[TabRegistryEntry] = []
+        # Use a set to automatically handle duplicates
+        tab_options: set[TabRegistryEntry] = set()
         for entry in self.tab_registry:
             for mime_type in entry.mime_types:
                 if PurePath(path_mime).match(mime_type):
-                    tab_options.append(entry)
+                    tab_options.add(entry)
             if path.suffix in entry.file_extensions:
-                tab_options.append(entry)
+                tab_options.add(entry)
 
+        # Sort by weight (TabRegistryEntry.__lt__ handles this)
         return sorted(tab_options, reverse=True)
 
     def get_file_tab(self, path: Path) -> type[Tab] | None:
@@ -791,6 +797,13 @@ class BaseApp(ConfigurableApp, Application, ABC):
             syntax_theme = "tango" if self.color_palette.bg.is_light else "euporie"
         return syntax_theme
 
+    base_styles = (
+        Style(MIME_STYLE),
+        Style(HTML_STYLE),
+        Style(LOG_STYLE),
+        Style(IPYWIDGET_STYLE),
+    )
+
     def create_merged_style(self) -> BaseStyle:
         """Generate a new merged style for the application.
 
@@ -801,6 +814,11 @@ class BaseApp(ConfigurableApp, Application, ABC):
             Return a combined style to use for the application
 
         """
+        styles: list[BaseStyle] = [
+            style_from_pygments_cls(get_style_by_name(self.syntax_theme)),
+            *self.base_styles,
+        ]
+
         # Get foreground and background colors based on the configured colour scheme
         theme_colors: dict[str, dict[str, str]] = {
             "default": {},
@@ -844,7 +862,7 @@ class BaseApp(ConfigurableApp, Application, ABC):
         )
 
         # Build app style
-        app_style = build_style(cp)
+        styles.append(build_style(cp))
 
         # Apply style transformations based on the configured color scheme
         self.style_transformation = merge_style_transformations(
@@ -862,16 +880,11 @@ class BaseApp(ConfigurableApp, Application, ABC):
             ]
         )
 
-        return merge_styles(
-            [
-                style_from_pygments_cls(get_style_by_name(self.syntax_theme)),
-                Style(MIME_STYLE),
-                Style(HTML_STYLE),
-                Style(LOG_STYLE),
-                Style(IPYWIDGET_STYLE),
-                app_style,
-            ]
-        )
+        # Add user style customizations
+        if custom_style_dict := self.config.custom_styles:
+            styles.append(Style.from_dict(custom_style_dict))
+
+        return merge_styles(styles)
 
     def update_style(self, query: Setting | None = None) -> None:
         """Update the application's style when the syntax theme is changed."""

euporie/core/bars/command.py

@@ -3,14 +3,14 @@
 from __future__ import annotations
 
 import logging
+import re
+from functools import lru_cache
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.completion.base import Completer, Completion
-from prompt_toolkit.filters import (
-    buffer_has_focus,
-    has_focus,
-)
+from prompt_toolkit.filters import buffer_has_focus, has_focus, vi_navigation_mode
+from prompt_toolkit.key_binding.vi_state import InputMode
 from prompt_toolkit.layout.containers import ConditionalContainer, Container, Window
 from prompt_toolkit.layout.controls import (
     BufferControl,
@@ -29,6 +29,7 @@ from euporie.core.key_binding.registry import (
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
+    from typing import Unpack
 
     from prompt_toolkit.completion.base import CompleteEvent
     from prompt_toolkit.document import Document
@@ -39,6 +40,23 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
+@lru_cache
+def _parse_cmd(text: str) -> tuple[Command | None, str]:
+    """Parse a command line to command and arguments.
+
+    Command names cannot start with digits, so lines staring with digits have an empty
+    command string (this is used for the go-to-cell/go-to-line shortcuts).
+    """
+    if match := re.fullmatch(r"^(?P<cmd>[^\d][^\s]*|)\s*(?P<args>.*)$", text):
+        cmd, args = match.groups()
+    else:
+        cmd, args = "", ""
+    try:
+        return get_cmd(cmd), args
+    except KeyError:
+        return None, args
+
+
 class CommandCompleter(Completer):
     """Completer of commands."""
 
@@ -49,7 +67,11 @@ class CommandCompleter(Completer):
         prefix = document.text
         found_so_far: set[Command] = set()
         for alias, command in commands.items():
-            if alias.startswith(prefix) and command not in found_so_far:
+            if (
+                alias.startswith(prefix)
+                and command not in found_so_far
+                and not command.hidden()
+            ):
                 yield Completion(
                     command.name,
                     start_position=-len(prefix),
@@ -105,21 +127,18 @@ class CommandBar:
 
     def _validate(self, text: str) -> bool:
         """Verify that a valid command has been entered."""
-        cmd, _, args = text.partition(" ")
-        try:
-            get_cmd(cmd)
-        except KeyError:
-            return False
-        else:
-            return True
+        cmd, _args = _parse_cmd(text)
+        return bool(cmd)
 
     def _accept(self, buffer: Buffer) -> bool:
         """Return value determines if the text is kept."""
-        # TODO - lookup and run command with args
-        get_app().layout.focus_last()
+        app = get_app()
+        app.vi_state.input_mode = InputMode.NAVIGATION
+        app.layout.focus_last()
         text = buffer.text.strip()
-        cmd, _, args = text.partition(" ")
-        get_cmd(cmd).run(args)
+        cmd, args = _parse_cmd(text)
+        if cmd:
+            cmd.run(args)
         return False
 
     def __pt_container__(self) -> Container:
@@ -135,25 +154,28 @@ class CommandBar:
                 "activate-command-bar-shell-alt": "A-!",
             },
             "euporie.core.bars.command:CommandBar": {
-                "deactivate-command-bar": "escape",
+                "deactivate-command-bar": ["escape", "c-c"],
             },
         }
     )
 
     @staticmethod
     @add_cmd(name="activate-command-bar-alt", hidden=True)
-    @add_cmd(filter=~buffer_has_focus)
+    @add_cmd(filter=~buffer_has_focus | vi_navigation_mode)
     def _activate_command_bar(event: KeyPressEvent) -> None:
         """Enter command mode."""
         event.app.layout.focus(COMMAND_BAR_BUFFER)
+        event.app.vi_state.input_mode = InputMode.INSERT
 
     @staticmethod
     @add_cmd(filter=~buffer_has_focus)
     @add_cmd(name="activate-command-bar-shell-alt", hidden=True)
     def _activate_command_bar_shell(event: KeyPressEvent) -> None:
         """Enter command mode."""
-        layout = event.app.layout
+        app = event.app
+        layout = app.layout
         layout.focus(COMMAND_BAR_BUFFER)
+        app.vi_state.input_mode = InputMode.INSERT
         if isinstance(control := layout.current_control, BufferControl):
             buffer = control.buffer
             buffer.text = "shell "
@@ -163,20 +185,24 @@ class CommandBar:
     @add_cmd(hidden=True)
     def _deactivate_command_bar(event: KeyPressEvent) -> None:
         """Exit command mode."""
-        layout = event.app.layout
+        app = event.app
+        layout = app.layout
         layout.focus(COMMAND_BAR_BUFFER)
         if isinstance(control := layout.current_control, BufferControl):
+            app.vi_state.input_mode = InputMode.NAVIGATION
             buffer = control.buffer
             buffer.reset()
-            event.app.layout.focus_previous()
+            app.layout.focus_previous()
 
     @staticmethod
     @add_cmd(aliases=["shell"])
-    async def _run_shell_command(event: KeyPressEvent) -> None:
+    async def _run_shell_command(
+        event: KeyPressEvent, *cmd_arg: Unpack[tuple[str]]
+    ) -> None:
         """Run system command."""
-        app = event.app
-        if event._arg:
-            await app.run_system_command(
-                event._arg,
-                display_before_text=[("bold", "$ "), ("", f"{event._arg}\n")],
+        command = " ".join(str(x) for x in cmd_arg)
+        if command:
+            await event.app.run_system_command(
+                command,
+                display_before_text=[("bold", "$ "), ("", f"{command}\n")],
             )

euporie/core/bars/search.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+import re
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.buffer import Buffer
@@ -27,6 +28,7 @@ from euporie.core.key_binding.registry import (
 if TYPE_CHECKING:
     from prompt_toolkit.filters import FilterOrBool
     from prompt_toolkit.formatted_text.base import AnyFormattedText
+    from prompt_toolkit.layout.controls import UIControl
 
 log = logging.getLogger(__name__)
 
@@ -119,9 +121,17 @@ def find_searchable_controls(
     search_buffer_control: SearchBufferControl, current_control: BufferControl | None
 ) -> list[BufferControl]:
     """Find list of searchable controls and the index of the next control."""
-    searchable_controls: list[BufferControl] = []
+    # If a tab provides a list of buffers to search, use that. Otherwise, trawl the
+    # layout for buffer controls with this as its search control
+    long_list: list[UIControl]
+    if tab := get_app().tab:
+        try:
+            long_list = list(tab.__pt_searchables__())
+        except NotImplementedError:
+            long_list = list(get_app().layout.find_all_controls())
     next_control_index = 0
-    for control in get_app().layout.find_all_controls():
+    searchable_controls: list[BufferControl] = []
+    for control in long_list:
         # Find the index of the next searchable control so we can link the search
         # control to it if the currently focused control is not searchable. This is so
         # that the next searchable control can be focused when search is completed.
@@ -134,6 +144,7 @@ def find_searchable_controls(
         ):
             # Add it to our list
             searchable_controls.append(control)
+    # Cut list based on current control index
     searchable_controls = (
         searchable_controls[next_control_index:]
         + searchable_controls[:next_control_index]
@@ -332,3 +343,33 @@ def accept_search() -> None:
     search_buffer_control.buffer.append_to_history()
     # Stop the search
     stop_search()
+
+
+@add_cmd()
+def _replace_all(find_str: str, replace_str: str) -> None:
+    """Find and replace text in all searchable buffers.
+
+    Args:
+        find_str: String pattern to find (will be converted to regex)
+        replace_str: Replacement string
+    """
+    # Convert find string to regex pattern
+    pattern = re.compile(find_str)
+
+    # Get searchable controls
+    search_buffer_control, current_control = find_search_control()
+    if search_buffer_control is None:
+        return
+    searchable_controls = find_searchable_controls(
+        search_buffer_control, current_control
+    )
+
+    # Apply replacements to each buffer
+    for control in searchable_controls:
+        if isinstance(control, BufferControl):
+            buffer = control.buffer
+            text = buffer.text
+            new_text = pattern.sub(replace_str, text)
+            if new_text != text:
+                buffer.text = new_text
+                buffer.on_text_changed()

euporie/core/border.py

@@ -512,6 +512,11 @@ _GRID_CHARS = {
     GridChar(LowerLeftQuarterLine, NoLine, NoLine, UpperRightEighthLine): " ",
     GridChar(UpperRightQuarterLine, UpperRightEighthLine, NoLine, NoLine): " ",
 
+    GridChar(NoLine, NoLine, UpperRightQuarterLine, UpperRightEighthLine): "▁",
+    GridChar(UpperRightQuarterLine, NoLine, NoLine, UpperRightEighthLine): "▔",
+    GridChar(LowerLeftQuarterLine, UpperRightEighthLine, NoLine, NoLine): "▔",
+    GridChar(NoLine, LowerLeftEighthLine, LowerLeftQuarterLine, NoLine): "▁",
+
     # LowerLeftQuarterLine
     GridChar(LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine, NoLine): "▎",
     GridChar(NoLine, LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine): "▂",
@@ -875,9 +880,9 @@ InsetGrid = (
 
 OutsetGrid = (
     LowerLeftEighthLine.top_edge
-    + UpperRightEighthLine.right_edge
+    + UpperRightQuarterLine.right_edge
     + UpperRightEighthLine.bottom_edge
-    + LowerLeftEighthLine.left_edge
+    + LowerLeftQuarterLine.left_edge
     + ThinLine.inner
 )
 

euporie/core/comm/base.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 
     from prompt_toolkit.layout.containers import AnyContainer
 
-    from euporie.core.kernel.client import Kernel
+    from euporie.core.kernel.jupyter import JupyterKernel
     from euporie.core.tabs.kernel import KernelTab
     from euporie.core.widgets.cell_outputs import OutputParent
 
@@ -40,7 +40,7 @@ class CommView:
         """
         self.container = container
         self.setters: dict[str, Callable[..., None]] = dict(setters or {})
-        self.kernel: Kernel | None = None
+        self.kernel: JupyterKernel | None = None
 
     def update(self, changes: dict[str, Any]) -> None:
         """Update the view to reflect changes in the Comm.