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

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

@@ -22,7 +22,7 @@ from prompt_toolkit.layout.containers import (
 )
 from prompt_toolkit.layout.dimension import Dimension
 
-from euporie.console.tabs.console import ConsoleTab
+from euporie.console.tabs.console import Console
 from euporie.core import __logo__
 from euporie.core.app import BaseApp
 from euporie.core.commands import add_cmd
@@ -82,7 +82,7 @@ class ConsoleApp(BaseApp):
         self.search_bar = SearchBar()
         self.bindings_to_load += ["euporie.console.app.ConsoleApp"]
 
-        self.tabs = [ConsoleTab(self)]
+        self.tabs = []
         self.pager = Pager()
 
         self.config.get_item("mouse_support").event += lambda x: setattr(
@@ -99,6 +99,8 @@ class ConsoleApp(BaseApp):
 
     def load_container(self) -> FloatContainer:
         """Return a container with all opened tabs."""
+        self.tabs = [Console(self)]
+
         assert self.pager is not None
         assert self.search_bar is not None
         assert self.tab is not None
@@ -166,7 +168,7 @@ class ConsoleApp(BaseApp):
         app = get_app()
         nb_app = NotebookApp()
         for tab in app.tabs:
-            if isinstance(tab, ConsoleTab):
+            if isinstance(tab, Console):
                 nb = Notebook(
                     app=nb_app,
                     path=tab.path,
@@ -195,7 +197,7 @@ class ConsoleApp(BaseApp):
         app = get_app()
         tab = app.tab
         app.renderer.clear()
-        if isinstance(tab, ConsoleTab):
+        if isinstance(tab, Console):
             tab.reset()
             app.layout.focus(tab.input_box)
 

euporie/console/tabs/console.py

@@ -28,6 +28,7 @@ from prompt_toolkit.layout.containers import (
 )
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.layout import Layout
+from upath import UPath
 
 from euporie.core.commands import add_cmd, get_cmd
 from euporie.core.config import add_setting
@@ -52,6 +53,7 @@ from euporie.core.widgets.page import PrintingContainer
 from euporie.core.widgets.pager import PagerState
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import Any, Callable, Sequence
 
     from prompt_toolkit.application.application import Application
@@ -59,32 +61,35 @@ if TYPE_CHECKING:
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
     from prompt_toolkit.layout.containers import Float
-    from upath import UPath
 
     from euporie.core.app import BaseApp
 
 log = logging.getLogger(__name__)
 
 
-class ConsoleTab(KernelTab):
+class Console(KernelTab):
     """Interactive console.
 
     An interactive console which connects to a Jupyter kernel.
 
     """
 
+    bg_init = False
+
     def __init__(
         self,
         app: BaseApp,
-        path: UPath | None = None,
+        path: Path | None = None,
         use_kernel_history: bool = True,
+        connection_file: str = "",
     ) -> None:
-        """Create a new :py:class:`ConsoleTab` tab instance.
+        """Create a new :py:class:`Console` tab instance.
 
         Args:
             app: The euporie application the console tab belongs to
             path: A file path to open (not used currently)
             use_kernel_history: If :const:`True`, history will be loaded from the kernel
+            connection_file: The connection file of an existing kernel
         """
         # Kernel setup
         self._metadata = {}
@@ -105,7 +110,12 @@ class ConsoleTab(KernelTab):
         )
         self.kernel_tab = self
 
-        super().__init__(app=app, path=path, use_kernel_history=use_kernel_history)
+        super().__init__(
+            app=app,
+            path=path,
+            use_kernel_history=use_kernel_history,
+            connection_file=app.config.connection_file,
+        )
 
         self.lang_info: dict[str, Any] = {}
         self.execution_count = 0
@@ -477,7 +487,7 @@ class ConsoleTab(KernelTab):
         """Request the output is refreshed (does nothing)."""
         pass
 
-    def statusbar_fields(
+    def __pt_status__(
         self,
     ) -> tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]:
         """Generate the formatted text for the statusbar."""
@@ -534,7 +544,7 @@ class ConsoleTab(KernelTab):
             callback=_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:
         """Save the console as a notebook."""
         from euporie.core.tabs.notebook import BaseNotebook
 
@@ -573,7 +583,7 @@ class ConsoleTab(KernelTab):
         from euporie.console.app import get_app
 
         console = get_app().tab
-        assert isinstance(console, ConsoleTab)
+        assert isinstance(console, Console)
         console.run()
 
     @staticmethod
@@ -585,7 +595,7 @@ class ConsoleTab(KernelTab):
         from euporie.console.app import get_app
 
         console = get_app().tab
-        assert isinstance(console, ConsoleTab)
+        assert isinstance(console, Console)
         console.inspect()
 
     @staticmethod
@@ -644,6 +654,21 @@ class ConsoleTab(KernelTab):
         """,
     )
 
+    add_setting(
+        name="connection_file",
+        flags=["--connection-file", "--kernel-connection-file"],
+        type_=UPath,
+        help_="Attempt to connect to an existing kernel using a JSON connection info file",
+        default=None,
+        description="""
+            If the file does not exist, kernel connection information will be written
+            to the file path provided.
+
+            If the file exists, kernel connection info will be read from the file,
+            allowing euporie to connect to existing kernels.
+        """,
+    )
+
     # ################################# Key Bindings ##################################
 
     register_bindings(

euporie/core/__init__.py

@@ -1,10 +1,15 @@
 """This package defines the euporie application and its components."""
 
 __app_name__ = "euporie"
-__version__ = "2.3.2"
+__version__ = "2.4.1"
 __logo__ = "⚈"
 __strapline__ = "Jupyter in the terminal"
 __author__ = "Josiah Outram Halstead"
 __email__ = "josiah@halstead.email"
 __copyright__ = f"© 2022, {__author__}"
 __license__ = "MIT"
+
+
+# Register extensions to external packages
+from euporie.core import path  # noqa F401
+from euporie.core import pygments  # noqa F401

euporie/core/__main__.py

@@ -5,7 +5,7 @@ def main(name: "str" = "launch") -> "None":
     """Load and launches the application."""
     from importlib.metadata import entry_points
 
-    for entry in entry_points()["euporie.apps"]:
+    for entry in entry_points().get("euporie.apps", []):
         if entry.name == name:
             return entry.load().launch()
     else:

euporie/core/app.py

@@ -5,7 +5,10 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import signal
+import sys
 from functools import partial
+from pathlib import PurePath
 from typing import TYPE_CHECKING, cast
 from weakref import WeakSet
 
@@ -17,7 +20,6 @@ from prompt_toolkit.cursor_shapes import CursorShape, CursorShapeConfig
 from prompt_toolkit.data_structures import Point
 from prompt_toolkit.enums import EditingMode
 from prompt_toolkit.filters import Condition, buffer_has_focus, to_filter
-from prompt_toolkit.formatted_text import to_formatted_text
 from prompt_toolkit.input.defaults import create_input
 from prompt_toolkit.key_binding.bindings.basic import load_basic_bindings
 from prompt_toolkit.key_binding.bindings.cpr import load_cpr_bindings
@@ -39,7 +41,6 @@ from prompt_toolkit.key_binding.key_bindings import (
 )
 from prompt_toolkit.layout.containers import Float, FloatContainer, Window, to_container
 from prompt_toolkit.layout.layout import Layout
-from prompt_toolkit.layout.menus import CompletionsMenu
 from prompt_toolkit.output import ColorDepth
 from prompt_toolkit.output.defaults import create_output
 from prompt_toolkit.output.vt100 import Vt100_Output as PtkVt100_Output
@@ -61,6 +62,7 @@ from upath import UPath
 
 from euporie.core.commands import add_cmd
 from euporie.core.config import Config, add_setting
+from euporie.core.convert.core import get_mime
 from euporie.core.current import get_app
 from euporie.core.filters import in_tmux, insert_mode, replace_mode, tab_has_focus
 from euporie.core.io import Vt100_Output, Vt100Parser
@@ -71,7 +73,8 @@ from euporie.core.key_binding.registry import (
     register_bindings,
 )
 from euporie.core.key_binding.vi_state import ViState
-from euporie.core.log import default_logs, setup_logs
+from euporie.core.log import setup_logs
+from euporie.core.path import parse_path
 from euporie.core.renderer import Renderer
 from euporie.core.style import (
     DEFAULT_COLORS,
@@ -83,19 +86,20 @@ from euporie.core.style import (
     build_style,
 )
 from euporie.core.terminal import TerminalInfo
-from euporie.core.utils import ChainedList, parse_path
+from euporie.core.utils import ChainedList
 from euporie.core.widgets.decor import Shadow
+from euporie.core.widgets.menu import CompletionsMenu
 
 if TYPE_CHECKING:
     from asyncio import AbstractEventLoop
-    from typing import Any, Callable, Literal, Sequence
+    from pathlib import Path
+    from types import FrameType
+    from typing import Any, Callable
 
     from prompt_toolkit.clipboard import Clipboard
     from prompt_toolkit.contrib.ssh import PromptToolkitSSHSession
     from prompt_toolkit.filters import Filter, FilterOrBool
-    from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
     from prompt_toolkit.input import Input
-    from prompt_toolkit.layout.containers import AnyContainer
     from prompt_toolkit.layout.layout import FocusableElement
     from prompt_toolkit.layout.screen import WritePosition
     from prompt_toolkit.output import Output
@@ -107,12 +111,6 @@ if TYPE_CHECKING:
     from euporie.core.widgets.pager import Pager
     from euporie.core.widgets.search_bar import SearchBar
 
-    StatusBarFields = tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]
-    ContainerStatusDict = dict[
-        AnyContainer,
-        Callable[[], StatusBarFields],
-    ]
-
 log = logging.getLogger(__name__)
 
 
@@ -182,7 +180,6 @@ class BaseApp(Application):
     mouse_position: Point
 
     config = Config()
-    status_default: StatusBarFields = ([], [])
     need_mouse_support: bool = False
     log_stdout_level: str = "CRITICAL"
 
@@ -255,8 +252,6 @@ class BaseApp(Application):
             self.dialogs.values(),
             self.menus.values(),
         )
-        # Mapping of Containers to status field generating functions
-        self.container_statuses: ContainerStatusDict = {}
         # Continue loading when the application has been launched
         # and an event loop has been creeated
         self.pre_run_callables = [self.pre_run]
@@ -345,16 +340,12 @@ class BaseApp(Application):
         # Set the application's style, and update it when the terminal responds
         self.update_style()
         self.term_info.colors.event += self.update_style
+        # Pause rendering while we load the layout
         self.pause_rendering()
         # Load completions menu. This must be done after the app is initialized, because
         # :py:func:`get_app` is needed to access the config
         self.menus["completions"] = Float(
-            content=Shadow(
-                CompletionsMenu(
-                    max_height=16,
-                    scroll_offset=1,
-                )
-            ),
+            content=Shadow(CompletionsMenu()),
             xcursor=True,
             ycursor=True,
         )
@@ -389,10 +380,7 @@ class BaseApp(Application):
             async def await_terminal_feedback() -> None:
                 try:
                     # Send queries to the terminal if supported
-                    if self.input.__class__.__name__ in (
-                        "Vt100Input",
-                        "PosixPipeInput",
-                    ):
+                    if self.input.__class__.__name__ == "Vt100Input":
                         self.term_info.send_all()
                         # Give the terminal a chance to respond
                         await asyncio.sleep(0.1)
@@ -421,6 +409,7 @@ class BaseApp(Application):
 
         """
         input_ = create_input(always_prefer_tty=True)
+
         if stdin := getattr(input_, "stdin", None):
             if not stdin.isatty():
                 from euporie.core.io import IgnoredInput
@@ -515,7 +504,7 @@ class BaseApp(Application):
     def launch(cls) -> None:
         """Launch the app."""
         # Load default logging
-        default_logs()
+        setup_logs()
         # Load the app's configuration
         cls.config.load(cls)
         # Configure the logs
@@ -525,7 +514,40 @@ class BaseApp(Application):
         # Run the application
         with create_app_session(input=cls.load_input(), output=cls.load_output()):
             # Create an instance of the app and run it
-            return cls().run()
+
+            original_sigterm = signal.getsignal(signal.SIGTERM)
+            original_sigint = signal.getsignal(signal.SIGINT)
+
+            app = cls()
+
+            signal.signal(signal.SIGTERM, app.cleanup)
+            signal.signal(signal.SIGINT, app.cleanup)
+
+            result = app.run()
+
+            signal.signal(signal.SIGTERM, original_sigterm)
+            signal.signal(signal.SIGINT, original_sigint)
+
+            return result
+
+    def cleanup(self, signum: int, frame: FrameType | None) -> None:
+        """Restore the state of the terminal on unexpected exit."""
+        log.critical("Unexpected exit signal, restoring terminal")
+        output = self.output
+        self.exit()
+        # Reset terminal state
+        output.quit_alternate_screen()
+        output.disable_mouse_support()
+        output.reset_cursor_key_mode()
+        output.enable_autowrap()
+        output.disable_bracketed_paste()
+        output.clear_title()
+        output.reset_cursor_shape()
+        output.show_cursor()
+        output.reset_attributes()
+        output.flush()
+        # Exit the main thread
+        sys.exit(1)
 
     @classmethod
     async def interact(cls, ssh_session: PromptToolkitSSHSession) -> None:
@@ -544,27 +566,52 @@ class BaseApp(Application):
             floats=cast("list[Float]", self.floats),
         )
 
-    def get_file_tab(self, path: UPath) -> type[Tab] | None:
+    def get_file_tabs(self, path: Path) -> list[type[Tab]]:
+        """Return the tab to use for a file path."""
+        from euporie.core.tabs.base import Tab
+
+        path_mime = get_mime(path) or "text/plain"
+        log.debug("File %s has mime type: %s", path, path_mime)
+
+        tab_options = set()
+        for tab_cls in Tab._registry:
+            for mime_type in tab_cls.mime_types:
+                if PurePath(path_mime).match(mime_type):
+                    tab_options.add(tab_cls)
+            if path.suffix in tab_cls.file_extensions:
+                tab_options.add(tab_cls)
+
+        return sorted(tab_options, key=lambda x: x.weight, reverse=True)
+
+    def get_file_tab(self, path: Path) -> type[Tab] | None:
         """Return the tab to use for a file path."""
+        if tabs := self.get_file_tabs(path):
+            return tabs[0]
         return None
 
-    def open_file(self, path: UPath, read_only: bool = False) -> None:
+    def open_file(
+        self, path: Path, read_only: bool = False, tab_class: type[Tab] | None = None
+    ) -> None:
         """Create a tab for a file.
 
         Args:
             path: The file path of the notebook file to open
             read_only: If true, the file should be opened read_only
+            tab_class: The tab type to use to open the file
 
         """
         ppath = parse_path(path)
         log.info(f"Opening file {path}")
         for tab in self.tabs:
-            if ppath == getattr(tab, "path", ""):
+            if ppath == getattr(tab, "path", "") and (
+                tab_class is None or isinstance(tab, tab_class)
+            ):
                 log.info(f"File {path} already open, activating")
                 self.layout.focus(tab)
                 break
         else:
-            tab_class = self.get_file_tab(path)
+            if tab_class is None:
+                tab_class = self.get_file_tab(path)
             if tab_class is None:
                 log.error("Unable to display file %s", path)
             else:
@@ -757,44 +804,6 @@ class BaseApp(Application):
         """Block default style loading."""
         return DummyStyle()
 
-    def format_status(self, part: Literal["left", "right"]) -> StyleAndTextTuples:
-        """Format the fields in the statusbar generated by the current tab.
-
-        Args:
-            part: ``'left'`` to return the fields on the left side of the statusbar,
-                and ``'right'`` to return the fields on the right
-
-        Returns:
-            A list of style and text tuples for display in the statusbar
-
-        """
-        entries: StatusBarFields = ([], [])
-        for container, status_func in self.container_statuses.items():
-            if self.layout.has_focus(container):
-                entries = status_func()
-                break
-        else:
-            if not self.tabs:
-                entries = self.status_default
-
-        output: StyleAndTextTuples = []
-        # Show the tab's status fields
-        for field in entries[0 if part == "left" else 1]:
-            if field:
-                if isinstance(field, tuple):
-                    ft = [field]
-                else:
-                    ft = to_formatted_text(field, style="class:status.field")
-                output += [
-                    ("class:status.field", " "),
-                    *ft,
-                    ("class:status.field", " "),
-                    ("class:status", " "),
-                ]
-        if output:
-            output.pop()
-        return output
-
     def draw(self, render_as_done: bool = True) -> None:
         """Draw the app without focus, leaving the cursor below the drawn output."""
         # Hide ephemeral containers
@@ -908,45 +917,6 @@ class BaseApp(Application):
         """,
     )
 
-    add_setting(
-        name="log_file",
-        flags=["--log-file"],
-        nargs="?",
-        default="",
-        type_=str,
-        title="the log file path",
-        help_="File path for logs",
-        description="""
-            When set to a file path, the log output will be written to the given path.
-            If no value is given output will be sent to the standard output.
-        """,
-    )
-
-    add_setting(
-        name="log_level",
-        flags=["--log-level"],
-        type_=str,
-        default="",
-        title="the log level",
-        help_="Set the log level",
-        choices=["debug", "info", "warning", "error", "critical"],
-        description="""
-            When set, logging events at the given level are emitted.
-        """,
-    )
-
-    add_setting(
-        name="log_config",
-        flags=["--log-config"],
-        type_=str,
-        default=None,
-        title="additional logging configuration",
-        help_="Additional logging configuration",
-        description="""
-            A JSON string specifying additional logging configuration.
-        """,
-    )
-
     add_setting(
         name="edit_mode",
         flags=["--edit-mode"],

euporie/core/border.py

@@ -275,22 +275,21 @@ ThickQuadrupleDashedLine = LineStyle("QuadDashed", (3, 1), parent=ThickLine)
 ThickTripleDashedLine = LineStyle("TripleDashed", (3, 2), parent=ThickLine)
 ThickDoubleDashedLine = LineStyle("DoubleDashed", (3, 3), parent=ThickLine)
 
-#  ▂▂▂▂▂▂▂▂▂▂▂▂
-# 🮇Quarter Line▎
-#  🮂🮂🮂🮂🮂🮂🮂🮂🮂🮂🮂🮂
+UpperRightQuarterLine = LineStyle("UpperRightQuarterLine", (4, 2), parent=ThickLine)
+LowerLeftQuarterLine = LineStyle("LowerLeftQuarterLine", (4, 2), parent=ThickLine)
 
-UpperRightHalfLine = LineStyle("UpperRightHalfLine", (4, 2), parent=ThickLine)
-LowerLeftHalfLine = LineStyle("LowerLeftHalfLine", (4, 2), parent=ThickLine)
+UpperRightHalfLine = LineStyle("UpperRightHalfLine", (5, 2), parent=ThickLine)
+LowerLeftHalfLine = LineStyle("LowerLeftHalfLine", (5, 2), parent=ThickLine)
 UpperRightHalfDottedLine = LineStyle(
-    "UpperRightHalfDottedLine", (4, 1), parent=UpperRightHalfLine
+    "UpperRightHalfDottedLine", (5, 1), parent=UpperRightHalfLine
 )
 LowerLeftHalfDottedLine = LineStyle(
-    "LowerLeftHalfDottedLine", (4, 2), parent=LowerLeftHalfLine
+    "LowerLeftHalfDottedLine", (5, 2), parent=LowerLeftHalfLine
 )
 
 
-FullLine = LineStyle("FullLine", (5, 2), parent=ThickLine)
-FullDottedLine = LineStyle("FullDottedLine", (5, 1), parent=ThickLine)
+FullLine = LineStyle("FullLine", (6, 2), parent=ThickLine)
+FullDottedLine = LineStyle("FullDottedLine", (6, 1), parent=ThickLine)
 
 
 class GridChar(NamedTuple):
@@ -502,6 +501,37 @@ _GRID_CHARS = {
     GridChar(ThinLine,              UpperRightEighthLine,   NoLine,                 UpperRightEighthLine): "▔",
     GridChar(NoLine,                NoLine,                 UpperRightEighthLine,   LowerLeftEighthLine ): "▁",
     GridChar(LowerLeftEighthLine,   UpperRightEighthLine,   NoLine,                 NoLine              ): "▔",
+
+    # UpperRightQuarterLine
+    GridChar(UpperRightQuarterLine, NoLine, UpperRightQuarterLine, NoLine): "🮇",
+    GridChar(NoLine, UpperRightQuarterLine, NoLine, UpperRightQuarterLine): "🮂",
+    GridChar(NoLine, UpperRightQuarterLine, UpperRightQuarterLine, NoLine): "🮇",
+    GridChar(UpperRightQuarterLine, NoLine, NoLine, UpperRightQuarterLine): "🮂",
+    GridChar(UpperRightQuarterLine, UpperRightQuarterLine, UpperRightQuarterLine, NoLine): "🮇",
+    GridChar(UpperRightQuarterLine, UpperRightQuarterLine, NoLine, UpperRightQuarterLine): "🮂",
+    # Corners
+    GridChar(NoLine, LowerLeftEighthLine, UpperRightQuarterLine, NoLine): " ",
+    GridChar(NoLine, NoLine, LowerLeftQuarterLine, LowerLeftEighthLine): " ",
+    GridChar(LowerLeftQuarterLine, NoLine, NoLine, UpperRightEighthLine): " ",
+    GridChar(UpperRightQuarterLine, UpperRightEighthLine, NoLine, NoLine): " ",
+
+    # LowerLeftQuarterLine
+    GridChar(LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine, NoLine): "▎",
+    GridChar(NoLine, LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine): "▂",
+    GridChar(NoLine, LowerLeftQuarterLine, LowerLeftQuarterLine, NoLine): "▂",
+    GridChar(LowerLeftQuarterLine, NoLine, NoLine, LowerLeftQuarterLine): "▎",
+    GridChar(NoLine, LowerLeftQuarterLine, LowerLeftQuarterLine, LowerLeftQuarterLine): "▂",
+    GridChar(LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine, LowerLeftQuarterLine): "▎",
+    # Half/ThinLine combos
+    GridChar(LowerLeftQuarterLine, ThinLine, LowerLeftQuarterLine, NoLine): "▎",
+    GridChar(NoLine, LowerLeftQuarterLine, ThinLine, LowerLeftQuarterLine): "▂",
+    GridChar(LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine, ThinLine): "▎",
+    GridChar(ThinLine, LowerLeftQuarterLine, NoLine, LowerLeftQuarterLine): "▂",
+    GridChar(UpperRightQuarterLine, ThinLine, UpperRightQuarterLine, NoLine): "🮇",
+    GridChar(NoLine, UpperRightQuarterLine, ThinLine, UpperRightQuarterLine): "🮂",
+    GridChar(UpperRightQuarterLine, NoLine, UpperRightQuarterLine, ThinLine): "🮇",
+    GridChar(ThinLine, UpperRightQuarterLine, NoLine, UpperRightQuarterLine): "🮂",
+
     # UpperRightHalfLine
     GridChar(UpperRightHalfLine, NoLine, UpperRightHalfLine, NoLine): "▐",
     GridChar(NoLine, UpperRightHalfLine, NoLine, UpperRightHalfLine): "▀",
@@ -817,15 +847,15 @@ class GridStyle:
 
 ThinGrid = ThinLine.grid
 
-InnerEigthGrid = (
-    LowerLeftEighthLine.top_edge
-    + LowerLeftEighthLine.right_edge
-    + UpperRightEighthLine.left_edge
+InsetGrid = (
+    UpperRightQuarterLine.left_edge
+    + LowerLeftQuarterLine.right_edge
     + UpperRightEighthLine.bottom_edge
+    + LowerLeftEighthLine.top_edge
     + ThinLine.inner
 )
 
-OuterEigthGrid = (
+OutsetGrid = (
     LowerLeftEighthLine.top_edge
     + UpperRightEighthLine.right_edge
     + UpperRightEighthLine.bottom_edge

euporie/core/comm/base.py

@@ -11,7 +11,7 @@ from euporie.core.current import get_app
 from euporie.core.widgets.display import Display
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Sequence
+    from typing import Any, Callable, Mapping, Sequence
 
     from prompt_toolkit.layout.containers import AnyContainer
 
@@ -29,7 +29,7 @@ class CommView:
     def __init__(
         self,
         container: AnyContainer,
-        setters: dict[str, Callable[..., None]] | None = None,
+        setters: Mapping[str, Callable[..., None]] | None = None,
     ) -> None:
         """Create a new instance of the Comm vieew.
 
@@ -39,7 +39,7 @@ class CommView:
                 be called when the named state value changed.
         """
         self.container = container
-        self.setters = setters or {}
+        self.setters: dict[str, Callable[..., None]] = dict(setters or {})
         self.kernel: Kernel | None = None
 
     def update(self, changes: dict[str, Any]) -> None:
@@ -117,4 +117,5 @@ class UnimplementedComm(Comm):
 
     def process_data(self, data: dict, buffers: Sequence[bytes]) -> None:
         """Doe nothing when data is received."""
-        return None
+        self.data = data
+        self.buffers = buffers