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

euporie/core/widgets/tree.py

@@ -2,108 +2,118 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, cast
+from functools import partial
+from typing import TYPE_CHECKING
 
-from prompt_toolkit.filters import Condition
-from prompt_toolkit.layout.containers import ConditionalContainer
+from prompt_toolkit.layout.containers import Window
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
 
-from euporie.core.layout.containers import HSplit, VSplit, Window
-
 if TYPE_CHECKING:
     from typing import Any
 
     from prompt_toolkit.formatted_text import StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
-    from prompt_toolkit.layout.containers import AnyContainer
 
 
 class JsonView:
     """A JSON-view container."""
 
     def __init__(
-        self, data: Any, title: str | None = None, expanded: bool = True
+        self, data: Any, title: str | None = None, expanded: bool = False
     ) -> None:
         """Create a new instance."""
-        if title is None:
-            self.title = "root"
-        else:
-            self.title = title
-        self.expanded = expanded
-
-        self.children = []
-        self.value_style = ""
-        self.value = ""
-
-        if isinstance(data, list):
-            data = dict(enumerate(data))
-            self.value = f"[] {len(data)} items"
-            self.value_style = "class:pygments.comment"
-        if isinstance(data, dict):
-            self.value = f"{{}} {len(data)} items"
-            self.value_style = "class:pygments.comment"
-            self.children = [
-                JsonView(data=value, title=key, expanded=expanded)
-                for key, value in data.items()
-            ]
-        else:
-            self.value = f"{data!r}"
-            self.value_style = {
-                str: "class:pygments.literal.string",
-                int: "class:pygments.literal.number",
-                float: "class:pygments.literal.number",
-                bool: "class:pygments.keyword.constant",
-            }.get(type(data), "")
-
-        self.container = HSplit(
-            [
-                Window(
-                    FormattedTextControl(self.format_title),
-                    dont_extend_height=True,
-                ),
-                ConditionalContainer(
-                    VSplit(
-                        [
-                            Window(
-                                width=2,
-                                char="  ",
-                                style="",
-                            ),
-                            HSplit(self.children),
-                        ]
-                    ),
-                    filter=Condition(lambda: self.expanded and bool(self.children)),
-                ),
-            ],
+        self.data = data
+        self.title = "root" if title is None else title
+        self.start_expanded = expanded
+        self._toggled_paths: set[tuple[str, ...]] = set()
+        self.container = Window(
+            FormattedTextControl(self._get_formatted_text, focusable=True),
             style="class:tree",
         )
 
-    def toggle(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
-        """Toggle the expansion state."""
+    def _get_value_style(self, value: Any) -> str:
+        """Return the style for a given value type."""
+        return {
+            str: "class:pygments.literal.string",
+            int: "class:pygments.literal.number",
+            float: "class:pygments.literal.number",
+            bool: "class:pygments.keyword.constant",
+        }.get(type(value), "")
+
+    def _format_value(self, value: Any) -> tuple[str, str]:
+        """Return the formatted value and its style."""
+        if isinstance(value, (list, dict)):
+            length = len(value)
+            if isinstance(value, list):
+                return f" [] {length} items", "class:pygments.comment"
+            return f" {{}} {length} items", "class:pygments.comment"
+        return repr(value), self._get_value_style(value)
+
+    def _get_formatted_text(self) -> StyleAndTextTuples:
+        """Generate the complete tree view as formatted text."""
+        result: StyleAndTextTuples = []
+        toggled_paths = self._toggled_paths
+        start_expanded = self.start_expanded
+        toggle = self._toggle
+        format_value = self._format_value
+
+        def format_node(
+            data: Any, path: tuple[str, ...], indent: int, key: str
+        ) -> None:
+            is_expanded = (path in toggled_paths) ^ start_expanded
+            has_children = isinstance(data, (dict, list))
+            mouse_handler = partial(toggle, path=path)
+
+            value, style = format_value(data)
+            row: StyleAndTextTuples = [
+                # Add indentation
+                ("", "  " * indent),
+                # Add toggle symbol
+                (
+                    ("class:pygments.operator", "▼" if is_expanded else "▶")
+                    if has_children
+                    else ("", " ")
+                ),
+                ("", " "),
+                ("class:pygments.keyword", str(key)),
+                ("class:pygments.punctuation", ": "),
+                (style, value),
+                ("", "\n"),
+            ]
+
+            # Apply mouse_handler to rows with children
+            if has_children:
+                row = [(style, text, mouse_handler) for (style, text, *_) in row]
+
+            result.extend(row)
+
+            if is_expanded and has_children:
+                if isinstance(data, list):
+                    data = {str(i): v for i, v in enumerate(data)}
+
+                for k, v in data.items():
+                    new_path = (*path, str(k)) if path else (str(k),)
+                    format_node(v, new_path, indent + 1, k)
+
+        format_node(self.data, (), 0, self.title)
+        return result
+
+    def _toggle(
+        self, mouse_event: MouseEvent, path: tuple[str, ...]
+    ) -> NotImplementedOrNone:
+        """Toggle the expansion state of a node."""
         if (
             mouse_event.button == MouseButton.LEFT
             and mouse_event.event_type == MouseEventType.MOUSE_UP
         ):
-            self.expanded = not self.expanded
+            if path in self._toggled_paths:
+                self._toggled_paths.remove(path)
+            else:
+                self._toggled_paths.add(path)
             return None
         return NotImplemented
 
-    def format_title(self) -> StyleAndTextTuples:
-        """Return the tree node toggle and title."""
-        return cast(
-            "StyleAndTextTuples",
-            [
-                ("class:pygments.operator", "▼" if self.expanded else "▶", self.toggle)
-                if self.children
-                else ("", " ", self.toggle),
-                ("", " ", self.toggle),
-                ("class:pygments.keyword", f"{self.title}", self.toggle),
-                ("class:pygments.punctuation", ": ", self.toggle),
-                (self.value_style, self.value, self.toggle),
-            ],
-        )
-
-    def __pt_container__(self) -> AnyContainer:
+    def __pt_container__(self) -> Window:
         """Return the tree-view container's content."""
         return self.container

euporie/notebook/app.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import logging
 from functools import partial
 from typing import TYPE_CHECKING, cast
+from weakref import WeakKeyDictionary
 
 from prompt_toolkit.filters import Condition
 from prompt_toolkit.formatted_text.base import to_formatted_text
@@ -89,6 +90,7 @@ class NotebookApp(BaseApp):
         super().__init__(**kwargs)
         self.bindings_to_load.append("euporie.notebook.app.NotebookApp")
 
+        self._tab_bar_tabs: dict[int, WeakKeyDictionary[Tab, TabBarTab]] = {}
         self.on_tabs_change += self.set_tab_container
 
         # Register config hooks
@@ -136,21 +138,36 @@ class NotebookApp(BaseApp):
 
     def set_tab_container(self, app: BaseApp | None = None) -> None:
         """Set the container to use to display opened tabs."""
+        tab_mode = TabMode(self.config.tab_mode)
         if not self.tabs:
             self._tab_container = Pattern(
                 self.config.background_character,
                 self.config.background_pattern,
             )
-        elif TabMode(self.config.tab_mode) == TabMode.TILE_HORIZONTALLY:
+        elif tab_mode == TabMode.TILE_HORIZONTALLY:
+            children = []
+            for tab in self.tabs:
+
+                def _get_tab_container(tab: Tab = tab) -> Tab:
+                    return tab
+
+                children.append(DynamicContainer(_get_tab_container))
             self._tab_container = HSplit(
-                children=self.tabs,
+                children=children,
                 padding=1,
                 padding_style="class:tab-padding",
                 padding_char="─",
             )
-        elif TabMode(self.config.tab_mode) == TabMode.TILE_VERTICALLY:
+        elif tab_mode == TabMode.TILE_VERTICALLY:
+            children = []
+            for tab in self.tabs:
+
+                def _get_tab_container(tab: Tab = tab) -> Tab:
+                    return tab
+
+                children.append(DynamicContainer(_get_tab_container))
             self._tab_container = VSplit(
-                children=self.tabs,
+                children=children,
                 padding=1,
                 padding_style="class:tab-padding",
                 padding_char="│",
@@ -161,9 +178,7 @@ class NotebookApp(BaseApp):
                     ConditionalContainer(
                         Window(
                             TabBarControl(
-                                tabs=self.tab_bar_tabs,
-                                active=lambda: self._tab_idx,
-                                closeable=True,
+                                tabs=self.tab_bar_tabs, active=lambda: self._tab_idx
                             ),
                             height=2,
                             style="class:app-tab-bar",
@@ -281,14 +296,18 @@ class NotebookApp(BaseApp):
 
     def tab_bar_tabs(self) -> list[TabBarTab]:
         """Return a list of the current tabs for the tab-bar."""
-        return [
-            TabBarTab(
-                title=partial(lambda x: x.title, tab),
-                on_activate=partial(setattr, self, "tab_idx", i),
-                on_close=partial(self.close_tab, tab),
-            )
-            for i, tab in enumerate(self.tabs)
-        ]
+        result = []
+        for i, tab in enumerate(self.tabs):
+            index_dict = self._tab_bar_tabs.setdefault(i, WeakKeyDictionary())
+            if tab not in index_dict:
+                index_dict[tab] = TabBarTab(
+                    title=lambda tab=tab: tab.title,  # type: ignore [misc]
+                    on_activate=partial(setattr, self, "tab_idx", i),
+                    on_close=partial(self.close_tab, tab),
+                    closeable=True,
+                )
+            result.append(self._tab_bar_tabs[i][tab])
+        return result
 
     def _handle_exception(
         self, loop: AbstractEventLoop, context: dict[str, Any]
@@ -474,9 +493,9 @@ class NotebookApp(BaseApp):
                         children=[
                             get_cmd("toggle-enable-language-servers").menu,
                             separator,
+                            self.config.menus.autosuggest,
                             get_cmd("toggle-autoformat").menu,
                             get_cmd("toggle-autocomplete").menu,
-                            get_cmd("toggle-autosuggest").menu,
                             get_cmd("toggle-autoinspect").menu,
                         ],
                         description="Turn code assistance tools on or off",

euporie/notebook/tabs/edit.py

@@ -3,16 +3,16 @@
 from __future__ import annotations
 
 import logging
+from functools import partial
 from typing import TYPE_CHECKING, ClassVar
 
 from prompt_toolkit.layout.containers import HSplit
 from prompt_toolkit.layout.dimension import Dimension
 
 from euporie.core.filters import insert_mode, replace_mode
-from euporie.core.kernel.client import Kernel, MsgCallbacks
+from euporie.core.kernel.jupyter import JupyterKernel, MsgCallbacks
 from euporie.core.key_binding.registry import load_registered_bindings
 from euporie.core.lexers import detect_lexer
-from euporie.core.path import UntitledPath
 from euporie.core.tabs.kernel import KernelTab
 from euporie.core.widgets.inputs import KernelInput
 
@@ -41,7 +41,7 @@ class EditorTab(KernelTab):
         self,
         app: BaseApp,
         path: Path | None = None,
-        kernel: Kernel | None = None,
+        kernel: JupyterKernel | None = None,
         comms: dict[str, Comm] | None = None,
         use_kernel_history: bool = False,
     ) -> None:
@@ -93,7 +93,7 @@ class EditorTab(KernelTab):
         if self.dirty and (unsaved := self.app.dialogs.get("unsaved")):
             unsaved.show(
                 tab=self,
-                cb=cb,
+                cb=partial(super().close, cb),
             )
         else:
             super().close(cb)

euporie/notebook/tabs/json.py

@@ -10,6 +10,8 @@ from typing import TYPE_CHECKING, ClassVar
 from prompt_toolkit.layout.containers import VSplit
 from prompt_toolkit.layout.dimension import Dimension
 
+from euporie.core.layout.scroll import ScrollingContainer
+from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.tabs.base import Tab
 from euporie.core.widgets.tree import JsonView
 
@@ -65,8 +67,10 @@ class JsonTab(Tab):
 
         return VSplit(
             [
-                JsonView(data, title=self.path.name, expanded=True),
-                # MarginContainer(ScrollbarMargin(), target=self.display.window),
+                scroll := ScrollingContainer(
+                    children=[JsonView(data, title=self.path.name, expanded=True)]
+                ),
+                MarginContainer(ScrollbarMargin(), target=scroll),
             ],
             width=Dimension(weight=1),
             height=Dimension(weight=1),

euporie/notebook/tabs/notebook.py

@@ -48,7 +48,7 @@ if TYPE_CHECKING:
     from euporie.core.app.app import BaseApp
     from euporie.core.bars.status import StatusBarFields
     from euporie.core.comm.base import Comm
-    from euporie.core.kernel.client import Kernel
+    from euporie.core.kernel.base import BaseKernel
 
 log = logging.getLogger(__name__)
 
@@ -77,7 +77,7 @@ class Notebook(BaseNotebook):
         self,
         app: BaseApp,
         path: Path | None = None,
-        kernel: Kernel | None = None,
+        kernel: BaseKernel | None = None,
         comms: dict[str, Comm] | None = None,
         use_kernel_history: bool = True,
         json: dict[str, Any] | None = None,
@@ -97,7 +97,6 @@ class Notebook(BaseNotebook):
         self.multiple_cells_selected = multiple_cells_selected
         self.clipboard: list[Cell] = []
         self.undo_buffer: deque[tuple[int, list[Cell]]] = deque(maxlen=10)
-
         self.default_callbacks["set_next_input"] = self.set_next_input
 
     # Tab stuff
@@ -117,7 +116,11 @@ class Notebook(BaseNotebook):
 
             def _kernel_name() -> StyleAndTextTuples:
                 ft: StyleAndTextTuples = [
-                    ("", self.kernel_display_name, self._statusbar_kernel_handler)
+                    (
+                        "",
+                        self.kernel_display_name or "No Kernel",
+                        self._statusbar_kernel_handler,
+                    )
                 ]
                 return ft
 
@@ -164,13 +167,28 @@ class Notebook(BaseNotebook):
         self.app.dialogs["error"].show(exception=error, when="starting the kernel")
 
     def load_container(self) -> AnyContainer:
-        """Load the main notebook container."""
+        """Trigger loading of the main notebook container."""
+
+        async def _load() -> None:
+            # Load notebook file
+            self.load()
+            # Load an focus container
+            prev = self.container
+            self.container = self._load_container()
+            self.loaded = True
+            # Update the focus if the old container had focus
+            if self.app.layout.has_focus(prev):
+                self.focus()
+
+        self.app.create_background_task(_load())
+
+        return self.container
+
+    def _load_container(self) -> AnyContainer:
+        """Actually load the main notebook container."""
         self.page = ScrollingContainer(
             self.rendered_cells, width=self.app.config.max_notebook_width
         )
-        # Ensure all cells get initialized ASAP to prevent race conditions
-        # creating multiple version of cells across threads
-        self.page.all_children()
 
         expand = Condition(lambda: self.app.config.expand)
 

euporie/preview/tabs/notebook.py

@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 
     from euporie.core.app.app import BaseApp
     from euporie.core.comm.base import Comm
-    from euporie.core.kernel.client import Kernel
+    from euporie.core.kernel.base import BaseKernel
 
 log = logging.getLogger(__name__)
 
@@ -54,17 +54,6 @@ class PreviewNotebook(BaseNotebook):
         """Filter cells before kernel is loaded."""
         super().pre_init_kernel()
 
-        # Filter the cells to be shown
-        n_cells = len(self.json["cells"]) - 1
-        start: int | None = None
-        stop: int | None = None
-        if self.app.config.cell_start is not None:
-            start = min(max(self.app.config.cell_start, -n_cells), n_cells)
-        if self.app.config.cell_stop is not None:
-            stop = min(max(self.app.config.cell_stop, -n_cells), n_cells)
-        log.debug("Showing cells %s to %s", start, stop)
-        self.json["cells"] = self.json["cells"][start:stop]
-
     def post_init_kernel(self) -> None:
         """Optionally start kernel after it is loaded."""
         super().post_init_kernel()
@@ -78,7 +67,7 @@ class PreviewNotebook(BaseNotebook):
 
     def init_kernel(
         self,
-        kernel: Kernel | None = None,
+        kernel: BaseKernel | None = None,
         comms: dict[str, Comm] | None = None,
         use_kernel_history: bool = False,
         connection_file: Path | None = None,
@@ -162,6 +151,21 @@ class PreviewNotebook(BaseNotebook):
 
     def load_container(self) -> AnyContainer:
         """Load the notebook's main container."""
+        # Load file
+        self.load()
+
+        # Filter the cells to be shown
+        n_cells = len(self.json["cells"]) - 1
+        start: int | None = None
+        stop: int | None = None
+        if self.app.config.cell_start is not None:
+            start = min(max(self.app.config.cell_start, -n_cells), n_cells)
+        if self.app.config.cell_stop is not None:
+            stop = min(max(self.app.config.cell_stop, -n_cells), n_cells)
+        log.debug("Showing cells %s to %s", start, stop)
+        self.json["cells"] = self.json["cells"][start:stop]
+
+        # Generate container
         no_expand = ~self.app.config.filters.expand
         return PrintingContainer(
             [

euporie/web/tabs/web.py

@@ -45,8 +45,6 @@ class WebTab(Tab):
         super().__init__(app, path)
         self.status: Callable[[], StatusBarFields] | None = None
 
-        # self.container = self.load_container()
-
         def _load() -> None:
             old_container = self.container
             self.container = self.load_container()
@@ -73,13 +71,16 @@ class WebTab(Tab):
     def load_url(self, url: str | Path, new_tab: bool = False, **kwargs: Any) -> bool:
         """Load a new URL, or the URL in the address-bar."""
         log.debug("Loading %s", url)
+        self.webview.loading = True
+        self.app.invalidate()
         if not url:
             return False
         if isinstance(url, str):
-            url = UPath(url)
+            url = UPath(url, protocol="https" if ":" not in url else None)
         if not new_tab and get_mime(url) in self.mime_types:
             self.webview.load_url(url, **kwargs)
         else:
+            self.webview.loading = False
             get_app().open_file(url)
         return True
 
@@ -89,6 +90,8 @@ class WebTab(Tab):
         if url is not None:
             self.path = UPath(url)
             self.url_bar.text = str(url)
+        # Focus the webview
+        self.app.layout.current_control = self.webview
 
     def load_container(self) -> AnyContainer:
         """Abcract method for loading the notebook's main container."""
@@ -114,10 +117,25 @@ class WebTab(Tab):
             disabled=Condition(lambda: not self.webview.next_stack),
             on_click=lambda x: self.webview.nav_next(),
         )
+        button_refresh = Button(
+            "↻",
+            on_click=lambda x: (self.load_url(self.path) and False) or None,
+        )
+
+        def _select_url() -> None:
+            """Select all in url bar when it gains focus."""
+            from prompt_toolkit.selection import SelectionState
+
+            buffer = self.url_bar.buffer
+            buffer.selection_state = SelectionState(0)
+            buffer.cursor_position = len(buffer.text)
+            buffer.selection_state.enter_shift_mode()
+
         self.url_bar = Text(
             text=str(path),
             show_borders=DiBool(top=True, right=False, bottom=True, left=True),
             accept_handler=lambda buf: self.load_url(buf.text),
+            on_focus=_select_url,
         )
         button_go = Button(
             "➜",
@@ -132,6 +150,7 @@ class WebTab(Tab):
                     [
                         FocusedStyle(button_prev),
                         FocusedStyle(button_next),
+                        FocusedStyle(button_refresh),
                         FocusedStyle(self.url_bar),
                         FocusedStyle(button_go),
                     ],

euporie/web/widgets/webview.py

@@ -325,6 +325,7 @@ class WebViewControl(UIControl):
         """Handle click events."""
         url = node.attrs.get("_link_path")
         title = node.attrs.get("title")
+        alt = node.attrs.get("alt")
         if url:
             # TODO - Check for #anchor links and scroll accordingly
             if (
@@ -343,6 +344,8 @@ class WebViewControl(UIControl):
             self.status.clear()
             if title:
                 self.status.append(str(title))
+            if title:
+                self.status.append(str(alt))
             if url:
                 self.status.append(str(url))
             return None

{euporie-2.8.6.dist-info → euporie-2.8.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euporie
-Version: 2.8.6
+Version: 2.8.8
 Summary: Euporie is a suite of terminal applications for interacting with Jupyter kernels
 Project-URL: Documentation, https://euporie.readthedocs.io/en/latest
 Project-URL: Issues, https://github.com/joouha/euporie/issues