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

euporie/core/widgets/cell.py

@@ -6,7 +6,7 @@ import asyncio
 import logging
 import os
 import weakref
-from functools import partial
+from functools import lru_cache, partial
 from pathlib import Path
 from typing import TYPE_CHECKING, cast
 from weakref import WeakKeyDictionary
@@ -50,6 +50,7 @@ if TYPE_CHECKING:
     from prompt_toolkit.completion.base import Completer
     from prompt_toolkit.formatted_text.base import StyleAndTextTuples
 
+    from euporie.core.border import GridStyle
     from euporie.core.format import Formatter
     from euporie.core.inspection import Inspector
     from euporie.core.lsp import LspClient
@@ -79,6 +80,18 @@ def get_cell_id(cell_json: dict) -> str:
     return cell_id
 
 
+@lru_cache(maxsize=32)
+def _get_border_style(
+    selected: bool, focused: bool, show_borders: bool, multi_selected: bool
+) -> GridStyle:
+    """Get the border style grid based on cell state."""
+    if not (show_borders or selected):
+        return NoLine.grid
+    if focused and multi_selected:
+        return ThickLine.outer
+    return ThinLine.outer
+
+
 class Cell:
     """A kernel_tab cell element.
 
@@ -86,8 +99,6 @@ class Cell:
     focused.
     """
 
-    input_box: KernelInput
-
     def __init__(
         self, index: int, json: dict, kernel_tab: BaseNotebook, is_new: bool = False
     ) -> None:
@@ -158,6 +169,14 @@ class Cell:
             """Update cell json when the input buffer has been edited."""
             weak_self._set_input(buf.text)
             weak_self.kernel_tab.dirty = True
+            weak_self.on_change()
+            # Re-render markdown cells when edited outside of edit mode
+            if (
+                weak_self.cell_type == "markdown"
+                and not weak_self.kernel_tab.in_edit_mode()
+            ):
+                weak_self.output_area.json = weak_self.output_json
+                weak_self.refresh()
 
         def on_cursor_position_changed(buf: Buffer) -> None:
             """Respond to cursor movements."""
@@ -199,42 +218,22 @@ class Cell:
         )
         self.input_box.buffer.name = self.cell_type
 
-        self.input_box.buffer.on_text_changed += lambda buf: weak_self.on_change()
-
         def border_char(name: str) -> Callable[..., str]:
             """Return a function which returns the cell border character to display."""
 
             def _inner() -> str:
-                grid = NoLine.grid
-                if weak_self and (
-                    weak_self.kernel_tab.app.config.show_cell_borders
-                    or weak_self.selected
-                ):
-                    if weak_self.focused and multiple_cells_selected():
-                        grid = ThickLine.outer
-                    else:
-                        grid = ThinLine.outer
+                if not weak_self:
+                    return " "
+                grid = _get_border_style(
+                    weak_self.selected,
+                    weak_self.focused,
+                    weak_self.kernel_tab.app.config.show_cell_borders,
+                    multiple_cells_selected(),
+                )
                 return getattr(grid, name.upper())
 
             return _inner
 
-        # @lru_cache(maxsize=None)
-        # def _cell_border_char(
-        #     name: str,
-        #     show_cell_borders: bool,
-        #     focused: bool,
-        #     selected: bool,
-        #     multiple_cells_selected: bool,
-        # ) -> str:
-        #     if show_cell_borders or selected:
-        #         if focused and multiple_cells_selected:
-        #             grid = ThickLine.outer
-        #         else:
-        #             grid = ThinLine.outer
-        #     else:
-        #         grid = NoLine.grid
-        #     return getattr(grid, name.upper())
-
         self.control = Window(
             FormattedTextControl(
                 border_char("TOP_LEFT"),
@@ -764,6 +763,7 @@ class Cell:
     def set_execution_count(self, n: int) -> None:
         """Set the execution count of the cell."""
         self.json["execution_count"] = n
+        self.refresh()
 
     def add_output(self, output_json: dict[str, Any], own: bool) -> None:
         """Add a new output to the cell."""

euporie/core/widgets/cell_outputs.py

@@ -116,6 +116,16 @@ class CellOutputDataElement(CellOutputElement):
                     format_ = data_format
                     break
 
+        config = get_app().config
+
+        # Limit size of text only outputs
+        if (
+            format_ == "ansi"
+            and (limit := config.text_output_limit) > 0
+            and len(data) > limit
+        ):
+            data = data[:limit] + "\n… (Output truncated)"
+
         self._datum = Datum(
             data,
             format_,
@@ -123,7 +133,6 @@ class CellOutputDataElement(CellOutputElement):
             py=metadata.get("height"),
             bg=bg_color,
         )
-        config = get_app().config
 
         self.container = Display(
             self._datum,

euporie/core/widgets/dialog.py

@@ -16,6 +16,7 @@ from prompt_toolkit.filters import (
     buffer_has_focus,
     has_completions,
     has_focus,
+    vi_insert_mode,
 )
 from prompt_toolkit.formatted_text import AnyFormattedText, to_formatted_text
 from prompt_toolkit.formatted_text.utils import split_lines
@@ -40,7 +41,6 @@ from euporie.core.border import (
     UpperRightHalfLine,
 )
 from euporie.core.commands import add_cmd
-from euporie.core.filters import tab_can_save
 from euporie.core.ft.utils import FormattedTextAlign, align, lex
 from euporie.core.key_binding.registry import register_bindings
 from euporie.core.layout.containers import HSplit, VSplit, Window
@@ -64,6 +64,7 @@ if TYPE_CHECKING:
     from prompt_toolkit.mouse_events import MouseEvent
 
     from euporie.core.app.app import BaseApp
+    from euporie.core.kernel.base import KernelInfo
     from euporie.core.tabs.base import Tab
     from euporie.core.tabs.kernel import KernelTab
 
@@ -197,7 +198,7 @@ class Dialog(Float, metaclass=ABCMeta):
 
         # Create key-bindings
         kb = KeyBindings()
-        kb.add("escape")(lambda event: self.hide())
+        kb.add("escape", filter=~(buffer_has_focus & vi_insert_mode))(self.hide)
         kb.add("tab", filter=~has_completions)(focus_next)
         kb.add("s-tab", filter=~has_completions)(focus_previous)
 
@@ -597,21 +598,6 @@ class SaveAsDialog(FileDialog):
                 if callable(cb):
                     cb()
 
-    # ################################### Commands ####################################
-
-    @staticmethod
-    @add_cmd(
-        menu_title="Save As…",
-        filter=tab_can_save,
-    )
-    def _save_as() -> None:
-        """Save the current file at a new location."""
-        from euporie.core.app.current import get_app
-
-        app = get_app()
-        if dialog := app.dialogs.get("save-as"):
-            dialog.show(tab=app.tab)
-
     # ################################# Key Bindings ##################################
 
     register_bindings(
@@ -655,62 +641,37 @@ class SelectKernelDialog(Dialog):
 
     title = "Select Kernel"
 
-    def load(
-        self,
-        kernel_specs: dict[str, Any] | None = None,
-        runtime_dirs: dict[str, Path] | None = None,
-        tab: KernelTab | None = None,
-        message: str = "",
-    ) -> None:
+    def load(self, tab: KernelTab | None = None, message: str = "") -> None:
         """Load dialog body & buttons."""
-        from jupyter_core.paths import jupyter_runtime_dir
-
+        from euporie.core.kernel import list_kernels
         from euporie.core.widgets.layout import TabbedSplit
 
-        kernel_specs = kernel_specs or {}
-        runtime_dirs = runtime_dirs or {}
-
-        options_specs = Select(
-            options=list(kernel_specs.keys()),
-            labels=[
-                kernel_spec.get("spec", {}).get("display_name", kernel_name)
-                for kernel_name, kernel_spec in kernel_specs.items()
-            ],
-            style="class:input,radio-buttons",
-            prefix=("○", "◉"),
-            multiple=False,
-            border=None,
-            rows=5,
-            dont_extend_width=False,
-        )
-        self.to_focus = options_specs
-
-        connection_files = {
-            path.name: path
-            for path in Path(jupyter_runtime_dir()).glob("kernel-*.json")
-        }
-        options_files = Select(
-            options=list(connection_files.values()),
-            labels=list(connection_files.keys()),
-            style="class:input,radio-buttons",
-            prefix=("○", "◉"),
-            multiple=False,
-            border=None,
-            rows=5,
-            dont_extend_width=False,
-        )
-
-        msg_ft = (f"{message}\n\n" if message else "") + "Please select a kernel:"
+        infos = list_kernels()
+        infos_by_kind: dict[str, list[KernelInfo]] = {}
+        for info in infos:
+            infos_by_kind.setdefault(info.kind, []).append(info)
+
+        selects = {}
+        for kind, infos in infos_by_kind.items():
+            selects[kind] = Select(
+                options=infos,
+                labels=[info.display_name for info in infos],
+                style="class:input,radio-buttons",
+                prefix=("○", "◉"),
+                multiple=False,
+                border=None,
+                rows=5,
+                dont_extend_width=False,
+            )
 
         self.body = HSplit(
             [
-                Label(msg_ft),
+                Label(
+                    (f"{message}\n\n" if message else "") + "Please select a kernel:"
+                ),
                 tabs := TabbedSplit(
-                    [
-                        FocusedStyle(options_specs),
-                        FocusedStyle(options_files),
-                    ],
-                    titles=["New", "Existing"],
+                    [FocusedStyle(select) for select in selects.values()],
+                    titles=[kind.title() for kind in selects],
                     width=Dimension(min=30),
                 ),
             ]
@@ -719,15 +680,9 @@ class SelectKernelDialog(Dialog):
         def _change_kernel() -> None:
             self.hide()
             assert tab is not None
-            if tabs.active == 0:
-                name = options_specs.value
-                connection_file = None
-            else:
-                name = None
-                connection_file = options_files.value
-            tab.kernel.change(
-                name=name, connection_file=connection_file, cb=tab.kernel_started
-            )
+            if (index := tabs.active) is not None:
+                info = list(selects.values())[index].value
+                tab.switch_kernel(info.factory)
 
         self.buttons = {
             "Select": _change_kernel,

euporie/core/widgets/forms.py

@@ -11,17 +11,19 @@ from math import ceil, floor
 from typing import TYPE_CHECKING, cast
 from weakref import finalize
 
-from prompt_toolkit.buffer import ValidationState
+from prompt_toolkit.auto_suggest import DynamicAutoSuggest
+from prompt_toolkit.buffer import Buffer, ValidationState
 from prompt_toolkit.cache import SimpleCache
-from prompt_toolkit.completion.base import ConditionalCompleter
-from prompt_toolkit.completion.word_completer import WordCompleter
+from prompt_toolkit.completion import Completer, ConditionalCompleter, WordCompleter
 from prompt_toolkit.data_structures import Point
+from prompt_toolkit.document import Document
 from prompt_toolkit.filters import (
     Always,
     Condition,
     Filter,
     FilterOrBool,
     has_focus,
+    is_true,
     to_filter,
 )
 from prompt_toolkit.formatted_text.base import to_formatted_text
@@ -39,13 +41,19 @@ from prompt_toolkit.layout.controls import (
     UIControl,
 )
 from prompt_toolkit.layout.dimension import Dimension
-from prompt_toolkit.layout.processors import AfterInput, ConditionalProcessor
+from prompt_toolkit.layout.processors import (
+    AfterInput,
+    BeforeInput,
+    ConditionalProcessor,
+    PasswordProcessor,
+    Processor,
+)
 from prompt_toolkit.layout.screen import WritePosition
 from prompt_toolkit.layout.utils import explode_text_fragments
+from prompt_toolkit.lexers import DynamicLexer, Lexer
 from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
 from prompt_toolkit.utils import Event
 from prompt_toolkit.validation import Validator
-from prompt_toolkit.widgets.base import TextArea
 
 from euporie.core.app.current import get_app
 from euporie.core.border import InsetGrid
@@ -59,7 +67,8 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
     from typing import Any, Callable
 
-    from prompt_toolkit.buffer import Buffer, BufferAcceptHandler
+    from prompt_toolkit.auto_suggest import AutoSuggest
+    from prompt_toolkit.buffer import BufferAcceptHandler
     from prompt_toolkit.completion.base import Completer
     from prompt_toolkit.formatted_text.base import (
         AnyFormattedText,
@@ -498,6 +507,7 @@ class ExpandingBufferControl(BufferControl):
         focus_on_click: FilterOrBool = False,
         key_bindings: KeyBindingsBase | None = None,
         expand: FilterOrBool = True,
+        on_focus: Callable[[], None] | None = None,
     ) -> None:
         """Add an ``expand`` parameter to the buffer control."""
         super().__init__(
@@ -513,6 +523,7 @@ class ExpandingBufferControl(BufferControl):
             key_bindings=key_bindings,
         )
         self.expand = to_filter(expand)
+        self.on_focus = on_focus
 
     def preferred_width(self, max_available_width: int) -> int | None:
         """Enure text box expands to available width.
@@ -528,6 +539,16 @@ class ExpandingBufferControl(BufferControl):
         else:
             return None
 
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
+        """Optionally call focus handler when focused."""
+        layout = get_app().layout
+        was_focused = layout.current_control == self
+        result = super().mouse_handler(mouse_event)
+        is_focused = layout.current_control == self
+        if not was_focused and is_focused and callable(self.on_focus):
+            self.on_focus()
+        return result
+
 
 class Text:
     """A text input widget."""
@@ -554,6 +575,9 @@ class Text:
         password: FilterOrBool = False,
         wrap_lines: FilterOrBool = False,
         prompt: AnyFormattedText | None = None,
+        on_focus: Callable[[], None] | None = None,
+        complete_while_typing: FilterOrBool = True,
+        auto_suggest: AutoSuggest | None = None,
     ) -> None:
         """Create a new text widget instance.
 
@@ -580,33 +604,44 @@ class Text:
             disabled: A filter which when evaluated to :py:const:`True` causes the
                 widget to be disabled
             password: A filter to determine if the text input is a password field
-            prompt: Text to display before the input
             wrap_lines: Whether to wrap lines wider than the text area
+            prompt: Text to display before the input
+            on_focus: Function to call when the buffer gains focus
+            complete_while_typing: Whether to show completions while typing
+            auto_suggest: Auto-suggestion behavior for the text input
         """
         self.style = style
         self.options = options or []
         self.disabled = to_filter(disabled)
-
         self.placeholder = placeholder
+        self.wrap_lines = wrap_lines
+        self.complete_while_typing = complete_while_typing
+        self.auto_suggest = auto_suggest
+        self.lexer = lexer
 
-        self.text_area = TextArea(
-            str(text),
+        self.buffer = Buffer(
+            document=Document(str(text), 0),
             multiline=multiline,
-            height=Dimension(min=min_height, max=height, preferred=height),
-            width=width,
-            focusable=~self.disabled,
-            focus_on_click=~self.disabled,
             read_only=self.disabled,
-            style=f"{style} class:text,text-area",
-            validator=Validator.from_callable(validation) if validation else None,
-            accept_handler=accept_handler,
             completer=completer
             or ConditionalCompleter(
                 WordCompleter(self.options),
                 filter=Condition(lambda: bool(self.options)),
             ),
-            lexer=lexer,
+            complete_while_typing=Condition(
+                lambda: is_true(self.complete_while_typing)
+            ),
+            validator=Validator.from_callable(validation) if validation else None,
+            validate_while_typing=validation is not None,
+            auto_suggest=DynamicAutoSuggest(lambda: self.auto_suggest),
+            accept_handler=accept_handler,
+        )
+
+        self.control = ExpandingBufferControl(
+            buffer=self.buffer,
+            lexer=DynamicLexer(lambda: self.lexer),
             input_processors=[
+                BeforeInput(prompt, style="class:text-area.prompt"),
                 ConditionalProcessor(
                     AfterInput(
                         lambda: self.placeholder, style="class:text,placeholder"
@@ -615,58 +650,35 @@ class Text:
                         lambda: self.placeholder is not None and self.buffer.text == ""
                     ),
                 ),
+                ConditionalProcessor(
+                    processor=PasswordProcessor(), filter=to_filter(password)
+                ),
                 *(input_processors or []),
             ],
-            password=password,
-            wrap_lines=wrap_lines,
-        )
-        self.buffer = self.text_area.buffer
-
-        # Patch text area control's to expand to fill available width
-        # Do this without monkey-pathing by sub-classing :class:`BufferControl` and
-        # re-assigning the text-area's control
-        self.text_area.control = ExpandingBufferControl(
-            buffer=self.text_area.control.buffer,
-            input_processors=self.text_area.control.input_processors,
-            include_default_input_processors=(
-                self.text_area.control.include_default_input_processors
-            ),
-            lexer=self.text_area.control.lexer,
-            preview_search=self.text_area.control.preview_search,
-            focusable=self.text_area.control.focusable,
-            search_buffer_control=self.text_area.control._search_buffer_control,
-            menu_position=self.text_area.control.menu_position,
-            focus_on_click=self.text_area.control.focus_on_click,
-            key_bindings=self.text_area.control.key_bindings,
+            focusable=~self.disabled,
+            focus_on_click=~self.disabled,
             expand=expand,
+            on_focus=on_focus,
         )
-        window = self.text_area.window
-        self.text_area.window = Window(
-            height=window.height,
-            width=window.width,
-            dont_extend_height=window.dont_extend_height,
-            dont_extend_width=window.dont_extend_width,
-            content=self.text_area.control,
-            style=window.style,
-            wrap_lines=window.wrap_lines,
-            left_margins=window.left_margins,
-            right_margins=window.right_margins,
-            get_line_prefix=window.get_line_prefix,
+
+        self.window = Window(
+            height=Dimension(min=min_height, max=height, preferred=height),
+            width=width,
+            content=self.control,
+            wrap_lines=Condition(lambda: is_true(self.wrap_lines)),
+            style=f"{style} class:text,text-area",
         )
-        self.text_area.window.content = self.text_area.control
 
         if on_text_changed:
-            self.text_area.buffer.on_text_changed += on_text_changed
+            self.buffer.on_text_changed += on_text_changed
         if validation:
-            self.text_area.buffer.validate_while_typing = Always()
+            self.buffer.validate_while_typing = Always()
         self.container = Border(
             VSplit(
                 [
-                    self.text_area,
+                    self.window,
                     ConditionalContainer(
-                        MarginContainer(
-                            ScrollbarMargin(), target=self.text_area.window
-                        ),
+                        MarginContainer(ScrollbarMargin(), target=self.window),
                         filter=to_filter(multiline),
                     ),
                 ]
@@ -678,7 +690,7 @@ class Text:
 
     def border_style(self) -> str:
         """Calculate the style to apply to the widget's border."""
-        if self.text_area.buffer.validation_state == ValidationState.INVALID:
+        if self.buffer.validation_state == ValidationState.INVALID:
             return f"{self.style} class:text,border,invalid"
         else:
             return f"{self.style} class:text,border"

euporie/core/widgets/inputs.py

@@ -250,7 +250,10 @@ class KernelInput(TextArea):
             buffer=self.buffer,
             lexer=DynamicLexer(
                 lambda: _get_lexer(
-                    app.config.syntax_highlighting, self.lexer, self.language
+                    # Only lex buffers with text
+                    self.buffer.text and app.config.syntax_highlighting,
+                    self.lexer,
+                    self.language,
                 )
             ),
             input_processors=[
@@ -506,7 +509,7 @@ class StdInput:
             password=Condition(lambda: self.password),
             style="class:input",
         )
-        self.window = text.text_area.window
+        self.window = text.window
         self.container = ConditionalContainer(
             LabelledWidget(
                 body=text,
@@ -517,8 +520,8 @@ class StdInput:
 
     def accept(self, buffer: Buffer) -> bool:
         """Send the input to the kernel and hide the input box."""
-        if self.kernel_tab.kernel.kc is not None:
-            self.kernel_tab.kernel.kc.input(buffer.text)
+        if self.kernel_tab.kernel is not None:
+            self.kernel_tab.kernel.input(buffer.text)
         # Cleanup
         self.active = False