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

euporie/core/convert/__init__.py

@@ -1,31 +1 @@
 """Sub-module concerned with the conversion of data formats."""
-
-from euporie.core.convert.formats import (
-    ansi,
-    base64,
-    ft,
-    html,
-    jpeg,
-    markdown,
-    pdf,
-    pil,
-    png,
-    rich,
-    sixel,
-    svg,
-)
-
-__all__ = [
-    "ansi",
-    "base64",
-    "jpeg",
-    "html",
-    "markdown",
-    "ft",
-    "pdf",
-    "pil",
-    "png",
-    "rich",
-    "sixel",
-    "svg",
-]

euporie/core/convert/datum.py

@@ -3,31 +3,31 @@
 from __future__ import annotations
 
 import asyncio
-import hashlib
 import inspect
 import io
 import logging
 import threading
+from hashlib import md5
 from typing import TYPE_CHECKING, Generic, TypeVar
 from weakref import ReferenceType, WeakValueDictionary, finalize, ref
 
-import imagesize
-from PIL.Image import Image as PilImage
 from prompt_toolkit.data_structures import Size
 from prompt_toolkit.layout.containers import WindowAlign
 
+from euporie.core.app.current import get_app
 from euporie.core.convert.registry import (
     _CONVERTOR_ROUTE_CACHE,
     _FILTER_CACHE,
     converters,
 )
-from euporie.core.current import get_app
 from euporie.core.ft.utils import to_plain_text
 
 if TYPE_CHECKING:
+    from collections.abc import Coroutine
     from pathlib import Path
-    from typing import Any, ClassVar, Coroutine
+    from typing import Any, ClassVar
 
+    from PIL.Image import Image as PilImage
     from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from rich.console import ConsoleRenderable
 
@@ -35,7 +35,7 @@ if TYPE_CHECKING:
     from euporie.core.style import ColorPaletteColor
 
 
-T = TypeVar("T", bytes, str, "StyleAndTextTuples", PilImage, "ConsoleRenderable")
+T = TypeVar("T", bytes, str, "StyleAndTextTuples", "PilImage", "ConsoleRenderable")
 
 
 log = logging.getLogger(__name__)
@@ -139,6 +139,10 @@ class Datum(Generic[T], metaclass=_MetaDatum):
         self._conversions: dict[
             tuple[str, int | None, int | None, str | None, str | None, bool], T | None
         ] = {}
+        self._queue: dict[
+            tuple[str, int | None, int | None, str | None, str | None, bool],
+            asyncio.Event,
+        ] = {}
         self._finalizer = finalize(self, self._cleanup_datum_sizes, self.hash)
         self._finalizer.atexit = False
 
@@ -153,7 +157,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:
@@ -163,23 +170,31 @@ class Datum(Generic[T], metaclass=_MetaDatum):
             return data.encode()
         elif isinstance(data, list):
             return to_plain_text(data).encode()
-        elif isinstance(data, PilImage):
-            return data.tobytes()
         elif isinstance(data, bytes):
             return data
         else:
-            return b"Error"
+            from PIL.Image import Image as PilImage
+
+            if isinstance(data, PilImage):
+                return data.tobytes()
+            else:
+                return b"Error"
 
     @staticmethod
     def get_hash(data: Any) -> str:
         """Calculate a hash of data."""
-        if isinstance(data, str):
+        if isinstance(data, bytes):
+            hash_data = data
+        elif isinstance(data, str):
             hash_data = data.encode()
-        elif isinstance(data, PilImage):
-            hash_data = data.tobytes()
         else:
-            hash_data = data
-        return hashlib.sha1(hash_data).hexdigest()  # noqa S324
+            from PIL.Image import Image as PilImage
+
+            if isinstance(data, PilImage):
+                hash_data = data.tobytes()
+            else:
+                hash_data = data
+        return md5(hash_data, usedforsecurity=False).hexdigest()
 
     @property
     def hash(self) -> str:
@@ -226,37 +241,56 @@ class Datum(Generic[T], metaclass=_MetaDatum):
         if not bg and hasattr(app := get_app(), "color_palette"):
             bg = self.bg or app.color_palette.bg.base_hex
 
-        if (key := (to, cols, rows, fg, bg, extend)) in self._conversions:
-            return self._conversions[key]
+        if (key_conv := (to, cols, rows, fg, bg, extend)) in self._queue:
+            await self._queue[key_conv].wait()
+        if key_conv in self._conversions:
+            return self._conversions[key_conv]
+
+        self._queue[key_conv] = event = asyncio.Event()
 
         routes = _CONVERTOR_ROUTE_CACHE[(self.format, to)]
-        # log.debug(
-        #     "Converting from '%s' to '%s' using route: %s", self, to, routes
-        # )
+        log.debug(
+            "Converting %s->'%s'@%s using routes: %s",
+            self,
+            to,
+            (cols, rows),
+            routes,
+        )
         output: T | None = None
         if routes:
             datum = self
             output = None
             for route in routes:
                 for stage_a, stage_b in zip(route, route[1:]):
-                    key = (stage_b, cols, rows, fg, bg, extend)
-                    if key in self._conversions:
-                        output = self._conversions[key]
+                    key_stage = (stage_b, cols, rows, fg, bg, extend)
+                    if key_stage in self._conversions:
+                        output = self._conversions[key_stage]
                     else:
                         # Find converter with lowest weight
-                        func = sorted(
+                        for converter in sorted(
                             [
                                 conv
                                 for conv in converters[stage_b][stage_a]
                                 if _FILTER_CACHE.get((conv,), conv.filter_)
                             ],
                             key=lambda x: x.weight,
-                        )[0].func
-                        try:
-                            output = await func(datum, cols, rows, fg, bg, extend)
-                            self._conversions[key] = output
-                        except Exception:
-                            log.exception("An error occurred during format conversion")
+                        ):
+                            try:
+                                output = await converter.func(
+                                    datum, cols, rows, fg, bg, extend
+                                )
+                                self._conversions[key_stage] = output
+                            except Exception:
+                                log.debug(
+                                    "Conversion step %s failed",
+                                    converter,
+                                    exc_info=True,
+                                )
+                                continue
+                            else:
+                                break
+                        else:
+                            log.warning("An error occurred during format conversion")
                             output = None
                     if output is None:
                         log.error(
@@ -290,6 +324,9 @@ class Datum(Generic[T], metaclass=_MetaDatum):
         if output is None:
             output = ERROR_OUTPUTS.get(to, "(Conversion Error)")
 
+        event.set()
+        del self._queue[key_conv]
+
         return output
 
     def _to_sync(self, coro: Coroutine) -> Any:
@@ -323,36 +360,68 @@ class Datum(Generic[T], metaclass=_MetaDatum):
         try:
             return self._pixel_size
         except AttributeError:
-            px, py = self.px, self.py
+            pass
+
+        px, py = self.px, self.py
+        self_data = self.data
+        format = self.format
+        data: bytes
+
+        while px is None or py is None:
             # Do not bother trying if the format is ANSI
-            if self.format != "ansi" and (px is None or py is None):
-                # Try using imagesize to get the size of the output
-                if (
-                    self.format not in {"png", "svg", "jpeg", "gif", "tiff"}
-                    and _CONVERTOR_ROUTE_CACHE[(self.format, "png")]
-                ):
-                    data = await self.convert_async(to="png")
+            if format == "ansi":
+                break
+
+            from PIL.Image import Image as PilImage
+
+            if isinstance(self_data, PilImage):
+                px, py = self_data.size
+                break
+
+            # Decode base64 data
+            if format.startswith("base64-"):
+                data = await self.convert_async(to=format[7:])
+
+            # Encode string data
+            if isinstance(self_data, str):
+                data = self_data.encode()
+
+            if isinstance(self_data, bytes):
+                data = self_data
+
+            # Try using imagesize to get the size of the output
+            try:
+                import imagesize
+
+                px_calc, py_calc = imagesize.get(io.BytesIO(data))
+            except ValueError:
+                px_calc = py_calc = -1
+
+            if (
+                format != "png"
+                and px_calc <= 0
+                and py_calc <= 0
+                and _CONVERTOR_ROUTE_CACHE[(format, "png")]
+            ):
+                # Try converting to PNG on failure
+                self_data = await self.convert_async(to="png")
+                format = "png"
+                continue
+
+            if px is None and px_calc > 0:
+                if py is not None and py_calc > 0:
+                    px = int(px_calc * py / py_calc)
                 else:
-                    data = self.data
-                if isinstance(data, str):
-                    data = data.encode()
-                try:
-                    px_calc, py_calc = imagesize.get(io.BytesIO(data))
-                except ValueError:
-                    pass
+                    px = px_calc
+            if py is None and py_calc > 0:
+                if px is not None and px_calc > 0:
+                    py = int(py_calc * px / px_calc)
                 else:
-                    if px is None and px_calc > 0:
-                        if py is not None and py_calc > 0:
-                            px = px_calc * py / py_calc
-                        else:
-                            px = px_calc
-                    if py is None and py_calc > 0:
-                        if px is not None and px_calc > 0:
-                            py = py_calc * px / px_calc
-                        else:
-                            py = py_calc
-            self._pixel_size = (px, py)
-            return self._pixel_size
+                    py = py_calc
+            break
+
+        self._pixel_size = (px, py)
+        return self._pixel_size
 
     def pixel_size(self) -> Any:
         """Get data dimensions synchronously."""
@@ -370,8 +439,8 @@ class Datum(Generic[T], metaclass=_MetaDatum):
             px, py = await self.pixel_size_async()
             if px is not None and py is not None:
                 app = get_app()
-                if hasattr(app, "term_info"):
-                    cell_px, cell_py = app.term_info.cell_size_px
+                if hasattr(app, "cell_size_px"):
+                    cell_px, cell_py = app.cell_size_px
                 else:
                     cell_px, cell_py = 10, 20
                 cols = max(1, int(px // cell_px))
@@ -381,7 +450,9 @@ class Datum(Generic[T], metaclass=_MetaDatum):
 
     def cell_size(self) -> Any:
         """Get cell width and aspect synchronously."""
-        return self._to_sync(self.cell_size_async())
+        if self._cell_size is None:
+            return self._to_sync(self.cell_size_async())
+        return self._cell_size
 
     # def crop(self, bbox: DiInt) -> T:
     #     """Crop displayable data."""

euporie/core/convert/formats/__init__.py

@@ -3,4 +3,35 @@
 They are grouped into sub-modules based on output format.
 """
 
+from . import (
+    ansi,
+    base64,
+    ft,
+    html,
+    jpeg,
+    markdown,
+    pdf,
+    pil,
+    png,
+    rich,
+    sixel,
+    svg,
+)
+
+__all__ = [
+    "BASE64_FORMATS",
+    "ansi",
+    "base64",
+    "ft",
+    "html",
+    "jpeg",
+    "markdown",
+    "pdf",
+    "pil",
+    "png",
+    "rich",
+    "sixel",
+    "svg",
+]
+
 BASE64_FORMATS = {"png", "jpeg", "pdf", "gif"}

euporie/core/convert/formats/ansi.py

@@ -4,14 +4,13 @@ from __future__ import annotations
 
 import logging
 from functools import partial
-from math import ceil
 from typing import TYPE_CHECKING
 
+from euporie.core.app.current import get_app
 from euporie.core.convert.formats.common import chafa_convert_cmd, chafa_convert_py
 from euporie.core.convert.formats.pil import set_background
 from euporie.core.convert.registry import register
-from euporie.core.convert.utils import call_subproc
-from euporie.core.current import get_app
+from euporie.core.convert.utils import call_subproc, scale_to_fit
 from euporie.core.filters import command_exists, have_modules
 
 if TYPE_CHECKING:
@@ -169,9 +168,10 @@ async def html_to_ansi_py_htmlparser(
 @register(
     from_="latex",
     to="ansi",
-    filter_=have_modules("flatlatex.latexfuntypes"),
+    filter_=command_exists("utftex"),
+    weight=0,
 )
-async def latex_to_ansi_py_flatlatex(
+async def latex_to_ansi_utftex(
     datum: Datum,
     cols: int | None = None,
     rows: int | None = None,
@@ -179,16 +179,15 @@ async def latex_to_ansi_py_flatlatex(
     bg: str | None = None,
     extend: bool = True,
 ) -> str:
-    """Convert LaTeX to ANSI using :py:mod:`flatlatex`."""
-    import flatlatex
-
-    return flatlatex.converter().convert(datum.data.strip().strip("$").strip())
+    """Render LaTeX maths as unicode."""
+    return (await call_subproc(datum.data, ["utftex"])).decode()
 
 
 @register(
     from_="latex",
     to="ansi",
     filter_=have_modules("pylatexenc"),
+    weight=0,
 )
 async def latex_to_ansi_py_pylatexenc(
     datum: Datum,
@@ -204,6 +203,36 @@ async def latex_to_ansi_py_pylatexenc(
     return LatexNodes2Text().latex_to_text(datum.data.strip().strip("$").strip())
 
 
+@register(
+    from_="latex",
+    to="ansi",
+    filter_=have_modules("flatlatex.latexfuntypes"),
+    weight=0,
+)
+async def latex_to_ansi_py_flatlatex(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    fg: str | None = None,
+    bg: str | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert LaTeX to ANSI using :py:mod:`flatlatex`."""
+    import flatlatex
+    from flatlatex.latexfuntypes import latexfun
+
+    converter = flatlatex.converter()
+    for style in (
+        r"\textstyle",
+        r"\displaystyle",
+        r"\scriptstyle",
+        r"\scriptscriptstyle",
+    ):
+        converter._converter__cmds[style] = latexfun(lambda x: "", 0)
+
+    return converter.convert(datum.data.strip().strip("$").strip())
+
+
 @register(
     from_="latex",
     to="ansi",
@@ -244,27 +273,14 @@ async def pil_to_ansi_py_timg(
     """Convert a PIL image to ANSI text using :py:mod:`timg`."""
     import timg
 
-    data = datum.data
-    px, py = get_app().term_info.cell_size_px
-
-    # Calculate rows based on image aspect ratio
-    w, h = data.size
-    if rows is None and cols is not None:
-        w, h = data.size
-        rows = ceil(cols / w * h)
-    elif cols is None and rows is not None:
-        w, h = data.size
-        cols = ceil(rows / h * w)
-    elif rows is None and cols is None:
-        cols = ceil(w / px)
-        rows = ceil(h / py)
-    assert rows is not None
-    assert cols is not None
-
-    # `timg` assumes a 2x1 terminal cell aspect ratio, so we correct for while
-    # resizing the image
-    data = data.resize((cols, ceil(rows * 2 * (px / py) / 0.5)))
-
+    # Scale image to fit available space
+    cols, rows = await scale_to_fit(datum, cols, rows)
+    # `timg` assumes a 2x1 terminal cell aspect ratio, so we correct for this while
+    px, py = get_app().cell_size_px
+    rows = int(rows * 2 * (px / py) / 0.5)
+    # Resize the image
+    data = datum.data.resize((cols, rows))
+    # Set background if necessary
     if bg:
         data = set_background(data, bg)
     return timg.Ansi24HblockMethod(data).to_string()

euporie/core/convert/formats/common.py

@@ -6,8 +6,8 @@ import base64
 import logging
 from typing import TYPE_CHECKING
 
-from euporie.core.convert.utils import call_subproc
-from euporie.core.current import get_app
+from euporie.core.app.current import get_app
+from euporie.core.convert.utils import call_subproc, scale_to_fit
 
 if TYPE_CHECKING:
     from typing import Any, Literal
@@ -41,14 +41,15 @@ async def imagemagick_convert(
     extend: bool = True,
 ) -> str | bytes:
     """Convert image data to PNG bytes using ``imagemagick``."""
-    cmd: list[Any] = ["convert", "-density", "300"]
+    cmd: list[Any] = ["magick"]
+    if bg:
+        cmd += ["-background", bg]
+    cmd.extend(["-[0]", "-density", "300"])
     app = get_app()
-    if cols is not None and hasattr(app, "term_info"):
-        px, _ = app.term_info.cell_size_px
+    if cols is not None and hasattr(app, "cell_size_px"):
+        px, _ = app.cell_size_px
         cmd += ["-geometry", f"{int(cols * px)}"]
-    if bg:
-        cmd += ["-background", bg, "-flatten"]
-    cmd += ["-[0]", f"{output_format}:-"]
+    cmd += [f"{output_format}:-"]
     result: bytes | str = await call_subproc(datum.data, cmd)
 
     if output_format in {"sixel", "svg"} and isinstance(result, bytes):
@@ -90,7 +91,7 @@ async def chafa_convert_py(
     extend: bool = True,
 ) -> str | bytes:
     """Convert image data to ANSI text using ::`chafa.py`."""
-    from chafa.chafa import Canvas, CanvasConfig, PixelMode, PixelType
+    from chafa import Canvas, CanvasConfig, PixelMode, PixelType
     from PIL import Image
 
     pil_mode_to_pixel_type = {
@@ -111,25 +112,12 @@ async def chafa_convert_py(
     # Always convert the image, as unconverted images sometime result in an off-by-one
     # line width errors resulting in diagonal image striping for some reason
     data = data.convert("RGBA", palette=Image.Palette.ADAPTIVE, colors=16)
-
     # Init canvas config
     config = CanvasConfig()
     # Set output mode
     config.pixel_mode = str_to_pixel_mode[output_format]
     # Configure the canvas geometry based on our cell size
-    if hasattr(app := get_app(), "term_info"):
-        px, py = app.term_info.cell_size_px
-    else:
-        px, py = 10, 20
-    config.cell_width, config.cell_height = px, py
-    # Set canvas height and width
-    if cols:
-        config.width = cols
-        if rows:
-            config.height = max(1, rows)
-        # If we don't have specified, use the image's aspect
-        else:
-            config.height = max(1, int(cols / data.size[0] * data.size[1] * px / py))
+    config.width, config.height = await scale_to_fit(datum, cols, rows)
 
     # Set the foreground color
     if fg and (color := fg.lstrip("#")):

euporie/core/convert/formats/html.py

@@ -3,61 +3,66 @@
 from __future__ import annotations
 
 import logging
+from functools import cache
 from typing import TYPE_CHECKING
 
-from markdown_it import MarkdownIt
-from mdit_py_plugins.amsmath import amsmath_plugin
-from mdit_py_plugins.dollarmath.index import dollarmath_plugin
-from mdit_py_plugins.texmath.index import texmath_plugin
-from pygments import highlight
-from pygments.formatters import HtmlFormatter
-
+from euporie.core.app.current import get_app
 from euporie.core.convert.registry import register
-from euporie.core.current import get_app
 from euporie.core.lexers import detect_lexer
 
 if TYPE_CHECKING:
+    from markdown_it import MarkdownIt
+
     from euporie.core.convert.datum import Datum
 
 log = logging.getLogger(__name__)
 
 
-class MarkdownParser(MarkdownIt):
-    """Subclas the markdown parser to allow ``file:`` URIs."""
+@cache
+def markdown_parser() -> MarkdownIt:
+    """Lazy-load a markdown parser."""
+    from markdown_it import MarkdownIt
+    from mdit_py_plugins.amsmath import amsmath_plugin
+    from mdit_py_plugins.dollarmath.index import dollarmath_plugin
+    from mdit_py_plugins.texmath.index import texmath_plugin
+    from pygments import highlight
+    from pygments.formatters import HtmlFormatter
 
-    def validateLink(self, url: str) -> bool:
-        """Allow all link URIs."""
-        return True
+    class MarkdownParser(MarkdownIt):
+        """Subclas the markdown parser to allow ``file:`` URIs."""
 
+        def validateLink(self, url: str) -> bool:
+            """Allow all link URIs."""
+            return True
 
-markdown_parser = (
-    (
-        MarkdownParser(
-            options_update={
-                "highlight": lambda text, language, lang_args: highlight(
-                    text,
-                    detect_lexer(text, language=language),
-                    HtmlFormatter(
-                        nowrap=True,
-                        noclasses=True,
-                        style=(
-                            app.syntax_theme
-                            if hasattr((app := get_app()), "syntax_theme")
-                            else "default"
+    return (
+        (
+            MarkdownParser(
+                options_update={
+                    "highlight": lambda text, language, lang_args: highlight(
+                        text,
+                        detect_lexer(text, language=language),
+                        HtmlFormatter(
+                            nowrap=True,
+                            noclasses=True,
+                            style=(
+                                app.syntax_theme
+                                if hasattr((app := get_app()), "syntax_theme")
+                                else "default"
+                            ),
                         ),
-                    ),
-                )
-            }
+                    )
+                }
+            )
+            .enable("linkify")
+            .enable("table")
+            .enable("strikethrough")
         )
-        .enable("linkify")
-        .enable("table")
-        .enable("strikethrough")
+        .use(texmath_plugin)
+        .use(dollarmath_plugin)
+        .use(amsmath_plugin)
+        # .use(tasklists_plugin)
     )
-    .use(texmath_plugin)
-    .use(dollarmath_plugin)
-    .use(amsmath_plugin)
-    # .use(tasklists_plugin)
-)
 
 
 @register(from_="markdown", to="html")
@@ -70,7 +75,7 @@ async def markdown_to_html_markdown_it(
     extend: bool = True,
 ) -> str:
     """Convert markdown to HTML using :py:mod:`markdownit_py`."""
-    assert markdown_parser is not None
+    parser = markdown_parser()
     data = datum.data
     markup = data.decode() if isinstance(data, bytes) else data
-    return markdown_parser.render(markup)
+    return parser.render(markup)