euporie 2.8.13__py3-none-any.whl → 2.8.15__py3-none-any.whl

euporie/core/convert/formats/svg.py

@@ -8,6 +8,8 @@ from euporie.core.convert.registry import register
 from euporie.core.filters import have_modules
 
 if TYPE_CHECKING:
+    from typing import Any
+
     from euporie.core.convert.datum import Datum
 
 
@@ -18,7 +20,7 @@ async def latex_to_svg_py_ziamath(
     rows: int | None = None,
     fg: str | None = None,
     bg: str | None = None,
-    extend: bool = True,
+    **kwargs: Any,
 ) -> str:
     """Convert LaTeX to SVG using :py:mod:`ziamath`."""
     import ziamath as zm

euporie/core/ft/html.py

@@ -21,6 +21,7 @@ from prompt_toolkit.data_structures import Size
 from prompt_toolkit.filters.base import Condition
 from prompt_toolkit.filters.utils import _always as always
 from prompt_toolkit.filters.utils import _never as never
+from prompt_toolkit.filters.utils import to_filter
 from prompt_toolkit.formatted_text.utils import split_lines
 from prompt_toolkit.layout.containers import WindowAlign
 from prompt_toolkit.layout.dimension import Dimension
@@ -108,7 +109,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable
 
     from fsspec.spec import AbstractFileSystem
-    from prompt_toolkit.filters.base import Filter
+    from prompt_toolkit.filters.base import Filter, FilterOrBool
     from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.mouse_events import MouseEvent
@@ -191,6 +192,23 @@ _GRID_TEMPLATE_REPEAT_RE = re.compile(
     r"repeat\(\s*(?P<count>\d+)\s*,\s*(?P<value>[^)]+?)\s*\)"
 )
 
+_MATHJAX_TAG_RE = re.compile(
+    r"""
+        ^(?P<beginning>.*?)
+        (?P<middle>
+            \\\[(?P<display_bracket>.*?)\\\]
+            |
+            \\\((?P<inline_bracket>.*?)\\\)
+            |
+            \$\$(?P<display_dollar>.*?)\$\$
+            |
+            \$(?P<inline_dollar>.*?)(?: \$(?=\$\$) | (?<!\$)\$(?!\$) )
+        )
+        (?P<end>.*)$
+    """,
+    re.MULTILINE | re.VERBOSE,
+)
+
 # List of elements which might not have a close tag
 _VOID_ELEMENTS = (
     "area",
@@ -1038,7 +1056,17 @@ class Theme(Mapping):
         """Calculate the theme defined in CSS."""
         specificity_rules = []
         element = self.element
+        # Pre-compute element attributes once
+        element_name = element.name
+        element_is_first = element.is_first_child_element
+        element_is_last = element.is_last_child_element
+        element_sibling_idx = element.sibling_element_index
+        element_attrs = element.attrs
+        element_parent = element.parent
+        element_parents_rev = [x for x in element.parents[::-1] if x]
+
         for condition, css_block in css.items():
+            # TODO - cache CSS within condition blocks
             if condition():
                 for selectors, rule in css_block.items():
                     for selector_parts in selectors:
@@ -1048,42 +1076,42 @@ class Theme(Mapping):
                             selector.item or "",
                             selector.attr or "",
                             selector.pseudo or "",
-                            element.name,
-                            element.is_first_child_element,
-                            element.is_last_child_element,
-                            element.sibling_element_index,
-                            **element.attrs,
+                            element_name,
+                            element_is_first,
+                            element_is_last,
+                            element_sibling_idx,
+                            **element_attrs,
                         ):
                             continue
 
                         # All of the parent selectors should match a separate parent in order
                         # TODO - combinators
                         # https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors#combinators
-                        unmatched_parents: list[Node] = [
-                            x for x in element.parents[::-1] if x
-                        ]
-
-                        _unmatched_parents: list[Node]
-                        parent = element.parent
-                        if parent and (
-                            (selector.comb == ">" and parent)
+                        unmatched_parents: list[Node]
+                        if element_parent and (
+                            (selector.comb == ">" and element_parent)
                             # Pseudo-element selectors only match direct ancestors
                             or ((item := selector.item) and item.startswith("::"))
                         ):
-                            _unmatched_parents = [parent]
+                            unmatched_parents = [element_parent]
                         else:
-                            _unmatched_parents = unmatched_parents
+                            unmatched_parents = element_parents_rev[:]
 
                         # TODO investigate caching element / selector chains so we don't have to
                         # iterate through every parent every time
 
                         # Iterate through selector items in reverse, skipping the last
                         for selector in selector_parts[-2::-1]:
-                            for i, parent in enumerate(_unmatched_parents):
+                            # Pre-compute selector attributes
+                            item = selector.item or ""
+                            attrs = selector.attr or ""
+                            pseudo = selector.pseudo or ""
+                            parent: Node | None
+                            for i, parent in enumerate(unmatched_parents):
                                 if parent and match_css_selector(
-                                    selector.item or "",
-                                    selector.attr or "",
-                                    selector.pseudo or "",
+                                    item,
+                                    attrs,
+                                    pseudo,
                                     parent.name,
                                     parent.is_first_child_element,
                                     parent.is_last_child_element,
@@ -1093,9 +1121,9 @@ class Theme(Mapping):
                                     if selector.comb == ">" and (
                                         parent := parent.parent
                                     ):
-                                        _unmatched_parents = [parent]
+                                        unmatched_parents = [parent]
                                     else:
-                                        _unmatched_parents = unmatched_parents[i + 1 :]
+                                        unmatched_parents = element_parents_rev[i + 1 :]
                                     break
                             else:
                                 break
@@ -1109,6 +1137,10 @@ class Theme(Mapping):
                             # the rest of the selectors for this rule
                             break
 
+        # Shortcut in case of no rules
+        if not specificity_rules:
+            return {}
+
         # Move !important rules to the end
         rules = [
             (k, v)
@@ -1300,10 +1332,7 @@ class Theme(Mapping):
             return max([len(x) for x in self.element.text.split()] or [0])
         else:
             return max(
-                [
-                    child.theme.min_content_width
-                    for child in self.element.renderable_contents
-                ]
+                [child.theme.min_content_width for child in self.element.contents]
                 or [0]
             )
 
@@ -1314,10 +1343,7 @@ class Theme(Mapping):
             return max([len(x) for x in self.element.text.split("\n")] or [0])
         else:
             return sum(
-                [
-                    child.theme.max_content_width
-                    for child in self.element.renderable_contents
-                ]
+                [child.theme.max_content_width for child in self.element.contents]
                 or [0]
             )
 
@@ -1375,7 +1401,7 @@ class Theme(Mapping):
 
     @property
     def height(self) -> int | None:
-        """The perscribed height."""
+        """The prescribed height."""
         # TODO - process min-/max-height
         if value := self.get("height"):
             theme_height = css_dimension(
@@ -1914,12 +1940,12 @@ class Theme(Mapping):
     def skip(self) -> bool:
         """Determine if the element should not be displayed."""
         return (
-            "none" in self.theme["display"]
-            or (
-                (element := self.element).name == "::text"
-                and not self.preformatted
-                and not element.text
+            (
+                (element := self.element).name in ("::before", "::after")
+                and self.theme.get("content") in (None, "normal")
             )
+            or "none" in self.theme["display"]
+            or (element.name == "::text" and not self.preformatted and not element.text)
             or (self.theme["position"] == "absolute" and self.hidden)
         )
 
@@ -2169,13 +2195,13 @@ _BROWSER_CSS: CssSelectors = {
                 CssSelector(item="q"),
                 CssSelector(item="::before"),
             ),
-        ): {"content": "“"},
+        ): {"content": "'“'"},
         (
             (
                 CssSelector(item="q"),
                 CssSelector(item="::after"),
             ),
-        ): {"content": "”"},
+        ): {"content": "'”'"},
         # Images
         (
             (CssSelector(item="img", attr="[_missing]"),),
@@ -2778,6 +2804,7 @@ _BROWSER_CSS: CssSelectors = {
             "_pt_class": "markdown,code",
         },
         (
+            (CssSelector(item="::latex"),),
             (
                 CssSelector(item="::root", attr="[_initial_format=markdown]"),
                 CssSelector(item=".math"),
@@ -2824,7 +2851,7 @@ _BROWSER_CSS: CssSelectors = {
                 CssSelector(item="*"),
             ),
         ): {
-            "pt_class": "markdown,code,block",
+            "_pt_class": "markdown,code,block",
         },
         (
             (
@@ -2841,7 +2868,12 @@ _BROWSER_CSS: CssSelectors = {
             "overflow_y": "hidden",
             "vertical_align": "middle",
         },
-    }
+    },
+    get_app().config.filters.wrap_cell_outputs: {
+        ((CssSelector(item="table.dataframe"),),): {
+            "max_width": "100%",
+        },
+    },
 }
 
 
@@ -2868,9 +2900,6 @@ class Node:
         self.contents: list[Node] = contents or []
         self.closed = False
         self.marker: Node | None = None
-        self.before: Node | None = None
-        self.after: Node | None = None
-
         self.theme = Theme(self, parent_theme=parent.theme if parent else None)
 
     def reset(self) -> None:
@@ -2911,22 +2940,49 @@ class Node:
     @cached_property
     def preceding_text(self) -> str:
         """Return the text preceding this element."""
-        s = ""
         parent = self.parent
-        while parent and not parent.theme.d_blocky:
+        # Move up to the current block element
+        while parent and not (parent.theme.d_blocky or parent.theme.d_inline_block):
             parent = parent.parent
-        if parent:
-            for node in parent.renderable_descendents:
-                if node is self:
-                    break
-                s += node.text
-        return s
+        if not parent:
+            return ""
+
+        def _text_descendents(node: Node) -> Generator[Node]:
+            for child in node.contents:
+                if child.name == "::text":
+                    yield child
+                elif (
+                    child.contents
+                    and (child.theme.d_inline or child.theme.d_inline_block)
+                    and child.theme.in_flow
+                ):
+                    yield from _text_descendents(child)
+
+        last_valid_text = ""
+        for node in _text_descendents(parent):
+            if node is self:
+                return last_valid_text
+            elif text := node.text:
+                last_valid_text = text
+        return ""
 
     @cached_property
     def text(self) -> str:
         """Get the element's computed text."""
-        if text := self._text:
-            # if False and not (preformatted := self.theme.preformatted):
+        text = self._text
+
+        # Allow replacing context of pseudo-elements
+        if (
+            (parent := self.parent)
+            and parent.name.startswith("::")
+            and (_text := parent.theme.theme.get("content", "").strip())
+        ):
+            if _text.startswith('"') and _text.endswith('"'):
+                text = _text.strip('"')
+            elif _text.startswith("'") and _text.endswith("'"):
+                text = _text.strip("'")
+
+        if text:
             if not (preformatted := self.theme.preformatted):
                 # 1. All spaces and tabs immediately before and after a line break are ignored
                 text = re.sub(r"(\s+(?=\n)|(?<=\n)\s+)", "", text, flags=re.MULTILINE)
@@ -2997,44 +3053,6 @@ class Node:
             if element.name == tag:
                 yield element
 
-    @cached_property
-    def renderable_contents(self) -> list[Node]:
-        """List the node's contents including '::before' and '::after' elements."""
-        # Do not add '::before' and '::after' elements to themselves
-        if self.name.startswith("::"):
-            return self.contents
-
-        contents = []
-
-        # Add ::before node
-        before_node = Node(dom=self.dom, name="::before", parent=self)
-        if (text := before_node.theme.theme.get("content", "").strip()) and (
-            (text.startswith('"') and text.endswith('"'))
-            or (text.startswith("'") and text.endswith("'"))
-        ):
-            text = text.strip('"').strip("'")
-            before_node.contents.append(
-                Node(dom=self.dom, name="::text", parent=before_node, text=text)
-            )
-            contents.append(before_node)
-
-        contents.extend(self.contents)
-
-        # Add ::after node
-        after_node = Node(dom=self.dom, name="::after", parent=self)
-
-        if (text := after_node.theme.theme.get("content", "")) and (
-            (text.startswith('"') and text.endswith('"'))
-            or (text.startswith("'") and text.endswith("'"))
-        ):
-            text = text.strip('"').strip("'")
-            after_node.contents.append(
-                Node(dom=self.dom, name="::text", parent=after_node, text=text)
-            )
-            contents.append(after_node)
-
-        return contents
-
     @property
     def descendents(self) -> Generator[Node]:
         """Yield all descendent elements."""
@@ -3044,18 +3062,10 @@ class Node:
 
     @property
     def renderable_descendents(self) -> Generator[Node]:
-        """Yield descendents, including pseudo and skipping inline elements."""
-        for child in self.renderable_contents:
-            if (
-                child.theme.d_inline
-                and child.renderable_contents
-                and child.name != "::text"
-            ):
+        """Yield descendent elements with actual text content."""
+        for child in self.contents:
+            if child.theme.d_inline and child.contents and child.name != "::text":
                 yield from child.renderable_descendents
-            # elif (
-            #     child.name == "::text" and self.name != "::block" and self.theme.d_blocky
-            # ):
-            #     yield Node(dom=self.dom, name="::block", parent=self, contents=[child])
             else:
                 yield child
 
@@ -3473,6 +3483,7 @@ class HTML:
         fill: bool = True,
         css: CssSelectors | None = None,
         browser_css: CssSelectors | None = None,
+        mathjax: FilterOrBool = True,
         mouse_handler: Callable[[Node, MouseEvent], NotImplementedOrNone] | None = None,
         paste_fixed: bool = True,
         defer_assets: bool = False,
@@ -3494,6 +3505,7 @@ class HTML:
             fill: Whether remaining space in block elements should be filled
             css: Base CSS to apply when rendering the HTML
             browser_css: The browser CSS to use
+            mathjax: Whether to search for LaTeX in MathJax tags
             mouse_handler: A mouse handler function to use when links are clicked
             paste_fixed: Whether fixed elements should be pasted over the output
             defer_assets: Whether to render the page before remote assets are loaded
@@ -3508,6 +3520,7 @@ class HTML:
 
         self.browser_css = browser_css or _BROWSER_CSS
         self.css: CssSelectors = css or {}
+        self.mathjax = to_filter(mathjax)
         self.defer_assets = defer_assets
 
         self.render_count = 0
@@ -3552,6 +3565,7 @@ class HTML:
 
         Do not touch element's themes!
         """
+        mathjax = self.mathjax()
 
         def _process_css(data: bytes) -> None:
             try:
@@ -3606,6 +3620,68 @@ class HTML:
                 self._url_fs_map[url] = fs
                 self._url_cbs[url] = partial(_process_img, child)
 
+            # Convert non-HTML MathJax tags in texts to <::latex> special tags
+            elif mathjax and child.name == "::text":
+                text = child._text
+                nodes = []
+                while text:
+                    # Split out MathJax parts
+                    if (match := re.match(_MATHJAX_TAG_RE, text)) is not None:
+                        groups = match.groupdict()
+                        before = groups["beginning"]
+                        latex = groups["display_bracket"] or groups["display_dollar"]
+                        b_attrs: list[tuple[str, str | None]] | None
+                        if latex:
+                            b_attrs = [("style", "display: block")]
+                        else:
+                            latex = groups["inline_bracket"] or groups["inline_dollar"]
+                            b_attrs = []
+                        text = groups["end"]
+                    else:
+                        break
+                    # Add the text before the MathJax tag
+                    if before:
+                        nodes.append(
+                            Node(
+                                dom=self,
+                                name="::text",
+                                parent=child.parent,
+                                text=before,
+                            )
+                        )
+                    # Add the LaTeX node
+                    if latex:
+                        latex_node = Node(
+                            dom=self, name="::latex", parent=child.parent, attrs=b_attrs
+                        )
+                        latex_node.contents = [
+                            Node(dom=self, name="::text", parent=latex_node, text=latex)
+                        ]
+                        nodes.append(latex_node)
+                if nodes:
+                    parent = child.parent
+                    # Add a text node for any remaining text
+                    if text:
+                        nodes.append(
+                            Node(dom=self, name="::text", parent=parent, text=text)
+                        )
+                    # Replace the original text node with the new nodes
+                    if parent is not None:
+                        index = parent.contents.index(child)
+                        parent.contents[index : index + 1] = nodes
+
+            # Add pseudo-elements just before rendering
+            if child.name not in _VOID_ELEMENTS and not child.name.startswith("::"):
+                before_node = Node(dom=self, name="::before", parent=child)
+                before_node.contents.append(
+                    Node(dom=self, name="::text", parent=before_node)
+                )
+                after_node = Node(dom=self, name="::after", parent=child)
+                after_node.contents.append(
+                    Node(dom=self, name="::text", parent=after_node)
+                )
+                child.contents = [before_node, *child.contents, after_node]
+
         self._dom_processed = True
 
     async def load_assets(self) -> None:
@@ -3647,7 +3723,7 @@ class HTML:
         self, width: int | None, height: int | None
     ) -> StyleAndTextTuples:
         """Render the current markup at a given size, asynchronously."""
-        # log.debug("Rendering at (%d, %d)", width, height)
+        # log.debug("Rendering at (%r, %r)", width, height)
         no_w = width is None and self.width is None
         no_h = height is None and self.height is None
         if no_w or no_h:
@@ -3732,7 +3808,7 @@ class HTML:
         self.render_count += 1
         self.formatted_text = ft
 
-        # Load assets after initial render and requuest a re-render when loaded
+        # Load assets after initial render and request a re-render when loaded
         if self.defer_assets and not self._assets_loaded:
             loop = asyncio.get_event_loop()
             task = loop.create_task(self.load_assets())
@@ -3934,7 +4010,7 @@ class HTML:
         table_x_dim = Dimension(
             min=table_theme.min_width,
             preferred=table_theme.content_width if "width" in table_theme else None,
-            max=table_theme.max_width or table_theme.content_width,
+            max=table_theme.max_width,
         )
 
         table = Table(
@@ -4044,7 +4120,7 @@ class HTML:
                     fill=True,
                 )
                 if ft_caption:
-                    ft.extend(ft_caption)
+                    ft.extend([*ft_caption, ("", "\n")])
 
         ft.extend(ft_table)
 
@@ -4414,7 +4490,7 @@ class HTML:
     ) -> StyleAndTextTuples:
         """Display images rendered as ANSI art."""
         theme = element.theme
-        # HTMLParser clobber the case of element attributes
+        # HTMLParser clobbers the case of element attributes
         element.attrs["xmlns"] = "http://www.w3.org/2000/svg"
         element.attrs["xmlns:xlink"] = "http://www.w3.org/1999/xlink"
         # We fix the SVG viewBox here
@@ -4517,7 +4593,7 @@ class HTML:
 
         # Render each child node
         for child, rendering in zip(coros, renderings):
-            # Start a new line if we encounter a <br> element
+            # Start a new line if we just passed a <br> element
             if child.name == "br":
                 flush()
                 continue
@@ -4577,10 +4653,7 @@ class HTML:
             # current output. This might involve re-aligning the last line in the
             # output, which could have been an inline-block
 
-            elif d_inline and (
-                # parent_theme.d_inline or parent_theme.d_inline_block or preformatted
-                parent_theme.d_inline or preformatted
-            ):
+            elif d_inline and (parent_theme.d_inline or preformatted):
                 new_line.extend(rendering)
 
             elif d_inline or d_inline_block:
@@ -4798,14 +4871,6 @@ class HTML:
                     ignore_whitespace=True,
                     style=theme.style,
                 )
-            else:
-                ft = truncate(
-                    ft,
-                    content_width,
-                    placeholder="",
-                    ignore_whitespace=True,
-                    style=theme.style,
-                )
 
         # Truncate or expand the height
         overflow_y = theme.get("overflow_y") in {"hidden", "auto"}
@@ -4986,6 +5051,7 @@ if __name__ == "__main__":
     import sys
 
     from prompt_toolkit.application.current import create_app_session, set_app
+    from prompt_toolkit.formatted_text.utils import to_formatted_text
     from prompt_toolkit.shortcuts.utils import print_formatted_text
     from prompt_toolkit.styles.style import Style
 
@@ -5000,11 +5066,12 @@ if __name__ == "__main__":
         set_app(DummyApp()),
     ):
         print_formatted_text(
-            HTML(
-                path.read_text(),
-                base=path,
-                collapse_root_margin=False,
-                fill=True,
+            to_formatted_text(
+                asyncio.run(
+                    HTML(
+                        path.read_text(), base=path, collapse_root_margin=False
+                    )._render(None, None)
+                )
             ),
             style=Style(HTML_STYLE),
         )

euporie/core/ft/table.py

@@ -232,7 +232,7 @@ class SpacerCell(Cell):
             width=None,
             align=align,
             style=expands.style,
-            padding=0,
+            padding=expands.padding,
             border_line=expands.border_line,
             border_style=expands.border_style,
             border_visibility=expands.border_visibility,

euporie/core/kernel/__init__.py

@@ -12,11 +12,15 @@ if TYPE_CHECKING:
     from euporie.core.kernel.base import BaseKernel, KernelInfo, MsgCallbacks
     from euporie.core.tabs.kernel import KernelTab
 
-KERNEL_REGISTRY = {
-    "local": "euporie.core.kernel.local:LocalPythonKernel",
-}
+KERNEL_REGISTRY = {}
 if find_spec("jupyter_client"):
     KERNEL_REGISTRY["jupyter"] = "euporie.core.kernel.jupyter:JupyterKernel"
+KERNEL_REGISTRY.update(
+    {
+        "local": "euporie.core.kernel.local:LocalPythonKernel",
+        "none": "euporie.core.kernel.base:NoKernel",
+    }
+)
 
 
 def list_kernels() -> list[KernelInfo]:

euporie/core/kernel/base.py

@@ -499,6 +499,19 @@ class BaseKernel(ABC):
 class NoKernel(BaseKernel):
     """A `None` kernel."""
 
+    @classmethod
+    def variants(cls) -> list[KernelInfo]:
+        """Return available kernel specifications."""
+        return [
+            KernelInfo(
+                name="none",
+                display_name="No Kernel",
+                factory=cls,
+                kind="new",
+                type=cls,
+            )
+        ]
+
     @property
     def spec(self) -> dict[str, str]:
         """The kernelspec metadata for the current kernel instance."""

euporie/core/kernel/local.py

@@ -24,7 +24,7 @@ from euporie.core.app.current import get_app
 from euporie.core.kernel.base import BaseKernel, KernelInfo, MsgCallbacks
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Unpack
+    from typing import Any, Callable, TextIO, Unpack
 
     from euporie.core.tabs.kernel import KernelTab
 
@@ -175,7 +175,7 @@ class LocalPythonKernel(BaseKernel):
             virtual_env_path = Path(
                 os.environ["VIRTUAL_ENV"], "lib", "python{}.{}", "site-packages"
             )
-            p_ver = sys.version_info[:2]
+            p_ver = tuple(str(x) for x in sys.version_info[:2])
 
             # Predict version from py[thon]-x.x in the $VIRTUAL_ENV
             re_m = re.search(r"\bpy(?:thon)?([23])\.(\d+)\b", os.environ["VIRTUAL_ENV"])
@@ -631,7 +631,12 @@ class InputBuiltin(BaseHook):
         self._is_password = is_password
         update_wrapper(self, input)
 
-    def __call__(self, prompt: str = "", stream: Any = None) -> str:
+    def __call__(
+        self,
+        prompt: str = "",
+        stream: TextIO | None = None,
+        echo_char: str | None = None,
+    ) -> str:
         """Get input from user via callback."""
         if (callbacks := self.callbacks) and (get_input := callbacks.get("get_input")):
             # Clear any previous input