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

euporie/notebook/tabs/notebook.py

@@ -54,17 +54,18 @@ from euporie.notebook.filters import (
 )
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import Any, Deque, MutableSequence, Sequence
 
-    from prompt_toolkit.formatted_text.base import AnyFormattedText, StyleAndTextTuples
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.layout.containers import AnyContainer
     from prompt_toolkit.mouse_events import MouseEvent
-    from upath import UPath
 
     from euporie.core.app import BaseApp
     from euporie.core.comm.base import Comm
     from euporie.core.kernel import Kernel
+    from euporie.core.widgets.status_bar import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -75,12 +76,23 @@ class Notebook(BaseNotebook):
     A tab which allows running and editing a notebook.
     """
 
+    name = "Notebook Editor"
+    weight = 3
+    mime_types = {"application/x-ipynb+json"}
+    file_extensions = {".ipynb"}
+    try:
+        from jupytext.formats import NOTEBOOK_EXTENSIONS
+    except ModuleNotFoundError:
+        pass
+    else:
+        file_extensions |= set(NOTEBOOK_EXTENSIONS)
+
     allow_stdin = True
 
     def __init__(
         self,
         app: BaseApp,
-        path: UPath | None = None,
+        path: Path | None = None,
         kernel: Kernel | None = None,
         comms: dict[str, Comm] | None = None,
         use_kernel_history: bool = True,
@@ -102,9 +114,6 @@ class Notebook(BaseNotebook):
         self.clipboard: list[Cell] = []
         self.undo_buffer: Deque[tuple[int, list[Cell]]] = deque(maxlen=10)
 
-        if not kernel:
-            self.kernel.start(cb=self.kernel_started, wait=False)
-
     # Tab stuff
 
     def _statusbar_kernel_handeler(self, event: MouseEvent) -> NotImplementedOrNone:
@@ -115,29 +124,45 @@ class Notebook(BaseNotebook):
         else:
             return NotImplemented
 
-    def statusbar_fields(
-        self,
-    ) -> tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]:
+    def __pt_status__(self) -> StatusBarFields | None:
         """Generate the formatted text for the statusbar."""
-        rendered = self.page.pre_rendered
-        return (
-            [
-                self.mode(),
-                f"Cell {self.page.selected_slice.start+1}",
-                f"Rendering… ({rendered:.0%})" if rendered < 1 else "",
-                "Saving…" if self.saving else "",
-            ],
-            [
-                lambda: cast(
-                    "StyleAndTextTuples",
-                    [("", self.kernel_display_name, self._statusbar_kernel_handeler)],
-                ),
-                KERNEL_STATUS_REPR[self.kernel.status] if self.kernel else ".",
-            ],
-        )
+        if self.loaded:
+            rendered = self.page.pre_rendered
+            return (
+                [
+                    self.mode(),
+                    f"Cell {self.page.selected_slice.start+1}",
+                    f"Rendering… ({rendered:.0%})" if rendered < 1 else "",
+                    "Saving…" if self.saving else "",
+                ],
+                [
+                    lambda: cast(
+                        "StyleAndTextTuples",
+                        [
+                            (
+                                "",
+                                self.kernel_display_name,
+                                self._statusbar_kernel_handeler,
+                            )
+                        ],
+                    ),
+                    KERNEL_STATUS_REPR[self.kernel.status] if self.kernel else ".",
+                ],
+            )
+        else:
+            return ([], [])
 
     # Notebook stuff
 
+    def post_init_kernel(self) -> None:
+        """Start the kernel after if has been loaded."""
+        # Start kernel
+        if self.kernel._status == "stopped":
+            self.kernel.start(cb=self.kernel_started, wait=False)
+
+        # Load container
+        super().post_init_kernel()
+
     @property
     def selected_indices(self) -> list[int]:
         """Return a list of the currently selected cell indices."""
@@ -219,7 +244,8 @@ class Notebook(BaseNotebook):
             width=Dimension(weight=1),
             height=Dimension(min=1, weight=2),
             key_bindings=load_registered_bindings(
-                "euporie.notebook.tabs.notebook.Notebook"
+                "euporie.core.tabs.base.Tab",
+                "euporie.notebook.tabs.notebook.Notebook",
             ),
         )
 
@@ -315,7 +341,7 @@ class Notebook(BaseNotebook):
 
     def refresh_cell(self, cell: Cell) -> None:
         """Trigger the refresh of a notebook cell."""
-        self.page.get_child_render_info(cell.index).refresh = True
+        self.page.get_child_render_info(cell.index).invalidate()
 
     def add_cell_above(self) -> None:
         """Inert a cell above the current selection."""
@@ -568,16 +594,6 @@ class Notebook(BaseNotebook):
 
     # ################################### Commands ####################################
 
-    @staticmethod
-    @add_cmd(
-        filter=notebook_has_focus,
-    )
-    def _save_notebook() -> None:
-        """Save the current notebook."""
-        tab = get_app().tab
-        if isinstance(tab, Notebook):
-            tab.save()
-
     @staticmethod
     @add_cmd(
         filter=cell_has_focus & ~buffer_has_focus,
@@ -930,6 +946,11 @@ class Notebook(BaseNotebook):
         if isinstance(nb, Notebook):
             for cell in nb.cells:
                 cell.set_cell_type("markdown", clear=True)
+                # Remove unallowed additional properties
+                json = cell.json
+                json.pop("execution_count", None)
+                json.pop("outputs", None)
+                cell.run_or_render()
 
     @staticmethod
     @add_cmd(
@@ -993,7 +1014,7 @@ class Notebook(BaseNotebook):
         title="Collapse cell inputs",
     )
     def _hide_cell_inputs() -> None:
-        """Collape the selected cells' inputs."""
+        """Collapse the selected cells' inputs."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
             for cell in nb.cells:
@@ -1028,7 +1049,7 @@ class Notebook(BaseNotebook):
         title="Collapse cell outputs",
     )
     def _hide_cell_outputs() -> None:
-        """Collape the selected cells' outputs."""
+        """Collapse the selected cells' outputs."""
         nb = get_app().tab
         if isinstance(nb, Notebook):
             for cell in nb.cells:
@@ -1187,7 +1208,6 @@ class Notebook(BaseNotebook):
     register_bindings(
         {
             "euporie.notebook.tabs.notebook.Notebook": {
-                "save-notebook": "c-s",
                 "enter-cell-edit-mode": "enter",
                 "exit-edit-mode": "escape",
                 "run-selected-cells": ["c-enter", "c-e"],
@@ -1234,7 +1254,6 @@ class Notebook(BaseNotebook):
                 "scroll-output-right": "right",
                 "toggle-expand": "w",
                 "notebook-toggle-line-numbers": "l",
-                "reset-tab": "f5",
             }
         }
     )

euporie/preview/__main__.py

@@ -3,9 +3,11 @@
 
 def main() -> "None":
     """Call the main entrypoint to the application."""
+    import sys
+
     from euporie.core import __main__
 
-    __main__.main(__name__.split(".")[1])
+    __main__.main(str(sys.modules[__name__].__package__).rpartition(".")[2])
 
 
 if __name__ == "__main__":

euporie/preview/app.py

@@ -20,6 +20,7 @@ from euporie.core.key_binding.registry import register_bindings
 from euporie.preview.tabs.notebook import PreviewNotebook
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import IO, Any, TextIO
 
     from prompt_toolkit.application.application import _AppResult
@@ -91,7 +92,7 @@ class PreviewApp(BaseApp):
         # Select the first tab after files are opened
         self.post_load_callables.append(partial(setattr, self, "tab_idx", 0))
 
-    def get_file_tab(self, path: UPath) -> type[Tab]:
+    def get_file_tab(self, path: Path) -> type[Tab]:
         """Return the tab to use for a file path."""
         return PreviewNotebook
 

euporie/preview/tabs/notebook.py

@@ -21,12 +21,12 @@ from euporie.core.widgets.cell import Cell
 from euporie.core.widgets.page import PrintingContainer
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import Any, Callable
 
     from prompt_toolkit.application.application import Application
     from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from prompt_toolkit.layout.containers import AnyContainer
-    from upath import UPath
 
     from euporie.core.app import BaseApp
 
@@ -36,25 +36,28 @@ log = logging.getLogger(__name__)
 class PreviewNotebook(BaseNotebook):
     """A notebook tab which renders cells sequentially."""
 
+    bg_init = False
+
     def __init__(
         self,
         app: BaseApp,
-        path: UPath | None = None,
+        path: Path | None = None,
         use_kernel_history: bool = False,
     ) -> None:
         """Create a new instance."""
-        super().__init__(app, path, use_kernel_history=use_kernel_history)
         self.cell_index = 0
-        self.app.before_render += self.before_render
-        self.app.after_render += self.after_render
         self.cells: FastDictCache[tuple[int], Cell] = FastDictCache(
             get_value=self.get_cell
         )
 
-        # If we are running the notebook, pause rendering util the kernel has started
-        if self.app.config.run:
-            self.app.pause_rendering()
-            self.kernel.start(cb=self.kernel_started, wait=True)
+        super().__init__(app, path, use_kernel_history=use_kernel_history)
+
+        self.app.before_render += self.before_render
+        self.app.after_render += self.after_render
+
+    def pre_init_kernel(self) -> None:
+        """Filter cells before kernel is loaded."""
+        super().pre_init_kernel()
 
         # Filter the cells to be shown
         n_cells = len(self.json["cells"]) - 1
@@ -67,8 +70,17 @@ class PreviewNotebook(BaseNotebook):
         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()
+        # If we are running the notebook, pause rendering util the kernel has started
+        if self.app.config.run:
+            self.app.pause_rendering()
+            self.kernel.start(cb=self.kernel_started, wait=True)
+
     def print_title(self) -> None:
         """Print a notebook's filename."""
+        from euporie.core.border import DoubleLine
         from euporie.core.formatted_text.utils import (
             FormattedTextAlign,
             add_border,
@@ -80,7 +92,8 @@ class PreviewNotebook(BaseNotebook):
         ft: StyleAndTextTuples = [("bold", str(self.path))]
         ft = wrap(ft, width - 4)
         ft = align(ft, how=FormattedTextAlign.CENTER, width=width - 4)
-        ft = add_border(ft, width=width)
+        ft = add_border(ft, width=width, border_grid=DoubleLine.grid)
+        ft.append(("", "\n"))
         self.app.print_text(ft)
 
     def kernel_started(self, result: dict | None = None) -> None:

euporie/web/tabs/web.py

@@ -0,0 +1,149 @@
+"""Defines a web-view tab."""
+
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.eventloop.utils import run_in_executor_with_context
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.layout.containers import HSplit, VSplit
+from prompt_toolkit.layout.dimension import Dimension
+from upath import UPath
+
+from euporie.core.convert.core import get_mime
+from euporie.core.current import get_app
+from euporie.core.data_structures import DiBool
+from euporie.core.margins import MarginContainer, ScrollbarMargin
+from euporie.core.tabs.base import Tab
+from euporie.core.widgets.decor import FocusedStyle
+from euporie.core.widgets.display import DisplayWindow
+from euporie.core.widgets.forms import Button, Text
+from euporie.web.widgets.webview import WebViewControl
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Any, Callable
+
+    from prompt_toolkit.layout.containers import AnyContainer
+
+    from euporie.core.app import BaseApp
+    from euporie.core.widgets.status_bar import StatusBarFields
+
+log = logging.getLogger(__name__)
+
+
+class WebTab(Tab):
+    """Tab class for displaying files."""
+
+    name = "Web Viewer"
+    weight = 2
+    mime_types = {"text/html"}
+
+    def __init__(self, app: BaseApp, path: Path | None) -> None:
+        """Call when the tab is created."""
+        super().__init__(app, path)
+        self.status: Callable[[], StatusBarFields] | None = None
+
+        def _load() -> None:
+            self.container = self.load_container()
+
+        run_in_executor_with_context(_load)
+
+    @property
+    def title(self) -> str:
+        """Return the tab title."""
+        if webview := getattr(self, "webview", None):
+            if title := webview.title:
+                return title
+        if self.path is not None:
+            return str(self.path.name) or str(self.path)
+        else:
+            return "<Web Page>"
+
+    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)
+        if not url:
+            return False
+        if isinstance(url, str):
+            url = UPath(url)
+
+        if not new_tab and get_mime(url) == "text/html":
+            self.webview.load_url(url, **kwargs)
+        else:
+            get_app().open_file(url)
+        return True
+
+    def _url_loaded(self, webview: WebViewControl) -> None:
+        """Trigger callback when the URL is loaded."""
+        url = webview.url
+        if url is not None:
+            self.path = UPath(url)
+            self.url_bar.text = str(url)
+
+    def load_container(self) -> AnyContainer:
+        """Abcract method for loading the notebook's main container."""
+        assert self.path is not None
+        path = self.path
+        self.webview = WebViewControl(url=path, link_handler=self.load_url)
+        self.webview.rendered += self._url_loaded
+
+        def _status() -> StatusBarFields:
+            return ([self.webview.status] if self.webview is not None else [], [])
+
+        self.status = _status
+
+        button_prev = Button(
+            "◀",
+            show_borders=DiBool(top=True, right=False, bottom=True, left=True),
+            disabled=Condition(lambda: not self.webview.prev_stack),
+            on_click=lambda x: self.webview.nav_prev(),
+        )
+        button_next = Button(
+            "▶",
+            show_borders=DiBool(top=True, right=True, bottom=True, left=False),
+            disabled=Condition(lambda: not self.webview.next_stack),
+            on_click=lambda x: self.webview.nav_next(),
+        )
+        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),
+        )
+        button_go = Button(
+            "➜",
+            show_borders=DiBool(top=True, right=True, bottom=True, left=False),
+            on_click=lambda x: (self.load_url(self.url_bar.text) and None)
+            or None,  # Magical typing magic
+        )
+
+        return HSplit(
+            [
+                VSplit(
+                    [
+                        FocusedStyle(button_prev),
+                        FocusedStyle(button_next),
+                        FocusedStyle(self.url_bar),
+                        FocusedStyle(button_go),
+                    ],
+                    style="class:tab.toolbar",
+                ),
+                VSplit(
+                    [
+                        window := DisplayWindow(self.webview),
+                        MarginContainer(ScrollbarMargin(), target=window),
+                    ]
+                ),
+            ],
+            width=Dimension(weight=1),
+            height=Dimension(weight=1),
+        )
+
+    def __pt_status__(self) -> StatusBarFields:
+        """Return a list of statusbar field values shown then this tab is active."""
+        if callable(self.status):
+            return self.status()
+        else:
+            return ([], [])