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

euporie/core/ft/html.py

@@ -24,6 +24,7 @@ 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.formatted_text.utils import split_lines
+from prompt_toolkit.layout.containers import WindowAlign
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.utils import Event
 from upath import UPath
@@ -56,6 +57,7 @@ from euporie.core.data_structures import DiBool, DiInt, DiStr
 from euporie.core.ft.table import Cell, Table, compute_padding
 from euporie.core.ft.utils import (
     FormattedTextAlign,
+    FormattedTextVerticalAlign,
     add_border,
     align,
     apply_reverse_overwrites,
@@ -70,6 +72,7 @@ from euporie.core.ft.utils import (
     paste,
     strip,
     truncate,
+    valign,
 )
 
 
@@ -94,6 +97,7 @@ if TYPE_CHECKING:
     from pathlib import Path
     from typing import Any, Callable, Generator, Iterator
 
+    from fsspec.spec import AbstractFileSystem
     from prompt_toolkit.filters.base import Filter
     from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
@@ -874,6 +878,13 @@ class Theme(Mapping):
         self.available_width = available_width
         self.available_height = available_height
 
+    def reset(self) -> None:
+        """Reset all cached properties."""
+        # Iterate ove a copy of keys as dict changes size during loop
+        for attr in list(self.__dict__.keys()):
+            if isinstance(Theme.__dict__.get(attr), cached_property):
+                delattr(self, attr)
+
     @cached_property
     def theme(self) -> dict[str, str]:
         """Return the combined computed theme."""
@@ -1741,6 +1752,12 @@ class Theme(Mapping):
         if "line-through" in theme["text_decoration"]:
             style = f"{style} strike"
 
+        if "blink" in theme["text_decoration"]:
+            style = f"{style} blink"
+
+        if self.hidden:
+            style = f"{style} hidden nounderline"
+
         return style
 
     async def text_transform(self, value: str) -> str:
@@ -1928,17 +1945,19 @@ class Theme(Mapping):
         )
 
     @cached_property
-    def grid_template(self) -> Iterator[list[str]]:
+    def grid_template(self) -> list[list[str]]:
         """Calculate the size of the grid tracks."""
 
         def _multiply_repeats(m: re.Match) -> str:
             result = m.groupdict()
             return " ".join(int(result["count"]) * [result["value"]])
 
+        template = []
         for css_item in ("grid_template_columns", "grid_template_rows"):
             value = self.theme.get(css_item, "")
             value = _GRID_TEMPLATE_REPEAT_RE.sub(_multiply_repeats, value)
-            yield [m.group() for m in _GRID_TEMPLATE_RE.finditer(value)]
+            template.append([m.group() for m in _GRID_TEMPLATE_RE.finditer(value)])
+        return template
 
     @cached_property
     def grid_column_start(self) -> int | None:
@@ -1995,6 +2014,11 @@ class Theme(Mapping):
             (order > 0, order),
         )
 
+    @cached_property
+    def latex(self) -> bool:
+        """If the element should be rendered as LaTeX."""
+        return self.theme.get("_format") == "latex"
+
     # Mapping methods - these are passed on to the underlying theme dictionary
 
     def __getitem__(self, key: str) -> Any:
@@ -2075,6 +2099,10 @@ _BROWSER_CSS: CssSelectors = {
             "display": "inline",
             "font_weight": "bold",
         },
+        ((CssSelector(item="blink"),),): {
+            "display": "inline",
+            "text_decoration": "blink",
+        },
         (
             (CssSelector(item="cite"),),
             (CssSelector(item="dfn"),),
@@ -2739,7 +2767,13 @@ _BROWSER_CSS: CssSelectors = {
                 CssSelector(item="::root", attr="[_initial_format=markdown]"),
                 CssSelector(item=".math"),
             ),
-        ): {"text_transform": "latex"},
+        ): {
+            "_format": "latex",
+            "text_transform": "latex",
+            "display": "inline-block",
+            "vertical_align": "top",
+            # "margin_right": "1em",
+        },
         (
             (
                 CssSelector(item="::root", attr="[_initial_format=markdown]"),
@@ -2747,6 +2781,7 @@ _BROWSER_CSS: CssSelectors = {
             ),
         ): {
             "text_align": "center",
+            "display": "block",
         },
         (
             (
@@ -2823,6 +2858,16 @@ class Node:
 
         self.theme = Theme(self, parent_theme=parent.theme if parent else None)
 
+    def reset(self) -> None:
+        """Reset the node and all its children."""
+        for attr in list(self.__dict__.keys()):
+            if isinstance(Node.__dict__.get(attr), cached_property):
+                delattr(self, attr)
+        self.theme.reset()
+        for child in self.contents:
+            child.reset()
+        self.marker = None
+
     def _outer_html(self, d: int = 0, attrs: bool = True) -> str:
         dd = " " * d
         s = ""
@@ -3425,7 +3470,9 @@ class HTML:
         browser_css: CssSelectors | None = None,
         mouse_handler: Callable[[Node, MouseEvent], NotImplementedOrNone] | None = None,
         paste_fixed: bool = True,
+        defer_assets: bool = False,
         on_update: Callable[[HTML], None] | None = None,
+        on_change: Callable[[HTML], None] | None = None,
         _initial_format: str = "",
     ) -> None:
         """Initialize the markdown formatter.
@@ -3444,7 +3491,9 @@ class HTML:
             browser_css: The browser CSS to use
             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
             on_update: An optional callback triggered when the DOM updates
+            on_change: An optional callback triggered when the DOM changes
             _initial_format: The initial format of the data being displayed
 
         """
@@ -3454,6 +3503,7 @@ class HTML:
 
         self.browser_css = browser_css or _BROWSER_CSS
         self.css: CssSelectors = css or {}
+        self.defer_assets = defer_assets
 
         self.render_count = 0
         self.width = width
@@ -3473,8 +3523,12 @@ class HTML:
         self.fixed_mask: StyleAndTextTuples = []
         # self.anchors = []
         self.on_update = Event(self, on_update)
+        self.on_change = Event(self, on_change)
 
-        self.assets_loaded = False
+        self._dom_processed = False
+        self._assets_loaded = False
+        self._url_cbs: dict[str, Callable[[Any], None]] = {}
+        self._url_fs_map: dict[str, AbstractFileSystem] = {}
 
     # Lazily load attributes
 
@@ -3488,12 +3542,11 @@ class HTML:
         """Parse the markup."""
         return self.parser.parse(self.markup)
 
-    async def load_assets(self) -> None:
+    def process_dom(self) -> None:
         """Load CSS styles and image resources.
 
         Do not touch element's themes!
         """
-        url_cbs = {}
 
         def _process_css(data: bytes) -> None:
             try:
@@ -3529,7 +3582,9 @@ class HTML:
                 and (href := attrs.get("href", ""))
             ):
                 url = urljoin(str(self.base), href)
-                url_cbs[url] = _process_css
+                fs, url = url_to_fs(url)
+                self._url_fs_map[url] = fs
+                self._url_cbs[url] = _process_css
 
             # In case of a <style> tab, load first child's text
             elif child.name == "style":
@@ -3542,22 +3597,40 @@ class HTML:
             elif child.name == "img" and (src := child.attrs.get("src")):
                 child.attrs["_missing"] = "true"
                 url = urljoin(str(self.base), src)
-                url_cbs[url] = partial(_process_img, child)
+                fs, url = url_to_fs(url)
+                self._url_fs_map[url] = fs
+                self._url_cbs[url] = partial(_process_img, child)
+
+        self._dom_processed = True
+
+    async def load_assets(self) -> None:
+        """Load remote assets asynchronously."""
+        self._assets_loaded = True
 
         # Load all remote assets for each protocol using fsspec (where they are loaded
         # asynchronously in their own thread) and trigger callbacks if the file is
         # loaded successfully
-        m = [url_to_fs(url) for url in url_cbs]
-        fs_to_urls = {fs: [url for f, url in m if f == fs] for fs in dict(m)}
-        for fs, urls in fs_to_urls.items():
-            for url, result in fs.cat(urls).items():
-                if not isinstance(result, Exception):
-                    log.debug("File %s loaded", url)
-                    url_cbs[url](result)
-                else:
-                    log.error("Error loading %s", url)
+        fs_url_map = {
+            fs: [url for url, f in self._url_fs_map.items() if f == fs]
+            for fs in set(self._url_fs_map.values())
+        }
+        for fs, urls in fs_url_map.items():
+            try:
+                results = fs.cat(urls, recursive=False, on_error="return")
+            except Exception:
+                log.warning("Error connecting to %s", fs)
+            else:
+                # for url, result in zip(urls, results.values()):
+                for url, result in results.items():
+                    if not isinstance(result, Exception):
+                        log.debug("File %s loaded", url)
+                        self._url_cbs[url](result)
+                    else:
+                        log.warning("Error loading %s", url)
 
-        self.assets_loaded = True
+        # Reset all nodes so they will update with the new CSS from assets
+        if self.defer_assets:
+            self.soup.reset()
 
     def render(self, width: int | None, height: int | None) -> StyleAndTextTuples:
         """Render the current markup at a given size."""
@@ -3585,7 +3658,10 @@ class HTML:
         assert self.width is not None
         assert self.height is not None
 
-        if not self.assets_loaded:
+        # The soup gets parsed when we load assets, and asset data gets attached to it
+        if not self._dom_processed:
+            self.process_dom()
+        if not self.defer_assets and not self._assets_loaded:
             await self.load_assets()
 
         ft = await self.render_element(
@@ -3651,6 +3727,12 @@ class HTML:
         self.render_count += 1
         self.formatted_text = ft
 
+        # Load assets after initial render and requuest 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())
+            task.add_done_callback(lambda fut: self.on_change.fire())
+
         return ft
 
     async def render_element(
@@ -3676,6 +3758,9 @@ class HTML:
         elif element.theme.d_grid:
             render_func = self.render_grid_content
 
+        elif element.theme.latex:
+            render_func = self.render_latex_content
+
         else:
             name = element.name.lstrip(":")
             render_func = getattr(
@@ -3711,14 +3796,15 @@ class HTML:
 
         """
         ft: StyleAndTextTuples = []
-        if text := element.text:
-            if transformed := (await element.theme.text_transform(text)):
-                text = transformed
-            if parent_theme := element.theme.parent_theme:
-                style = parent_theme.style
-            else:
-                style = ""
-            ft = [(style, text)]
+
+        text = await element.theme.text_transform(element.text)
+
+        if parent_theme := element.theme.parent_theme:
+            style = parent_theme.style
+        else:
+            style = ""
+
+        ft.append((style, text))
         return ft
 
     async def render_details_content(
@@ -4178,6 +4264,47 @@ class HTML:
 
         return table.render()
 
+    async def render_latex_content(
+        self,
+        element: Node,
+        left: int = 0,
+        fill: bool = True,
+        align_content: bool = True,
+    ) -> StyleAndTextTuples:
+        """Render LaTeX math content."""
+        theme = element.theme
+
+        # Render text representation
+        ft: StyleAndTextTuples = await self.render_node_content(
+            element, left, fill, align_content
+        )
+
+        # Render graphic representation
+        latex = element.text + "".join(
+            child.text for child in element.renderable_descendents
+        )
+        latex = f"${latex}$"
+        if element.theme.d_blocky:
+            latex = f"${latex}$"
+        datum = Datum(
+            latex,
+            "latex",
+            fg=theme.color,
+            bg=theme.background_color,
+            align=WindowAlign.CENTER,
+        )
+        self.graphic_data.add(datum)
+
+        # Calculate size and pad text representation
+        cols, aspect = await datum.cell_size_async()
+        rows = max(len(list(split_lines(ft))), ceil(cols * aspect))
+        cols = max(cols, max_line_width(ft))
+
+        key = datum.add_size(Size(rows, cols))
+        ft = [(f"[Graphic_{key}]", ""), *ft]
+        ft = valign(ft, height=rows, how=FormattedTextVerticalAlign.TOP)
+        return ft
+
     @overload
     async def _render_image(
         self, data: bytes, format_: str, theme: Theme, path: Path | None = None
@@ -4249,7 +4376,7 @@ class HTML:
         content_width = theme.content_width
         # content_height = theme.content_height
         src = str(element.attrs.get("src", ""))
-        path = self.base / src
+        path = UPath(urljoin(str(self.base), src))
 
         if not element.attrs.get("_missing") and (data := element.attrs.get("_data")):
             # Display it graphically
@@ -4825,20 +4952,6 @@ class HTML:
                 padding_style=parent_style,
             )
 
-        # Ensure hidden content is blank and styled like the parent
-        if theme.hidden:
-            ft = cast(
-                "StyleAndTextTuples",
-                [
-                    (
-                        parent_style,
-                        "\n".join([" " * len(x) for x in text.split("\n")]),
-                        *rest,
-                    )
-                    for style, text, *rest in ft
-                ],
-            )
-
         # Apply mouse handler to links
         if (
             (parent := element.parent)