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

euporie/data/desktop/euporie-console.desktop

@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Application
+Terminal=true
+Name=Euporie Console
+Icon=utilities-terminal
+Exec=bash -i -c 'euporie-console %f'
+Categories=Application;

euporie/data/desktop/euporie-notebook.desktop

@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Application
+Terminal=true
+Name=Euporie Notebook
+Icon=utilities-terminal
+Exec=bash -i -c 'euporie-notebook %f'
+Categories=Application;

euporie/hub/__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/hub/app.py

@@ -42,7 +42,7 @@ class EuporieSSHServer(asyncssh.SSHServer):  # type: ignore
 
     def begin_auth(self, username: str) -> bool | Awaitable[bool]:
         """Perform authentication in the SSH server."""
-        if self.app_cls.config.no_auth:
+        if not self.app_cls.config.auth:
             # No authentication.
             return False
         return super().begin_auth(username)
@@ -68,18 +68,20 @@ class HubApp(BaseApp):
     @classmethod
     def launch(cls) -> None:
         """Launch the HubApp SSH server."""
+        # Default logging configuration
+        setup_logs()
+
         # Configure some setting defaults
         cls.config.settings["log_file"].value = "-"
+        cls.config.settings["log_level"].value = "info"
         cls.config.settings[
             "log_config"
         ].value = '{"loggers": {"asyncssh": {"handlers":["stdout"], "level": "DEBUG"}}}'
 
         # Load the app's configuration
         cls.config.load(cls)
-        # Configure the logs
-        setup_logs(cls.config)
 
-        if cls.config.no_auth:
+        if not cls.config.auth:
             log.warning(
                 "This server has been configured without SSH authentication, "
                 "meaning anyone can connect"
@@ -188,11 +190,11 @@ class HubApp(BaseApp):
     )
 
     add_setting(
-        name="no_auth",
-        flags=["--no-auth"],
+        name="auth",
+        flags=["--auth"],
         type_=bool,
         help_="Allow unauthenticated access to euporie hub",
-        default=False,
+        default=True,
         description="""
             When set, users will be able to access euporie hub without authentication.
 

euporie/notebook/__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/notebook/app.py

@@ -25,6 +25,7 @@ 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.key_binding.registry import register_bindings
+from euporie.core.tabs.base import Tab
 from euporie.core.widgets.decor import Pattern
 from euporie.core.widgets.dialog import (
     AboutDialog,
@@ -55,10 +56,9 @@ if TYPE_CHECKING:
 
     from prompt_toolkit.formatted_text import StyleAndTextTuples
     from prompt_toolkit.layout.containers import AnyContainer, Float
-    from upath import UPath
 
-    from euporie.core.tabs.base import Tab
     from euporie.core.widgets.cell import Cell
+    from euporie.core.widgets.status_bar import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -81,16 +81,14 @@ class NotebookApp(BaseApp):
         kwargs.setdefault("full_screen", True)
         kwargs.setdefault("leave_graphics", False)
         super().__init__(**kwargs)
-        self.search_bar = SearchBar()
         self.bindings_to_load.append("euporie.notebook.app.NotebookApp")
-        self.pre_run_callables.append(self.load_default_statusbar_fields)
 
         # Register config hooks
         self.config.get_item("show_cell_borders").event += lambda x: self.refresh()
 
-    def load_default_statusbar_fields(self) -> None:
+    def statusbar_defaults(self) -> StatusBarFields | None:
         """Load the default statusbar fields (run after keybindings are loaded)."""
-        self.status_default = (
+        return (
             [
                 [
                     ("", "Press "),
@@ -101,26 +99,6 @@ class NotebookApp(BaseApp):
             [[("", "Press "), ("bold", get_cmd("quit").key_str()), ("", " to quit")]],
         )
 
-    def get_file_tab(self, path: UPath) -> type[Tab]:
-        """Return the tab to use for a file path."""
-        if path.suffix == ".ipynb":
-            return Notebook
-        else:
-            import mimetypes
-
-            from euporie.core.convert.base import MIME_FORMATS
-
-            mime, _ = mimetypes.guess_type(path)
-            log.debug("File %s has mime type: %s", path, mime)
-            if (mime or "").startswith("text/") and mime not in MIME_FORMATS:
-                from euporie.notebook.tabs.edit import EditorTab
-
-                return EditorTab
-            else:
-                from euporie.notebook.tabs.display import DisplayTab
-
-                return DisplayTab
-
     async def _poll_terminal_colors(self) -> None:
         """Repeatedly query the terminal for its background and foreground colours."""
         while self.config.terminal_polling_interval:
@@ -221,8 +199,7 @@ class NotebookApp(BaseApp):
         )
 
         self.pager = Pager()
-
-        assert self.search_bar is not None
+        self.search_bar = SearchBar()
 
         self.dialogs["command-palette"] = CommandPalette(self)
         self.dialogs["about"] = AboutDialog(self)
@@ -282,7 +259,7 @@ class NotebookApp(BaseApp):
                         height=Dimension(min=1),
                     ),
                     self.search_bar,
-                    StatusBar(),
+                    StatusBar(default=self.statusbar_defaults()),
                 ],
                 style="class:body",
             ),
@@ -385,7 +362,7 @@ class NotebookApp(BaseApp):
                     get_cmd("new-notebook").menu,
                     get_cmd("open-file").menu,
                     separator,
-                    get_cmd("save-notebook").menu,
+                    get_cmd("save-file").menu,
                     get_cmd("save-as").menu,
                     get_cmd("close-tab").menu,
                     separator,

euporie/notebook/tabs/__init__.py

@@ -1,6 +1,10 @@
 """Tab for use in euporie notebook editor."""
 
-from .log import LogView
-from .notebook import Notebook
+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
 
-__all__ = ["LogView", "Notebook"]
+__all__ = ["DisplayTab", "EditorTab", "JsonTab", "LogView", "Notebook", "WebTab"]

euporie/notebook/tabs/display.py

@@ -5,22 +5,22 @@ 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.layout.containers import VSplit
 from prompt_toolkit.layout.dimension import Dimension
 
-from euporie.core.convert.base import get_format
+from euporie.core.convert.core import MIME_FORMATS, get_format
 from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.tabs.base import Tab
 from euporie.core.widgets.display import Display
 
 if TYPE_CHECKING:
-    from typing import Sequence
+    from pathlib import Path
 
-    from prompt_toolkit.formatted_text import AnyFormattedText
     from prompt_toolkit.layout.containers import AnyContainer
-    from upath import UPath
 
     from euporie.core.app import BaseApp
+    from euporie.core.widgets.status_bar import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -28,15 +28,24 @@ log = logging.getLogger(__name__)
 class DisplayTab(Tab):
     """Tab class for displaying files."""
 
-    def __init__(self, app: BaseApp, path: UPath | None = None) -> None:
+    name = "File Viewer"
+    mime_types = set(MIME_FORMATS.keys())
+
+    def __init__(self, app: BaseApp, path: Path | None = None) -> None:
         """Call when the tab is created."""
         super().__init__(app, path)
+
+        # Load file and container in background
         if self.path is not None:
-            self.container = self.load_container()
 
-    def statusbar_fields(
-        self,
-    ) -> tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]:
+            def _load() -> None:
+                self.container = self.load_container()
+                self.app.layout.focus(self.container)
+                self.app.invalidate()
+
+            run_in_executor_with_context(_load)
+
+    def __pt_status__(self) -> StatusBarFields | None:
         """Return a list of statusbar field values shown then this tab is active."""
         return ([str(self.path)], [])
 

euporie/notebook/tabs/edit.py

@@ -8,22 +8,23 @@ from typing import TYPE_CHECKING
 from prompt_toolkit.layout.containers import VSplit
 from prompt_toolkit.layout.dimension import Dimension
 
+from euporie.core.filters import insert_mode, replace_mode
 from euporie.core.kernel import Kernel, MsgCallbacks
+from euporie.core.key_binding.registry import load_registered_bindings
 from euporie.core.lexers import detect_lexer
-
-# from euporie.core.margins import MarginContainer
+from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.tabs.base import KernelTab
 from euporie.core.widgets.inputs import KernelInput
 
 if TYPE_CHECKING:
-    from typing import Sequence
+    from pathlib import Path
+    from typing import Callable
 
-    from prompt_toolkit.formatted_text import AnyFormattedText
     from prompt_toolkit.layout.containers import AnyContainer
-    from upath import UPath
 
     from euporie.core.app import BaseApp
     from euporie.core.comm.base import Comm
+    from euporie.core.widgets.status_bar import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -31,61 +32,143 @@ log = logging.getLogger(__name__)
 class EditorTab(KernelTab):
     """Tab class for editing text files."""
 
+    name = "Text Editor"
+    weight = 1
+    mime_types = {"text/*"}
+
     allow_stdin = True
     _metadata = {}
 
     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 = False,
     ) -> None:
         """Call when the tab is created."""
         self.default_callbacks = MsgCallbacks({})
+        self._metadata = {}
+        self.loaded = False
+
         super().__init__(app, path, kernel, comms, use_kernel_history)
 
-        # Load file
+    def post_init_kernel(self) -> None:
+        """Load UI and file in background after kernel has inited."""
+        # Load the UI
+        self.container = self.load_container()
+        self.app.layout.focus(self.container)
+
+        # Read file
+        self.load()
+
+    def load(self) -> None:
+        """Load the text file."""
         if self.path is not None:
             text = self.path.read_text()
         else:
             text = ""
 
-        # Detect language
-        lexer = detect_lexer(text, path)
-        self._metadata = {"kernelspec": {"language": lexer.name}}
+        # Set text
+        self.input_box.text = text
+        self.input_box.buffer.on_text_changed += lambda b: setattr(self, "dirty", True)
+        self.input_box.read_only = False
+        self.loaded = True
 
-        # Load UI
-        self.container = self.load_container()
+        # Detect language
+        lexer = detect_lexer(text[:1000], self.path)
+        if lexer:
+            self._metadata = {"kernelspec": {"language": lexer.name}}
+        # Re-lex the file
+        self.input_box.control._fragment_cache.clear()
+        self.app.invalidate()
 
-        self.input_box.text = text
+    @property
+    def position(self) -> str:
+        """Return the position of the cursor in the document."""
+        doc = self.input_box.buffer.document
+        return f"{doc.cursor_position_row + 1}:{doc.cursor_position_col}"
 
-    def statusbar_fields(
-        self,
-    ) -> tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]:
+    def __pt_status__(self) -> StatusBarFields | None:
         """Return a list of statusbar field values shown then this tab is active."""
-        return ([str(self.path)], [])
+        if not self.loaded:
+            return (["Loading…"], [])
+        return (
+            [
+                ("I" if insert_mode() else ("o" if replace_mode() else ">")),
+                self.position,
+            ],
+            [str(self.path)],
+        )
 
     @property
-    def title(self) -> str:
-        """Return the tab title."""
+    def path_name(self) -> str:
+        """Return the path name."""
         if self.path is not None:
-            return str(self.path.name)
+            return self.path.name
         else:
-            return "<New File>"
+            return "(New file)"
+
+    @property
+    def title(self) -> str:
+        """Return the tab title."""
+        return ("* " if self.dirty else "") + self.path_name
 
     def load_container(self) -> AnyContainer:
         """Abcract method for loading the notebook's main container."""
         assert self.path is not None
 
-        self.input_box = KernelInput(kernel_tab=self)
+        self.input_box = KernelInput(kernel_tab=self, right_margins=[], read_only=True)
 
         return VSplit(
             [
                 self.input_box,
-                # MarginContainer(ScrollbarMargin(), target=self.input_box.window),
+                MarginContainer(ScrollbarMargin(), target=self.input_box.window),
             ],
             width=Dimension(weight=1),
             height=Dimension(weight=1),
+            key_bindings=load_registered_bindings("euporie.core.tabs.base.Tab"),
         )
+
+    def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
+        """Save the current file."""
+        if path is not None:
+            self.path = path
+
+        if self.path is None:
+            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()
+
+            # Save to a temp file, then replace the original
+            temp_path = self.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()

euporie/notebook/tabs/json.py

@@ -0,0 +1,73 @@
+"""Contain a tab for displaying JSON data."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.eventloop.utils import run_in_executor_with_context
+from prompt_toolkit.layout.containers import VSplit
+from prompt_toolkit.layout.dimension import Dimension
+
+from euporie.core.tabs.base import Tab
+from euporie.core.widgets.tree import JsonView
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    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 JsonTab(Tab):
+    """Tab class for JSON data."""
+
+    name = "JSON Viewer"
+    mime_types = {"*json"}
+    filte_types = {".json"}
+
+    def __init__(self, app: BaseApp, path: Path | None = None) -> None:
+        """Call when the tab is created."""
+        super().__init__(app, path)
+
+        # Load file and container in background
+        if self.path is not None:
+
+            def _load() -> None:
+                self.container = self.load_container()
+                self.app.layout.focus(self.container)
+                self.app.invalidate()
+
+            run_in_executor_with_context(_load)
+
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return a list of statusbar field values shown then this tab is active."""
+        return ([str(self.path)], [])
+
+    @property
+    def title(self) -> str:
+        """Return the tab title."""
+        if self.path is not None:
+            return str(self.path.name) or str(self.path)
+        else:
+            return "<file>"
+
+    def load_container(self) -> AnyContainer:
+        """Abcract method for loading the notebook's main container."""
+        assert self.path is not None
+
+        data = json.load(self.path.open())
+
+        return VSplit(
+            [
+                JsonView(data, title=self.path.name, expanded=True),
+                # MarginContainer(ScrollbarMargin(), target=self.display.window),
+            ],
+            width=Dimension(weight=1),
+            height=Dimension(weight=1),
+        )

euporie/notebook/tabs/log.py

@@ -2,33 +2,33 @@
 
 from __future__ import annotations
 
-from pathlib import Path
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.filters import Condition, has_focus
 from prompt_toolkit.formatted_text.base import FormattedText
-from prompt_toolkit.layout.containers import HSplit
+from prompt_toolkit.layout.containers import HSplit, VSplit
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.widgets import SearchToolbar
 
 from euporie.core.commands import add_cmd
 from euporie.core.current import get_app
 from euporie.core.log import LOG_QUEUE, QueueHandler
+from euporie.core.margins import MarginContainer, ScrollbarMargin
+from euporie.core.path import parse_path
 from euporie.core.tabs.base import Tab
 from euporie.core.widgets.formatted_text_area import FormattedTextArea
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import Callable
 
-    from upath import UPath
-
     from euporie.core.app import BaseApp
 
 
 class LogView(Tab):
     """A tab which allows you to view log entries."""
 
-    def __init__(self, app: BaseApp, path: UPath | None = None) -> None:
+    def __init__(self, app: BaseApp, path: Path | None = None) -> None:
         """Create a new log view tab instance."""
         super().__init__(app, path)
         # Build the container
@@ -38,7 +38,7 @@ class LogView(Tab):
         self.text_area = FormattedTextArea(
             formatted_text=[],
             read_only=True,
-            scrollbar=True,
+            scrollbar=False,
             line_numbers=Condition(lambda: self.app.config.line_numbers),
             search_field=self.search_field,
             focus_on_click=True,
@@ -46,7 +46,17 @@ class LogView(Tab):
             dont_extend_width=False,
         )
         self.container = HSplit(
-            [self.text_area, self.search_field],
+            [
+                VSplit(
+                    [
+                        self.text_area,
+                        MarginContainer(
+                            ScrollbarMargin(), target=self.text_area.window
+                        ),
+                    ]
+                ),
+                self.search_field,
+            ],
             width=Dimension(weight=1),
             height=Dimension(weight=1),
         )
@@ -72,7 +82,7 @@ class LogView(Tab):
     def title(self) -> str:
         """Return the title of this tab."""
         suffix = (
-            f" ({Path(self.app.config.log_file).name})"
+            f" ({parse_path(self.app.config.log_file).name})"
             if self.app.config.log_file
             else ""
         )