euporie 2.8.5__py3-none-any.whl → 2.8.7__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/display.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import TYPE_CHECKING, ClassVar
 
@@ -12,7 +13,6 @@ from euporie.core.convert.datum import Datum
 from euporie.core.convert.mime import MIME_FORMATS, get_format
 from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.tabs.base import Tab
-from euporie.core.utils import run_in_thread_with_context
 from euporie.core.widgets.display import Display
 
 if TYPE_CHECKING:
@@ -44,7 +44,7 @@ class DisplayTab(Tab):
                 self.app.layout.focus(self.container)
                 self.app.invalidate()
 
-            run_in_thread_with_context(_load)
+            app.create_background_task(asyncio.to_thread(_load))
 
     def __pt_status__(self) -> StatusBarFields | None:
         """Return a list of statusbar field values shown then this tab is active."""

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)
@@ -154,46 +154,11 @@ class EditorTab(KernelTab):
             ),
         )
 
-    def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
-        """Save the current file."""
-        if path is not None:
-            self.path = path
+    def write_file(self, path: Path) -> None:
+        """Write the file's text data to a path.
 
-        if isinstance(self.path, UntitledPath):
-            if dialog := self.app.dialogs.get("save-as"):
-                dialog.show(tab=self, cb=cb)
-        else:
-            log.debug("Saving file...")
-            self.saving = True
-            self.app.invalidate()
-            # Ensure parent path exists
-            parent = self.path.parent
-            parent.mkdir(exist_ok=True, parents=True)
-            # Save to a temp file, then replace the original
-            temp_path = parent / f".{self.path.stem}.tmp{self.path.suffix}"
-            log.debug("Using temporary file %s", temp_path.name)
-            try:
-                open_file = temp_path.open("w")
-            except NotImplementedError:
-                if dialog := self.app.dialogs.get("save-as"):
-                    dialog.show(tab=self, cb=cb)
-            else:
-                try:
-                    open_file.write(self.input_box.buffer.text)
-                except Exception:
-                    if dialog := self.app.dialogs.get("save-as"):
-                        dialog.show(tab=self, cb=cb)
-                else:
-                    try:
-                        temp_path.rename(self.path)
-                    except Exception:
-                        if dialog := self.app.dialogs.get("save-as"):
-                            dialog.show(tab=self, cb=cb)
-                    else:
-                        self.dirty = False
-                        self.saving = False
-                        self.app.invalidate()
-                        log.debug("File saved")
-            # Run the callback
-            if callable(cb):
-                cb()
+        Args:
+            path: An path at which to save the file
+
+        """
+        path.write_text(self.input_box.buffer.text)

euporie/notebook/tabs/json.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
 from typing import TYPE_CHECKING, ClassVar
@@ -9,8 +10,9 @@ 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.utils import run_in_thread_with_context
 from euporie.core.widgets.tree import JsonView
 
 if TYPE_CHECKING:
@@ -43,7 +45,7 @@ class JsonTab(Tab):
                 self.app.layout.focus(self.container)
                 self.app.invalidate()
 
-            run_in_thread_with_context(_load)
+            app.create_background_task(asyncio.to_thread(_load))
 
     def __pt_status__(self) -> StatusBarFields | None:
         """Return a list of statusbar field values shown then this tab is active."""
@@ -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/__init__.py

@@ -0,0 +1 @@
+"""A euporie web viewer component."""

euporie/web/tabs/__init__.py

@@ -0,0 +1,14 @@
+"""Tabs for use in euporie notebook editor."""
+
+from euporie.core.tabs import _TAB_REGISTRY, TabRegistryEntry
+
+_TAB_REGISTRY.extend(
+    [
+        TabRegistryEntry(
+            path="euporie.web.tabs.web:WebTab",
+            name="Web Viewer",
+            mime_types={"text/html", "text/markdown"},
+            weight=2,
+        ),
+    ]
+)