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

euporie/core/convert/datum.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import asyncio
 import hashlib
+import inspect
 import io
 import logging
 import threading
@@ -13,6 +14,7 @@ import imagesize
 from PIL.Image import Image as PilImage
 from prompt_toolkit.cache import SimpleCache
 from prompt_toolkit.data_structures import Size
+from prompt_toolkit.layout.containers import WindowAlign
 
 from euporie.core.convert.registry import (
     _CONVERTOR_ROUTE_CACHE,
@@ -26,18 +28,20 @@ if TYPE_CHECKING:
     from pathlib import Path
     from typing import Any, ClassVar, Coroutine
 
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
     from rich.console import ConsoleRenderable
 
+    from euporie.core.data_structures import DiInt
     from euporie.core.style import ColorPaletteColor
 
 
-T = TypeVar("T", bytes, str, PilImage, "ConsoleRenderable")
+T = TypeVar("T", bytes, str, "StyleAndTextTuples", PilImage, "ConsoleRenderable")
 
 
 log = logging.getLogger(__name__)
 
 
-ERROR_OUTPUTS = {
+ERROR_OUTPUTS: dict[str, Any] = {
     "ansi": "(Format Conversion Error)",
     "ft": [("fg:white bg:darkred", "(Format Conversion Error)")],
 }
@@ -77,27 +81,42 @@ def get_loop() -> asyncio.AbstractEventLoop:
     return _LOOP[0]
 
 
-class Datum(Generic[T]):
+class _MetaDatum(type):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._instances: WeakValueDictionary[
+            tuple[Any, ...], Datum
+        ] = WeakValueDictionary()
+
+    def __call__(self, data: T, *args: Any, **kwargs: Any) -> Datum[T]:
+        data_hash = Datum.get_hash(data)
+        key: tuple[Any, ...] = (
+            data_hash,
+            *args,
+            # Get defaults for non-passed kwargs
+            *(
+                kwargs.get(param.name, param.default)
+                for param in inspect.signature(Datum.__init__).parameters.values()
+                if param.default is not inspect._empty
+                and param.name not in {"path", "source"}
+            ),
+        )
+        if key in self._instances:
+            return self._instances[key]
+        instance = super().__call__(data, *args, **kwargs)
+        self._instances[key] = instance
+        return instance
+
+
+class Datum(Generic[T], metaclass=_MetaDatum):
     """Class for storing and converting display data."""
 
     _pixel_size: tuple[int | None, int | None]
     _hash: str
     _root: ReferenceType[Datum]
 
-    _instances: WeakValueDictionary[str, Datum] = WeakValueDictionary()
     _sizes: ClassVar[dict[str, tuple[ReferenceType[Datum], Size]]] = {}
 
-    def __new__(cls, data: T, *args: Any, **kwargs: Any) -> Datum:
-        """Create a single instance based on unique data."""
-        data_hash = cls.get_hash(data)
-
-        if instance := cls._instances.get(data_hash):
-            return instance
-
-        instance = super().__new__(cls)
-        cls._instances[data_hash] = instance
-        return instance
-
     def __init__(
         self,
         data: T,
@@ -108,24 +127,37 @@ class Datum(Generic[T]):
         bg: ColorPaletteColor | str | None = None,
         path: Path | None = None,
         source: Datum | None = None,
+        align: WindowAlign = WindowAlign.LEFT,
     ) -> None:
         """Create a new instance of display data."""
         # self.self = self
         self.data: T = data
         self.format = format
         self.px, self.py = px, py
-        self.fg = str(fg) if fg else None
-        self.bg = str(bg) if bg else None
+        self._fg = str(fg) if fg else None
+        self._bg = str(bg) if bg else None
         self.path = path
         self.source: ReferenceType[Datum] = ref(source) if source else ref(self)
-
+        self.align = align
         self._cell_size: tuple[int, float] | None = None
-
-        self._conversions: dict[tuple[str, int | None, int | None, bool], T] = {}
-
+        self._conversions: dict[tuple[str, int | None, int | None, bool], T | None] = {}
         self._finalizer = finalize(self, self._cleanup_datum_sizes, self.hash)
         self._finalizer.atexit = False
 
+    @property
+    def fg(self) -> str:
+        """The foreground color."""
+        if not (fg := self._fg) and hasattr(app := get_app(), "color_palette"):
+            return app.color_palette.fg.base_hex
+        return fg or "#ffffff"
+
+    @property
+    def bg(self) -> str:
+        """The background color."""
+        if not (bg := self._bg) and hasattr(app := get_app(), "color_palette"):
+            return app.color_palette.bg.base_hex
+        return bg or "#000000"
+
     def __repr__(self) -> str:
         """Return a string representation of object."""
         return f"{self.__class__.__name__}(format={self.format!r})"
@@ -196,45 +228,44 @@ class Datum(Generic[T]):
         cols: int | None = None,
         rows: int | None = None,
         extend: bool = True,
+        bbox: DiInt | None = None,
     ) -> Any:
         """Perform conversion asynchronously, caching the result."""
         if to == self.format:
             # TODO - crop
             return self.data
 
-        if to in self._conversions:
+        if (to, cols, rows, extend) in self._conversions:
             return self._conversions[to, cols, rows, extend]
 
         routes = _CONVERTOR_ROUTE_CACHE[(self.format, to)]
         # log.debug(
         #     "Converting from '%s' to '%s' using route: %s", self, to, routes
         # )
-        if not routes:
-            # raise NotImplementedError(
-            # f"Cannot convert from `self.format` to `to`"
-            # )
-            log.warning("Cannot convert from `%s` to `%s`", self.format, to)
-            output = None
-        else:
+        output: T | None = None
+        if routes:
             datum = self
             output = None
             for route in routes:
                 for stage_a, stage_b in zip(route, route[1:]):
-                    # Find converter with lowest weight
-                    func = 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, extend)
-                        self._conversions[stage_b, cols, rows, extend] = output
-                    except Exception:
-                        log.exception("An error occurred during format conversion")
-                        output = None
+                    if (stage_b, cols, rows, extend) in self._conversions:
+                        output = self._conversions[stage_b, cols, rows, extend]
+                    else:
+                        # Find converter with lowest weight
+                        func = 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, extend)
+                            self._conversions[stage_b, cols, rows, extend] = output
+                        except Exception:
+                            log.exception("An error occurred during format conversion")
+                            output = None
                     if output is None:
                         log.error(
                             "Failed to convert `%s`"
@@ -261,6 +292,9 @@ class Datum(Generic[T]):
                     # If this route succeeded, stop trying routes
                     break
 
+        # Crop or pad output
+        # if bbox and any(bbox):
+
         if output is None:
             output = ERROR_OUTPUTS.get(to, "(Conversion Error)")
 
@@ -299,7 +333,10 @@ class Datum(Generic[T]):
             # 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"}:
+                if (
+                    self.format not in {"png", "svg", "jpeg", "gif", "tiff"}
+                    and _CONVERTOR_ROUTE_CACHE[(self.format, "png")]
+                ):
                     data = await self.convert_async(to="png")
                 else:
                     data = self.data

euporie/core/convert/formats/ansi.py

@@ -246,10 +246,9 @@ async def pil_to_ansi_py_timg(
     # resizing the image
     data = data.resize((cols, ceil(rows * 2 * (px / py) / 0.5)))
 
-    bg = str(datum.bg) or get_app().color_palette.bg.base_hex
+    bg = str(datum.bg or get_app().color_palette.bg.base_hex)
     if bg:
         data = set_background(data, bg)
-    data = set_background(data, bg)
     return timg.Ansi24HblockMethod(data).to_string()
 
 

euporie/core/convert/formats/common.py

@@ -46,7 +46,7 @@ async def imagemagick_convert(
     if not bg and hasattr(app, "color_palette"):
         bg = app.color_palette.bg.base_hex
     if bg:
-        cmd += ["-background", str(bg)]
+        cmd += ["-background", str(bg), "-flatten"]
     cmd += ["-[0]", f"{output_format}:-"]
     result: bytes | str = await call_subproc(datum.data, cmd)
 
@@ -86,6 +86,7 @@ async def chafa_convert_py(
 ) -> str | bytes:
     """Convert image data to ANSI text using ::`chafa.py`."""
     from chafa.chafa import Canvas, CanvasConfig, PixelMode, PixelType
+    from PIL import Image
 
     pil_mode_to_pixel_type = {
         "RGBa": PixelType.CHAFA_PIXEL_RGBA8_PREMULTIPLIED,
@@ -102,10 +103,9 @@ async def chafa_convert_py(
 
     # Convert PIL image to format that chafa can use
     data = datum.data
-    if data.mode not in pil_mode_to_pixel_type:
-        from PIL import Image
-
-        data = data.convert("RGBA", palette=Image.Palette.ADAPTIVE, colors=16)
+    # 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()
@@ -127,9 +127,7 @@ async def chafa_convert_py(
             config.height = max(1, int(cols / data.size[0] * data.size[1] * px / py))
 
     # Set the foreground color
-    if not (fg := datum.fg) and hasattr(app, "color_palette"):
-        fg = app.color_palette.fg.base_hex
-    if fg and (color := fg.lstrip("#")):
+    if (fg := datum.fg) and (color := fg.lstrip("#")):
         config.fg_color = (
             int(color[0:2], 16),
             int(color[2:4], 16),
@@ -137,9 +135,7 @@ async def chafa_convert_py(
         )
 
     # Set the background color
-    if not (bg := datum.bg) and hasattr(app, "color_palette"):
-        bg = app.color_palette.bg.base_hex
-    if bg and (color := bg.lstrip("#")):
+    if (bg := datum.bg) and (color := bg.lstrip("#")):
         config.bg_color = (
             int(color[0:2], 16),
             int(color[2:4], 16),

euporie/core/convert/formats/ft.py

@@ -55,11 +55,11 @@ async def html_to_ft(
     return await html._render(cols, rows)
 
 
-_BLACKLISTED_LEXERS = {
-    "CBM BASIC V2",
-    "Tera Term macro",
-    "Text only",
-    "GDScript",
+_WHITELISTED_LEXERS = {
+    "python",
+    "markdown",
+    "javascript",
+    "json",
 }
 
 
@@ -72,6 +72,7 @@ async def ansi_to_ft(
     cols: int | None = None,
     rows: int | None = None,
     extend: bool = True,
+    lex: bool = False,
 ) -> StyleAndTextTuples:
     """Convert ANSI text to formatted text, lexing & formatting automatically."""
     data = datum.data
@@ -84,8 +85,10 @@ async def ansi_to_ft(
         markup = markup.expandtabs()
         # Use lexer whitelist
         if (
-            lexer := detect_lexer(markup, path=datum.path)
-        ) is not None and lexer.name not in _BLACKLISTED_LEXERS:
+            lex
+            and (lexer := detect_lexer(markup, path=datum.path)) is not None
+            and lexer.name in _WHITELISTED_LEXERS
+        ):
             from prompt_toolkit.lexers.pygments import _token_cache
 
             log.debug('Lexing output using "%s" lexer', lexer.name)

euporie/core/convert/formats/png.py

@@ -73,7 +73,7 @@ async def latex_to_png_dvipng(
             "-T",
             "tight",
             "-D",
-            "150",
+            "175",
             "-z",
             "9",
             "-bg",
@@ -122,14 +122,15 @@ async def latex_to_png_py_mpl(
     from matplotlib.backends import backend_agg
 
     # mpl mathtext doesn't support display math, force inline
-    data = datum.data.replace("$$", "$")
-
+    data = datum.data.strip().replace("$$", "$")
+    if not data.startswith("$"):
+        data = f"${data}$"
     buffer = BytesIO()
     prop = font_manager.FontProperties(size=12)
     parser = mathtext.MathTextParser("path")
     width, height, depth, _, _ = parser.parse(data, dpi=72, prop=prop)
-    fig = figure.Figure(figsize=(width or 256 / 72, height or 256 / 72))
-    fig.text(0, depth / height, data, fontproperties=prop, color=datum.fg)
+    fig = figure.Figure(figsize=(width / 72, height / 72))
+    fig.text(0, depth / height, data, fontproperties=prop, color=datum.fg, usetex=False)
     backend_agg.FigureCanvasAgg(fig)
     fig.savefig(buffer, dpi=120, format="png", transparent=True)
     return buffer.getvalue()
@@ -138,7 +139,7 @@ async def latex_to_png_py_mpl(
 register(
     from_=("svg", "jpeg", "pdf", "gif"),
     to="png",
-    filter_=commands_exist("convert", "magick"),
+    filter_=commands_exist("convert", "mogrify"),
 )(partial(imagemagick_convert, "PNG"))
 
 

euporie/core/convert/formats/sixel.py

@@ -59,7 +59,7 @@ async def png_to_sixel_img2sixel(
 register(
     from_=("png", "jpeg", "svg", "pdf"),
     to="sixel",
-    filter_=commands_exist("convert", "magick"),
+    filter_=commands_exist("convert", "mogrify"),
 )(partial(imagemagick_convert, "sixel"))
 
 

euporie/core/convert/formats/svg.py

@@ -0,0 +1,28 @@
+"""Contain function which convert data to SVG format."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from euporie.core.convert.registry import register
+from euporie.core.convert.utils import have_modules
+
+if TYPE_CHECKING:
+    from euporie.core.convert.datum import Datum
+
+
+@register(from_="latex", to="svg", filter_=have_modules("ziamath"))
+async def latex_to_svg_py_ziamath(
+    datum: Datum,
+    cols: int | None = None,
+    rows: int | None = None,
+    extend: bool = True,
+) -> str:
+    """Convert LaTeX to SVG using :py:mod:`ziamath`."""
+    import ziamath as zm
+
+    data = datum.data.strip()
+    if not data.startswith("$"):
+        data = f"$${data}$$"
+    latex = zm.Text(data, color=datum.fg, size=12)
+    return latex.svg()

euporie/core/convert/mime.py

@@ -10,9 +10,6 @@ from typing import TYPE_CHECKING
 from upath import UPath
 from upath.implementations.http import HTTPPath
 
-# from euporie.core.cache import cache
-from euporie.core.path import DataPath
-
 if TYPE_CHECKING:
     from pathlib import Path
 
@@ -50,11 +47,11 @@ def get_mime(path: Path | str) -> str | None:
     mime = None
 
     # Read from path of data URI
-    if isinstance(path, DataPath):
-        mime = path._mime
+    if path.exists() and isinstance(stat := path.stat(), dict):
+        mime = stat.get("mimetype")
 
-    # If we have a web-address, nsure we have a url
-    # Check http-headers and nsure we have a url
+    # If we have a web-address, ensure we have a url
+    # Check http-headers and ensure we have a url
     if not mime and isinstance(path, HTTPPath) and path._url is not None:
         from fsspec.asyn import sync
 

euporie/core/data_structures.py

@@ -1,5 +1,7 @@
 """Contain commonly used data structures."""
 
+from __future__ import annotations
+
 from functools import lru_cache
 from typing import NamedTuple
 
@@ -7,13 +9,13 @@ from typing import NamedTuple
 class DiBool(NamedTuple):
     """A tuple of four bools with directions."""
 
-    top: "bool" = False
-    right: "bool" = False
-    bottom: "bool" = False
-    left: "bool" = False
+    top: bool = False
+    right: bool = False
+    bottom: bool = False
+    left: bool = False
 
     @classmethod
-    def from_value(cls, value: "bool") -> "DiBool":
+    def from_value(cls, value: bool) -> DiBool:
         """Construct an instance from a single value."""
         return cls(top=value, right=value, bottom=value, left=value)
 
@@ -21,13 +23,13 @@ class DiBool(NamedTuple):
 class DiInt(NamedTuple):
     """A tuple of four integers with directions."""
 
-    top: "int" = 0
-    right: "int" = 0
-    bottom: "int" = 0
-    left: "int" = 0
+    top: int = 0
+    right: int = 0
+    bottom: int = 0
+    left: int = 0
 
     @classmethod
-    def from_value(cls, value: "int") -> "DiInt":
+    def from_value(cls, value: int) -> DiInt:
         """Construct an instance from a single value."""
         return cls(top=value, right=value, bottom=value, left=value)
 
@@ -35,13 +37,13 @@ class DiInt(NamedTuple):
 class DiStr(NamedTuple):
     """A tuple of four strings with directions."""
 
-    top: "str" = ""
-    right: "str" = ""
-    bottom: "str" = ""
-    left: "str" = ""
+    top: str = ""
+    right: str = ""
+    bottom: str = ""
+    left: str = ""
 
     @classmethod
-    def from_value(cls, value: "str") -> "DiStr":
+    def from_value(cls, value: str) -> DiStr:
         """Construct an instance from a single value."""
         return cls(top=value, right=value, bottom=value, left=value)
 
@@ -49,22 +51,22 @@ class DiStr(NamedTuple):
 class WeightedInt(NamedTuple):
     """Ainterger with an associated weight."""
 
-    weight: "int"
-    value: "int"
+    weight: int
+    value: int
 
 
 class WeightedDiInt(NamedTuple):
     """A tuple of four weighted integers."""
 
-    top: "WeightedInt"
-    right: "WeightedInt"
-    bottom: "WeightedInt"
-    left: "WeightedInt"
+    top: WeightedInt
+    right: WeightedInt
+    bottom: WeightedInt
+    left: WeightedInt
 
     # We cannot use :py:func:`functools.cached_property` here as it does not work with
     # :py:Class:`NamedTuple`s.
     @property  # type: ignore
     @lru_cache(maxsize=1)  # noqa: B019
-    def unweighted(self) -> "DiInt":
+    def unweighted(self) -> DiInt:
         """Get the padding without weights."""
         return DiInt(*(x.value for x in self))

euporie/core/filters.py

@@ -24,6 +24,18 @@ if TYPE_CHECKING:
     from prompt_toolkit.layout.containers import Window
 
 
+@Condition
+@lru_cache
+def have_ruff() -> bool:
+    """Determine if ruff is available."""
+    try:
+        import ruff  # noqa F401
+    except ModuleNotFoundError:
+        return False
+    else:
+        return True
+
+
 @Condition
 @lru_cache
 def have_black() -> bool:
@@ -61,10 +73,12 @@ def have_ssort() -> bool:
 
 
 # Determine if we have at least one formatter
-have_formatter = have_black | have_isort | have_ssort
+have_formatter = have_black | have_isort | have_ssort | have_ruff
 
-# Determine if euporie is running inside tmux.
+# Determine if euporie is running inside a multiplexer.
+in_screen = to_filter(os.environ.get("TERM", "").startswith("screen"))
 in_tmux = to_filter(os.environ.get("TMUX") is not None)
+in_mplex = in_tmux | in_screen
 
 
 @Condition

euporie/core/format.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
+import contextlib
 import logging
 from typing import TYPE_CHECKING
 
+from euporie.core.filters import have_black, have_isort, have_ruff, have_ssort
 from euporie.core.log import stdout_to_log
 
 if TYPE_CHECKING:
@@ -13,6 +15,27 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
+def format_ruff(text: str) -> str:
+    """Format a code string using :py:mod:`ruff`."""
+    from ruff.__main__ import find_ruff_bin
+
+    try:
+        ruff_path = find_ruff_bin()
+    except FileNotFoundError:
+        pass
+    else:
+        import subprocess
+
+        with contextlib.suppress(subprocess.CalledProcessError):
+            text = subprocess.check_output(
+                [ruff_path, "format", "-"],
+                input=text,
+                text=True,
+                stderr=subprocess.DEVNULL,
+            )
+    return text
+
+
 def format_black(text: str) -> str:
     """Format a code string using :py:mod:`black`."""
     try:
@@ -22,7 +45,7 @@ def format_black(text: str) -> str:
     else:
         try:
             text = black.format_str(text, mode=black.Mode()).rstrip()
-        except black.parsing.InvalidInput:
+        except (black.parsing.InvalidInput, KeyError):
             log.warning("Error formatting code with black: invalid input")
     return text
 
@@ -60,10 +83,13 @@ def format_ssort(text: str) -> str:
 
 def format_code(text: str, config: Config) -> str:
     """Format a code string using :py:mod:``."""
-    if config.format_ssort:
+    formatters = set(config.formatters)
+    if have_ssort() and "ssort" in formatters:
         text = format_ssort(text)
-    if config.format_isort:
+    if have_isort() and "isort" in formatters:
         text = format_isort(text)
-    if config.format_black:
+    if have_black() and "black" in formatters:
         text = format_black(text)
+    if have_ruff() and "ruff" in formatters:
+        text = format_ruff(text)
     return text.strip()

euporie/core/ft/ansi.py

@@ -73,7 +73,8 @@ class ANSI(PTANSI):
             # Check for backspace
             elif char == "\x08":
                 # TODO - remove last character from last non-ZeroWidthEscape fragment
-                formatted_text.pop()
+                if formatted_text:
+                    formatted_text.pop()
                 continue
 
             elif char in ("\x1b", "\x9b"):