euporie 2.8.3__py3-none-any.whl → 2.8.4__py3-none-any.whl

euporie/core/convert/datum.py

@@ -153,7 +153,10 @@ class Datum(Generic[T], metaclass=_MetaDatum):
         for key, (datum_ref, _size) in list(size_instances.items()):
             datum = datum_ref()
             if not datum or datum.hash == data_hash:
-                del size_instances[key]
+                try:
+                    del size_instances[key]
+                except KeyError:
+                    pass
             del datum
 
     def to_bytes(self) -> bytes:

euporie/core/convert/registry.py

@@ -58,7 +58,7 @@ def register(
     return decorator
 
 
-def find_route(from_: str, to: str) -> list | None:
+def _find_route(from_: str, to: str) -> list | None:
     """Find the shortest conversion path between two formats."""
     if from_ == to:
         return [from_]
@@ -100,5 +100,10 @@ def find_route(from_: str, to: str) -> list | None:
 
 
 _CONVERTOR_ROUTE_CACHE: FastDictCache[tuple[str, str], list | None] = FastDictCache(
-    find_route
+    _find_route
 )
+
+
+def find_route(from_: str, to: str) -> list | None:
+    """Find and cache conversion routes."""
+    return _CONVERTOR_ROUTE_CACHE[from_, to]

euporie/core/filters.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from functools import partial, reduce
+from functools import lru_cache, partial, reduce
 from importlib import import_module
 from shutil import which
 from typing import TYPE_CHECKING
@@ -27,6 +27,7 @@ if TYPE_CHECKING:
     from prompt_toolkit.layout.containers import Window
 
 
+@lru_cache(maxsize=None)
 def command_exists(*cmds: str) -> Filter:
     """Verify a list of external commands exist on the system."""
     filters = [
@@ -36,6 +37,7 @@ def command_exists(*cmds: str) -> Filter:
     return reduce(lambda a, b: a & b, filters, to_filter(True))
 
 
+@lru_cache(maxsize=None)
 def have_modules(*modules: str) -> Filter:
     """Verify a list of python modules are importable."""
 

euporie/core/ft/html.py

@@ -4318,14 +4318,12 @@ class HTML:
     @overload
     async def _render_image(
         self, data: bytes, format_: str, theme: Theme, path: Path | None = None
-    ) -> StyleAndTextTuples:
-        ...
+    ) -> StyleAndTextTuples: ...
 
     @overload
     async def _render_image(
         self, data: str, format_: str, theme: Theme, path: Path | None = None
-    ) -> StyleAndTextTuples:
-        ...
+    ) -> StyleAndTextTuples: ...
 
     async def _render_image(self, data, format_, theme, path=None):
         """Render an image and prepare graphic representation."""

euporie/core/graphics.py

@@ -335,9 +335,9 @@ class KittyGraphicControl(GraphicControl):
         super().__init__(datum=datum, scale=scale, bbox=bbox)
         self.kitty_image_id = 0
         self.loaded = False
-        self._datum_pad_cache: FastDictCache[
-            tuple[Datum, int, int], Datum
-        ] = FastDictCache(get_value=self._pad_datum, size=1)
+        self._datum_pad_cache: FastDictCache[tuple[Datum, int, int], Datum] = (
+            FastDictCache(get_value=self._pad_datum, size=1)
+        )
 
     def _pad_datum(self, datum: Datum, cell_size_x: int, cell_size_y: int) -> Datum:
         from PIL import ImageOps
@@ -704,9 +704,9 @@ class GraphicProcessor:
         self.control = control
 
         self.positions: dict[str, Point] = {}
-        self._position_cache: FastDictCache[
-            tuple[UIContent], dict[str, Point]
-        ] = FastDictCache(self._load_positions, size=1_000)
+        self._position_cache: FastDictCache[tuple[UIContent], dict[str, Point]] = (
+            FastDictCache(self._load_positions, size=1_000)
+        )
         self._float_cache: FastDictCache[tuple[str], Float | None] = FastDictCache(
             self.get_graphic_float, size=1_000
         )

euporie/core/kernel.py

@@ -9,13 +9,13 @@ import os
 import re
 import sys
 import threading
+from _frozen_importlib import _DeadlockError
 from collections import defaultdict
 from subprocess import PIPE, STDOUT  # S404 - Security implications considered
 from typing import TYPE_CHECKING, TypedDict
 from uuid import uuid4
 
 import nbformat
-from _frozen_importlib import _DeadlockError
 from jupyter_client import AsyncKernelManager, KernelManager
 from jupyter_client.kernelspec import NATIVE_KERNEL_NAME, NoSuchKernel
 from jupyter_client.provisioning import KernelProvisionerFactory as KPF
@@ -130,7 +130,8 @@ class MsgCallbacks(TypedDict, total=False):
 
     get_input: Callable[[str, bool], None] | None
     set_execution_count: Callable[[int], None] | None
-    add_output: Callable[[dict[str, Any]], None] | None
+    add_output: Callable[[dict[str, Any], bool], None] | None
+    add_input: Callable[[dict[str, Any], bool], None] | None
     clear_output: Callable[[bool], None] | None
     done: Callable[[dict[str, Any]], None] | None
     set_metadata: Callable[[tuple[str, ...], Any], None] | None
@@ -151,6 +152,8 @@ class Kernel:
     Has the ability to run itself in it's own thread.
     """
 
+    _CLIENT_ID = f"euporie-{os.getpid()}"
+
     def __init__(
         self,
         kernel_tab: KernelTab,
@@ -457,6 +460,9 @@ class Kernel:
                         ]
                         self.dead = False
 
+                    # Set username so we can identify our own messages
+                    self.kc.session.username = self._CLIENT_ID
+
             # Start monitoring the kernel status
             if self.monitor_task is not None:
                 self.monitor_task.cancel()
@@ -507,22 +513,24 @@ class Kernel:
             rsp = await msg_getter_coro()
             # Run msg type handler
             msg_type = rsp.get("header", {}).get("msg_type")
+            own = rsp.get("parent_header", {}).get("username") == self._CLIENT_ID
             if callable(handler := getattr(self, f"on_{channel}_{msg_type}", None)):
-                handler(rsp)
+                handler(rsp, own)
             else:
-                self.on_unhandled(channel, rsp)
+                self.on_unhandled(channel, rsp, own)
 
-    def on_unhandled(self, channel: str, rsp: dict[str, Any]) -> None:
+    def on_unhandled(self, channel: str, rsp: dict[str, Any], own: bool) -> None:
         """Report unhandled messages to the debug log."""
         log.debug(
-            "Unhandled %s message:\nparent_id = '%s'\ntype = '%s'\ncontent='%s'",
+            "Unhandled %s message:\nparent_id = '%s'\ntype = '%s'\ncontent='%s'\nown: %s",
             channel,
             rsp.get("parent_header", {}).get("msg_id"),
             rsp["header"]["msg_type"],
             rsp.get("content"),
+            own,
         )
 
-    def on_stdin_input_request(self, rsp: dict[str, Any]) -> None:
+    def on_stdin_input_request(self, rsp: dict[str, Any], own: bool) -> None:
         """Call ``get_input`` callback for a stdin input request message."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         content = rsp.get("content", {})
@@ -532,7 +540,7 @@ class Kernel:
                 content.get("password", False),
             )
 
-    def on_shell_status(self, rsp: dict[str, Any]) -> None:
+    def on_shell_status(self, rsp: dict[str, Any], own: bool) -> None:
         """Call ``set_execution_count`` callback for a shell status response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         content = rsp.get("content", {})
@@ -548,7 +556,7 @@ class Kernel:
         ):
             set_execution_count(execution_count)
 
-    def on_shell_execute_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_execute_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell execute reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         content = rsp.get("content", {})
@@ -579,7 +587,8 @@ class Kernel:
                             nbformat.v4.new_output(
                                 "execute_result",
                                 data=data,
-                            )
+                            ),
+                            own,
                         )
                 elif source == "set_next_input":
                     if callable(
@@ -605,7 +614,7 @@ class Kernel:
         ):
             done(content)
 
-    def on_shell_kernel_info_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_kernel_info_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell kernel info response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(
@@ -613,25 +622,25 @@ class Kernel:
         ):
             set_kernel_info(rsp.get("content", {}))
 
-    def on_shell_complete_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_complete_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell completion reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_shell_history_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_history_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell history reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_shell_inspect_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_inspect_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell inspection reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_shell_is_complete_reply(self, rsp: dict[str, Any]) -> None:
+    def on_shell_is_complete_reply(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for a shell completeness reply response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(
@@ -641,7 +650,7 @@ class Kernel:
         ):
             completeness_status(rsp.get("content", {}))
 
-    def on_iopub_status(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_status(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub status response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         status = rsp.get("content", {}).get("execution_state")
@@ -670,9 +679,11 @@ class Kernel:
                 rsp["header"]["date"].isoformat(),
             )
 
-    def on_iopub_execute_input(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_execute_input(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub execute input response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
+        content = rsp.get("content", {})
+
         if self.kernel_tab.app.config.record_cell_timing and callable(
             set_metadata := self.msg_id_callbacks[msg_id]["set_metadata"]
         ):
@@ -681,23 +692,36 @@ class Kernel:
                 rsp["header"]["date"].isoformat(),
             )
 
-    def on_iopub_display_data(self, rsp: dict[str, Any]) -> None:
+        execution_count: int | None = None
+        if (execution_count := content.get("execution_count")) and (
+            callable(
+                set_execution_count := self.msg_id_callbacks[msg_id][
+                    "set_execution_count"
+                ]
+            )
+        ):
+            set_execution_count(execution_count)
+
+        if callable(add_input := self.msg_id_callbacks[msg_id].get("add_input")):
+            add_input(content, own)
+
+    def on_iopub_display_data(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub display data response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            add_output(nbformat.v4.output_from_msg(rsp), own)
 
-    def on_iopub_update_display_data(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_update_display_data(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub update display data response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            add_output(nbformat.v4.output_from_msg(rsp), own)
 
-    def on_iopub_execute_result(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_execute_result(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub execute result response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            add_output(nbformat.v4.output_from_msg(rsp), own)
 
         if (execution_count := rsp.get("content", {}).get("execution_count")) and (
             callable(
@@ -708,21 +732,21 @@ class Kernel:
         ):
             set_execution_count(execution_count)
 
-    def on_iopub_error(self, rsp: dict[str, dict[str, Any]]) -> None:
+    def on_iopub_error(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub error response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id", "")
         if callable(add_output := self.msg_id_callbacks[msg_id].get("add_output")):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            add_output(nbformat.v4.output_from_msg(rsp), own)
         if callable(done := self.msg_id_callbacks[msg_id].get("done")):
             done(rsp.get("content", {}))
 
-    def on_iopub_stream(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_stream(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub stream response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
         if callable(add_output := self.msg_id_callbacks[msg_id]["add_output"]):
-            add_output(nbformat.v4.output_from_msg(rsp))
+            add_output(nbformat.v4.output_from_msg(rsp), own)
 
-    def on_iopub_clear_output(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_clear_output(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub clear output response."""
         # Clear cell output, either now or when we get the next output
         msg_id = rsp.get("parent_header", {}).get("msg_id")
@@ -737,7 +761,7 @@ class Kernel:
         )
     '''
 
-    def on_iopub_comm_open(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_comm_open(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an comm open response."""
         # TODO
         # "If the target_name key is not found on the receiving side, then it should
@@ -747,13 +771,13 @@ class Kernel:
             content=rsp.get("content", {}), buffers=rsp.get("buffers", [])
         )
 
-    def on_iopub_comm_msg(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_comm_msg(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub comm message response."""
         self.kernel_tab.comm_msg(
             content=rsp.get("content", {}), buffers=rsp.get("buffers", [])
         )
 
-    def on_iopub_comm_close(self, rsp: dict[str, Any]) -> None:
+    def on_iopub_comm_close(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub comm close response."""
         self.kernel_tab.comm_close(
             content=rsp.get("content", {}), buffers=rsp.get("buffers", [])
@@ -795,7 +819,7 @@ class Kernel:
         source: str,
         get_input: Callable[[str, bool], None] | None = None,
         set_execution_count: Callable[[int], None] | None = None,
-        add_output: Callable[[dict[str, Any]], None] | None = None,
+        add_output: Callable[[dict[str, Any], bool], None] | None = None,
         clear_output: Callable[[bool], None] | None = None,
         done: Callable[[dict[str, Any]], None] | None = None,
         set_metadata: Callable[[tuple[str, ...], Any], None] | None = None,

euporie/core/key_binding/bindings/__init__.py

@@ -6,6 +6,7 @@ from euporie.core.key_binding.bindings import (
     micro,
     mouse,
     page_navigation,
+    vi,
 )
 
-__all__ = ["basic", "completion", "micro", "mouse", "page_navigation"]
+__all__ = ["basic", "completion", "micro", "mouse", "page_navigation", "vi"]

euporie/core/key_binding/bindings/mouse.py

@@ -22,6 +22,7 @@ from prompt_toolkit.key_binding.bindings.mouse import (
 from prompt_toolkit.keys import Keys
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType, MouseModifier
 from prompt_toolkit.mouse_events import MouseEvent as PtkMouseEvent
+from prompt_toolkit.renderer import HeightIsUnknownError
 
 from euporie.core.app import BaseApp
 
@@ -102,29 +103,23 @@ def _parse_mouse_data(
         # Parse event type.
         if sgr:
             if sgr_pixels:
-                # Calculate cell position
+                # Scale down pixel-wise mouse position to cell based, and calculate
+                # relative position of mouse within the cell
                 cell_x, cell_y = cell_size_xy
                 px, py = x, y
                 fx, fy = px / cell_x + 1, py / cell_y + 1
                 x, y = int(fx), int(fy)
                 rx, ry = fx - x, fy - y
-
             try:
-                (
-                    mouse_button,
-                    mouse_event_type,
-                    mouse_modifiers,
-                ) = xterm_sgr_mouse_events[mouse_event, m]
+                (mouse_button, mouse_event_type, mouse_modifiers) = (
+                    xterm_sgr_mouse_events[mouse_event, m]
+                )
             except KeyError:
                 return None
 
         else:
             # Some other terminals, like urxvt, Hyper terminal, ...
-            (
-                mouse_button,
-                mouse_event_type,
-                mouse_modifiers,
-            ) = urxvt_mouse_events.get(
+            (mouse_button, mouse_event_type, mouse_modifiers) = urxvt_mouse_events.get(
                 mouse_event, (UNKNOWN_BUTTON, MOUSE_MOVE, UNKNOWN_MODIFIER)
             )
 
@@ -153,9 +148,10 @@ def load_mouse_bindings() -> KeyBindings:
     def _(event: KeyPressEvent) -> NotImplementedOrNone:
         """Handle incoming mouse event, include SGR-pixel mode."""
         # Ensure mypy knows this would only run in a euporie appo
-        assert isinstance(app := event.app, BaseApp)
+        app = event.app
+        assert isinstance(app, BaseApp)
 
-        if not event.app.renderer.height_is_known:
+        if not app.renderer.height_is_known:
             return NotImplemented
 
         mouse_event = _MOUSE_EVENT_CACHE[
@@ -169,10 +165,9 @@ def load_mouse_bindings() -> KeyBindings:
         if mouse_event.event_type is not None:
             # Take region above the layout into account. The reported
             # coordinates are absolute to the visible part of the terminal.
-            from prompt_toolkit.renderer import HeightIsUnknownError
-
             x, y = mouse_event.position
 
+            # Adjust position to take into account space above non-full screen apps
             try:
                 rows_above = app.renderer.rows_above_layout
             except HeightIsUnknownError:
@@ -180,28 +175,35 @@ def load_mouse_bindings() -> KeyBindings:
             else:
                 y -= rows_above
 
-            # Save global mouse position
-            app.mouse_position = mouse_event.position
+            # Save mouse position within the app
+            app.mouse_position = Point(x=x, y=y)
 
             # Apply limits to mouse position if enabled
             if (mouse_limits := app.mouse_limits) is not None:
                 x = max(
                     mouse_limits.xpos,
-                    min(x, mouse_limits.xpos + (mouse_limits.width - 1)),
+                    min(x, mouse_limits.xpos + (mouse_limits.width) - 1),
                 )
                 y = max(
                     mouse_limits.ypos,
-                    min(y, mouse_limits.ypos + (mouse_limits.height - 1)),
+                    min(y, mouse_limits.ypos + (mouse_limits.height) - 1),
                 )
 
-            mouse_event.position = Point(x=x, y=y)
+            # Do not modify the mouse event in the cache, instead create a new instance
+            mouse_event = MouseEvent(
+                position=Point(x=x, y=y),
+                event_type=mouse_event.event_type,
+                button=mouse_event.button,
+                modifiers=mouse_event.modifiers,
+                cell_position=mouse_event.cell_position,
+            )
 
             # Call the mouse handler from the renderer.
             # Note: This can return `NotImplemented` if no mouse handler was
             #       found for this position, or if no repainting needs to
             #       happen. this way, we avoid excessive repaints during mouse
             #       movements.
-            handler = event.app.renderer.mouse_handlers.mouse_handlers[y][x]
+            handler = app.renderer.mouse_handlers.mouse_handlers[y][x]
 
             return handler(mouse_event)
 

euporie/core/key_binding/bindings/vi.py

@@ -0,0 +1,46 @@
+"""Add additional keys to the prompt_toolkit vi key-bindings."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from prompt_toolkit.buffer import indent, unindent
+from prompt_toolkit.filters.app import vi_insert_mode
+from prompt_toolkit.key_binding.bindings.vi import (
+    load_vi_bindings as load_ptk_vi_bindings,
+)
+
+from euporie.core.filters import cursor_in_leading_ws
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding.key_bindings import (
+        ConditionalKeyBindings,
+        KeyBindings,
+        KeyBindingsBase,
+    )
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+
+
+def load_vi_bindings() -> KeyBindingsBase:
+    """Load vi keybindings from PTK, adding additional bindings."""
+    # We know the type of the vi bindings
+    vi_bindings = cast(
+        "KeyBindings",
+        cast("ConditionalKeyBindings", load_ptk_vi_bindings()).key_bindings,
+    )
+    handle = vi_bindings.add
+
+    @handle("c-i", filter=vi_insert_mode & cursor_in_leading_ws)
+    def _indent(event: KeyPressEvent) -> None:
+        """Indent lines."""
+        buffer = event.current_buffer
+        current_row = buffer.document.cursor_position_row
+        indent(buffer, current_row, current_row + event.arg)
+
+    @handle("s-tab", filter=vi_insert_mode & cursor_in_leading_ws)
+    def _unindent(event: KeyPressEvent) -> None:
+        """Unindent lines."""
+        current_row = event.current_buffer.document.cursor_position_row
+        unindent(event.current_buffer, current_row, current_row + event.arg)
+
+    return vi_bindings

euporie/core/layout/cache.py

@@ -256,7 +256,10 @@ class CachedContainer(Container):
             cols: The columns to copy
             rows: The rows to copy
                                                                                                                                                                                        .
-        """  # Copy write positions
+        """
+        # Copy write positions
+        new_wps = {}
+
         for win, wp in self.screen.visible_windows_to_write_positions.items():
             new_wp = BoundedWritePosition(
                 xpos=wp.xpos + left,
@@ -270,10 +273,9 @@ class CachedContainer(Container):
                     left=max(0, wp.width - (cols.stop - wp.xpos)),
                 ),
             )
-            screen.visible_windows_to_write_positions[win] = new_wp
-            screen.height = max(screen.height, self.screen.height)
+            new_wps[win] = new_wp
 
-            # # Modify render info
+            # Modify render info
             info = win.render_info
             if info is not None:
                 visible_line_to_row_col = {
@@ -308,7 +310,10 @@ class CachedContainer(Container):
                         win.render_info, "horizontal_scroll", horizontal_scroll
                     )
 
-        @lru_cache
+        screen.visible_windows_to_write_positions.update(new_wps)
+        screen.height = max(screen.height, self.screen.height)
+
+        @lru_cache(maxsize=None)
         def _wrap_mouse_handler(handler: Callable) -> MouseHandler:
             def _wrapped(mouse_event: MouseEvent) -> NotImplementedOrNone:
                 # Modify mouse events to reflect position of content
@@ -334,14 +339,17 @@ class CachedContainer(Container):
         output_db = screen.data_buffer
         output_zwes = screen.zero_width_escapes
         output_mhs = mouse_handlers.mouse_handlers
-        for y in range(max(0, rows.start), rows.stop):
+
+        rows_range = range(max(0, rows.start), rows.stop)
+        cols_range = range(max(0, cols.start), cols.stop)
+        for y in rows_range:
             input_db_row = input_db[y]
             input_zwes_row = input_zwes[y]
             input_mhs_row = input_mhs[y]
             output_dbs_row = output_db[top + y]
             output_zwes_row = output_zwes[top + y]
             output_mhs_row = output_mhs[top + y]
-            for x in range(max(0, cols.start), cols.stop):
+            for x in cols_range:
                 # Data
                 output_dbs_row[left + x] = input_db_row[x]
                 # Escape sequences
@@ -353,24 +361,26 @@ class CachedContainer(Container):
         layout = get_app().layout
         if self.screen.show_cursor:
             for window, point in self.screen.cursor_positions.items():
-                if layout.current_control == window.content:
-                    assert window.render_info is not None
-                    if (
-                        (
-                            window.render_info.ui_content.show_cursor
-                            and not window.always_hide_cursor()
-                        )
-                        and point.x in range(cols.start, cols.stop)
-                        and point.y in range(rows.start, rows.stop)
-                    ):
-                        screen.cursor_positions[window] = Point(
-                            x=left + point.x, y=top + point.y
-                        )
-                        screen.show_cursor = True
+                if (
+                    layout.current_control == window.content
+                    and window.render_info is not None
+                    and window.render_info.ui_content.show_cursor
+                    and not window.always_hide_cursor()
+                    and cols.start <= point.x < cols.stop
+                    and rows.start <= point.y < rows.stop
+                ):
+                    screen.cursor_positions[window] = Point(
+                        x=left + point.x, y=top + point.y
+                    )
+                    screen.show_cursor = True
 
         # Copy menu positions
-        for window, point in self.screen.menu_positions.items():
-            screen.menu_positions[window] = Point(x=left + point.x, y=top + point.y)
+        screen.menu_positions.update(
+            {
+                window: Point(x=left + point.x, y=top + point.y)
+                for window, point in self.screen.menu_positions.items()
+            }
+        )
 
     def get_children(self) -> list[Container]:
         """Return a list of all child containers."""