euporie 2.8.1__py3-none-any.whl → 2.8.5__py3-none-any.whl

euporie/notebook/app.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import logging
 from functools import partial
 from typing import TYPE_CHECKING, cast
@@ -12,17 +11,20 @@ from prompt_toolkit.formatted_text.base import to_formatted_text
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     DynamicContainer,
+    Float,
     FloatContainer,
     WindowAlign,
 )
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.dimension import Dimension
-from upath import UPath
 
-from euporie.core import __logo__
-from euporie.core.app import BaseApp
-from euporie.core.commands import add_cmd, get_cmd
-from euporie.core.config import add_setting
+from euporie.core.app.app import BaseApp
+from euporie.core.bars.command import CommandBar
+from euporie.core.bars.menu import ToolbarCompletionsMenu
+from euporie.core.bars.search import SearchBar
+from euporie.core.bars.status import StatusBar, StatusContainer
+from euporie.core.commands import get_cmd
+from euporie.core.filters import has_tabs
 from euporie.core.ft.utils import truncate
 from euporie.core.key_binding.registry import register_bindings
 from euporie.core.layout.containers import HSplit, VSplit, Window
@@ -41,26 +43,27 @@ from euporie.core.widgets.dialog import (
 )
 from euporie.core.widgets.file_browser import FileBrowser
 from euporie.core.widgets.layout import TabBarControl, TabBarTab
+from euporie.core.widgets.logo import Logo
 from euporie.core.widgets.menu import MenuBar, MenuItem
 from euporie.core.widgets.pager import Pager
 from euporie.core.widgets.palette import CommandPalette
-from euporie.core.widgets.search import SearchBar
-from euporie.core.widgets.status import StatusBar, StatusContainer
 from euporie.notebook.enums import TabMode
-from euporie.notebook.tabs import Notebook
 from euporie.notebook.widgets.side_bar import SideBar
 
 if TYPE_CHECKING:
     from asyncio import AbstractEventLoop
-    from typing import Any, Callable, Sequence
+    from collections.abc import Sequence
+    from typing import Any, Callable
 
     from prompt_toolkit.application.application import Application
     from prompt_toolkit.formatted_text import StyleAndTextTuples
-    from prompt_toolkit.layout.containers import AnyContainer, Float
+    from prompt_toolkit.layout.containers import AnyContainer
 
+    from euporie.core.bars.status import StatusBarFields
+    from euporie.core.tabs import TabRegistryEntry
     from euporie.core.tabs.base import Tab
     from euporie.core.widgets.cell import Cell
-    from euporie.core.widgets.status import StatusBarFields
+    from euporie.notebook.tabs.notebook import Notebook
 
 log = logging.getLogger(__name__)
 
@@ -74,6 +77,8 @@ class NotebookApp(BaseApp):
     notebooks in the terminal.
     """
 
+    _tab_container: AnyContainer
+
     name = "notebook"
 
     def __init__(self, **kwargs: Any) -> None:
@@ -84,32 +89,35 @@ class NotebookApp(BaseApp):
         super().__init__(**kwargs)
         self.bindings_to_load.append("euporie.notebook.app.NotebookApp")
 
-        # Register config hooks
-        self.config.get_item("show_cell_borders").event += lambda x: self.refresh()
+        self.on_tabs_change += self.set_tab_container
 
-    async def _poll_terminal_colors(self) -> None:
-        """Repeatedly query the terminal for its background and foreground colours."""
-        while self.config.terminal_polling_interval:
-            await asyncio.sleep(self.config.terminal_polling_interval)
-            self.term_info.colors.send()
+        # Register config hooks
+        self.config.events.show_cell_borders += lambda x: self.refresh()
+        self.config.events.tab_mode += self.set_tab_container
+        self.config.events.background_pattern += self.set_tab_container
+        self.config.events.background_character += self.set_tab_container
 
     def pre_run(self, app: Application | None = None) -> None:
         """Continue loading the app."""
         super().pre_run(app)
-        # Ensure an opened tab is focused
-        if self.tab:
-            self.tab.focus()
+        # Add a toolbar completion menu
+        self.menus["toolbar_completions"] = Float(
+            content=ToolbarCompletionsMenu(), ycursor=True, transparent=True
+        )
+
+    @property
+    def tab_registry(self) -> list[TabRegistryEntry]:
+        """Return the tab registry."""
+        from euporie.notebook.tabs import _TAB_REGISTRY
 
-        # Load style hooks and start polling terminal style
-        if self.config.terminal_polling_interval and hasattr(
-            self.input, "vt100_parser"
-        ):
-            self.create_background_task(self._poll_terminal_colors())
+        return _TAB_REGISTRY
 
     def format_title(self) -> StyleAndTextTuples:
         """Format the tab's title for display in the top right of the app."""
-        if self.tab:
-            title = truncate(to_formatted_text(self.tab.title, style="bold"), 30)
+        if self.tabs:
+            # Get tab without re-focusing it
+            tab = self.tabs[self._tab_idx]
+            title = truncate(to_formatted_text(tab.title, style="bold"), 30)
             return [("", " "), *title, ("", " ")]
         else:
             return []
@@ -118,29 +126,58 @@ class NotebookApp(BaseApp):
         """Return a container with all opened tabs.
 
         Returns:
-            A layout displaying the opened tab containers.
-
+            A layout container displaying the opened tab containers.
         """
-        if self.tabs:
-            if TabMode(self.config.tab_mode) == TabMode.TILE_HORIZONTALLY:
-                return HSplit(
-                    children=self.tabs,
-                    padding=1,
-                    padding_style="class:tab-padding",
-                    padding_char="─",
-                )
-            elif TabMode(self.config.tab_mode) == TabMode.TILE_VERTICALLY:
-                return VSplit(
-                    children=self.tabs,
-                    padding=1,
-                    padding_style="class:tab-padding",
-                    padding_char="│",
-                )
-            else:
-                return DynamicContainer(lambda: self.tabs[self._tab_idx])
+        try:
+            return self._tab_container
+        except AttributeError:
+            self.set_tab_container()
+            return self._tab_container
+
+    def set_tab_container(self, app: BaseApp | None = None) -> None:
+        """Set the container to use to display opened tabs."""
+        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:
+            self._tab_container = HSplit(
+                children=self.tabs,
+                padding=1,
+                padding_style="class:tab-padding",
+                padding_char="─",
+            )
+        elif TabMode(self.config.tab_mode) == TabMode.TILE_VERTICALLY:
+            self._tab_container = VSplit(
+                children=self.tabs,
+                padding=1,
+                padding_style="class:tab-padding",
+                padding_char="│",
+            )
         else:
-            return Pattern(
-                self.config.background_character, self.config.background_pattern
+            self._tab_container = HSplit(
+                [
+                    ConditionalContainer(
+                        Window(
+                            TabBarControl(
+                                tabs=self.tab_bar_tabs,
+                                active=lambda: self._tab_idx,
+                                closeable=True,
+                            ),
+                            height=2,
+                            style="class:app-tab-bar",
+                            dont_extend_height=True,
+                        ),
+                        filter=Condition(
+                            lambda: (
+                                len(self.tabs) > 1 or self.config.always_show_tab_bar
+                            )
+                            and TabMode(self.config.tab_mode) == TabMode.STACK
+                        ),
+                    ),
+                    DynamicContainer(lambda: self.tabs[self._tab_idx]),
+                ]
             )
 
     def _statusbar_defaults(self) -> StatusBarFields | None:
@@ -158,22 +195,7 @@ class NotebookApp(BaseApp):
 
     def load_container(self) -> FloatContainer:
         """Build the main application layout."""
-        have_tabs = Condition(lambda: bool(self.tabs))
-
-        self.logo = StatusContainer(
-            body=Window(
-                FormattedTextControl(
-                    [("", f" {__logo__} ")],
-                    focusable=~have_tabs,
-                    show_cursor=False,
-                    style="class:menu,logo",
-                ),
-                height=1,
-                width=3,
-                dont_extend_width=True,
-            ),
-            status=self._statusbar_defaults,
-        )
+        self.logo = StatusContainer(body=Logo(), status=self._statusbar_defaults)
 
         title_bar = ConditionalContainer(
             Window(
@@ -183,29 +205,12 @@ class NotebookApp(BaseApp):
                 dont_extend_width=True,
                 align=WindowAlign.RIGHT,
             ),
-            filter=have_tabs,
-        )
-
-        self.tab_bar_control = TabBarControl(
-            tabs=self.tab_bar_tabs,
-            active=lambda: self._tab_idx,
-            closeable=True,
-        )
-        tab_bar = ConditionalContainer(
-            Window(
-                self.tab_bar_control,
-                height=2,
-                style="class:app-tab-bar",
-                dont_extend_height=True,
-            ),
-            filter=Condition(
-                lambda: (len(self.tabs) > 1 or self.config.always_show_tab_bar)
-                and TabMode(self.config.tab_mode) == TabMode.STACK
-            ),
+            filter=has_tabs,
         )
 
         self.pager = Pager()
         self.search_bar = SearchBar()
+        self.command_bar = CommandBar()
 
         self.dialogs["command-palette"] = CommandPalette(self)
         self.dialogs["about"] = AboutDialog(self)
@@ -227,7 +232,7 @@ class NotebookApp(BaseApp):
                     title_bar,
                 ]
             ),
-            filter=self.config.filter("show_top_bar"),
+            filter=self.config.filters.show_top_bar,
         )
 
         titles: Sequence[str]
@@ -255,7 +260,6 @@ class NotebookApp(BaseApp):
                             self.side_bar,
                             HSplit(
                                 [
-                                    tab_bar,
                                     DynamicContainer(self.tab_container),
                                     self.pager,
                                 ],
@@ -264,6 +268,7 @@ class NotebookApp(BaseApp):
                         ],
                         height=Dimension(min=1),
                     ),
+                    self.command_bar,
                     self.search_bar,
                     StatusBar(),
                 ],
@@ -347,6 +352,8 @@ class NotebookApp(BaseApp):
     @property
     def notebook(self) -> Notebook | None:
         """Return the currently active notebook."""
+        from euporie.notebook.tabs.notebook import Notebook
+
         if isinstance(self.tab, Notebook):
             return self.tab
         return None
@@ -354,6 +361,8 @@ class NotebookApp(BaseApp):
     @property
     def cell(self) -> Cell | None:
         """Return the currently active cell."""
+        from euporie.notebook.tabs.notebook import Notebook
+
         if isinstance(self.tab, Notebook):
             return self.tab.cell
         return None
@@ -422,7 +431,7 @@ class NotebookApp(BaseApp):
                         "Tab mode",
                         children=[
                             get_cmd(f"set-tab-mode-{choice}").menu
-                            for choice in self.config.get_item("tab_mode").choices
+                            for choice in self.config.choices.tab_mode
                         ],
                     ),
                 ],
@@ -444,13 +453,21 @@ class NotebookApp(BaseApp):
                         ],
                         description="Turn elements of euporie's interface on or off",
                     ),
-                    self.config.get_item("color_scheme").menu,
-                    self.config.get_item("syntax_theme").menu,
+                    self.config.menus.color_scheme,
+                    MenuItem(
+                        "Syntax highlighting",
+                        children=[
+                            self.config.menus.syntax_highlighting,
+                            separator,
+                            *self.config.menus.syntax_theme.children,
+                        ],
+                        description="Configure syntax highlighting",
+                    ),
                     get_cmd("toggle-expand").menu,
                     get_cmd("toggle-line-numbers").menu,
-                    self.config.get_item("set_cursor_shape").menu,
+                    self.config.menus.set_cursor_shape,
                     separator,
-                    self.config.get_item("edit_mode").menu,
+                    self.config.menus.edit_mode,
                     separator,
                     MenuItem(
                         "Code tools",
@@ -483,124 +500,6 @@ class NotebookApp(BaseApp):
             ),
         ]
 
-    # ################################### Commands ####################################
-
-    @staticmethod
-    @add_cmd()
-    def _new_notebook() -> None:
-        """Create a new file."""
-        from euporie.notebook.current import get_app
-
-        app = get_app()
-        app.tabs.append(Notebook(app, None))
-        app.tabs[-1].focus()
-
-    @staticmethod
-    @add_cmd()
-    def _view_documentation() -> None:
-        """Open the documentation in a web-view tab."""
-        from euporie.core.current import get_app
-
-        get_app().open_file(UPath("https://euporie.readthedocs.io/"))
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="tab_mode",
-        flags=["--tab-mode"],
-        type_=str,
-        choices=[mode.value for mode in TabMode],
-        default="stack",
-        help_="The method used to display multiple tabs",
-        description="""
-            Determines how multiple tabs are displayed when more than one tab is open.
-            * ``stack`` displays one tab at a time with a tab-bar
-            * ``tile_horizontally`` displays tabs side-by-side
-            * ``tile_vertically`` displays tabs one-atop-the-next
-        """,
-    )
-
-    add_setting(
-        name="always_show_tab_bar",
-        flags=["--always-show-tab-bar"],
-        type_=bool,
-        help_="Always show the tab bar",
-        default=False,
-        description="""
-            When set, the tab bar will always be shown - otherwise the tab bar is only
-            shown when multiple tabs are open.
-        """,
-    )
-
-    add_setting(
-        name="background_pattern",
-        flags=["--background-pattern", "--bg-pattern"],
-        type_=int,
-        choices=list(range(6)),
-        help_="The background pattern to use",
-        default=2,
-        schema={
-            "minimum": 0,
-            "maximum": 5,
-        },
-        description="""
-            The background pattern to use when the notebook is narrower than the
-            available width. Zero mean no pattern is used.
-        """,
-    )
-
-    add_setting(
-        name="background_character",
-        flags=["--background-character", "--bg-char"],
-        type_=str,
-        help_="Character for background pattern",
-        default="·",
-        schema={
-            "maxLength": 1,
-        },
-        description="""
-            The character to use when drawing the background pattern.
-
-            Recommended characters include: "·", "⬤", "╳", "╱", "╲", "░", "▒", "▓", "▞", "╬"
-        """,  # ,
-    )
-
-    add_setting(
-        name="run_after_external_edit",
-        flags=["--run-after-external-edit"],
-        type_=bool,
-        help_="Run cells after editing externally",
-        default=False,
-        description="""
-            Whether to execute a cell immediately after editing in `$EDITOR`.
-        """,
-    )
-
-    add_setting(
-        name="run",
-        flags=["--run"],
-        type_=bool,
-        help_="Run the notebook files when loaded",
-        default=False,
-        description="""
-            If set, notebooks will be run automatically when opened, or if previewing a
-            file, the notebooks will be run before being output.
-        """,
-    )
-
-    add_setting(
-        name="show_top_bar",
-        flags=["--show-top-bar"],
-        type_=bool,
-        title="top bar",
-        help_="Show the top bar",
-        default=True,
-        schema={"type": "boolean"},
-        description="""
-            Whether the top bar should be shown at the top of the screen.
-        """,
-    )
-
     # ################################# Key Bindings ##################################
 
     register_bindings(

euporie/notebook/filters.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from prompt_toolkit.filters import Condition
 
-from euporie.core.current import get_app
+from euporie.core.app.current import get_app
 
 
 @Condition

euporie/notebook/tabs/__init__.py

@@ -1,10 +1,49 @@
 """Tab for use in euporie notebook editor."""
 
-from euporie.notebook.tabs.display import DisplayTab
-from euporie.notebook.tabs.edit import EditorTab
-from euporie.notebook.tabs.json import JsonTab
-from euporie.notebook.tabs.log import LogView
-from euporie.notebook.tabs.notebook import Notebook
-from euporie.web.tabs.web import WebTab
+from euporie.core.convert.mime import MIME_FORMATS
+from euporie.core.tabs import _TAB_REGISTRY, TabRegistryEntry
 
-__all__ = ["DisplayTab", "EditorTab", "JsonTab", "LogView", "Notebook", "WebTab"]
+_TAB_REGISTRY.extend(
+    [
+        TabRegistryEntry(
+            path="euporie.notebook.tabs.display:DisplayTab",
+            name="File Viewer",
+            mime_types=set(MIME_FORMATS.keys()),
+        ),
+        TabRegistryEntry(
+            path="euporie.notebook.tabs.edit:EditorTab",
+            name="Text Editor",
+            mime_types={"text/*"},
+            weight=1,
+        ),
+        TabRegistryEntry(
+            path="euporie.notebook.tabs.json:JsonTab",
+            name="JSON Viewer",
+            mime_types={"*json"},
+            file_extensions={".json": None},
+        ),
+        TabRegistryEntry(
+            path="euporie.notebook.tabs.notebook:Notebook",
+            name="Notebook Editor",
+            mime_types={"application/x-ipynb+json"},
+            file_extensions={".ipynb": None},
+            weight=3,
+        ),
+        TabRegistryEntry(
+            path="euporie.web.tabs.web:WebTab",
+            name="Web Viewer",
+            mime_types={"text/html", "text/markdown"},
+            weight=2,
+        ),
+    ]
+)
+
+try:
+    from jupytext.formats import NOTEBOOK_EXTENSIONS
+except ModuleNotFoundError:
+    pass
+else:
+    for entry in _TAB_REGISTRY:
+        if entry.path == "euporie.notebook.tabs.notebook:Notebook":
+            entry.file_extensions.update(dict.fromkeys(NOTEBOOK_EXTENSIONS))
+            break