euporie 2.3.2__py3-none-any.whl → 2.4.1__py3-none-any.whl

euporie/core/widgets/decor.py

@@ -1,6 +1,6 @@
 """Decorative widgets."""
 
-# from __future__ import annotations
+from __future__ import annotations
 
 import logging
 from typing import TYPE_CHECKING
@@ -30,7 +30,7 @@ from euporie.core.data_structures import DiBool
 from euporie.core.style import ColorPaletteColor
 
 if TYPE_CHECKING:
-    from typing import Callable, Optional, Union
+    from typing import Callable
 
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.layout.containers import AnyContainer
@@ -48,12 +48,12 @@ class Line(Container):
 
     def __init__(
         self,
-        char: "Optional[str]" = None,
-        width: "Optional[int]" = None,
-        height: "Optional[int]" = None,
-        collapse: "bool" = False,
-        style: "str" = "class:grid-line",
-    ) -> "None":
+        char: str | None = None,
+        width: int | None = None,
+        height: int | None = None,
+        collapse: bool = False,
+        style: str = "class:grid-line",
+    ) -> None:
         """Initialize a grid line.
 
         Args:
@@ -78,28 +78,26 @@ class Line(Container):
         self.char = Char(char, style)
         self.collapse = collapse
 
-    def reset(self) -> "None":
+    def reset(self) -> None:
         """Reet the state of the line. Does nothing."""
 
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
+    def preferred_width(self, max_available_width: int) -> Dimension:
         """Return the preferred width of the line."""
         return Dimension(min=int(not self.collapse), max=self.width)
 
-    def preferred_height(
-        self, width: "int", max_available_height: "int"
-    ) -> "Dimension":
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
         """Return the preferred height of the line."""
         return Dimension(min=int(not self.collapse), max=self.height)
 
     def write_to_screen(
         self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
-        z_index: "Optional[int]",
-    ) -> "None":
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
         """Draw a continuous line in the ``write_position`` area.
 
         Args:
@@ -124,7 +122,7 @@ class Line(Container):
             for x in range(xpos, xpos + write_position.width):
                 row[x] = self.char
 
-    def get_children(self) -> "list":
+    def get_children(self) -> list:
         """Return an empty list of the container's children."""
         return []
 
@@ -134,37 +132,35 @@ class Pattern(Container):
 
     def __init__(
         self,
-        char: "Union[str, Callable[[], str]]",
-        pattern: "Union[int, Callable[[], int]]" = 1,
-    ) -> "None":
+        char: str | Callable[[], str],
+        pattern: int | Callable[[], int] = 1,
+    ) -> None:
         """Initialize the :class:`Pattern`."""
         self.bg = Char(" ", "class:pattern")
         self.char = char
         self.pattern = pattern
 
-    def reset(self) -> "None":
+    def reset(self) -> None:
         """Reet the pattern. Does nothing."""
         pass
 
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
+    def preferred_width(self, max_available_width: int) -> Dimension:
         """Return an empty dimension (expand to available width)."""
         return Dimension()
 
-    def preferred_height(
-        self, width: "int", max_available_height: "int"
-    ) -> "Dimension":
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
         """Return an empty dimension (expand to available height)."""
         return Dimension()
 
     def write_to_screen(
         self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
-        z_index: "Optional[int]",
-    ) -> "None":
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
         """Fill the whole area of write_position with a pattern.
 
         Args:
@@ -208,7 +204,7 @@ class Pattern(Container):
                 else:
                     row[x] = bg
 
-    def get_children(self) -> "list":
+    def get_children(self) -> list:
         """Return an empty list of the container's children."""
         return []
 
@@ -218,11 +214,11 @@ class Border:
 
     def __init__(
         self,
-        body: "AnyContainer",
-        border: "Optional[GridStyle]" = ThinLine.grid,
-        style: "Union[str, Callable[[], str]]" = "class:border",
-        show_borders: "Optional[DiBool]" = None,
-    ) -> "None":
+        body: AnyContainer,
+        border: GridStyle | None = ThinLine.grid,
+        style: str | Callable[[], str] = "class:border",
+        show_borders: DiBool | None = None,
+    ) -> None:
         """Create a new border widget which wraps another container.
 
         Args:
@@ -244,7 +240,7 @@ class Border:
         border_bottom = to_filter(show_borders.bottom)
         border_left = to_filter(show_borders.left)
 
-        self.container: "AnyContainer"
+        self.container: AnyContainer
         if border is not None and any(show_borders):
             self.container = HSplit(
                 [
@@ -344,10 +340,10 @@ class Border:
         else:
             self.container = body
 
-    def add_style(self, extra: "str") -> "Callable[[], str]":
+    def add_style(self, extra: str) -> Callable[[], str]:
         """Return a function which adds a style string to the border style."""
 
-        def _style() -> "str":
+        def _style() -> str:
             if callable(self.style):
                 return f"{self.style()} {extra}"
             else:
@@ -355,7 +351,7 @@ class Border:
 
         return _style
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the border widget's container."""
         return self.container
 
@@ -365,10 +361,10 @@ class FocusedStyle(Container):
 
     def __init__(
         self,
-        body: "AnyContainer",
-        style_focus: "Union[str, Callable[[], str]]" = "class:focused",
-        style_hover: "Union[str, Callable[[], str]]" = "class:hovered",
-    ) -> "None":
+        body: AnyContainer,
+        style_focus: str | Callable[[], str] = "class:focused",
+        style_hover: str | Callable[[], str] = "",
+    ) -> None:
         """Create a new instance of the widget.
 
         Args:
@@ -382,29 +378,27 @@ class FocusedStyle(Container):
         self.hover = False
         self.has_focus = has_focus(self.body)
 
-    def reset(self) -> "None":
+    def reset(self) -> None:
         """Reet the wrapped container."""
         to_container(self.body).reset()
 
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
+    def preferred_width(self, max_available_width: int) -> Dimension:
         """Return the wrapped container's preferred width."""
         return to_container(self.body).preferred_width(max_available_width)
 
-    def preferred_height(
-        self, width: "int", max_available_height: "int"
-    ) -> "Dimension":
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
         """Return the wrapped container's preferred height."""
         return to_container(self.body).preferred_height(width, max_available_height)
 
     def write_to_screen(
         self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
-        z_index: "Optional[int]",
-    ) -> "None":
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
         """Draw the wrapped container with the additional style."""
         to_container(self.body).write_to_screen(
             screen,
@@ -422,10 +416,10 @@ class FocusedStyle(Container):
             y_max = y_min + write_position.height
 
             # Wrap mouse handlers to add "hover" class on hover
-            def _wrap_mouse_handler(handler: "Callable") -> "MouseHandler":
+            def _wrap_mouse_handler(handler: Callable) -> MouseHandler:
                 def wrapped_mouse_handler(
-                    mouse_event: "MouseEvent",
-                ) -> "NotImplementedOrNone":
+                    mouse_event: MouseEvent,
+                ) -> NotImplementedOrNone:
                     result = handler(mouse_event)
 
                     if mouse_event.event_type == MouseEventType.MOUSE_MOVE:
@@ -452,7 +446,7 @@ class FocusedStyle(Container):
                 for x in range(x_min, x_max):
                     row[x] = mouse_handler_wrappers[(row[x],)]
 
-    def get_style(self) -> "str":
+    def get_style(self) -> str:
         """Determine the style to apply depending on the focus status."""
         style = ""
         if self.has_focus():
@@ -465,7 +459,7 @@ class FocusedStyle(Container):
             )
         return style
 
-    def get_children(self) -> "list[Container]":
+    def get_children(self) -> list[Container]:
         """Return the list of child :class:`.Container` objects."""
         return [to_container(self.body)]
 
@@ -480,28 +474,26 @@ class DropShadow(Container):
         self.cp = app.color_palette
         self.renderer = app.renderer
 
-    def reset(self) -> "None":
+    def reset(self) -> None:
         """Reet the wrapped container - here, do nothing."""
 
-    def preferred_width(self, max_available_width: "int") -> "Dimension":
+    def preferred_width(self, max_available_width: int) -> Dimension:
         """Return the wrapped container's preferred width."""
         return Dimension(weight=1)
 
-    def preferred_height(
-        self, width: "int", max_available_height: "int"
-    ) -> "Dimension":
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
         """Return the wrapped container's preferred height."""
         return Dimension(weight=1)
 
     def write_to_screen(
         self,
-        screen: "Screen",
-        mouse_handlers: "MouseHandlers",
-        write_position: "WritePosition",
-        parent_style: "str",
-        erase_bg: "bool",
-        z_index: "Optional[int]",
-    ) -> "None":
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
         """Draw the wrapped container with the additional style."""
         attr_cache = self.renderer._attrs_for_style
         if attr_cache is not None:
@@ -551,7 +543,7 @@ class Shadow:
     :py:class:`prompt_toolkit.widows.base.Shadow` class.
     """
 
-    def __init__(self, body: "AnyContainer") -> "None":
+    def __init__(self, body: AnyContainer) -> None:
         """Initialize a new drop-shadow container.
 
         Args:
@@ -580,7 +572,7 @@ class Shadow:
             ],
         )
 
-        def get_contents() -> "AnyContainer":
+        def get_contents() -> AnyContainer:
             if filter_():
                 return shadow
             else:
@@ -588,7 +580,7 @@ class Shadow:
 
         self.container = DynamicContainer(get_contents)
 
-    def __pt_container__(self) -> "AnyContainer":
+    def __pt_container__(self) -> AnyContainer:
         """Return the container's content."""
         return self.container
 

euporie/core/widgets/dialog.py

@@ -6,13 +6,19 @@ import logging
 import traceback
 from abc import ABCMeta, abstractmethod
 from functools import partial
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.cache import SimpleCache
 from prompt_toolkit.clipboard import ClipboardData
 from prompt_toolkit.completion import PathCompleter
 from prompt_toolkit.data_structures import Point
-from prompt_toolkit.filters import Condition, has_completions, has_focus
+from prompt_toolkit.filters import (
+    Condition,
+    buffer_has_focus,
+    has_completions,
+    has_focus,
+)
 from prompt_toolkit.formatted_text import AnyFormattedText, to_formatted_text
 from prompt_toolkit.formatted_text.utils import split_lines
 from prompt_toolkit.key_binding.bindings.focus import focus_next, focus_previous
@@ -31,6 +37,7 @@ from prompt_toolkit.layout.screen import WritePosition
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType
 from prompt_toolkit.widgets.base import Box, Label
 
+from euporie.core.app import get_app
 from euporie.core.border import (
     FullLine,
     LowerLeftHalfLine,
@@ -58,6 +65,7 @@ if TYPE_CHECKING:
 
     from euporie.core.app import BaseApp
     from euporie.core.tabs.base import KernelTab
+    from euporie.core.widgets.file_browser import FileBrowserControl
 
 log = logging.getLogger(__name__)
 
@@ -184,14 +192,23 @@ class Dialog(Float, metaclass=ABCMeta):
         self.button_widgets: list[AnyContainer] = []
 
         # Create key-bindings
-        self.kb = KeyBindings()
-        self.kb.add("escape")(lambda event: self.hide())
-        self.kb.add("tab", filter=~has_completions)(focus_next)
-        self.kb.add("s-tab", filter=~has_completions)(focus_previous)
+        kb = KeyBindings()
+        kb.add("escape")(lambda event: self.hide())
+        kb.add("tab", filter=~has_completions)(focus_next)
+        kb.add("s-tab", filter=~has_completions)(focus_previous)
+
+        @kb.add("enter", filter=~has_completions & ~buffer_has_focus)
+        def _focus_button(event: KeyPressEvent) -> NotImplementedOrNone:
+            if self.button_widgets:
+                app.layout.focus(self.button_widgets[0])
+                return None
+            return NotImplemented
+
+        self.kb = kb
         self.buttons_kb = KeyBindings()
 
         # Create title row
-        title_window = Window(height=1, style="class:dialog,title")
+        title_window = Window(height=1, style="class:dialog,dialog-title")
         title_window.content = DialogTitleControl(
             lambda: self.title, self, title_window
         )
@@ -234,7 +251,7 @@ class Dialog(Float, metaclass=ABCMeta):
                         ],
                         style="class:dialog,body",
                         key_bindings=self.kb,
-                        modal=True,
+                        modal=False,
                     ),
                     border=DialogGrid,
                     style="class:dialog,border",
@@ -452,6 +469,7 @@ class FileDialog(Dialog, metaclass=ABCMeta):
         self.file_browser.control.on_open += lambda path: self.validate(
             self.filepath.buffer, tab=tab, cb=cb
         )
+        self.file_browser.control.selected = None
         self.error = error
         self.to_focus = self.filepath
 
@@ -467,23 +485,65 @@ class OpenFileDialog(FileDialog):
 
     title = "Select a File to Open"
 
+    def __init__(self, app: BaseApp) -> None:
+        """Additional body components."""
+        from euporie.core.widgets.forms import Dropdown
+
+        super().__init__(app)
+
+        self.tab_dd = tab_dd = Dropdown(options=[])
+
+        def _update_options(fb: FileBrowserControl) -> None:
+            tabs = get_app().get_file_tabs(path) if (path := fb.path).is_file() else []
+            tab_dd.options = tabs
+            tab_dd.labels = [tab.name for tab in tabs]
+
+        self.file_browser.control.on_select += _update_options
+
+        if isinstance(self.body, HSplit):
+            self.body.children.append(
+                ConditionalContainer(
+                    FocusedStyle(LabelledWidget(tab_dd, "Open with:")),
+                    filter=Condition(lambda: len(tab_dd.options) > 1),
+                )
+            )
+
+    def load(
+        self,
+        text: str = "",
+        tab: Tab | None = None,
+        error: str = "",
+        cb: Callable | None = None,
+    ) -> None:
+        """Load the dialog body."""
+        super().load(text=text, tab=tab, error=error, cb=cb)
+        self.tab_dd.options = []
+        self.tab_dd.labels = []
+
     def validate(
         self, buffer: Buffer, tab: Tab | None, cb: Callable | None = None
     ) -> None:
         """Validate the the file to open exists."""
-        from euporie.core.utils import parse_path
+        from upath import UPath
+
+        from euporie.core.path import parse_path
 
         path = parse_path(self.file_browser.control.dir / buffer.text)
         if path is not None:
-            if str(path).startswith("http") or path.is_file():
-                self.hide()
-                self.app.open_file(path)
-            elif not path.exists():
+            if not path.exists():
+                path = UPath(buffer.text)
+
+            if path.exists():
+                if path.is_dir():
+                    self.file_browser.control.dir = path
+                elif path.is_file():
+                    self.hide()
+                    self.app.open_file(path, tab_class=self.tab_dd.value)
+                return
+            else:
                 self.show(
                     error="The file path specified does not exist", text=buffer.text
                 )
-            elif path.is_dir():
-                self.file_browser.control.dir = path
 
     # ################################### Commands ####################################
 
@@ -516,7 +576,7 @@ class SaveAsDialog(FileDialog):
         self, buffer: Buffer, tab: Tab | None, cb: Callable | None = None
     ) -> None:
         """Validate the the file to open exists."""
-        from euporie.core.utils import parse_path
+        from euporie.core.path import parse_path
 
         path = parse_path(self.file_browser.control.dir / buffer.text)
         if tab and path is not None:
@@ -589,13 +649,19 @@ class SelectKernelDialog(Dialog):
     def load(
         self,
         kernel_specs: dict[str, Any] | None = None,
+        runtime_dirs: dict[str, Path] | None = None,
         tab: KernelTab | None = None,
         message: str = "",
     ) -> None:
         """Load dialog body & buttons."""
+        from jupyter_core.paths import jupyter_runtime_dir
+
+        from euporie.core.widgets.layout import TabbedSplit
+
         kernel_specs = kernel_specs or {}
+        runtime_dirs = runtime_dirs or {}
 
-        options = Select(
+        options_specs = Select(
             options=list(kernel_specs.keys()),
             labels=[
                 kernel_spec.get("spec", {}).get("display_name", kernel_name)
@@ -608,21 +674,51 @@ class SelectKernelDialog(Dialog):
             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" if message else "") + "Please select a kernel:\n"
+        msg_ft = (f"{message}\n\n" if message else "") + "Please select a kernel:"
 
         self.body = HSplit(
             [
                 Label(msg_ft),
-                FocusedStyle(options),
+                tabs := TabbedSplit(
+                    [
+                        FocusedStyle(options_specs),
+                        FocusedStyle(options_files),
+                    ],
+                    titles=["New", "Existing"],
+                    width=Dimension(min=30),
+                ),
             ]
         )
 
         def _change_kernel() -> None:
             self.hide()
             assert tab is not None
-            name = options.options[options.index or 0]
-            tab.kernel.change(name, cb=tab.kernel_started)
+            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
+            )
 
         self.buttons = {
             "Select": _change_kernel,
@@ -672,6 +768,7 @@ class ErrorDialog(Dialog):
 
     def load(self, exception: Exception | None = None, when: str = "") -> None:
         """Load dialog body & buttons."""
+        from euporie.core.margins import MarginContainer, ScrollbarMargin
         from euporie.core.widgets.formatted_text_area import FormattedTextArea
         from euporie.core.widgets.forms import Checkbox
 
@@ -705,12 +802,17 @@ class ErrorDialog(Dialog):
                     Box(checkbox, padding_left=0),
                 ),
                 ConditionalContainer(
-                    FormattedTextArea(
-                        lex([("", tb_text)], "pytb"),
-                        width=80,
-                        height=Dimension(min=10),
-                        wrap_lines=False,
-                        style="",
+                    VSplit(
+                        [
+                            fta := FormattedTextArea(
+                                lex([("", tb_text)], "pytb"),
+                                width=80,
+                                height=Dimension(min=10),
+                                wrap_lines=False,
+                                style="",
+                            ),
+                            MarginContainer(ScrollbarMargin(), target=fta.window),
+                        ]
                     ),
                     filter=Condition(lambda: checkbox.selected),
                 ),
@@ -775,6 +877,7 @@ class ShortcutsDialog(Dialog):
     def load(self, *args: Any, **kwargs: Any) -> None:
         """Load the dialog body."""
         from euporie.core.formatted_text.utils import max_line_width
+        from euporie.core.margins import MarginContainer, ScrollbarMargin
         from euporie.core.widgets.formatted_text_area import FormattedTextArea
 
         if not self.details:
@@ -783,13 +886,14 @@ class ShortcutsDialog(Dialog):
 
         width = max_line_width(self.details)
 
-        self.body = FormattedTextArea(
+        fta = FormattedTextArea(
             formatted_text=self.details,
             multiline=True,
             focusable=True,
             wrap_lines=False,
-            width=width,
+            width=width - 2,
         )
+        self.body = VSplit([fta, MarginContainer(ScrollbarMargin(), target=fta.window)])
 
     def format_key_info(self) -> StyleAndTextTuples:
         """Generate a table with the current key bindings."""