euporie 2.6.1__py3-none-any.whl → 2.7.0__py3-none-any.whl

euporie/console/tabs/console.py

@@ -7,7 +7,6 @@ from functools import partial
 from typing import TYPE_CHECKING, cast
 
 import nbformat
-from prompt_toolkit.application.run_in_terminal import in_terminal
 from prompt_toolkit.buffer import Buffer, ValidationState
 from prompt_toolkit.filters.app import (
     buffer_has_focus,
@@ -44,13 +43,13 @@ from euporie.core.key_binding.registry import (
     load_registered_bindings,
     register_bindings,
 )
+from euporie.core.layout.print import PrintingContainer
 from euporie.core.style import KERNEL_STATUS_REPR
 from euporie.core.tabs.base import KernelTab
 from euporie.core.terminal import edit_in_editor
 from euporie.core.validation import KernelValidator
 from euporie.core.widgets.cell_outputs import CellOutputArea
 from euporie.core.widgets.inputs import KernelInput, StdInput
-from euporie.core.widgets.page import PrintingContainer
 from euporie.core.widgets.pager import PagerState
 
 if TYPE_CHECKING:
@@ -177,8 +176,9 @@ class Console(KernelTab):
         """Run the code in the input box."""
         if buffer is None:
             buffer = self.input_box.buffer
+        app = self.app
         # Auto-reformat code
-        if self.app.config.autoformat:
+        if app.config.autoformat:
             self.reformat()
         # Get the code to run
         text = buffer.text
@@ -187,9 +187,12 @@ class Console(KernelTab):
         # Disable existing output
         self.live_output.style = "class:disabled"
         # Re-render the app and move to below the current output
-        self.app.draw()
+        original_layout = app.layout
+        app.layout = self.input_layout
+        app.draw()
+        app.layout = original_layout
         # Prevent displayed graphics on terminal being cleaned up (bit of a hack)
-        self.app.graphics.clear()
+        app.graphics.clear()
         # Run the previous entry
         if self.kernel.status == "starting":
             self.kernel_queue.append(partial(self.kernel.run, text, wait=False))
@@ -201,15 +204,15 @@ class Console(KernelTab):
         buffer.reset(append_to_history=True)
         # Remove any live outputs and disable mouse support
         self.live_output.reset()
-        if self.app.config.mouse_support is None:
-            self.app.need_mouse_support = False
+        if app.config.mouse_support is None:
+            app.need_mouse_support = False
         # Record the input as a cell in the json
         self.json["cells"].append(
             nbformat.v4.new_code_cell(source=text, execution_count=self.execution_count)
         )
         if (
-            self.app.config.max_stored_outputs
-            and len(self.json["cells"]) > self.app.config.max_stored_outputs
+            app.config.max_stored_outputs
+            and len(self.json["cells"]) > app.config.max_stored_outputs
         ):
             del self.json["cells"][0]
 
@@ -241,14 +244,12 @@ class Console(KernelTab):
     def render_outputs(self, app: Application[Any]) -> None:
         """Request that any unrendered outputs be rendered."""
         if self.output.json:
-            self.app.create_background_task(self.async_render_outputs())
-
-    async def async_render_outputs(self) -> None:
-        """Render any unrendered outputs above the application."""
-        if self.output.json:
-            # Run the output app in the terminal
-            async with in_terminal():
-                self.app.renderer.render(self.app, self.output_layout, is_done=True)
+            app = self.app
+            original_layout = self.app.layout
+            app.layout = self.output_layout
+            app.renderer.render(self.app, self.output_layout, is_done=True)
+            app.renderer.request_absolute_cursor_position()
+            app.layout = original_layout
             # Remove the outputs so they do not get rendered again
             self.output.reset()
 
@@ -410,9 +411,13 @@ class Console(KernelTab):
             height=1,
         )
 
+        def _handler(buffer: Buffer) -> bool:
+            self.run(buffer)
+            return True
+
         self.input_box = KernelInput(
             kernel_tab=self,
-            accept_handler=self.run,
+            accept_handler=_handler,
             on_cursor_position_changed=on_cursor_position_changed,
             validator=KernelValidator(self.kernel),
             # validate_while_typing=False,
@@ -424,8 +429,34 @@ class Console(KernelTab):
         self.app.focused_element = self.input_box.buffer
 
         self.stdin_box = StdInput(self)
+        input_row = [
+            # Spacing
+            ConditionalContainer(
+                Window(height=1, dont_extend_height=True),
+                filter=Condition(lambda: self.execution_count > 0)
+                & (
+                    (
+                        renderer_height_is_known
+                        & Condition(lambda: self.app.renderer.rows_above_layout > 0)
+                    )
+                    | ~renderer_height_is_known
+                ),
+            ),
+            # Input
+            ConditionalContainer(
+                VSplit(
+                    [
+                        input_prompt,
+                        self.input_box,
+                    ],
+                ),
+                filter=~self.stdin_box.visible,
+            ),
+        ]
+
+        self.input_layout = Layout(PrintingContainer(input_row))
 
-        self.input_layout = HSplit(
+        return HSplit(
             [
                 ConditionalContainer(
                     HSplit(
@@ -442,36 +473,13 @@ class Console(KernelTab):
                     Window(height=1, dont_extend_height=True),
                     filter=self.stdin_box.visible,
                 ),
-                # Spacing
-                ConditionalContainer(
-                    Window(height=1, dont_extend_height=True),
-                    filter=Condition(lambda: self.execution_count > 0)
-                    & (
-                        (
-                            renderer_height_is_known
-                            & Condition(lambda: self.app.renderer.rows_above_layout > 0)
-                        )
-                        | ~renderer_height_is_known
-                    ),
-                ),
-                # Input
-                ConditionalContainer(
-                    VSplit(
-                        [
-                            input_prompt,
-                            self.input_box,
-                        ],
-                    ),
-                    filter=~self.stdin_box.visible,
-                ),
+                *input_row,
             ],
             key_bindings=load_registered_bindings(
                 "euporie.console.tabs.console.Console"
             ),
         )
 
-        return self.input_layout
-
     def set_next_input(self, text: str, replace: bool = False) -> None:
         """Set the text for the next prompt."""
         self.input_box.buffer.text = text

euporie/core/__init__.py

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

euporie/core/app.py

@@ -39,7 +39,7 @@ from prompt_toolkit.key_binding.key_bindings import (
     ConditionalKeyBindings,
     merge_key_bindings,
 )
-from prompt_toolkit.layout.containers import Float, FloatContainer, Window, to_container
+from prompt_toolkit.layout.containers import Float, FloatContainer, to_container
 from prompt_toolkit.layout.layout import Layout
 from prompt_toolkit.output import ColorDepth
 from prompt_toolkit.output.defaults import create_output
@@ -64,7 +64,7 @@ from euporie.core.commands import add_cmd
 from euporie.core.config import Config, add_setting
 from euporie.core.convert.mime 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.filters import in_mplex, insert_mode, replace_mode, tab_has_focus
 from euporie.core.io import Vt100_Output, Vt100Parser
 from euporie.core.key_binding.key_processor import KeyProcessor
 from euporie.core.key_binding.micro_state import MicroState
@@ -73,6 +73,7 @@ from euporie.core.key_binding.registry import (
     register_bindings,
 )
 from euporie.core.key_binding.vi_state import ViState
+from euporie.core.layout.containers import Window
 from euporie.core.log import setup_logs
 from euporie.core.path import parse_path
 from euporie.core.renderer import Renderer
@@ -194,6 +195,7 @@ class BaseApp(Application):
         leave_graphics: FilterOrBool = True,
         extend_renderer_height: FilterOrBool = False,
         extend_renderer_width: FilterOrBool = False,
+        enable_page_navigation_bindings: FilterOrBool | None = True,
         **kwargs: Any,
     ) -> None:
         """Instantiate euporie specific application variables.
@@ -210,6 +212,8 @@ class BaseApp(Application):
                 beyond the height of the display
             extend_renderer_width: Whether the renderer width should be extended
                 beyond the height of the display
+            enable_page_navigation_bindings: Determines if page navigation keybindings
+                should be loaded
             kwargs: The key-word arguments for the :py:class:`Application`
 
         """
@@ -220,6 +224,7 @@ class BaseApp(Application):
                 "editing_mode": self.get_edit_mode(),
                 "mouse_support": Condition(lambda: self.need_mouse_support),
                 "cursor": CursorConfig(),
+                "enable_page_navigation_bindings": enable_page_navigation_bindings,
                 **kwargs,
             }
         )
@@ -270,6 +275,12 @@ class BaseApp(Application):
             "euporie.core.app.BaseApp",
             "euporie.core.terminal.TerminalInfo",
         ]
+
+        from euporie.core.key_binding.bindings.page_navigation import (
+            load_page_navigation_bindings,
+        )
+
+        self._page_navigation_bindings = load_page_navigation_bindings(self.config)
         # Determines which clipboard mechanism to use
         self.clipboard: Clipboard = EuporieClipboard(self)
         # Allow hiding element when manually redrawing app
@@ -365,10 +376,8 @@ class BaseApp(Application):
         with set_app(self):
             # Load key bindings
             self.load_key_bindings()
-
             # Send queries to the terminal
             self.term_info.send_all()
-
             # Read responses
             kp = self.key_processor
 
@@ -376,9 +385,9 @@ class BaseApp(Application):
                 kp.feed_multiple(self.input.read_keys())
 
             with self.input.raw_mode(), self.input.attach(read_from_input):
-                # Wait up to half a second for the terminal to respond to queries
-                await asyncio.sleep(0.5)
-
+                # Give the terminal time to respond and allow the event loop to read
+                # the terminal responses from the input
+                await asyncio.sleep(0.1)
             kp.process_keys()
 
         return await super().run_async(
@@ -495,12 +504,10 @@ class BaseApp(Application):
         setup_logs()
         # Load the app's configuration
         cls.config.load(cls)
-        # Configure the logs
-        setup_logs(cls.config)
-        # Warn about unrecognised configuration items
-        cls.config.warn()
         # Run the application
-        with create_app_session(input=cls.load_input(), output=cls.load_output()):
+        with create_app_session(
+            input=cls.load_input(), output=(output := cls.load_output())
+        ):
             # Create an instance of the app and run it
 
             original_sigterm = signal.getsignal(signal.SIGTERM)
@@ -516,7 +523,10 @@ class BaseApp(Application):
             signal.signal(signal.SIGTERM, original_sigterm)
             signal.signal(signal.SIGINT, original_sigint)
 
-            return result
+        # This seems to be needed for kitty
+        output.enable_autowrap()
+
+        return result
 
     def cleanup(self, signum: int, frame: FrameType | None) -> None:
         """Restore the state of the terminal on unexpected exit."""
@@ -524,13 +534,9 @@ class BaseApp(Application):
         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()
         self.renderer.reset()
@@ -738,6 +744,16 @@ class BaseApp(Application):
                 "default" if name in ("fg", "bg") else name,
             )
         # Add accent color
+        # self.color_palette.add_color(
+        #     "hl",
+        #     (bg := self.color_palette.bg)
+        #     .adjust(
+        #         hue=(bg.hue + (bg.hue - 0.036)) % 1,
+        #         saturation=(0.88 - bg.saturation),
+        #         brightness=0.4255 - bg.brightness,
+        #     )
+        #     .base_hex,
+        # )
         self.color_palette.add_color(
             "hl", base_colors.get(self.config.accent_color, self.config.accent_color)
         )
@@ -778,6 +794,8 @@ class BaseApp(Application):
     ) -> None:
         """Update the application's style when the syntax theme is changed."""
         self.renderer.style = self.create_merged_style()
+        # Trigger a re-draw
+        self.invalidate()
 
     def refresh(self) -> None:
         """Reet all tabs."""
@@ -933,11 +951,11 @@ class BaseApp(Application):
     add_setting(
         name="terminal_polling_interval",
         flags=["--terminal-polling-interval"],
-        type_=int,
+        type_=float,
         help_="Time between terminal colour queries",
-        default=0,
+        default=0.0,
         schema={
-            "min": 0,
+            "min": 0.0,
         },
         description="""
             Determine how frequently the terminal should be polled for changes to the
@@ -957,35 +975,27 @@ class BaseApp(Application):
     )
 
     add_setting(
-        name="format_black",
-        flags=["--format-black"],
-        type_=bool,
-        help_="Use black when re-formatting code cells",
-        default=True,
-        description="""
-            Whether to use :py:mod:`black` when reformatting code cells.
-        """,
-    )
-
-    add_setting(
-        name="format_isort",
-        flags=["--format-isort"],
-        type_=bool,
-        help_="Use isort when re-formatting code cells",
-        default=True,
-        description="""
-            Whether to use :py:mod:`isort` when reformatting code cells.
-        """,
-    )
-
-    add_setting(
-        name="format_ssort",
-        flags=["--format-ssort"],
-        type_=bool,
-        help_="Use ssort when re-formatting code cells",
-        default=True,
+        name="formatters",
+        flags=["--formatters"],
+        type_=str,
+        choices=["ruff", "black", "isort", "ssort"],
+        help_="List formatters to use when re-formatting code cells",
+        default=["ruff"],
+        action="append",
+        schema={
+            "type": "array",
+            "items": {
+                "description": "Formatters",
+                "type": "string",
+            },
+        },
         description="""
-            Whether to use :py:mod:`ssort` when reformatting code cells.
+            A list of the names of the formatters to use when reformatting code cells.
+            Supported formatters include:
+            - :py:mod:`ruff`
+            - :py:mod:`black`
+            - :py:mod:`isort`
+            - :py:mod:`ssort`
         """,
     )
 
@@ -1020,24 +1030,31 @@ class BaseApp(Application):
     )
 
     add_setting(
-        name="tmux_graphics",
-        flags=["--tmux-graphics"],
+        name="multiplexer_passthrough",
+        flags=["--multiplexer-passthrough"],
         type_=bool,
-        help_="Enable terminal graphics in tmux (experimental)",
+        help_="Use passthrough from within terminal multiplexers",
         default=False,
-        hidden=~in_tmux,
+        hidden=~in_mplex,
         description="""
-            If set, terminal graphics will be used if :program:`tmux` is running by
-            performing terminal escape sequence pass-through. You must restart euporie
-            for this to take effect.
+            If set and euporie is running inside a terminal multiplexer
+            (:program:`screen` or :program:`tmux`), then certain escape sequences
+            will be passed-through the multiplexer directly to the terminal.
 
-            You will also need to ensure that ``allow-passthrough`` is set to ``on`` in
-            your :program:`tmux` configuration.
+            This affects things such as terminal color detection and graphics display.
+
+            for tmux, you will also need to ensure that ``allow-passthrough`` is set to
+            ``on`` in your :program:`tmux` configuration.
 
             .. warning::
 
                Terminal graphics in :program:`tmux` is experimental, and is not
                guaranteed to work. Use at your own risk!
+
+            .. note::
+               As of version :command:`tmux` version ``3.4`` sixel graphics are
+               supported, which may result in better terminal graphics then using
+               multiplexer passthrough.
         """,
     )
 

euporie/core/comm/ipywidgets.py

@@ -16,14 +16,13 @@ from typing import TYPE_CHECKING
 from prompt_toolkit.filters.base import Condition
 from prompt_toolkit.layout.containers import HSplit, VSplit
 from prompt_toolkit.layout.processors import BeforeInput
-from prompt_toolkit.widgets.base import Box
 
 from euporie.core.comm.base import Comm, CommView
 from euporie.core.convert.datum import Datum
 from euporie.core.data_structures import DiBool
 from euporie.core.kernel import MsgCallbacks
+from euporie.core.layout.decor import FocusedStyle
 from euporie.core.widgets.cell_outputs import CellOutputArea
-from euporie.core.widgets.decor import FocusedStyle
 from euporie.core.widgets.display import Display
 from euporie.core.widgets.forms import (
     Button,
@@ -39,7 +38,12 @@ from euporie.core.widgets.forms import (
     ToggleButton,
     ToggleButtons,
 )
-from euporie.core.widgets.layout import AccordionSplit, ReferencedSplit, TabbedSplit
+from euporie.core.widgets.layout import (
+    AccordionSplit,
+    Box,
+    ReferencedSplit,
+    TabbedSplit,
+)
 
 if TYPE_CHECKING:
     from typing import Any, Iterable, MutableSequence, Sequence

euporie/core/config.py

@@ -45,7 +45,7 @@ _SCHEMA_TYPES: dict[type | Callable, str] = {
     bool: "boolean",
     str: "string",
     int: "integer",
-    float: "float",
+    float: "number",
     UPath: "string",
 }
 
@@ -212,17 +212,40 @@ class Setting:
                 filter=self.cmd_filter,
             )(self.toggle)
 
-        for choice in (self.choices or self.schema.get("enum", [])) or []:
-            add_cmd(
-                name=f"set-{name}-{choice}",
-                hidden=self.hidden,
-                toggled=Condition(partial(lambda x: self.value == x, choice)),
-                title=f"Set {self.title} to {choice}",
-                menu_title=str(choice).replace("_", " ").capitalize(),
-                description=f'Set the value of the "{self.name}" '
-                f'configuration option to "{choice}"',
-                filter=self.cmd_filter,
-            )(partial(setattr, self, "value", choice))
+        schema = self.schema
+        if schema.get("type") == "array":
+            for choice in self.choices or schema.get("items", {}).get("enum") or []:
+                add_cmd(
+                    name=f"toggle-{name}-{choice}",
+                    hidden=self.hidden,
+                    toggled=Condition(partial(lambda x: x in self.value, choice)),
+                    title=f"Toggle {choice} into {self.title}",
+                    menu_title=str(choice).replace("_", " ").capitalize(),
+                    description=f'Add or remove "{choice}" to or from the list of "{self.name}"',
+                    filter=self.cmd_filter,
+                )(
+                    partial(
+                        lambda choice: (
+                            self.value.remove
+                            if choice in self.value
+                            else self.value.append
+                        )(choice),
+                        choice,
+                    )
+                )
+
+        else:
+            for choice in self.choices or schema.get("enum", []) or []:
+                add_cmd(
+                    name=f"set-{name}-{choice}",
+                    hidden=self.hidden,
+                    toggled=Condition(partial(lambda x: self.value == x, choice)),
+                    title=f"Set {self.title} to {choice}",
+                    menu_title=str(choice).replace("_", " ").capitalize(),
+                    description=f'Set the value of the "{self.name}" '
+                    f'configuration option to "{choice}"',
+                    filter=self.cmd_filter,
+                )(partial(setattr, self, "value", choice))
 
     def toggle(self) -> None:
         """Toggle the setting's value."""
@@ -256,12 +279,17 @@ class Setting:
     @property
     def schema(self) -> dict[str, Any]:
         """Return a json schema property for the config item."""
-        return {
+        schema = {
             "description": self.help,
-            **({"enum": self.choices} if self.choices is not None else {}),
             **({"default": self.default} if self.default is not None else {}),
             **self._schema,
         }
+        if self.choices:
+            if self.nargs == "*" or "items" in schema:
+                schema["items"]["enum"] = self.choices
+            else:
+                schema["enum"] = self.choices
+        return schema
 
     @property
     def menu(self) -> MenuItem:
@@ -378,19 +406,14 @@ class Config:
 
         # Save a list of unknown configuration options so we can warn about them once
         # the logs are configured
-        self.unrecognised = [
-            (map_name, option_name)
-            for map_name, map_values in config_maps.items()
-            for option_name in map_values.keys() - Config.settings.keys()
-            if not isinstance(set_values[option_name], dict)
-        ]
-
-    def warn(self) -> None:
-        """Warn about unrecognised configuration items."""
-        for map_name, option_name in self.unrecognised:
-            log.warning(
-                "Configuration option '%s' not recognised in %s", option_name, map_name
-            )
+        for map_name, map_values in config_maps.items():
+            for option_name in map_values.keys() - Config.settings.keys():
+                if not isinstance(set_values[option_name], dict):
+                    log.warning(
+                        "Configuration option '%s' not recognised in %s",
+                        option_name,
+                        map_name,
+                    )
 
     @property
     def schema(self) -> dict[str, Any]:
@@ -432,6 +455,7 @@ class Config:
                     fastjsonschema.validate(self.schema, json_data)
                 except fastjsonschema.JsonSchemaValueException as error:
                     log.warning("Error in command line parameter `%s`: %s", name, error)
+                    log.warning("%s: %s", name, value)
                 else:
                     result[name] = value
         return result

euporie/core/convert/__init__.py

@@ -12,6 +12,7 @@ from euporie.core.convert.formats import (
     png,
     rich,
     sixel,
+    svg,
 )
 
 __all__ = [
@@ -26,4 +27,5 @@ __all__ = [
     "png",
     "rich",
     "sixel",
+    "svg",
 ]