euporie 2.8.4__py3-none-any.whl → 2.8.6__py3-none-any.whl

euporie/core/lsp.py

@@ -13,8 +13,9 @@ from typing import TYPE_CHECKING, NamedTuple
 from prompt_toolkit.utils import Event
 
 if TYPE_CHECKING:
+    from collections.abc import Coroutine, Sequence
     from concurrent.futures import Future
-    from typing import Any, Callable, Coroutine, Sequence
+    from typing import Any, Callable
 
 
 log = logging.getLogger(__name__)
@@ -475,6 +476,7 @@ class LspClient:
             "cellTextDocuments": [],
         }
         langs = self.can_change_nb_langs
+        lsp_notebook_cell: dict[str, Any]
         for cell in cells:
             if langs and cell.language not in langs:
                 continue
@@ -598,6 +600,7 @@ class LspClient:
             },
         }
         langs = self.can_change_nb_langs
+        lsp_notebook_cell: dict[str, Any]
         for cell in cells:
             # If specified, only sync cells with the languages the server has requested
             if langs and cell.language not in langs:
@@ -657,6 +660,7 @@ class LspClient:
                 "change": {"cells": (change := {"data": [], "textContent": []})},
             }
             langs = self.can_change_nb_langs
+            lsp_notebook_cell: dict[str, Any]
             for cell in cells:
                 self._doc_versions[cell.path] += 1
                 # If specified, only sync cells with the languages the server has requested
@@ -1032,10 +1036,24 @@ class LspClient:
 
 KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
     # Custom additions
-    "ruff": {"command": ["ruff-lsp"], "languages": {"python"}},
     "typos": {"command": ["typos-lsp"], "languages": set()},
     # Helix's known LSPs
     "als": {"command": ["als"]},
+    "ada-language-server": {"command": ["ada_language_server"], "languages": {"ada"}},
+    "ada-gpr-language-server": {
+        "command": ["ada_language_server", "--language-gpr"],
+        "languages": {"ada"},
+    },
+    "angular": {
+        "command": [
+            "ngserver",
+            "--stdio",
+            "--tsProbeLocations",
+            ".",
+            "--ngProbeLocations",
+            ".",
+        ]
+    },
     "awk-language-server": {"command": ["awk-language-server"], "languages": {"awk"}},
     "bash-language-server": {
         "command": ["bash-language-server", "start"],
@@ -1043,11 +1061,16 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
     },
     "bass": {"command": ["bass", "--lsp"], "languages": {"bass"}},
     "bicep-langserver": {"command": ["bicep-langserver"], "languages": {"bicep"}},
+    "bitbake-language-server": {
+        "command": ["bitbake-language-server"],
+        "languages": {"bitbake"},
+    },
     "bufls": {"command": ["bufls", "serve"], "languages": {"protobuf"}},
     "cairo-language-server": {
         "command": ["cairo-language-server"],
         "languages": {"cairo"},
     },
+    "circom-lsp": {"command": ["circom-lsp"], "languages": {"circom"}},
     "cl-lsp": {"command": ["cl-lsp", "stdio"], "languages": {"common-lisp"}},
     "clangd": {"command": ["clangd"], "languages": {"opencl", "cpp", "c"}},
     "clojure-lsp": {"command": ["clojure-lsp"], "languages": {"clojure"}},
@@ -1071,16 +1094,22 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "command": ["docker-langserver", "--stdio"],
         "languages": {"dockerfile"},
     },
+    "docker-compose-langserver": {
+        "command": ["docker-compose-langserver", "--stdio"],
+        "languages": {"docker-compose"},
+    },
     "dot-language-server": {
         "command": ["dot-language-server", "--stdio"],
         "languages": {"dot"},
     },
+    "earthlyls": {"command": ["earthlyls"], "languages": {"earthfile"}},
     "elixir-ls": {
-        "settings": {"elixirLS": {"dialyzerEnabled": False}},
+        "config": {"elixirLS": {"dialyzerEnabled": False}},
         "command": ["elixir-ls"],
-        "languages": {"elixir", "heex"},
+        "languages": {"heex", "elixir"},
     },
     "elm-language-server": {"command": ["elm-language-server"], "languages": {"elm"}},
+    "elp": {"command": ["elp", "server"], "languages": {"erlang"}},
     "elvish": {"command": ["elvish", "-lsp"], "languages": {"elvish"}},
     "erlang-ls": {"command": ["erlang_ls"], "languages": {"erlang"}},
     "forc": {"command": ["forc", "lsp"], "languages": {"sway"}},
@@ -1090,11 +1119,12 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"fortran"},
     },
     "fsharp-ls": {
-        "settings": {"AutomaticWorkspaceInit": True},
+        "config": {"AutomaticWorkspaceInit": True},
         "command": ["fsautocomplete"],
         "languages": {"fsharp"},
     },
     "gleam": {"command": ["gleam", "lsp"], "languages": {"gleam"}},
+    "glsl_analyzer": {"command": ["glsl_analyzer"], "languages": {"glsl"}},
     "graphql-language-service": {
         "command": ["graphql-lsp", "server", "-m", "stream"],
         "languages": {"graphql"},
@@ -1103,9 +1133,12 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "command": ["haskell-language-server-wrapper", "--lsp"],
         "languages": {"cabal", "haskell"},
     },
+    "hyprls": {"command": ["hyprls"], "languages": {"hyprlang"}},
     "idris2-lsp": {"command": ["idris2-lsp"], "languages": {"idris"}},
     "intelephense": {"command": ["intelephense", "--stdio"], "languages": {"php"}},
     "jdtls": {"command": ["jdtls"], "languages": {"java"}},
+    "jedi": {"command": ["jedi-language-server"], "languages": {"python"}},
+    "jq-lsp": {"command": ["jq-lsp"], "languages": {"jq"}},
     "jsonnet-language-server": {
         "command": ["jsonnet-language-server", "-t", "--lint"],
         "languages": {"jsonnet"},
@@ -1122,22 +1155,39 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         ],
         "languages": {"julia"},
     },
+    "koka": {
+        "command": ["koka", "--language-server", "--lsstdio"],
+        "languages": {"koka"},
+    },
     "kotlin-language-server": {
         "command": ["kotlin-language-server"],
         "languages": {"kotlin"},
     },
-    "lean": {"command": ["lean", "--server"], "languages": {"lean"}},
+    "lean": {"command": ["lean", "--server", "--memory=1024"], "languages": {"lean"}},
     "ltex-ls": {"command": ["ltex-ls"]},
     "markdoc-ls": {"command": ["markdoc-ls", "--stdio"], "languages": {"markdoc"}},
+    "markdown-oxide": {"command": ["markdown-oxide"], "languages": {"markdown"}},
     "marksman": {"command": ["marksman", "server"], "languages": {"markdown"}},
     "metals": {
-        "settings": {"isHttpEnabled": True},
+        "config": {
+            "isHttpEnabled": True,
+            "metals": {
+                "inlayHints": {
+                    "typeParameters": {"enable": True},
+                    "hintsInPatternMatch": {"enable": True},
+                }
+            },
+        },
         "command": ["metals"],
         "languages": {"scala"},
     },
+    "mesonlsp": {"command": ["mesonlsp", "--lsp"], "languages": {"meson"}},
     "mint": {"command": ["mint", "ls"], "languages": {"mint"}},
+    "mojo-lsp": {"command": ["mojo-lsp-server"], "languages": {"mojo"}},
     "nil": {"command": ["nil"], "languages": {"nix"}},
     "nimlangserver": {"command": ["nimlangserver"], "languages": {"nim"}},
+    "nimlsp": {"command": ["nimlsp"]},
+    "nixd": {"command": ["nixd"], "languages": {"nix"}},
     "nls": {"command": ["nls"], "languages": {"nickel"}},
     "nu-lsp": {"command": ["nu", "--lsp"], "languages": {"nu"}},
     "ocamllsp": {"command": ["ocamllsp"], "languages": {"ocaml", "ocaml-interface"}},
@@ -1150,6 +1200,10 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
     "pasls": {"command": ["pasls"], "languages": {"pascal"}},
     "pbkit": {"command": ["pb", "lsp"], "languages": {"protobuf"}},
     "perlnavigator": {"command": ["perlnavigator", "--stdio"], "languages": {"perl"}},
+    "pest-language-server": {
+        "command": ["pest-language-server"],
+        "languages": {"pest"},
+    },
     "prisma-language-server": {
         "command": ["prisma-language-server", "--stdio"],
         "languages": {"prisma"},
@@ -1158,13 +1212,18 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "command": ["purescript-language-server", "--stdio"],
         "languages": {"purescript"},
     },
-    "pylsp": {"command": ["pylsp"], "languages": {"python"}},
-    "pyright": {"settings": {}, "command": ["pyright-langserver", "--stdio"]},
+    "pylsp": {"command": ["pylsp"], "languages": {"snakemake", "python"}},
+    "pyright": {"config": {}, "command": ["pyright-langserver", "--stdio"]},
+    "basedpyright": {"config": {}, "command": ["basedpyright-langserver", "--stdio"]},
     "pylyzer": {"command": ["pylyzer", "--server"]},
     "qmlls": {"command": ["qmlls"], "languages": {"qml"}},
+    "quint-language-server": {
+        "command": ["quint-language-server", "--stdio"],
+        "languages": {"quint"},
+    },
     "r": {
         "command": ["R", "--no-echo", "-e", "languageserver::run()"],
-        "languages": {"r", "rmarkdown"},
+        "languages": {"rmarkdown", "r"},
     },
     "racket": {
         "command": ["racket", "-l", "racket-langserver"],
@@ -1176,11 +1235,16 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"rescript"},
     },
     "robotframework_ls": {"command": ["robotframework_ls"], "languages": {"robot"}},
+    "ruff": {"command": ["ruff", "server"], "languages": {"python"}},
     "serve-d": {"command": ["serve-d"], "languages": {"d"}},
     "slint-lsp": {"command": ["slint-lsp"], "languages": {"slint"}},
     "solargraph": {"command": ["solargraph", "stdio"], "languages": {"ruby"}},
     "solc": {"command": ["solc", "--lsp"], "languages": {"solidity"}},
     "sourcekit-lsp": {"command": ["sourcekit-lsp"], "languages": {"swift"}},
+    "spade-language-server": {
+        "command": ["spade-language-server"],
+        "languages": {"spade"},
+    },
     "svlangserver": {"command": ["svlangserver"], "languages": {"verilog"}},
     "swipl": {
         "command": [
@@ -1196,6 +1260,7 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         ],
         "languages": {"prolog"},
     },
+    "superhtml": {"command": ["superhtml", "lsp"], "languages": {"html"}},
     "tailwindcss-ls": {"command": ["tailwindcss-language-server", "--stdio"]},
     "taplo": {"command": ["taplo", "lsp", "stdio"], "languages": {"toml"}},
     "templ": {"command": ["templ", "lsp"], "languages": {"templ"}},
@@ -1204,36 +1269,38 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"tfvars", "hcl"},
     },
     "texlab": {"command": ["texlab"], "languages": {"latex", "bibtex"}},
+    "typespec": {"command": ["tsp-server", "--stdio"], "languages": {"typespec"}},
     "vala-language-server": {
         "command": ["vala-language-server"],
         "languages": {"vala"},
     },
+    "vale-ls": {"command": ["vale-ls"]},
     "vhdl_ls": {"command": ["vhdl_ls"], "languages": {"vhdl"}},
     "vlang-language-server": {"command": ["v-analyzer"], "languages": {"v"}},
     "vscode-css-language-server": {
-        "settings": {"provideFormatter": True, "css": {"validate": {"enable": True}}},
+        "config": {"provideFormatter": True, "css": {"validate": {"enable": True}}},
         "command": ["vscode-css-language-server", "--stdio"],
         "languages": {"scss", "css"},
     },
     "vscode-html-language-server": {
-        "settings": {"provideFormatter": True},
+        "config": {"provideFormatter": True},
         "command": ["vscode-html-language-server", "--stdio"],
         "languages": {"html"},
     },
     "vscode-json-language-server": {
-        "settings": {"provideFormatter": True, "json": {"validate": {"enable": True}}},
+        "config": {"provideFormatter": True, "json": {"validate": {"enable": True}}},
         "command": ["vscode-json-language-server", "--stdio"],
-        "languages": {"json"},
+        "languages": {"jsonc", "json"},
     },
     "vuels": {
-        "settings": {"typescript": {"tsdk": "node_modules/typescript/lib/"}},
+        "config": {"typescript": {"tsdk": "node_modules/typescript/lib/"}},
         "command": ["vue-language-server", "--stdio"],
         "languages": {"vue"},
     },
     "wgsl_analyzer": {"command": ["wgsl_analyzer"], "languages": {"wgsl"}},
     "yaml-language-server": {
         "command": ["yaml-language-server", "--stdio"],
-        "languages": {"yaml"},
+        "languages": {"yaml", "docker-compose"},
     },
     "zls": {"command": ["zls"], "languages": {"zig"}},
     "blueprint-compiler": {
@@ -1241,12 +1308,22 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"blueprint"},
     },
     "typst-lsp": {"command": ["typst-lsp"], "languages": {"typst"}},
+    "tinymist": {"command": ["tinymist"], "languages": {"typst"}},
+    "pkgbuild-language-server": {
+        "command": ["pkgbuild-language-server"],
+        "languages": {"pkgbuild"},
+    },
+    "helm_ls": {"command": ["helm_ls", "serve"], "languages": {"helm"}},
+    "ember-language-server": {
+        "command": ["ember-language-server", "--stdio"],
+        "languages": {"gts", "gjs", "glimmer"},
+    },
     "ansible-language-server": {
         "command": ["ansible-language-server", "--stdio"],
         "languages": {"yaml"},
     },
     "lua-language-server": {
-        "settings": {
+        "config": {
             "Lua": {
                 "hint": {
                     "enable": True,
@@ -1262,7 +1339,7 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"lua"},
     },
     "gopls": {
-        "settings": {
+        "config": {
             "hints": {
                 "assignVariableTypes": True,
                 "compositeLiteralFields": True,
@@ -1273,10 +1350,10 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
             }
         },
         "command": ["gopls"],
-        "languages": {"gotmpl", "gowork", "go", "gomod"},
+        "languages": {"go", "gowork", "gotmpl", "gomod"},
     },
     "golangci-lint-lsp": {
-        "settings": {
+        "config": {
             "command": [
                 "golangci-lint",
                 "run",
@@ -1289,7 +1366,7 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"go"},
     },
     "rust-analyzer": {
-        "settings": {
+        "config": {
             "inlayHints": {
                 "bindingModeHints": {"enable": False},
                 "closingBraceHints": {"minLines": 10},
@@ -1303,7 +1380,7 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"rust"},
     },
     "typescript-language-server": {
-        "settings": {
+        "config": {
             "hostInfo": "helix",
             "typescript": {
                 "inlayHints": {
@@ -1329,10 +1406,10 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
             },
         },
         "command": ["typescript-language-server", "--stdio"],
-        "languages": {"tsx", "typescript", "jsx", "javascript"},
+        "languages": {"jsx", "typescript", "javascript", "tsx"},
     },
     "svelteserver": {
-        "settings": {
+        "config": {
             "configuration": {
                 "typescript": {
                     "inlayHints": {
@@ -1359,4 +1436,21 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "command": ["svelteserver", "--stdio"],
         "languages": {"svelte"},
     },
+    "vscode-eslint-language-server": {
+        "config": {
+            "validate": "on",
+            "experimental": {"useFlatConfig": False},
+            "rulesCustomizations": [],
+            "run": "onType",
+            "problems": {"shortenToSingleLine": False},
+            "nodePath": "",
+            "codeAction": {
+                "disableRuleComment": {"enable": True, "location": "separateLine"},
+                "showDocumentation": {"enable": True},
+            },
+            "workingDirectory": {"mode": "location"},
+        },
+        "command": ["vscode-eslint-language-server", "--stdio"],
+        "languages": {"gts", "gjs"},
+    },
 }

euporie/core/margins.py

@@ -17,7 +17,7 @@ from prompt_toolkit.layout.screen import WritePosition
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType
 from prompt_toolkit.mouse_events import MouseEvent as PtkMouseEvent
 
-from euporie.core.current import get_app
+from euporie.core.app.current import get_app
 from euporie.core.key_binding.bindings.mouse import MouseEvent, RelativePosition
 from euporie.core.layout.containers import Window
 

euporie/core/path.py

@@ -9,35 +9,72 @@ from typing import TYPE_CHECKING
 import upath
 from aiohttp.client_reqrep import ClientResponse
 from fsspec.implementations.http import HTTPFileSystem as FsHTTPFileSystem
+from fsspec.implementations.http import get_client
 from fsspec.registry import register_implementation as fs_register_implementation
 from upath import UPath
 
 if TYPE_CHECKING:
+    import asyncio
+    from collections.abc import Mapping
     from os import PathLike
-    from typing import Any, Mapping
+    from typing import Any, Callable
 
-
-log = logging.getLogger(__name__)
-
-
-# Monkey-patch `aiohttp` to not raise exceptions on non-200 responses
+    import aiohttp
 
 
-def _raise_for_status(self: ClientResponse) -> None:
-    """Monkey-patch :py:class:`aiohttp.ClientResponse` not to raise for any status."""
-
+log = logging.getLogger(__name__)
 
-setattr(ClientResponse, "raise_for_status", _raise_for_status)  # noqa B010
 
+class NoRaiseClientResponse(ClientResponse):
+    """An ``aiohttp`` client response which does not raise on >=400 status responses."""
 
-# Define and register non-raising HTTP filesystem implementation for fsspec
+    @property
+    def ok(self) -> bool:
+        """Returns ``True`` if ``status`` is probably renderable."""
+        return self.status not in {405}
 
 
 class HTTPFileSystem(FsHTTPFileSystem):
-    """A :py:class:`HTTPFileSystem` which does not raise exceptions on 404 errors."""
+    """A HTTP filesystem implementation which does not raise on errors."""
+
+    def __init__(
+        self,
+        simple_links: bool = True,
+        block_size: int | None = None,
+        same_scheme: bool = True,
+        size_policy: None = None,
+        cache_type: str = "bytes",
+        cache_options: dict[str, Any] | None = None,
+        asynchronous: bool = False,
+        loop: asyncio.AbstractEventLoop | None = None,
+        client_kwargs: dict[str, Any] | None = None,
+        get_client: Callable[..., aiohttp.ClientSession] = get_client,
+        encoded: bool = False,
+        **storage_options: Any,
+    ) -> None:
+        """Defaults to using :py:mod:`NoRaiseClientResponse` for responses."""
+        client_kwargs = {
+            "response_class": NoRaiseClientResponse,
+            **(client_kwargs or {}),
+        }
+        super().__init__(
+            simple_links=simple_links,
+            block_size=block_size,
+            same_scheme=same_scheme,
+            size_policy=size_policy,
+            cache_type=cache_type,
+            cache_options=cache_options,
+            asynchronous=asynchronous,
+            loop=loop,
+            client_kwargs=client_kwargs,
+            get_client=get_client,
+            encoded=encoded,
+            **storage_options,
+        )
 
     def _raise_not_found_for_status(self, response: ClientResponse, url: str) -> None:
         """Do not raise an exception for 404 errors."""
+        response.raise_for_status()
 
 
 fs_register_implementation("http", HTTPFileSystem, clobber=True)
@@ -62,8 +99,15 @@ class UntitledPath(upath.core.UPath):
         return False
 
 
-def parse_path(path: str | PathLike, resolve: bool = True) -> Path:
+def parse_path(path: str | PathLike, resolve: bool | None = None) -> Path:
     """Parse and resolve a path."""
+    if resolve is None:
+        from upath.implementations.http import HTTPPath
+
+        if isinstance(path, HTTPPath):
+            resolve = True
+        else:
+            resolve = False
     if not isinstance(path, Path):
         path = UPath(path)
     try:
@@ -75,4 +119,9 @@ def parse_path(path: str | PathLike, resolve: bool = True) -> Path:
             path = path.resolve()
         except (AttributeError, NotImplementedError, Exception):
             log.info("Path %s not resolvable", path)
+    else:
+        try:
+            path = path.absolute()
+        except NotImplementedError:
+            pass
     return path

euporie/core/renderer.py

@@ -3,11 +3,13 @@
 from __future__ import annotations
 
 import logging
+from hashlib import md5
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.data_structures import Point, Size
 from prompt_toolkit.filters import to_filter
 from prompt_toolkit.layout.mouse_handlers import MouseHandlers
+from prompt_toolkit.layout.screen import Char
 from prompt_toolkit.renderer import Renderer as PtkRenderer
 from prompt_toolkit.renderer import _StyleStringHasStyleCache, _StyleStringToAttrsCache
 
@@ -25,7 +27,6 @@ if TYPE_CHECKING:
     from prompt_toolkit.output import ColorDepth, Output
     from prompt_toolkit.styles import BaseStyle
 
-
 __all__ = ["Renderer"]
 
 log = logging.getLogger(__name__)
@@ -117,19 +118,27 @@ def _output_screen_diff(
             write(char.char)
             last_style = char.style
 
+    def hash_screen_row(row: dict[int, Char], zwe_row: dict[int, str]) -> str:
+        """Generate a hash for a screen row to quickly detect changes."""
+        hasher = md5(usedforsecurity=False)
+        # Hash the character data
+        for idx in sorted(row.keys()):
+            cell = row[idx]
+            hasher.update(f"{idx}:{cell.char}:{cell.style}".encode())
+        # Hash the zero-width escapes
+        for idx in sorted(zwe_row.keys()):
+            hasher.update(f"{idx}:{zwe_row[idx]}".encode())
+        return hasher.hexdigest()
+
     def get_max_column_index(row: dict[int, Char], zwe_row: dict[int, str]) -> int:
         """Return max used column index, ignoring trailing unstyled whitespace."""
-        return max(
-            {
-                index
-                for index, cell in row.items()
-                if cell.char != " " or style_string_has_style[cell.style]
-            }
-            # Lag ZWE indices by one, as one could exist after the last line character
-            # but we don't want that to count towards the line width
-            | {x - 1 for x in zwe_row}
-            | {0}
-        )
+        max_idx = 0
+        for idx, cell in row.items():
+            if cell.char != " " or style_string_has_style[cell.style]:
+                max_idx = max(max_idx, idx)
+        for idx in zwe_row:
+            max_idx = max(max_idx, idx - 1)
+        return max_idx
 
     # Render for the first time: reset styling.
     if not previous_screen:
@@ -169,6 +178,14 @@ def _output_screen_diff(
         zwe_row = screen.zero_width_escapes[y]
         previous_zwe_row = previous_screen.zero_width_escapes[y]
 
+        # Quick comparison using row hashes
+        new_hash = hash_screen_row(new_row, zwe_row)
+        prev_hash = hash_screen_row(previous_row, previous_zwe_row)
+
+        if new_hash == prev_hash:
+            # Rows are identical, skip to next row
+            continue
+
         new_max_line_len = min(width - 1, get_max_column_index(new_row, zwe_row))
         previous_max_line_len = min(
             width - 1, get_max_column_index(previous_row, previous_zwe_row)
@@ -275,26 +292,34 @@ class Renderer(PtkRenderer):
         )
         self._extended_keys_enabled = False
         self._private_sixel_colors_enabled = False
+        self._sgr_pixel_enabled = False
         self.extend_height = to_filter(extend_height)
         self.extend_width = to_filter(extend_width)
 
     def reset(self, _scroll: bool = False, leave_alternate_screen: bool = True) -> None:
         """Reset the output."""
-        if isinstance(self.output, Vt100_Output):
+        output = self.output
+        if isinstance(output, Vt100_Output):
             # Disable extended keys before resetting the output
-            self.output.disable_extended_keys()
+            output.disable_extended_keys()
             self._extended_keys_enabled = False
 
             # Disable private sixel colors before resetting the output
-            self.output.disable_private_sixel_colors()
+            output.disable_private_sixel_colors()
             self._private_sixel_colors_enabled = False
 
+            # Disable sgr pixel mode
+            output.disable_sgr_pixel()
+            self._sgr_pixel_enabled = False
+
         super().reset(_scroll, leave_alternate_screen)
 
     def render(
         self, app: Application[Any], layout: Layout, is_done: bool = False
     ) -> None:
         """Render the current interface to the output."""
+        from euporie.core.app.app import BaseApp
+
         output = self.output
         self.app = app
 
@@ -320,13 +345,29 @@ class Renderer(PtkRenderer):
             output.enable_mouse_support()
             self._mouse_support_enabled = True
 
+            if (
+                isinstance(output, Vt100_Output)
+                and isinstance(app, BaseApp)
+                and app.term_sgr_pixel
+            ):
+                output.enable_sgr_pixel()
+                self._sgr_pixel_enabled = True
+
         elif not needs_mouse_support and self._mouse_support_enabled:
             output.disable_mouse_support()
             self._mouse_support_enabled = False
 
+            if (
+                isinstance(output, Vt100_Output)
+                and isinstance(app, BaseApp)
+                and (app.term_sgr_pixel or self._sgr_pixel_enabled)
+            ):
+                output.disable_sgr_pixel()
+                self._sgr_pixel_enabled = False
+
         # Ensable extended keys
-        if not self._extended_keys_enabled and isinstance(self.output, Vt100_Output):
-            self.output.enable_extended_keys()
+        if not self._extended_keys_enabled and isinstance(output, Vt100_Output):
+            output.enable_extended_keys()
             self._extended_keys_enabled = True
 
         # Ensable private sixel graphic color registers