euporie 2.8.5__py3-none-any.whl → 2.8.7__py3-none-any.whl

euporie/core/comm/ipywidgets.py

@@ -19,7 +19,7 @@ from prompt_toolkit.layout.processors import BeforeInput
 
 from euporie.core.comm.base import Comm, CommView
 from euporie.core.data_structures import DiBool
-from euporie.core.kernel.client import MsgCallbacks
+from euporie.core.kernel.jupyter import MsgCallbacks
 from euporie.core.layout.decor import FocusedStyle
 from euporie.core.widgets.forms import (
     Button,
@@ -518,7 +518,7 @@ class TextBoxIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
             container,
             setters={
                 "value": lambda x: setattr(text.buffer, "text", str(x)),
-                "rows": partial(setattr, text.text_area.window, "height"),
+                "rows": partial(setattr, text.window, "height"),
                 "placeholder": partial(setattr, text, "placeholder"),
                 "description_allow_html": partial(setattr, labelled_widget, "html"),
             },
@@ -1403,7 +1403,7 @@ class ColorPickerModel(TextBoxIpyWidgetComm):
             container,
             setters={
                 "value": lambda x: setattr(text.buffer, "text", str(x)),
-                "rows": partial(setattr, text.text_area.window, "height"),
+                "rows": partial(setattr, text.window, "height"),
                 "placeholder": partial(setattr, text, "placeholder"),
             },
         )

euporie/core/commands.py

@@ -41,6 +41,36 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
+def parse_args(arg: str) -> list[Any]:
+    """Parse a command argument string into a list of values.
+
+    Args:
+        arg: The argument string to parse
+
+    Returns:
+        A list of parsed values, with strings for items that couldn't be evaluated
+    """
+    if not arg:
+        return []
+
+    import ast
+
+    result = []
+    for item in arg.split():
+        try:
+            # Safely evaluate string as a Python literal
+            new_value = ast.literal_eval(item)
+        except (ValueError, SyntaxError):
+            # Keep as string if evaluation fails
+            result.append(item)
+        else:
+            if type(new_value) is str:
+                result.append(item)
+            else:
+                result.append(new_value)
+    return result
+
+
 class Command:
     """Wrap a function so it can be used as a key-binding or a menu item."""
 
@@ -110,18 +140,19 @@ class Command:
 
         self.keys: list[tuple[str | Keys, ...]] = []
 
-    def run(self, arg: str | None = None) -> None:
+    def run(self, arg: str = "") -> None:
         """Run the command's handler."""
         if self.filter():
             app = get_app()
             result = self.key_handler(
                 KeyPressEvent(
                     key_processor_ref=weakref.ref(app.key_processor),
-                    arg=arg,
+                    arg=None,
                     key_sequence=[],
                     previous_key_sequence=[],
                     is_repeat=False,
                 ),
+                *parse_args(arg),
             )
             if isawaitable(result):
 
@@ -141,14 +172,19 @@ class Command:
         handler = self.handler
         sig = signature(handler)
 
-        if sig.parameters:
-            # The handler already accepts a `KeyPressEvent` argument
+        if sig.parameters and next(iter(sig.parameters.keys())) == "event":
+            # The handler already accepts a `KeyPressEvent` argument named "event"
+            # as the first parameter
             return cast("KeyHandlerCallable", handler)
 
+        # Otherwise we need to wrap in a function which accepts a KeyPressEvent as the
+        # first parameter
         if iscoroutinefunction(handler):
 
-            async def _key_handler_async(event: KeyPressEvent) -> NotImplementedOrNone:
-                result = cast("CommandHandlerNoArgs", handler)()
+            async def _key_handler_async(
+                event: KeyPressEvent, *args: Any
+            ) -> NotImplementedOrNone:
+                result = cast("CommandHandlerNoArgs", handler)(*args)
                 assert isawaitable(result)
                 return await result
 
@@ -156,8 +192,8 @@ class Command:
 
         else:
 
-            def _key_handler(event: KeyPressEvent) -> NotImplementedOrNone:
-                return cast("CommandHandlerNoArgs", handler)()
+            def _key_handler(event: KeyPressEvent, *args: Any) -> NotImplementedOrNone:
+                return cast("CommandHandlerNoArgs", handler)(*args)
 
             return _key_handler
 
@@ -191,22 +227,6 @@ class Command:
             return format_keys([self.keys[0]])[0]
         return ""
 
-    @property
-    def menu_handler(self) -> Callable[[], None]:
-        """Return a menu handler for the command."""
-        handler = self.handler
-        if isawaitable(handler):
-
-            def _menu_handler() -> None:
-                task = cast("CommandHandlerNoArgs", handler)()
-                task = cast("Coroutine[Any, Any, None]", task)
-                if task is not None:
-                    get_app().create_background_task(task)
-
-            return _menu_handler
-        else:
-            return cast("Callable[[], None]", handler)
-
     @property
     def menu(self) -> MenuItem:
         """Return a menu item for the command."""

euporie/core/completion.py

@@ -10,26 +10,34 @@ from prompt_toolkit.completion.base import CompleteEvent, Completer, Completion
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Iterable
     from pathlib import Path
+    from typing import Callable
 
     from prompt_toolkit.document import Document
 
-    from euporie.core.kernel.client import Kernel
+    from euporie.core.kernel.base import BaseKernel
     from euporie.core.lsp import LspClient
 
 log = logging.getLogger(__name__)
 
 
 class KernelCompleter(Completer):
-    """A prompt_toolkit completer which provides completions from a Jupyter kernel."""
+    """A prompt_toolkit completer which provides completions from a kernel."""
 
-    def __init__(self, kernel: Kernel) -> None:
+    def __init__(self, kernel: BaseKernel | Callable[[], BaseKernel]) -> None:
         """Instantiate the completer for a given notebook.
 
         Args:
             kernel: A `Notebook` instance
 
         """
-        self.kernel = kernel
+        self._kernel = kernel
+
+    @property
+    def kernel(self) -> BaseKernel:
+        """Return the current kernel."""
+        if callable(self._kernel):
+            return self._kernel()
+        return self._kernel
 
     def get_completions(
         self, document: Document, complete_event: CompleteEvent
@@ -42,8 +50,8 @@ class KernelCompleter(Completer):
         self, document: Document, complete_event: CompleteEvent
     ) -> AsyncGenerator[Completion, None]:
         """Retrieve completions from a :class:`Kernel`."""
-        for kwargs in await self.kernel.complete_(
-            code=document.text,
+        for kwargs in await self.kernel.complete_async(
+            source=document.text,
             cursor_pos=document.cursor_position,
         ):
             if completion_type := kwargs.get("display_meta"):

euporie/core/convert/datum.py

@@ -249,13 +249,13 @@ class Datum(Generic[T], metaclass=_MetaDatum):
         self._queue[key_conv] = event = asyncio.Event()
 
         routes = _CONVERTOR_ROUTE_CACHE[(self.format, to)]
-        log.debug(
-            "Converting %s->'%s'@%s using routes: %s",
-            self,
-            to,
-            (cols, rows),
-            routes,
-        )
+        # log.debug(
+        #     "Converting %s->'%s'@%s using routes: %s",
+        #     self,
+        #     to,
+        #     (cols, rows),
+        #     routes,
+        # )
         output: T | None = None
         if routes:
             datum = self

euporie/core/data_structures.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 from functools import lru_cache
-from typing import NamedTuple
+from typing import NamedTuple, TypeVar, overload
+
+_T = TypeVar("_T")
 
 
 class DiBool(NamedTuple):
@@ -28,6 +30,23 @@ class DiInt(NamedTuple):
     bottom: int = 0
     left: int = 0
 
+    @overload
+    def __add__(self, other: tuple[int, ...], /) -> DiInt: ...
+    @overload
+    def __add__(self, other: tuple[_T, ...], /) -> DiInt: ...
+
+    def __add__(self, other):
+        """Add two DiInt instances together."""
+        if not isinstance(other, DiInt):
+            return NotImplemented
+
+        return DiInt(
+            top=self.top + other.top,
+            right=self.right + other.right,
+            bottom=self.bottom + other.bottom,
+            left=self.left + other.left,
+        )
+
     @classmethod
     def from_value(cls, value: int) -> DiInt:
         """Construct an instance from a single value."""

euporie/core/filters.py

@@ -64,6 +64,14 @@ def cursor_in_leading_ws() -> bool:
     return (not before) or before.isspace()
 
 
+@Condition
+def cursor_at_end_of_line() -> bool:
+    """Determine if the cursor of the current buffer is in leading whitespace."""
+    from prompt_toolkit.application.current import get_app
+
+    return get_app().current_buffer.document.is_cursor_at_the_end_of_line
+
+
 @Condition
 def has_suggestion() -> bool:
     """Determine if the current buffer can display a suggestion."""
@@ -133,6 +141,38 @@ def tab_has_focus() -> bool:
     return get_app().tab is not None
 
 
+@Condition
+def kernel_tab_has_focus() -> bool:
+    """Determine if there is a focused kernel tab."""
+    from euporie.core.app.current import get_app
+    from euporie.core.tabs.kernel import KernelTab
+
+    return isinstance(get_app().tab, KernelTab)
+
+
+@cache
+def tab_type_has_focus(tab_class_path: str) -> Condition:
+    """Determine if the focused tab is of a particular type."""
+    from pkgutil import resolve_name
+
+    from euporie.core.app.current import get_app
+
+    tab_class = cache(resolve_name)
+
+    return Condition(lambda: isinstance(get_app().tab, tab_class(tab_class_path)))
+
+
+@Condition
+def tab_can_save() -> bool:
+    """Determine if the current tab can save it's contents."""
+    from euporie.core.app.current import get_app
+    from euporie.core.tabs.base import Tab
+
+    return (
+        tab := get_app().tab
+    ) is not None and tab.__class__.write_file != Tab.write_file
+
+
 @Condition
 def pager_has_focus() -> bool:
     """Determine if there is a currently focused notebook."""
@@ -321,15 +361,6 @@ def multiple_cells_selected() -> bool:
     return False
 
 
-@Condition
-def kernel_tab_has_focus() -> bool:
-    """Determine if there is a focused kernel tab."""
-    from euporie.core.app.current import get_app
-    from euporie.core.tabs.kernel import KernelTab
-
-    return isinstance(get_app().tab, KernelTab)
-
-
 def scrollable(window: Window) -> Filter:
     """Return a filter which indicates if a window is scrollable."""
     return Condition(

euporie/core/format.py

@@ -110,11 +110,10 @@ class LspFormatter(Formatter):
                     range_ = change.get("range", {})
                     start = range_.get("start", {})
                     start_line = start.get("line", 0)
-                    start_char = start.get("char", 0)
+                    start_char = start.get("character", 0)
                     end = range_.get("end", {})
                     end_line = end.get("line", 0)
-                    end_char = end.get("char", 0)
-
+                    end_char = end.get("character", 0)
                     segment = range_to_slice(
                         start_line, start_char, end_line, end_char, text
                     )

euporie/core/ft/html.py

@@ -39,6 +39,7 @@ from euporie.core.border import (
     LowerLeftHalfDottedLine,
     LowerLeftHalfLine,
     NoLine,
+    RoundedLine,
     ThickDoubleDashedLine,
     ThickLine,
     ThickQuadrupleDashedLine,
@@ -558,7 +559,7 @@ def css_dimension(
     digits = ""
     i = 0
     try:
-        while (c := value[i]) in "0123456789.":
+        while (c := value[i]) in "-0123456789.":
             digits += c
             i += 1
     except IndexError:
@@ -924,19 +925,15 @@ class Theme(Mapping):
         available_height: int,
     ) -> None:
         """Set the space available to the element for rendering."""
-        if self.theme["position"] == "fixed":
+        if self.theme["position"] in {"fixed"}:
             # Space is given by position
-            position = self.position
             dom = self.element.dom
             assert dom.width is not None
             assert dom.height is not None
+            position = self.position
             self.available_width = (dom.width - position.right) - position.left
             self.available_height = (dom.height - position.bottom) - position.top
 
-        # elif parent_theme := self.parent_theme:
-        #     self.available_width = parent_theme.content_width
-        #     self.available_height = parent_theme.content_height
-
         else:
             self.available_width = available_width
             self.available_height = available_height
@@ -1527,6 +1524,7 @@ class Theme(Mapping):
             # Replace the margin on the parent
             if (
                 (first_child := element.first_child_element)
+                and first_child.theme.in_flow
                 and first_child.prev_node_in_flow is None
                 and not self.border_visibility.top
                 and not self.padding.top
@@ -1541,6 +1539,7 @@ class Theme(Mapping):
                     values["top"] = max(child_theme.base_margin.top, values["top"])
             if (
                 (last_child := element.last_child_element)
+                and last_child.theme.in_flow
                 and last_child.next_node_in_flow is None
                 and not self.padding.bottom
                 and not self.border_visibility.bottom
@@ -1671,6 +1670,10 @@ class Theme(Mapping):
                     NoLine,
                 )
 
+                # TODO - parse border_radius properly and check for corner radii
+                if output[direction] == ThinLine and self.theme.get("border_radius"):
+                    output[direction] = RoundedLine
+
         return DiLineStyle(**output)
 
     @cached_property
@@ -1857,7 +1860,11 @@ class Theme(Mapping):
         """The position of an element with a relative, absolute or fixed position."""
         # TODO - calculate position based on top, left, bottom,right, width, height
         soup_theme = self.element.dom.soup.theme
-        return DiInt(
+        position = DiInt(0, 0, 0, 0)
+        # if self.parent_theme is not None:
+        #     position += self.parent_theme.position
+        position += self.base_margin
+        position += DiInt(
             top=round(
                 css_dimension(
                     self.theme["top"],
@@ -1891,6 +1898,7 @@ class Theme(Mapping):
                 or 0
             ),
         )
+        return position
 
     @cached_property
     def anchors(self) -> DiBool:
@@ -1912,10 +1920,7 @@ class Theme(Mapping):
                 and not self.preformatted
                 and not element.text
             )
-            or (
-                self.theme["position"] == "absolute"
-                and try_eval(self.theme["opacity"]) == 0
-            )
+            or (self.theme["position"] == "absolute" and self.hidden)
         )
 
     @cached_property
@@ -3746,19 +3751,20 @@ class HTML:
     ) -> StyleAndTextTuples:
         """Render a Node."""
         # Update the element theme with the available space
-        element.theme.update_space(available_width, available_height)
+        theme = element.theme
+        theme.update_space(available_width, available_height)
 
         # Render the contents
-        if element.theme.d_table:
+        if theme.d_table:
             render_func = self.render_table_content
 
-        elif element.theme.d_list_item:
+        elif theme.d_list_item:
             render_func = self.render_list_item_content
 
-        elif element.theme.d_grid:
+        elif theme.d_grid:
             render_func = self.render_grid_content
 
-        elif element.theme.latex:
+        elif theme.latex:
             render_func = self.render_latex_content
 
         else:
@@ -4471,8 +4477,6 @@ class HTML:
         float_lines_right: list[StyleAndTextTuples] = []
         float_width_right = 0
 
-        content_width = parent_theme.content_width
-
         new_line: StyleAndTextTuples = []
 
         def flush() -> None:
@@ -4607,7 +4611,7 @@ class HTML:
                     # from each active float
                     if (
                         new_line
-                        and (content_width - float_width_left - float_width_right)
+                        and (available_width - float_width_left - float_width_right)
                         - left
                         - token_width
                         < 0
@@ -4633,7 +4637,7 @@ class HTML:
                             fillvalue=empty,
                         ):
                             line_width = (
-                                content_width
+                                available_width
                                 - fragment_list_width(ft_left)
                                 - fragment_list_width(ft_right)
                             )
@@ -4724,7 +4728,7 @@ class HTML:
                     fragment_list_width(float_lines_left[0]) if float_lines_left else 0
                 )
                 line_width = (
-                    content_width
+                    available_width
                     - fragment_list_width(ft_left)
                     - fragment_list_width(ft_right)
                 )
@@ -4844,7 +4848,7 @@ class HTML:
                     placeholder="",
                 )
 
-        # # Fill space around block elements so they fill the content width
+        # Fill space around block elements so they fill the content width
         if ft and ((fill and d_blocky and not theme.d_table) or d_inline_block):
             pad_width = None
             if d_blocky:
@@ -4929,7 +4933,6 @@ class HTML:
         parent_style = parent_theme.style if parent_theme else ""
 
         # Render the margin
-        # if d_blocky and (alignment := theme.block_align) != FormattedTextAlign.LEFT:
         if (alignment := theme.block_align) != FormattedTextAlign.LEFT:
             # Center block contents if margin_left and margin_right are "auto"
             ft = align(
@@ -4949,22 +4952,26 @@ class HTML:
                 padding_style=parent_style,
             )
 
-        # Apply mouse handler to links
-        if (
-            (parent := element.parent)
-            and parent.name == "a"
-            and callable(handler := self.mouse_handler)
-            and (href := parent.attrs.get("href"))
-        ):
-            element.attrs["_link_path"] = self.base.joinuri(href)
-            element.attrs["title"] = parent.attrs.get("title")
-            ft = cast(
-                "StyleAndTextTuples",
-                [
-                    (style, text, *(rest or [partial(handler, element)]))
-                    for style, text, *rest in ft
-                ],
-            )
+        # Apply mouse handler to elements with href, title, alt
+        if callable(handler := self.mouse_handler):
+            attrs = element.attrs
+            # Inline elements inherit from parents
+            if d_inline and (parent := element.parent):
+                p_attrs = parent.attrs
+                attrs.setdefault("href", p_attrs.get("href"))
+                attrs.setdefault("title", p_attrs.get("title"))
+                attrs.setdefault("alt", p_attrs.get("alt"))
+            # Resolve link paths
+            if href := attrs.get("href"):
+                attrs["_link_path"] = self.base.joinuri(href)
+            if {"title", "alt", "href"} & set(attrs):
+                ft = cast(
+                    "StyleAndTextTuples",
+                    [
+                        (style, text, *(rest or [partial(handler, element)]))
+                        for style, text, *rest in ft
+                    ],
+                )
 
         return ft