euporie 2.8.3__tar.gz → 2.8.4__tar.gz

{euporie-2.8.3 → euporie-2.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: euporie
-Version: 2.8.3
+Version: 2.8.4
 Summary: Euporie is a suite of terminal applications for interacting with Jupyter kernels
 Project-URL: Documentation, https://euporie.readthedocs.io/en/latest
 Project-URL: Issues, https://github.com/joouha/euporie/issues
@@ -28,16 +28,16 @@ Requires-Dist: fsspec[http]>=2022.12.0
 Requires-Dist: imagesize~=1.3
 Requires-Dist: jupyter-client>=7.1
 Requires-Dist: jupytext>=1.14.0
-Requires-Dist: linkify-it-py~=1.0
-Requires-Dist: markdown-it-py~=2.2.0
-Requires-Dist: mdit-py-plugins~=0.3.0
+Requires-Dist: linkify-it-py~=2.0
+Requires-Dist: markdown-it-py~=3.0
+Requires-Dist: mdit-py-plugins~=0.4.2
 Requires-Dist: nbformat~=5.0
 Requires-Dist: pillow>=9.0
 Requires-Dist: platformdirs~=3.5
 Requires-Dist: prompt-toolkit~=3.0.36
 Requires-Dist: pygments~=2.11
 Requires-Dist: pyperclip~=1.8
-Requires-Dist: sixelcrop~=0.1.6
+Requires-Dist: sixelcrop~=0.1.8
 Requires-Dist: timg~=1.1.6
 Requires-Dist: typing-extensions~=4.5
 Requires-Dist: universal-pathlib~=0.2.1

{euporie-2.8.3 → euporie-2.8.4}/euporie/console/tabs/console.py

@@ -62,7 +62,7 @@ if TYPE_CHECKING:
     from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
     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 prompt_toolkit.layout.containers import Container, Float
 
     from euporie.core.app import BaseApp
     from euporie.core.lsp import LspClient
@@ -103,6 +103,7 @@ class Console(KernelTab):
                 prompt, password
             ),
             set_execution_count=partial(setattr, self, "execution_count"),
+            add_input=self.new_input,
             add_output=self.new_output,
             clear_output=self.clear_output,
             # set_metadata=self.misc_callback,
@@ -132,6 +133,7 @@ class Console(KernelTab):
 
         self.json = nbformat.v4.new_notebook()
         self.json["metadata"] = self._metadata
+        self.render_queue: list[dict[str, Any]] = []
 
         self.container = self.load_container()
 
@@ -192,13 +194,12 @@ class Console(KernelTab):
         completeness_status = self.kernel.is_complete(code, wait=True).get(
             "status", "unknown"
         )
-        if (
+        return not (
             not code.strip()
             or completeness_status == "incomplete"
-            or (completeness_status == "unknown" and code[-2:] != "\n\n")
-        ):
-            return False
-        return True
+            or completeness_status == "unknown"
+            and code[-2:] != "\n\n"
+        )
 
     def run(self, buffer: Buffer | None = None) -> None:
         """Run the code in the input box."""
@@ -208,78 +209,125 @@ class Console(KernelTab):
         # Auto-reformat code
         if app.config.autoformat:
             self.input_box.reformat()
-        # Get the code to run
+        # # Get the code to run
         text = buffer.text
-        # Remove any selections from input
+        # # Remove any selections from input
         buffer.selection_state = None
         # Disable existing output
-        self.live_output.style = "class:disabled"
+        # self.live_output.style = "class:disabled"
         # Reset the diagnostics
         self.reports.clear()
+        # Increment this for display purposes until we get the response from the kernel
+        self.execution_count += 1
         # Move cursor to the start of the input
         buffer.cursor_position = 0
-        # Re-render the app and move to below the current output
-        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)
-        app.graphics.clear()
+        # Render input
+        self.new_input({"code": text}, own=True, force=True)
         # Run the previous entry
         if self.kernel.status == "starting":
             self.kernel_queue.append(partial(self.kernel.run, text, wait=False))
         else:
             self.kernel.run(text, wait=False)
-        # Increment this for display purposes until we get the response from the kernel
-        self.execution_count += 1
         # Reset the input & output
         buffer.reset(append_to_history=True)
-        # Remove any live outputs and disable mouse support
-        self.live_output.reset()
+        self.on_advance()
+
+    def new_input(
+        self, input_json: dict[str, Any], own: bool, force: bool = False
+    ) -> None:
+        """Create new cell inputs in response to kernel ``execute_input`` messages."""
+        # Skip our own inputs when relayed from the kernel
+        # We render them immediately when they are run to avoid delays in the UI
+        if own and not force:
+            return
+
+        app = self.app
+        if not own and not app.config.show_remote_inputs:
+            return
+
+        self.flush_live_output()
+
         # 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)
+        cell_json = nbformat.v4.new_code_cell(
+            source=input_json["code"],
+            execution_count=input_json.get("execution_count", self.execution_count),
         )
+        self.render_queue.append(cell_json)
+        self.json["cells"].append(cell_json)
         if (
             app.config.max_stored_outputs
             and len(self.json["cells"]) > app.config.max_stored_outputs
         ):
             del self.json["cells"][0]
-        self.on_advance()
 
-    def new_output(self, output_json: dict[str, Any]) -> None:
+        # Invalidate the app so the new input gets printed
+        app.invalidate()
+
+    def new_output(self, output_json: dict[str, Any], own: bool) -> None:
         """Print the previous output and replace it with the new one."""
+        if not own and not self.app.config.show_remote_outputs:
+            return
+
         # Clear the output if we were previously asked to
         if self.clear_outputs_on_output:
             self.clear_outputs_on_output = False
             # Clear the screen
             get_cmd("clear-screen").run()
 
-        # Add to record
-        if self.json["cells"]:
-            self.json["cells"][-1]["outputs"].append(output_json)
+        # If there is no cell in the virtual notebook, add an empty cell
+        if not self.json["cells"]:
+            self.json["cells"].append(
+                nbformat.v4.new_code_cell(execution_count=self.execution_count)
+            )
+        cell = self.json.cells[-1]
+
+        # If there is no code cell in the render queue, add a dummy cell with no input
+        if cell not in self.render_queue:
+            # Add to end of previous cell in virtual notebook
+            # cell["outputs"].append(output_json)
+            # Create virtual cell
+            cell = nbformat.v4.new_code_cell(
+                id=cell.id, execution_count=self.execution_count
+            )
+            self.render_queue.append(cell)
 
-        # Set output
+        # Add widgets to the live output
         if "application/vnd.jupyter.widget-view+json" in output_json.get("data", {}):
-            # Use a live output to display widgets
             self.live_output.add_output(output_json)
         else:
-            # Queue the output json
-            self.output.add_output(output_json)
-            # Invalidate the app so the output get printed
-            self.app.invalidate()
+            cell["outputs"].append(output_json)
+
+        # Invalidate the app so the output get printed
+        self.app.invalidate()
+
+    def flush_live_output(self) -> None:
+        """Flush any active live outputs to the terminal."""
+        if self.live_output.json:
+            self.render_queue.append(
+                nbformat.v4.new_code_cell(
+                    execution_count=None,
+                    outputs=self.live_output.json[:],
+                ),
+            )
+            self.live_output.reset()
 
     def render_outputs(self, app: Application[Any]) -> None:
         """Request that any unrendered outputs be rendered."""
-        if self.output.json:
+        # Check for unrendered cells or new output
+
+        # Clear the render queue so it does not get rendered again
+        render_queue = list(self.render_queue)
+        self.render_queue.clear()
+
+        if render_queue:
+            # Render the echo layout with any new cells / outputs
             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()
+            new_layout = self.echo_layout(render_queue)
+            app.layout = new_layout
+            app.renderer.render(app, new_layout, is_done=True)
             app.layout = original_layout
-            # Remove the outputs so they do not get rendered again
-            self.output.reset()
+            app.renderer.request_absolute_cursor_position()
 
     def reset(self) -> None:
         """Reset the state of the tab."""
@@ -293,10 +341,16 @@ class Console(KernelTab):
         self.app.invalidate()
 
     def prompt(
-        self, text: str, offset: int = 0, show_busy: bool = False
+        self,
+        text: str,
+        count: int | None = None,
+        offset: int = 0,
+        show_busy: bool = False,
     ) -> StyleAndTextTuples:
         """Determine what should be displayed in the prompt of the cell."""
-        prompt = str(self.execution_count + offset)
+        if count is None:
+            count = self.execution_count
+        prompt = str(count + offset)
         if show_busy and self.kernel.status in ("busy", "queued"):
             prompt = "*".center(len(prompt))
         ft: StyleAndTextTuples = [
@@ -317,59 +371,140 @@ class Console(KernelTab):
         """Return the file extension for scripts in the notebook's language."""
         return self.lang_info.get("file_extension", ".py")
 
-    def load_container(self) -> HSplit:
-        """Build the main application layout."""
-        # Output area
-
-        self.output = CellOutputArea([], parent=self)
-
-        @Condition
-        def first_output() -> bool:
-            """Check if the current outputs contain the first output."""
-            if self.output.json:
-                for output in self.json["cells"][-1].get("outputs", []):
-                    if output in self.live_output.json:
-                        continue
-                    return output == self.output.json[0]
-            return False
-
-        output_prompt = Window(
-            FormattedTextControl(partial(self.prompt, "Out", show_busy=False)),
-            dont_extend_width=True,
-            style="class:cell,output,prompt",
-            height=1,
-        )
-        output_margin = Window(
-            char=" ", width=lambda: len(str(self.execution_count)) + 7
-        )
+        # Echo area
+
+    def echo_layout(self, render_queue: list) -> Layout:
+        """Generate a layout for displaying executed cells."""
+        children: list[Container] = []
+        height_known = renderer_height_is_known()
+        rows_above_layout = self.app.renderer.rows_above_layout if height_known else 1
+        json_cells = self.json.cells
+        for i, cell in enumerate(render_queue):
+            if cell.source:
+                # Spacing between cells
+                if ((json_cells and cell.id != json_cells[0].id) or i > 0) and (
+                    (height_known and rows_above_layout > 0) or not height_known
+                ):
+                    children.append(
+                        Window(
+                            height=1,
+                            dont_extend_height=True,
+                        )
+                    )
 
-        output_area = PrintingContainer(
-            [
-                ConditionalContainer(
-                    Window(height=1, dont_extend_height=True), filter=first_output
-                ),
-                VSplit(
-                    [
-                        ConditionalContainer(output_prompt, filter=first_output),
-                        ConditionalContainer(output_margin, filter=~first_output),
-                        self.output,
-                    ]
-                ),
-            ],
-        )
-        # We need to ensure the output layout also has the application's floats so that
-        # graphics are displayed
-        self.output_layout = Layout(
+                # Cell input
+                children.append(
+                    VSplit(
+                        [
+                            Window(
+                                FormattedTextControl(
+                                    partial(
+                                        self.prompt,
+                                        "In ",
+                                        count=cell.execution_count,
+                                    )
+                                ),
+                                dont_extend_width=True,
+                                style="class:cell,input,prompt",
+                                height=1,
+                            ),
+                            KernelInput(
+                                text=cell.source,
+                                kernel_tab=self,
+                                language=lambda: self.language,
+                                read_only=True,
+                            ),
+                        ],
+                    ),
+                )
+
+            # Outputs
+            if outputs := cell.outputs:
+                children.append(
+                    Window(
+                        height=1,
+                        dont_extend_height=True,
+                    )
+                )
+
+                def _flush(
+                    buffer: list[dict[str, Any]], prompt: AnyFormattedText
+                ) -> None:
+                    if buffer:
+                        children.append(
+                            VSplit(
+                                [
+                                    Window(
+                                        FormattedTextControl(prompt),
+                                        dont_extend_width=True,
+                                        dont_extend_height=True,
+                                        style="class:cell,output,prompt",
+                                        height=1,
+                                    ),
+                                    CellOutputArea(
+                                        buffer, parent=self, style="class:disabled"
+                                    ),
+                                ]
+                            ),
+                        )
+                        buffer.clear()
+
+                buffer: list[dict[str, Any]] = []
+                ec = cell.execution_count
+                prompt: AnyFormattedText = ""
+                next_prompt: AnyFormattedText
+                for output in outputs:
+                    if (next_ec := output.get("execution_count")) is None:
+                        next_prompt = " " * (len(str(ec)) + 7)
+                    else:
+                        next_prompt = self.prompt("Out", count=next_ec, show_busy=False)
+                        ec = next_ec
+                    if next_prompt != prompt:
+                        _flush(buffer, prompt)
+                        prompt = next_prompt
+                    buffer.append(output)
+                _flush(buffer, prompt)
+
+        return Layout(
             FloatContainer(
-                output_area,
+                PrintingContainer(children),
                 floats=cast("list[Float]", self.app.graphics),
             )
         )
 
+    def load_container(self) -> HSplit:
+        """Build the main application layout."""
         # Live output area
 
         self.live_output = CellOutputArea([], parent=self)
 
+        live_output_row = ConditionalContainer(
+            HSplit(
+                [
+                    Window(height=1, dont_extend_height=True),
+                    VSplit(
+                        [
+                            Window(
+                                FormattedTextControl(
+                                    lambda: self.prompt(
+                                        "Out",
+                                        count=self.live_output.json[0][
+                                            "execution_count"
+                                        ],
+                                    )
+                                ),
+                                dont_extend_width=True,
+                                style="class:cell,output,prompt",
+                                height=1,
+                            ),
+                            self.live_output,
+                        ]
+                    ),
+                ]
+            ),
+            filter=Condition(lambda: bool(self.live_output.json)),
+        )
+
         # Input area
 
         input_kb = KeyBindings()
@@ -425,13 +560,6 @@ class Console(KernelTab):
             """Force new line on Shift-Enter."""
             event.current_buffer.newline(copy_margin=not in_paste_mode())
 
-        input_prompt = Window(
-            FormattedTextControl(partial(self.prompt, "In ", offset=1)),
-            dont_extend_width=True,
-            style="class:cell,input,prompt",
-            height=1,
-        )
-
         def _handler(buffer: Buffer) -> bool:
             self.run(buffer)
             return True
@@ -460,7 +588,7 @@ class Console(KernelTab):
             # Spacing
             ConditionalContainer(
                 Window(height=1, dont_extend_height=True),
-                filter=Condition(lambda: self.execution_count > 0)
+                filter=Condition(lambda: len(self.json["cells"]) > 0)
                 & (
                     (
                         renderer_height_is_known
@@ -473,7 +601,12 @@ class Console(KernelTab):
             ConditionalContainer(
                 VSplit(
                     [
-                        input_prompt,
+                        Window(
+                            FormattedTextControl(partial(self.prompt, "In ", offset=1)),
+                            dont_extend_width=True,
+                            style="class:cell,input,prompt",
+                            height=1,
+                        ),
                         self.input_box,
                     ],
                 ),
@@ -481,19 +614,9 @@ class Console(KernelTab):
             ),
         ]
 
-        self.input_layout = Layout(PrintingContainer(input_row))
-
         return HSplit(
             [
-                ConditionalContainer(
-                    HSplit(
-                        [
-                            Window(height=1, dont_extend_height=True),
-                            VSplit([output_margin, self.live_output]),
-                        ]
-                    ),
-                    filter=Condition(lambda: bool(self.live_output.json)),
-                ),
+                live_output_row,
                 # StdIn
                 self.stdin_box,
                 ConditionalContainer(

{euporie-2.8.3 → euporie-2.8.4}/euporie/core/__init__.py

@@ -1,7 +1,7 @@
 """This package defines the euporie application and its components."""
 
 __app_name__ = "euporie"
-__version__ = "2.8.3"
+__version__ = "2.8.4"
 __logo__ = "⚈"
 __strapline__ = "Jupyter in the terminal"
 __author__ = "Josiah Outram Halstead"

{euporie-2.8.3 → euporie-2.8.4}/euporie/core/__main__.py

@@ -14,7 +14,7 @@ def main(name: "str" = "launch") -> "None":
     # Monkey-patch prompt_toolkit
     from euporie.core.layout import containers  # noqa: F401
 
-    eps = entry_points()  # group="euporie.apps")
+    eps = entry_points()
     if isinstance(eps, dict):
         points = eps.get("euporie.apps")
     else:

{euporie-2.8.3 → euporie-2.8.4}/euporie/core/app.py

@@ -30,10 +30,7 @@ from prompt_toolkit.key_binding.bindings.emacs import (
 from prompt_toolkit.key_binding.bindings.mouse import (
     load_mouse_bindings as load_ptk_mouse_bindings,
 )
-from prompt_toolkit.key_binding.bindings.vi import (
-    load_vi_bindings,
-    load_vi_search_bindings,
-)
+from prompt_toolkit.key_binding.bindings.vi import load_vi_search_bindings
 from prompt_toolkit.key_binding.key_bindings import (
     ConditionalKeyBindings,
     merge_key_bindings,
@@ -54,6 +51,7 @@ from prompt_toolkit.styles import (
     merge_styles,
     style_from_pygments_cls,
 )
+from prompt_toolkit.utils import Event
 from pygments.styles import STYLE_MAP as pygments_styles
 from pygments.styles import get_style_by_name
 from upath import UPath
@@ -241,6 +239,7 @@ class BaseApp(Application):
         )
         # Contains the opened tab containers
         self.tabs: list[Tab] = []
+        self.on_tabs_change = Event(self)
         # Holds the search bar to pass to cell inputs
         self.search_bar: SearchBar | None = None
         # Holds the index of the current tab
@@ -367,12 +366,12 @@ class BaseApp(Application):
             xcursor=True,
             ycursor=True,
         )
-        # Open any files we need to
-        self.open_files()
         # Load the layout
         # We delay this until we have terminal responses to allow terminal graphics
         # support to be detected first
         self.layout = Layout(self.load_container(), self.focused_element)
+        # Open any files we need to
+        self.open_files()
 
     async def run_async(
         self,
@@ -462,6 +461,7 @@ class BaseApp(Application):
         from euporie.core.key_binding.bindings.basic import load_basic_bindings
         from euporie.core.key_binding.bindings.micro import load_micro_bindings
         from euporie.core.key_binding.bindings.mouse import load_mouse_bindings
+        from euporie.core.key_binding.bindings.vi import load_vi_bindings
 
         self._default_bindings = merge_key_bindings(
             [
@@ -648,7 +648,7 @@ class BaseApp(Application):
                 log.error("Unable to display file %s", path)
             else:
                 tab = tab_class(self, ppath)
-                self.tabs.append(tab)
+                self.add_tab(tab)
                 # Ensure the opened tab is focused at app start
                 self.focused_element = tab
                 # Ensure the newly opened tab is selected
@@ -688,7 +688,7 @@ class BaseApp(Application):
             try:
                 self.layout.focus(container)
             except ValueError:
-                self.to_focus = container
+                log.exception("Cannot focus tab")
 
     def focus_tab(self, tab: Tab) -> None:
         """Make a tab visible and focuses it."""
@@ -704,20 +704,22 @@ class BaseApp(Application):
         # Remove tab
         if tab in self.tabs:
             self.tabs.remove(tab)
-        # Update body container to reflect new tab list
-        # assert isinstance(self.body_container.body, HSplit)
-        # self.body_container.body.children[0] = VSplit(self.tabs)
-        # Focus another tab if one exists
-        if self.tab:
-            self.layout.focus(self.tab)
-        # If a tab is not open, the status bar is not shown, so focus the logo, so
-        # pressing tab focuses the menu
+            self.on_tabs_change()
+        # Focus the next active tab if one exists
+        if next_tab := self.tab:
+            next_tab.focus()
+        # If no tab is open, ensure something is focused
         else:
             try:
                 self.layout.focus_next()
             except ValueError:
                 pass
 
+    def add_tab(self, tab: Tab) -> None:
+        """Add a tab to the current tabs list."""
+        self.tabs.append(tab)
+        self.on_tabs_change()
+
     def close_tab(self, tab: Tab | None = None) -> None:
         """Close a notebook tab.
 
@@ -1302,8 +1304,8 @@ class BaseApp(Application):
                 "close-tab": "c-w",
                 "next-tab": "c-pagedown",
                 "previous-tab": "c-pageup",
-                "focus-next": "s-tab",
-                "focus-previous": "tab",
+                "focus-next": "tab",
+                "focus-previous": "s-tab",
                 "clear-screen": "c-l",
             }
         }

{euporie-2.8.3 → euporie-2.8.4}/euporie/core/clipboard.py

@@ -47,7 +47,7 @@ class Osc52Clipboard(Clipboard):
         if isinstance(output, Vt100_Output):
             output.get_clipboard()
             output.flush()
-            self.app.term_info.clipboard_data.await_response()
+            self.app.term_info.clipboard_data.await_response(timeout=5)
         return self._data
 
     def _update_clipboard(self, query: TerminalQuery) -> None:

{euporie-2.8.3 → euporie-2.8.4}/euporie/core/comm/ipywidgets.py

@@ -122,7 +122,7 @@ def _separate_buffers(
                         cloned_substrate = dict(substate)  # clone list/tuple
                     cloned_substrate[k] = vnew
     else:
-        raise ValueError("expected state to be a list or dict, not %r" % substate)
+        raise ValueError(f"Expected state to be a list or dict, not {substate!r}")
     return cloned_substrate if cloned_substrate is not None else substate
 
 
@@ -250,7 +250,7 @@ class OutputModel(IpyWidgetComm):
             {"outputs": partial(setattr, container, "json")},
         )
 
-    def add_output(self, json: dict[str, Any]) -> None:
+    def add_output(self, json: dict[str, Any], own: bool) -> None:
         """Add a new output to this widget."""
         if self.clear_output_wait:
             self.set_state("outputs", [json])
@@ -285,9 +285,9 @@ class OutputModel(IpyWidgetComm):
             else:
                 # Restore the message's callbacks
                 if self.original_callbacks:
-                    self.comm_container.kernel.msg_id_callbacks[
-                        self.prev_msg_id
-                    ] = self.original_callbacks
+                    self.comm_container.kernel.msg_id_callbacks[self.prev_msg_id] = (
+                        self.original_callbacks
+                    )
                     self.original_callbacks = MsgCallbacks()
                 else:
                     del self.comm_container.kernel.msg_id_callbacks[self.prev_msg_id]

{euporie-2.8.3 → euporie-2.8.4}/euporie/core/commands.py

@@ -243,4 +243,4 @@ def get_cmd(name: str) -> Command:
     try:
         return commands[name]
     except KeyError as e:
-        raise KeyError("Unknown command: %r" % name) from e
+        raise KeyError(f"Unknown command: {name}") from e