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

euporie/core/__init__.py

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

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,6 +20,14 @@ def _quit() -> None:
     get_app().exit()
 
 
+@add_cmd(aliases=["q!"])
+def _force_quit() -> None:
+    """Quit euporie without saving any changes."""
+    from prompt_toolkit.application.application import Application
+
+    Application.exit(get_app())
+
+
 @add_cmd(aliases=["wq", "x"])
 def _save_and_quit(event: KeyPressEvent) -> None:
     """Save the current tab then quits euporie."""
@@ -68,3 +76,20 @@ 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) -> None:
+    """Go to a line or cell by number."""
+    try:
+        idx = int(event._arg or "") - 1
+    except (ValueError, TypeError):
+        return
+    if buffer_has_focus():
+        buffer = get_app().current_buffer
+        buffer.cursor_position = len("".join(buffer.text.splitlines(True)[:idx]))
+    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(idx)

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

@@ -791,6 +791,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 +808,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 +856,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 +874,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,
@@ -39,6 +39,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 +66,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 +126,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 +153,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,12 +184,14 @@ 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"])

euporie/core/commands.py

@@ -191,22 +191,6 @@ class Command:
             return format_keys([self.keys[0]])[0]
         return ""
 
-    @property
-    def menu_handler(self) -> Callable[[], None]:
-        """Return a menu handler for the command."""
-        handler = self.handler
-        if isawaitable(handler):
-
-            def _menu_handler() -> None:
-                task = cast("CommandHandlerNoArgs", handler)()
-                task = cast("Coroutine[Any, Any, None]", task)
-                if task is not None:
-                    get_app().create_background_task(task)
-
-            return _menu_handler
-        else:
-            return cast("Callable[[], None]", handler)
-
     @property
     def menu(self) -> MenuItem:
         """Return a menu item for the command."""

euporie/core/filters.py

@@ -133,6 +133,38 @@ def tab_has_focus() -> bool:
     return get_app().tab is not None
 
 
+@Condition
+def kernel_tab_has_focus() -> bool:
+    """Determine if there is a focused kernel tab."""
+    from euporie.core.app.current import get_app
+    from euporie.core.tabs.kernel import KernelTab
+
+    return isinstance(get_app().tab, KernelTab)
+
+
+@cache
+def tab_type_has_focus(tab_class_path: str) -> Condition:
+    """Determine if the focused tab is of a particular type."""
+    from pkgutil import resolve_name
+
+    from euporie.core.app.current import get_app
+
+    tab_class = cache(resolve_name)
+
+    return Condition(lambda: isinstance(get_app().tab, tab_class(tab_class_path)))
+
+
+@Condition
+def tab_can_save() -> bool:
+    """Determine if the current tab can save it's contents."""
+    from euporie.core.app.current import get_app
+    from euporie.core.tabs.base import Tab
+
+    return (
+        tab := get_app().tab
+    ) is not None and tab.__class__.write_file != Tab.write_file
+
+
 @Condition
 def pager_has_focus() -> bool:
     """Determine if there is a currently focused notebook."""
@@ -321,15 +353,6 @@ def multiple_cells_selected() -> bool:
     return False
 
 
-@Condition
-def kernel_tab_has_focus() -> bool:
-    """Determine if there is a focused kernel tab."""
-    from euporie.core.app.current import get_app
-    from euporie.core.tabs.kernel import KernelTab
-
-    return isinstance(get_app().tab, KernelTab)
-
-
 def scrollable(window: Window) -> Filter:
     """Return a filter which indicates if a window is scrollable."""
     return Condition(

euporie/core/format.py

@@ -110,11 +110,10 @@ class LspFormatter(Formatter):
                     range_ = change.get("range", {})
                     start = range_.get("start", {})
                     start_line = start.get("line", 0)
-                    start_char = start.get("char", 0)
+                    start_char = start.get("character", 0)
                     end = range_.get("end", {})
                     end_line = end.get("line", 0)
-                    end_char = end.get("char", 0)
-
+                    end_char = end.get("character", 0)
                     segment = range_to_slice(
                         start_line, start_char, end_line, end_char, text
                     )