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

euporie/core/tabs/base.py

@@ -8,8 +8,10 @@ from collections import deque
 from functools import partial
 from typing import TYPE_CHECKING
 
+from prompt_toolkit.eventloop.utils import run_in_executor_with_context
 from prompt_toolkit.history import InMemoryHistory
-from prompt_toolkit.layout.containers import Window
+from prompt_toolkit.layout.containers import Window, WindowAlign
+from prompt_toolkit.layout.controls import FormattedTextControl
 
 from euporie.core.comm.registry import open_comm
 from euporie.core.commands import add_cmd
@@ -19,41 +21,55 @@ from euporie.core.current import get_app
 from euporie.core.filters import kernel_tab_has_focus, tab_has_focus
 from euporie.core.history import KernelHistory
 from euporie.core.kernel import Kernel, MsgCallbacks
+from euporie.core.key_binding.registry import (
+    register_bindings,
+)
 from euporie.core.suggest import HistoryAutoSuggest
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import Any, Callable, Deque, Sequence
 
     from prompt_toolkit.auto_suggest import AutoSuggest
     from prompt_toolkit.completion.base import Completer
-    from prompt_toolkit.formatted_text import AnyFormattedText
     from prompt_toolkit.history import History
     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__)
 
 
 class Tab(metaclass=ABCMeta):
-    """Bae class for interface tabs."""
+    """Base class for interface tabs."""
+
+    _registry: set[type[Tab]] = set()
+    name: str | None = None
+    weight: int = 0
+    mime_types: set[str] = set()
+    file_extensions: set[str] = set()
 
     container: AnyContainer
 
-    def __init__(self, app: BaseApp, path: UPath | None = None) -> None:
+    def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:
+        """Compile a registry of named tabs."""
+        super().__init_subclass__(**kwargs)
+        if cls.name:
+            Tab._registry.add(cls)
+
+    def __init__(self, app: BaseApp, path: Path | None = None) -> None:
         """Call when the tab is created."""
         self.app = app
         self.path = path
-        self.app.container_statuses[self] = self.statusbar_fields
-        self.container = Window()
+        self.container = Window(
+            FormattedTextControl([("fg:#888888", "\nLoading…")], focusable=True),
+            align=WindowAlign.CENTER,
+        )
 
-    def statusbar_fields(
-        self,
-    ) -> tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]:
-        """Return a list of statusbar field values shown then this tab is active."""
-        return ([], [])
+        self.dirty = False
+        self.saving = False
 
     @property
     def title(self) -> str:
@@ -71,8 +87,7 @@ class Tab(metaclass=ABCMeta):
             cb: A function to call after the tab is closed.
 
         """
-        if self in self.app.container_statuses:
-            del self.app.container_statuses[self]
+        # Run callback
         if callable(cb):
             cb()
 
@@ -80,10 +95,18 @@ class Tab(metaclass=ABCMeta):
         """Focus the tab (or make it visible)."""
         self.app.focus_tab(self)
 
-    def save(self, path: UPath | None = None, cb: Callable | None = None) -> None:
+    def _save(self, path: Path | None = None, cb: Callable | None = None) -> None:
+        """Perform the file save in a background thread."""
+        run_in_executor_with_context(self.save, path, cb)
+
+    def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
         """Save the current notebook."""
         raise NotImplementedError
 
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return a list of statusbar field values shown then this tab is active."""
+        return ([], [])
+
     def __pt_container__(self) -> AnyContainer:
         """Return the main container object."""
         return self.container
@@ -97,6 +120,27 @@ class Tab(metaclass=ABCMeta):
         if (tab := get_app().tab) is not None:
             tab.reset()
 
+    @staticmethod
+    @add_cmd(filter=tab_has_focus)
+    def _save_file() -> None:
+        """Save the current file."""
+        if (tab := get_app().tab) is not None:
+            try:
+                tab._save()
+            except NotImplementedError:
+                pass
+
+    # ################################# Key Bindings ##################################
+
+    register_bindings(
+        {
+            "euporie.core.tabs.base.Tab": {
+                "save-file": "c-s",
+                "reset-tab": "f5",
+            }
+        }
+    )
+
 
 class KernelTab(Tab, metaclass=ABCMeta):
     """A Tab which connects to a kernel."""
@@ -104,6 +148,7 @@ class KernelTab(Tab, metaclass=ABCMeta):
     kernel: Kernel
     kernel_language: str
     _metadata: dict[str, Any]
+    bg_init = True
 
     default_callbacks: MsgCallbacks
     allow_stdin: bool
@@ -111,14 +156,44 @@ class KernelTab(Tab, metaclass=ABCMeta):
     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,
+        connection_file: Path | None = None,
     ) -> None:
         """Create a new instance of a tab with a kernel."""
+        # Init tab
         super().__init__(app, path)
 
+        if self.bg_init:
+            # Load kernel in a background thread
+            run_in_executor_with_context(
+                partial(
+                    self.init_kernel, kernel, comms, use_kernel_history, connection_file
+                )
+            )
+        else:
+            self.init_kernel(kernel, comms, use_kernel_history, connection_file)
+
+    def pre_init_kernel(self) -> None:
+        """Run stuff before the kernel is loaded."""
+        pass
+
+    def post_init_kernel(self) -> None:
+        """Run stuff after the kernel is loaded."""
+        pass
+
+    def init_kernel(
+        self,
+        kernel: Kernel | None = None,
+        comms: dict[str, Comm] | None = None,
+        use_kernel_history: bool = False,
+        connection_file: Path | None = None,
+    ) -> None:
+        """Set up the tab's kernel and related components."""
+        self.pre_init_kernel()
+
         self.kernel_queue: Deque[Callable] = deque()
 
         if kernel:
@@ -129,6 +204,7 @@ class KernelTab(Tab, metaclass=ABCMeta):
                 kernel_tab=self,
                 allow_stdin=self.allow_stdin,
                 default_callbacks=self.default_callbacks,
+                connection_file=connection_file,
             )
         self.comms: dict[str, Comm] = comms or {}  # The client-side comm states
         self.completer: Completer = KernelCompleter(self.kernel)
@@ -138,6 +214,14 @@ class KernelTab(Tab, metaclass=ABCMeta):
         )
         self.suggester: AutoSuggest = HistoryAutoSuggest(self.history)
 
+        self.post_init_kernel()
+
+    def close(self, cb: Callable | None = None) -> None:
+        """Shut down kernel when tab is closed."""
+        if hasattr(self, "kernel"):
+            self.kernel.shutdown()
+        super().close(cb)
+
     def interrupt_kernel(self) -> None:
         """Interrupt the current `Notebook`'s kernel."""
         self.kernel.interrupt()
@@ -293,7 +377,7 @@ class KernelTab(Tab, metaclass=ABCMeta):
 
     add_setting(
         name="kernel_name",
-        flags=["--kernel-name"],
+        flags=["--kernel-name", "--kernel"],
         type_=str,
         help_="The name of the kernel to start by default",
         default="python3",

euporie/core/tabs/notebook.py

@@ -15,16 +15,23 @@ from euporie.core.comm.registry import open_comm
 from euporie.core.commands import get_cmd
 from euporie.core.config import add_setting
 from euporie.core.kernel import MsgCallbacks
+from euporie.core.path import parse_path
 from euporie.core.tabs.base import KernelTab
-from euporie.core.utils import parse_path
 from euporie.core.widgets.cell import Cell, get_cell_id
 
+try:
+    from jupytext import read as read_nb
+    from jupytext import write as write_nb
+except ModuleNotFoundError:
+    from nbformat import read as read_nb
+    from nbformat import write as write_nb
+
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import Any, Callable
 
     from prompt_toolkit.filters import Filter
     from prompt_toolkit.layout.containers import AnyContainer
-    from upath import UPath
 
     from euporie.core.app import BaseApp
     from euporie.core.comm.base import Comm
@@ -42,7 +49,7 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
     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,
@@ -73,25 +80,16 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
                 "dead": self.kernel_died,
             }
         )
-
-        # Load the notebook file
-        self.path = parse_path(path)
-        log.debug("Loading notebooks %s", self.path)
-
-        self.load(json)
+        self.json = json or {}
+        self._rendered_cells: dict[str, Cell] = {}
+        self.multiple_cells_selected: Filter = Never()
+        self.path = parse_path(path) if path else None
+        self.loaded = False
 
         super().__init__(
             app, path, kernel=kernel, comms=comms, use_kernel_history=use_kernel_history
         )
 
-        self._rendered_cells: dict[str, Cell] = {}
-        self.load_widgets_from_metadata()
-        self.dirty = False
-        self.saving = False
-        self.multiple_cells_selected: Filter = Never()
-
-        self.container = self.load_container()
-
     # Tab stuff
 
     def reset(self) -> None:
@@ -104,6 +102,30 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
 
     # KernelTab stuff
 
+    def pre_init_kernel(self) -> None:
+        """Run stuff before the kernel is loaded."""
+        # Load notebook file
+        self.load()
+
+    def post_init_kernel(self) -> None:
+        """Load the notebook container after the kernel has been loaded."""
+        # Replace the tab's container
+        prev = self.container
+        self.container = self.load_container()
+        self.loaded = True
+        self.app.invalidate()
+
+        # Update the focus if the old container had focus
+        if (layout := self.app.layout).has_focus(prev):
+
+            async def _focus_new_container() -> None:
+                layout.focus(self.container)
+
+            self.app.create_background_task(_focus_new_container())
+
+        # Load widgets
+        self.load_widgets_from_metadata()
+
     @property
     def metadata(self) -> dict[str, Any]:
         """Return a dictionary to hold notebook / kernel metadata."""
@@ -118,21 +140,22 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
         if confirm := self.app.dialogs.get("confirm"):
             confirm.show(
                 title="Kernel connection lost",
-                message="The kernel appears to have died\nas it can no longer be reached.\n\n"
+                message="The kernel appears to have died\n"
+                "as it can no longer be reached.\n\n"
                 "Do you want to restart the kernel?",
                 cb=self.kernel.restart,
             )
 
     # Notebook stuff
 
-    def load(self, json: dict[str, Any] | None = None) -> None:
+    def load(self) -> None:
         """Load the notebook file from the file-system."""
         # Open json file, or load from passed json object
         if self.path is not None and self.path.exists():
             with self.path.open() as f:
-                self.json = nbformat.read(f, as_version=4)
+                self.json = read_nb(f, as_version=4)
         else:
-            self.json = json or nbformat.v4.new_notebook()
+            self.json = self.json or nbformat.v4.new_notebook()
         # Ensure there is always at least one cell
         if not self.json.setdefault("cells", []):
             self.json["cells"] = [nbformat.v4.new_code_cell()]
@@ -242,7 +265,7 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
         else:
             super().close(cb)
 
-    def save(self, path: UPath | None = None, cb: Callable | None = None) -> None:
+    def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
         """Write the notebook's JSON to the current notebook's file.
 
         Additionally save the widget state to the notebook metadata.
@@ -267,24 +290,43 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
                 }
             }
         if self.path is None:
-            # get_cmd("save-as").run()
             if dialog := self.app.dialogs.get("save-as"):
                 dialog.show(tab=self, cb=cb)
         else:
             log.debug("Saving notebook..")
             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 = self.path.open("w")
+                open_file = temp_path.open("w")
             except NotImplementedError:
                 get_cmd("save-as").run()
             else:
-                with open_file as f:
-                    nbformat.write(nb=nbformat.from_dict(self.json), fp=f)
-                self.dirty = False
-                self.saving = False
-                self.app.invalidate()
-                log.debug("Notebook saved")
+                try:
+                    try:
+                        with open_file as f:
+                            write_nb(nb=nbformat.from_dict(self.json), fp=f)
+                    except AssertionError:
+                        # Jupytext requires a filename if we don't give it a format
+                        write_nb(nb=nbformat.from_dict(self.json), fp=temp_path)
+                except Exception:
+                    if dialog := self.app.dialogs.get("save-as"):
+                        dialog.show(tab=self, cb=cb)
+                else:
+                    open_file.close()
+                    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("Notebook saved")
             # Run the callback
             if callable(cb):
                 cb()

euporie/core/terminal.py

@@ -132,24 +132,6 @@ class TerminalQuery:
         return self._value or self.default
 
 
-class ColorQueryMixin:
-    """A mixin for terminal queries which check a terminal colour."""
-
-    pattern: re.Pattern
-
-    def verify(self, data: str) -> str | None:
-        """Verify the response contains a colour."""
-        if match := self.pattern.match(data):
-            if colors := match.groupdict():
-                r, g, b = (
-                    colors.get("r", "00"),
-                    colors.get("g", "00"),
-                    colors.get("b", "00"),
-                )
-                return f"#{r[:2]}{g[:2]}{b[:2]}"
-        return None
-
-
 class Colors(TerminalQuery):
     """A terminal query to retrieve colours as hex codes."""
 
@@ -237,6 +219,7 @@ class KittyGraphicsStatus(TerminalQuery):
     pattern = re.compile(r"^\x1b_Gi=(4294967295|0);(?P<status>OK)\x1b\\\Z")
 
     def _cmd(self) -> str:
+        """Hide the command in case the terminal does not support this sequence."""
         return "\x1b[s" + tmuxify(self.cmd) + "\x1b[u\x1b[2K"
 
     def verify(self, data: str) -> bool:
@@ -328,30 +311,47 @@ class SgrPixelStatus(TerminalQuery):
 
     default = False
     cache = True
-    cmd = "\x1b[?1016$p"
+    cmd = "\x1b[?1016h\x1b[?1016$p\x1b[?1016l"  # Enable, check, disable
     pattern = re.compile(r"^\x1b\[\?1016;(?P<Pm>\d)\$\Z")
 
     def verify(self, data: str) -> bool:
         """Verify the terminal response means sixel graphics are supported."""
         if match := self.pattern.match(data):
             if values := match.groupdict():
-                if values.get("Pm") != 0:
+                if values.get("Pm") in {"1", "3"}:
                     return True
         return False
 
 
+class CsiUStatus(TerminalQuery):
+    """A terminal query to check for CSI-u support."""
+
+    default = False
+    cache = True
+    cmd = "\x1b[?u"
+    pattern = re.compile(r"^\x1b\[\?\d+u")
+
+    def verify(self, data: str) -> bool:
+        """Verify the terminal responds."""
+        if match := self.pattern.match(data):
+            if match:
+                return True
+        return False
+
+
 class TerminalInfo:
     """A class to gather and hold information about the terminal."""
 
     input: Input
     output: Output
 
+    _queries: dict[type[TerminalQuery], TerminalQuery] = {}
+
     def __init__(self, input_: Input, output: Output, config: Config) -> None:
         """Instantiate the terminal information class."""
         self.input = input_
         self.output = output
         self.config = config
-        self._queries: list[TerminalQuery] = []
 
         self.colors = self.register(Colors)
         self.pixel_dimensions = self.register(PixelDimensions)
@@ -360,36 +360,44 @@ class TerminalInfo:
         self.iterm_graphics_status = self.register(ItermGraphicsStatus)
         self.depth_of_color = self.register(DepthOfColor)
         self.sgr_pixel_status = self.register(SgrPixelStatus)
+        self.csiu_status = self.register(CsiUStatus)
 
     def register(self, query: type[TerminalQuery]) -> TerminalQuery:
         """Instantiate and registers a query's response with the input parser."""
         # Create an instance of this query
-        query_inst = query(self.output, config=self.config)
-        self._queries.append(query_inst)
-
-        # If the query expects a response from the terminal, we need to add a
-        # key-binding for it and register it with the input parser
-        if query.pattern:
-            name = re.sub(r"(?<!^)(?=[A-Z])", "-", query.__name__).lower()
-            title = name.replace("-", " ")
-
-            # Add a "key" definition for this query
-            key_name = f"{query.__name__}Response"
-            key_code = f"<{name}-response>"
-            # Do not register the same key multiple times
-            if not hasattr(Keys, key_name):
-                extend_enum(Keys, key_name, key_code)
-            key = getattr(Keys, key_name)
-
-            # Register this key with the parser if supported
-            if parser := getattr(self.input, "vt100_parser", None):
-                # Register the key
-                parser.queries[key] = query.pattern
-
-            # Add a command for the query's key-binding
-            add_cmd(name=name, title=title, hidden=True)(query_inst._handle_response)
-            # Add key-binding
-            register_bindings({"euporie.core.app.BaseApp": {name: key}})
+        query_inst: TerminalQuery | None
+
+        if (query_inst := self._queries.get(query)) is None:
+            query_inst = query(self.output, config=self.config)
+            self._queries[query] = query_inst
+
+            # If the query expects a response from the terminal, we need to add a
+            # key-binding for it and register it with the input parser
+            if query.pattern:
+                name = re.sub(r"(?<!^)(?=[A-Z])", "-", query.__name__).lower()
+                title = name.replace("-", " ")
+
+                # Add a "key" definition for this query
+                key_name = f"{query.__name__}Response"
+                key_code = f"<{name}-response>"
+                # Do not register the same key multiple times
+                if not hasattr(Keys, key_name):
+                    extend_enum(Keys, key_name, key_code)
+                key = getattr(Keys, key_name)
+
+                # Register this key with the parser if supported
+                if (parser := getattr(self.input, "vt100_parser", None)) and hasattr(
+                    parser, "queries"
+                ):
+                    # Register the key
+                    parser.queries[key] = query.pattern
+
+                # Add a command for the query's key-binding
+                add_cmd(name=name, title=title, hidden=True)(
+                    query_inst._handle_response
+                )
+                # Add key-binding
+                register_bindings({"euporie.core.app.BaseApp": {name: key}})
 
         return query_inst
 
@@ -397,7 +405,7 @@ class TerminalInfo:
         """Send the command for all queries."""
         # Ensure line wrapping is off before sending queries
         self.output.disable_autowrap()
-        for query in self._queries:
+        for query in self._queries.values():
             query.send()
 
     def _tiocgwnsz(self) -> tuple[int, int, int, int]:

euporie/core/utils.py

@@ -6,10 +6,8 @@ from itertools import chain
 from typing import TYPE_CHECKING, Sequence, TypeVar, overload
 
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType
-from upath import UPath
 
 if TYPE_CHECKING:
-    from os import PathLike
     from typing import Callable, Iterable
 
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
@@ -48,20 +46,18 @@ class ChainedList(Sequence[T]):
         return len(self.data)
 
 
-def parse_path(path: str | PathLike | None) -> UPath | None:
-    """Pare and resolve a path."""
-    if path is None:
-        return None
-    upath = UPath(path)
-    try:
-        upath = upath.expanduser()
-    except NotImplementedError:
-        pass
-    try:
-        upath = upath.resolve()
-    except (AttributeError, NotImplementedError):
-        pass
-    return upath
+def dict_merge(target_dict: dict, input_dict: dict) -> None:
+    """Merge the second dictionary onto the first."""
+    for k in input_dict:
+        if k in target_dict:
+            if isinstance(target_dict[k], dict) and isinstance(input_dict[k], dict):
+                dict_merge(target_dict[k], input_dict[k])
+            elif isinstance(target_dict[k], list) and isinstance(input_dict[k], list):
+                target_dict[k] = [*target_dict[k], *input_dict[k]]
+            else:
+                target_dict[k] = input_dict[k]
+        else:
+            target_dict[k] = input_dict[k]
 
 
 def on_click(func: Callable) -> MouseHandler:

euporie/core/widgets/cell.py

@@ -151,6 +151,10 @@ class Cell:
 
         # Now we generate the main container used to represent a kernel_tab cell
 
+        source_hidden = Condition(
+            lambda: self.json["metadata"].get("jupyter", {}).get("source_hidden", False)
+        )
+
         self.input_box = KernelInput(
             kernel_tab=self.kernel_tab,
             text=self.input,
@@ -170,6 +174,7 @@ class Cell:
                 )
             ),
             accept_handler=lambda buffer: self.run_or_render() or True,
+            focusable=show_input & ~source_hidden,
         )
         self.input_box.buffer.name = self.cell_type
 
@@ -228,10 +233,6 @@ class Cell:
             height=1,
         )
 
-        source_hidden = Condition(
-            lambda: self.json["metadata"].get("jupyter", {}).get("source_hidden", False)
-        )
-
         input_row = ConditionalContainer(
             VSplit(
                 [
@@ -588,7 +589,7 @@ class Cell:
         if self.cell_type == "markdown":
             return "markdown"
         elif self.cell_type == "code":
-            lang_info = self.kernel_tab.json.metadata.get("language_info", {})
+            lang_info = self.kernel_tab.metadata.get("language_info", {})
             return lang_info.get("name", lang_info.get("pygments_lexer", "python"))
         else:
             return "raw"

euporie/core/widgets/cell_outputs.py

@@ -11,7 +11,7 @@ from prompt_toolkit.cache import SimpleCache
 from prompt_toolkit.layout.containers import DynamicContainer, HSplit, to_container
 from prompt_toolkit.widgets.base import Box
 
-from euporie.core.convert.base import BASE64_FORMATS, MIME_FORMATS, find_route
+from euporie.core.convert.core import BASE64_FORMATS, MIME_FORMATS, find_route
 from euporie.core.current import get_app
 from euporie.core.widgets.display import Display
 from euporie.core.widgets.tree import JsonView
@@ -39,7 +39,7 @@ log = logging.getLogger(__name__)
 
 
 class CellOutputElement(metaclass=ABCMeta):
-    """Bae class for the various types of cell outputs (display data or widgets)."""
+    """Base class for the various types of cell outputs (display data or widgets)."""
 
     data: Any