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

euporie/core/{app.py → app/app.py}

@@ -3,10 +3,12 @@
 from __future__ import annotations
 
 import asyncio
-import json
 import logging
+import os
 import signal
 import sys
+from abc import ABC, abstractmethod
+from enum import Enum
 from functools import partial
 from pathlib import PurePath
 from typing import TYPE_CHECKING, cast
@@ -14,8 +16,8 @@ from weakref import WeakSet, WeakValueDictionary
 
 from prompt_toolkit.application.application import Application, _CombinedRegistry
 from prompt_toolkit.application.current import create_app_session, set_app
-from prompt_toolkit.cursor_shapes import CursorShape, CursorShapeConfig
 from prompt_toolkit.data_structures import Point
+from prompt_toolkit.enums import EditingMode
 from prompt_toolkit.filters import Condition, buffer_has_focus, to_filter
 from prompt_toolkit.input.defaults import create_input
 from prompt_toolkit.key_binding.bindings.basic import (
@@ -30,10 +32,7 @@ from prompt_toolkit.key_binding.bindings.emacs import (
 from prompt_toolkit.key_binding.bindings.mouse import (
     load_mouse_bindings as load_ptk_mouse_bindings,
 )
-from prompt_toolkit.key_binding.bindings.vi import (
-    load_vi_bindings,
-    load_vi_search_bindings,
-)
+from prompt_toolkit.key_binding.bindings.vi import load_vi_search_bindings
 from prompt_toolkit.key_binding.key_bindings import (
     ConditionalKeyBindings,
     merge_key_bindings,
@@ -54,18 +53,15 @@ from prompt_toolkit.styles import (
     merge_styles,
     style_from_pygments_cls,
 )
-from pygments.styles import STYLE_MAP as pygments_styles
-from pygments.styles import get_style_by_name
-from upath import UPath
+from prompt_toolkit.utils import Event
 
-from euporie.core.clipboard import ConfiguredClipboard
-from euporie.core.commands import add_cmd
-from euporie.core.config import Config, add_setting
+from euporie.core.app.base import ConfigurableApp
+from euporie.core.app.cursor import CursorConfig
+from euporie.core.clipboard import CONFIGURED_CLIPBOARDS
 from euporie.core.convert.mime import get_mime
-from euporie.core.current import get_app
-from euporie.core.filters import in_mplex, insert_mode, replace_mode, tab_has_focus
+from euporie.core.filters import has_toolbar
 from euporie.core.format import CliFormatter
-from euporie.core.io import Vt100_Output, Vt100Parser
+from euporie.core.io import COLOR_DEPTHS, Vt100_Output, Vt100Parser
 from euporie.core.key_binding.key_processor import KeyProcessor
 from euporie.core.key_binding.micro_state import MicroState
 from euporie.core.key_binding.registry import (
@@ -86,8 +82,8 @@ from euporie.core.style import (
     MIME_STYLE,
     ColorPalette,
     build_style,
+    get_style_by_name,
 )
-from euporie.core.terminal import TerminalInfo
 from euporie.core.utils import ChainedList
 from euporie.core.widgets.decor import Shadow
 from euporie.core.widgets.menu import CompletionsMenu
@@ -96,84 +92,38 @@ if TYPE_CHECKING:
     from asyncio import AbstractEventLoop
     from pathlib import Path
     from types import FrameType
-    from typing import Any, Callable, TypeVar
+    from typing import Any, Callable, ClassVar, TypeVar
 
     # from prompt_toolkit.application import _AppResult
-    from prompt_toolkit.clipboard import Clipboard
     from prompt_toolkit.contrib.ssh import PromptToolkitSSHSession
-    from prompt_toolkit.enums import EditingMode
     from prompt_toolkit.filters import Filter, FilterOrBool
     from prompt_toolkit.input import Input
+    from prompt_toolkit.layout.containers import AnyContainer
     from prompt_toolkit.layout.layout import FocusableElement
     from prompt_toolkit.layout.screen import WritePosition
     from prompt_toolkit.output import Output
 
+    from euporie.core.bars.command import CommandBar
+    from euporie.core.bars.search import SearchBar
     from euporie.core.config import Setting
     from euporie.core.format import Formatter
+    from euporie.core.tabs import TabRegistryEntry
     from euporie.core.tabs.base import Tab
-    from euporie.core.terminal import TerminalQuery
     from euporie.core.widgets.dialog import Dialog
     from euporie.core.widgets.pager import Pager
-    from euporie.core.widgets.search import SearchBar
 
     _AppResult = TypeVar("_AppResult")
 
 log = logging.getLogger(__name__)
 
 
-_COLOR_DEPTHS = {
-    1: ColorDepth.DEPTH_1_BIT,
-    4: ColorDepth.DEPTH_4_BIT,
-    8: ColorDepth.DEPTH_8_BIT,
-    24: ColorDepth.DEPTH_24_BIT,
-}
-
-
-class CursorConfig(CursorShapeConfig):
-    """Determine which cursor mode to use."""
-
-    def get_cursor_shape(self, app: Application[Any]) -> CursorShape:
-        """Return the cursor shape to be used in the current state."""
-        if isinstance(app, BaseApp) and app.config.set_cursor_shape:
-            if insert_mode():
-                if app.config.cursor_blink:
-                    return CursorShape.BLINKING_BEAM
-                else:
-                    return CursorShape.BEAM
-            elif replace_mode():
-                if app.config.cursor_blink:
-                    return CursorShape.BLINKING_UNDERLINE
-                else:
-                    return CursorShape.UNDERLINE
-        return CursorShape.BLOCK
-
-    # ################################### Settings ####################################w
-
-    add_setting(
-        name="set_cursor_shape",
-        flags=["--set-cursor-shape"],
-        type_=bool,
-        default=True,
-        menu_title="Change cursor shape",
-        help_="Whether to set the shape of the cursor depending on the editing mode",
-        description="""
-            When set to True, the euporie will set the shape of the terminal's cursor
-            to a beam in insert mode and and underline in replace mode when editing.
-    """,
-    )
-    add_setting(
-        name="cursor_blink",
-        flags=["--cursor-blink"],
-        type_=bool,
-        default=False,
-        help_="Whether to blink the cursor",
-        description="""
-            When set to True, the cursor will blink.
-    """,
-    )
+class ExtraEditingMode(str, Enum):
+    """Additional editing modes."""
 
+    MICRO = "MICRO"
 
-class BaseApp(Application):
+
+class BaseApp(ConfigurableApp, Application, ABC):
     """All euporie apps.
 
     The base euporie application class.
@@ -182,12 +132,10 @@ class BaseApp(Application):
     wide methods can be easily added.
     """
 
-    name: str
     color_palette: ColorPalette
     mouse_position: Point
 
-    config = Config()
-    log_stdout_level: str = "CRITICAL"
+    _config_defaults: ClassVar[dict[str, Any]] = {"log_level_stdout": "critical"}
 
     def __init__(
         self,
@@ -221,7 +169,10 @@ class BaseApp(Application):
         # Initialise the application
         super().__init__(
             **{
-                "color_depth": self.config.color_depth,
+                "clipboard": CONFIGURED_CLIPBOARDS.get(
+                    self.config.clipboard, lambda: None
+                )(),
+                "color_depth": COLOR_DEPTHS.get(self.config.color_depth),
                 "editing_mode": self.get_edit_mode(),
                 "mouse_support": True,
                 "cursor": CursorConfig(),
@@ -241,14 +192,21 @@ class BaseApp(Application):
         )
         # Contains the opened tab containers
         self.tabs: list[Tab] = []
-        # Holds the search bar to pass to cell inputs
+        self.on_tabs_change = Event(self)
+        # Holds the optional toolbars
         self.search_bar: SearchBar | None = None
+        self.command_bar: CommandBar | None = None
         # Holds the index of the current tab
         self._tab_idx = 0
         # Add state for micro key-bindings
         self.micro_state = MicroState()
-        # Load the terminal information system
-        self.term_info = TerminalInfo(self.input, self.output, self.config)
+        # Default terminal info values
+        self.term_colors = dict(DEFAULT_COLORS)
+        self.term_graphics_sixel = False
+        self.term_graphics_iterm = False
+        self.term_graphics_kitty = False
+        self.term_sgr_pixel = False
+        self._term_size_px: tuple[int, int]
         # Floats at the app level
         self.leave_graphics = to_filter(leave_graphics)
         self.graphics: WeakSet[Float] = WeakSet()
@@ -273,15 +231,16 @@ class BaseApp(Application):
         self.key_processor = KeyProcessor(_CombinedRegistry(self))
         # List of key-bindings groups to load
         self.bindings_to_load = [
-            "euporie.core.app.BaseApp",
-            "euporie.core.terminal.TerminalInfo",
+            "euporie.core.app.app:BaseApp",
+            "euporie.core.io.TerminalInfo",
         ]
 
-        from euporie.core.key_binding.bindings.page_navigation import (
-            load_page_navigation_bindings,
-        )
+        if enable_page_navigation_bindings:
+            from euporie.core.key_binding.bindings.page_navigation import (
+                load_page_navigation_bindings,
+            )
 
-        self._page_navigation_bindings = load_page_navigation_bindings(self.config)
+            self._page_navigation_bindings = load_page_navigation_bindings(self.config)
         # Allow hiding element when manually redrawing app
         self._redrawing = False
         self.redrawing = Condition(lambda: self._redrawing)
@@ -293,14 +252,17 @@ class BaseApp(Application):
         self.set_title = to_filter(set_title)
         self.title = title or self.__class__.__name__
         # Register config hooks
-        self.config.get_item("edit_mode").event += self.update_edit_mode
-        self.config.get_item("syntax_theme").event += self.update_style
-        self.config.get_item("color_scheme").event += self.update_style
-        self.config.get_item("log_level").event += lambda x: setup_logs(self.config)
-        self.config.get_item("log_file").event += lambda x: setup_logs(self.config)
-        self.config.get_item("log_config").event += lambda x: setup_logs(self.config)
-        self.config.get_item("color_depth").event += lambda x: setattr(
-            self, "_color_depth", _COLOR_DEPTHS[x.value]
+        self.config.events.edit_mode += self.update_edit_mode
+        self.config.events.syntax_theme += self.update_style
+        self.config.events.color_scheme += self.update_style
+        self.config.events.log_level += lambda x: setup_logs(self.config)
+        self.config.events.log_file += lambda x: setup_logs(self.config)
+        self.config.events.log_config += lambda x: setup_logs(self.config)
+        self.config.events.color_depth += lambda x: setattr(
+            self, "_color_depth", COLOR_DEPTHS[self.config.color_depth]
+        )
+        self.config.events.clipboard += lambda x: setattr(
+            self, "clipboard", CONFIGURED_CLIPBOARDS[self.config.clipboard]
         )
         # Set up the color palette
         self.color_palette = ColorPalette()
@@ -318,6 +280,30 @@ class BaseApp(Application):
             CliFormatter(**info) for info in self.config.formatters
         ]
 
+    @property
+    def term_size_px(self) -> tuple[int, int]:
+        """The dimensions of the terminal in pixels."""
+        try:
+            return self._term_size_px
+        except AttributeError:
+            from euporie.core.io import _tiocgwinsz
+
+            _rows, _cols, px, py = _tiocgwinsz()
+            self._term_size_px = (px, py)
+        return self._term_size_px
+
+    @term_size_px.setter
+    def term_size_px(self, value: tuple[int, int]) -> None:
+        self._term_size_px = value
+
+    @property
+    def cell_size_px(self) -> tuple[int, int]:
+        """Get the pixel size of a single terminal cell."""
+        px, py = self.term_size_px
+        rows, cols = self.output.get_size()
+        # If we can't get the pixel size, just guess wildly
+        return px // cols or 10, py // rows or 20
+
     @property
     def title(self) -> str:
         """The application's title."""
@@ -351,28 +337,32 @@ class BaseApp(Application):
 
     def pre_run(self, app: Application | None = None) -> None:
         """Call during the 'pre-run' stage of application loading."""
-        # Determines which clipboard mechanism to use based on configuration
-        self.clipboard: Clipboard = ConfiguredClipboard(self)
-        # Determine what color depth to use
-        self._color_depth = _COLOR_DEPTHS.get(
-            self.config.color_depth, self.term_info.depth_of_color.value
-        )
-        # Set the application's style, and update it when the terminal responds
+        # Set the application's style
         self.update_style()
-        self.term_info.colors.event += self.update_style
-        # Load completions menu. This must be done after the app is set, because
-        # :py:func:`get_app` is needed to access the config
+        # Load completions menu.
         self.menus["completions"] = Float(
-            content=Shadow(CompletionsMenu()),
+            content=Shadow(CompletionsMenu(extra_filter=~has_toolbar)),
             xcursor=True,
             ycursor=True,
         )
-        # Open any files we need to
-        self.open_files()
         # Load the layout
         # We delay this until we have terminal responses to allow terminal graphics
         # support to be detected first
         self.layout = Layout(self.load_container(), self.focused_element)
+        # Open any files we need to
+        self.open_files()
+        # Start polling terminal style if configured
+        if self.config.terminal_polling_interval and hasattr(
+            self.input, "vt100_parser"
+        ):
+            self.create_background_task(self._poll_terminal_colors())
+
+    async def _poll_terminal_colors(self) -> None:
+        """Repeatedly query the terminal for its background and foreground colours."""
+        if isinstance(output := self.output, Vt100_Output):
+            while self.config.terminal_polling_interval:
+                await asyncio.sleep(self.config.terminal_polling_interval)
+                output.get_colors()
 
     async def run_async(
         self,
@@ -383,26 +373,50 @@ class BaseApp(Application):
     ) -> _AppResult:
         """Run the application."""
         with set_app(self):
+            # Use a custom vt100 parser to allow querying the terminal
+            if parser := getattr(self.input, "vt100_parser", None):
+                setattr(  # noqa B010
+                    self.input, "vt100_parser", Vt100Parser(parser.feed_key_callback)
+                )
+
             # Load key bindings
             self.load_key_bindings()
-            # Send queries to the terminal
-            self.term_info.send_all()
-            # Read responses
-            kp = self.key_processor
-
-            def read_from_input() -> None:
-                kp.feed_multiple(self.input.read_keys())
 
-            with self.input.raw_mode(), self.input.attach(read_from_input):
-                # Give the terminal time to respond and allow the event loop to read
-                # the terminal responses from the input
-                await asyncio.sleep(0.1)
-            kp.process_keys()
+            if isinstance(self.output, Vt100_Output):
+                # Send terminal queries
+                self.output.get_colors()
+                self.output.get_pixel_size()
+                self.output.get_kitty_graphics_status()
+                self.output.get_sixel_graphics_status()
+                self.output.get_iterm_graphics_status()
+                self.output.get_sgr_pixel_status()
+                self.output.get_csiu_status()
+                self.output.flush()
+
+                # Read responses
+                kp = self.key_processor
+
+                def read_from_input() -> None:
+                    kp.feed_multiple(self.input.read_keys())
+
+                with self.input.raw_mode(), self.input.attach(read_from_input):
+                    # Give the terminal time to respond and allow the event loop to read
+                    # the terminal responses from the input
+                    await asyncio.sleep(0.1)
+                kp.process_keys()
 
         return await super().run_async(
             pre_run, set_exception_handler, handle_sigint, slow_callback_duration
         )
 
+    @classmethod
+    async def interact(cls, ssh_session: PromptToolkitSSHSession) -> None:
+        """Run the app asynchronously for the hub SSH server."""
+        try:
+            await cls().run_async()
+        except EOFError:
+            pass
+
     @classmethod
     def load_input(cls) -> Input:
         """Create the input for this application to use.
@@ -420,12 +434,6 @@ class BaseApp(Application):
 
             input_ = IgnoredInput()
 
-        # Use a custom vt100 parser to allow querying the terminal
-        if parser := getattr(input_, "vt100_parser", None):
-            setattr(  # noqa B010
-                input_, "vt100_parser", Vt100Parser(parser.feed_key_callback)
-            )
-
         return input_
 
     @classmethod
@@ -462,6 +470,8 @@ class BaseApp(Application):
         from euporie.core.key_binding.bindings.basic import load_basic_bindings
         from euporie.core.key_binding.bindings.micro import load_micro_bindings
         from euporie.core.key_binding.bindings.mouse import load_mouse_bindings
+        from euporie.core.key_binding.bindings.terminal import load_terminal_bindings
+        from euporie.core.key_binding.bindings.vi import load_vi_bindings
 
         self._default_bindings = merge_key_bindings(
             [
@@ -494,7 +504,7 @@ class BaseApp(Application):
                 # Load extra mouse bindings
                 load_mouse_bindings(),
                 # Load terminal query response key bindings
-                # load_command_bindings("terminal"),
+                load_terminal_bindings(),
             ]
         )
         self.key_bindings = load_registered_bindings(
@@ -503,40 +513,39 @@ class BaseApp(Application):
 
     def _on_resize(self) -> None:
         """Query the terminal dimensions on a resize event."""
-        self.term_info.pixel_dimensions.send()
+        if isinstance(output := self.output, Vt100_Output):
+            output.get_pixel_size()
         super()._on_resize()
 
     @classmethod
     def launch(cls) -> None:
         """Launch the app."""
-        # Load default logging
-        setup_logs()
-        # Load the app's configuration
-        cls.config.load(cls)
+        super().launch()
         # Run the application
         with create_app_session(input=cls.load_input(), output=cls.load_output()):
             # Create an instance of the app and run it
             app = cls()
-
             # Handle SIGTERM while the app is running
             original_sigterm = signal.getsignal(signal.SIGTERM)
             signal.signal(signal.SIGTERM, app.cleanup)
-            # Run the app
-            try:
-                result = app.run()
-            except (EOFError, KeyboardInterrupt):
-                result = None
-            finally:
-                signal.signal(signal.SIGTERM, original_sigterm)
-                # Shut down any remaining LSP clients at exit
-                app.shutdown_lsps()
+            # Set and run the app
+            with set_app(app):
+                try:
+                    result = app.run()
+                except (EOFError, KeyboardInterrupt):
+                    result = None
+                finally:
+                    signal.signal(signal.SIGTERM, original_sigterm)
+                    # Shut down any remaining LSP clients at exit
+                    app.shutdown_lsps()
         return result
 
     def cleanup(self, signum: int, frame: FrameType | None) -> None:
         """Restore the state of the terminal on unexpected exit."""
         log.critical("Unexpected exit signal, restoring terminal")
         output = self.output
-        self.exit()
+        if self.is_running:
+            self.exit()
         self.shutdown_lsps()
         # Reset terminal state
         output.reset_cursor_key_mode()
@@ -548,12 +557,8 @@ class BaseApp(Application):
         # Exit the main thread
         sys.exit(1)
 
-    @classmethod
-    async def interact(cls, ssh_session: PromptToolkitSSHSession) -> None:
-        """Run the app asynchronously for the hub SSH server."""
-        await cls().run_async()
-
-    def load_container(self) -> FloatContainer:
+    @abstractmethod
+    def load_container(self) -> AnyContainer:
         """Load the root container for this application.
 
         Returns:
@@ -565,27 +570,32 @@ class BaseApp(Application):
             floats=cast("list[Float]", self.floats),
         )
 
-    def get_file_tabs(self, path: Path) -> list[type[Tab]]:
-        """Return the tab to use for a file path."""
-        from euporie.core.tabs.base import Tab
+    @property
+    def tab_registry(self) -> list[TabRegistryEntry]:
+        """Return the tab registry."""
+        from euporie.core.tabs import _TAB_REGISTRY
+
+        return _TAB_REGISTRY
 
+    def get_file_tabs(self, path: Path) -> list[TabRegistryEntry]:
+        """Return the tab to use for a file path."""
         path_mime = get_mime(path) or "text/plain"
         log.debug("File %s has mime type: %s", path, path_mime)
 
-        tab_options = set()
-        for tab_cls in Tab._registry:
-            for mime_type in tab_cls.mime_types:
+        tab_options: list[TabRegistryEntry] = []
+        for entry in self.tab_registry:
+            for mime_type in entry.mime_types:
                 if PurePath(path_mime).match(mime_type):
-                    tab_options.add(tab_cls)
-            if path.suffix in tab_cls.file_extensions:
-                tab_options.add(tab_cls)
+                    tab_options.append(entry)
+            if path.suffix in entry.file_extensions:
+                tab_options.append(entry)
 
-        return sorted(tab_options, key=lambda x: x.weight, reverse=True)
+        return sorted(tab_options, reverse=True)
 
     def get_file_tab(self, path: Path) -> type[Tab] | None:
         """Return the tab to use for a file path."""
         if tabs := self.get_file_tabs(path):
-            return tabs[0]
+            return tabs[0].tab_class
         return None
 
     def get_language_lsps(self, language: str) -> list[LspClient]:
@@ -648,7 +658,7 @@ class BaseApp(Application):
                 log.error("Unable to display file %s", path)
             else:
                 tab = tab_class(self, ppath)
-                self.tabs.append(tab)
+                self.add_tab(tab)
                 # Ensure the opened tab is focused at app start
                 self.focused_element = tab
                 # Ensure the newly opened tab is selected
@@ -688,7 +698,7 @@ class BaseApp(Application):
             try:
                 self.layout.focus(container)
             except ValueError:
-                self.to_focus = container
+                log.exception("Cannot focus tab")
 
     def focus_tab(self, tab: Tab) -> None:
         """Make a tab visible and focuses it."""
@@ -704,20 +714,22 @@ class BaseApp(Application):
         # Remove tab
         if tab in self.tabs:
             self.tabs.remove(tab)
-        # Update body container to reflect new tab list
-        # assert isinstance(self.body_container.body, HSplit)
-        # self.body_container.body.children[0] = VSplit(self.tabs)
-        # Focus another tab if one exists
-        if self.tab:
-            self.layout.focus(self.tab)
-        # If a tab is not open, the status bar is not shown, so focus the logo, so
-        # pressing tab focuses the menu
+            self.on_tabs_change()
+        # Focus the next active tab if one exists
+        if next_tab := self.tab:
+            next_tab.focus()
+        # If no tab is open, ensure something is focused
         else:
             try:
                 self.layout.focus_next()
             except ValueError:
                 pass
 
+    def add_tab(self, tab: Tab) -> None:
+        """Add a tab to the current tabs list."""
+        self.tabs.append(tab)
+        self.on_tabs_change()
+
     def close_tab(self, tab: Tab | None = None) -> None:
         """Close a notebook tab.
 
@@ -733,27 +745,49 @@ class BaseApp(Application):
 
     def get_edit_mode(self) -> EditingMode:
         """Return the editing mode enum defined in the configuration."""
-        from euporie.core.key_binding.bindings.micro import EditingMode
+        micro_mode = cast("EditingMode", ExtraEditingMode.MICRO)
 
         return {
-            "micro": EditingMode.MICRO,  # type: ignore
+            "micro": micro_mode,
             "vi": EditingMode.VI,
             "emacs": EditingMode.EMACS,
-        }.get(
-            str(self.config.edit_mode),
-            EditingMode.MICRO,  # type: ignore
-        )
+        }.get(str(self.config.edit_mode), micro_mode)
 
     def update_edit_mode(self, setting: Setting | None = None) -> None:
         """Set the keybindings for editing mode."""
         self.editing_mode = self.get_edit_mode()
         log.debug("Editing mode set to: %s", self.editing_mode)
 
+    @property
+    def color_depth(self) -> ColorDepth:
+        """The active :class:`.ColorDepth`.
+
+        The current value is determined as follows:
+
+        - If a color depth was given explicitly to this application, use that
+          value.
+        - Otherwise, fall back to the color depth that is reported by the
+          :class:`.Output` implementation. If the :class:`.Output` class was
+          created using `output.defaults.create_output`, then this value is
+          coming from the $PROMPT_TOOLKIT_COLOR_DEPTH environment variable.
+        """
+        # Detect terminal color depth
+        if self._color_depth is None:
+            if os.environ.get("NO_COLOR", "") or os.environ.get("TERM", "") == "dumb":
+                self._color_depth = ColorDepth.DEPTH_1_BIT
+            colorterm = os.environ.get("COLORTERM", "")
+            if "truecolor" in colorterm or "24bit" in colorterm:
+                self._color_depth = ColorDepth.DEPTH_24_BIT
+            elif "256" in os.environ.get("TERM", ""):
+                self._color_depth = ColorDepth.DEPTH_8_BIT
+
+        return super().color_depth
+
     @property
     def syntax_theme(self) -> str:
         """Calculate the current syntax theme."""
         syntax_theme = self.config.syntax_theme
-        if syntax_theme == self.config.settings["syntax_theme"].default:
+        if syntax_theme == self.config.defaults.syntax_theme:
             syntax_theme = "tango" if self.color_palette.bg.is_light else "euporie"
         return syntax_theme
 
@@ -782,7 +816,7 @@ class BaseApp(Application):
         }
         base_colors: dict[str, str] = {
             **DEFAULT_COLORS,
-            **self.term_info.colors.value,
+            **self.term_colors,
             **theme_colors.get(self.config.color_scheme, theme_colors["default"]),
         }
 
@@ -839,10 +873,7 @@ class BaseApp(Application):
             ]
         )
 
-    def update_style(
-        self,
-        query: TerminalQuery | Setting | None = None,
-    ) -> None:
+    def update_style(self, query: Setting | None = None) -> None:
         """Update the application's style when the syntax theme is changed."""
         self.renderer.style = self.create_merged_style()
 
@@ -893,406 +924,17 @@ class BaseApp(Application):
     # print(task.get_loop())
     # await asyncio.wait([task])
 
-    # ################################### Commands ####################################
-
-    @staticmethod
-    @add_cmd()
-    def _quit() -> None:
-        """Quit euporie."""
-        get_app().exit()
-
-    @staticmethod
-    @add_cmd(
-        name="close-tab",
-        filter=tab_has_focus,
-        menu_title="Close File",
-    )
-    def _close_tab() -> None:
-        """Close the current tab."""
-        get_app().close_tab()
-
-    @staticmethod
-    @add_cmd(
-        filter=tab_has_focus,
-    )
-    def _next_tab() -> None:
-        """Switch to the next tab."""
-        get_app().tab_idx += 1
-
-    @staticmethod
-    @add_cmd(
-        filter=tab_has_focus,
-    )
-    def _previous_tab() -> None:
-        """Switch to the previous tab."""
-        get_app().tab_idx -= 1
-
-    @staticmethod
-    @add_cmd(
-        filter=~buffer_has_focus,
-    )
-    def _focus_next() -> None:
-        """Focus the next control."""
-        get_app().layout.focus_next()
-
-    @staticmethod
-    @add_cmd(
-        filter=~buffer_has_focus,
-    )
-    def _focus_previous() -> None:
-        """Focus the previous control."""
-        get_app().layout.focus_previous()
-
-    @staticmethod
-    @add_cmd()
-    def _clear_screen() -> None:
-        """Clear the screen."""
-        get_app().renderer.clear()
-
-    # ################################### Settings ####################################w
-
-    add_setting(
-        name="files",
-        default=[],
-        flags=["files"],
-        nargs="*",
-        type_=UPath,
-        help_="List of file names to open",
-        schema={
-            "type": "array",
-            "items": {
-                "description": "File path",
-                "type": "string",
-            },
-        },
-        description="""
-            A list of file paths to open when euporie is launched.
-        """,
-    )
-
-    add_setting(
-        name="edit_mode",
-        flags=["--edit-mode"],
-        type_=str,
-        choices=["micro", "emacs", "vi"],
-        title="Editor key bindings",
-        help_="Key-binding mode for text editing",
-        default="micro",
-        description="""
-            Key binding style to use when editing cells.
-        """,
-    )
-
-    add_setting(
-        name="tab_size",
-        flags=["--tab-size"],
-        type_=int,
-        help_="Spaces per indentation level",
-        default=4,
-        schema={
-            "minimum": 1,
-        },
-        description="""
-            The number of spaces to use per indentation level. Should be set to 4.
-        """,
-    )
-
-    add_setting(
-        name="terminal_polling_interval",
-        flags=["--terminal-polling-interval"],
-        type_=float,
-        help_="Time between terminal colour queries",
-        default=0.0,
-        schema={
-            "min": 0.0,
-        },
-        description="""
-            Determine how frequently the terminal should be polled for changes to the
-            background / foreground colours. Set to zero to disable terminal polling.
-        """,
-    )
-
-    add_setting(
-        name="formatters",
-        flags=["--formatters"],
-        type_=json.loads,
-        help_="List of external code formatters",
-        default=[
-            # {"command": ["ruff", "format", "-"], "languages": ["python"]},
-            # {"command": ["black", "-"], "languages": ["python"]},
-            # {"command": ["isort", "-"], "languages": ["python"]},
-        ],
-        action="append",
-        schema={
-            "type": "array",
-            "items": {
-                "type": "object",
-                "properties": {
-                    "command": {
-                        "type": "array",
-                        "items": [{"type": "string"}],
-                    },
-                    "languages": {
-                        "type": "array",
-                        "items": [{"type": "string", "unique": True}],
-                    },
-                },
-                "required": ["command", "languages"],
-            },
-        },
-        description="""
-            An array listing languages and commands of formatters to use for
-            reformatting code cells. The command is an array of the command any any
-            arguments. Code to be formatted is pass in via the standard input, and
-            replaced with the standard output.
-
-            e.g.
-
-               [
-                 {"command": ["ruff", "format", "-"], "languages": ["python"]},
-                 {"command": ["black", "-"], "languages": ["python"]},
-                 {"command": ["isort", "-"], "languages": ["python"]}
-               ]
-        """,
-    )
-
-    add_setting(
-        name="syntax_theme",
-        flags=["--syntax-theme"],
-        type_=str,
-        help_="Syntax highlighting theme",
-        default="euporie",
-        schema={
-            # Do not want to print all theme names in `--help` screen as it looks messy
-            # so we only add them in the scheme, not as setting choices
-            "enum": list(pygments_styles.keys()),
-        },
-        description="""
-            The name of the pygments style to use for syntax highlighting.
-        """,
-    )
-
-    add_setting(
-        name="color_depth",
-        flags=["--color-depth"],
-        type_=int,
-        choices=[1, 4, 8, 24],
-        default=None,
-        help_="The color depth to use",
-        description="""
-            The number of bits to use to represent colors displayable on the screen.
-            If set to None, the supported color depth of the terminal will be detected
-            automatically.
-        """,
-    )
-
-    add_setting(
-        name="multiplexer_passthrough",
-        flags=["--multiplexer-passthrough"],
-        type_=bool,
-        help_="Use passthrough from within terminal multiplexers",
-        default=False,
-        hidden=~in_mplex,
-        description="""
-            If set and euporie is running inside a terminal multiplexer
-            (:program:`screen` or :program:`tmux`), then certain escape sequences
-            will be passed-through the multiplexer directly to the terminal.
-
-            This affects things such as terminal color detection and graphics display.
-
-            for tmux, you will also need to ensure that ``allow-passthrough`` is set to
-            ``on`` in your :program:`tmux` configuration.
-
-            .. warning::
-
-               Terminal graphics in :program:`tmux` is experimental, and is not
-               guaranteed to work. Use at your own risk!
-
-            .. note::
-               As of version :command:`tmux` version ``3.4`` sixel graphics are
-               supported, which may result in better terminal graphics then using
-               multiplexer passthrough.
-        """,
-    )
-
-    add_setting(
-        name="color_scheme",
-        flags=["--color-scheme"],
-        type_=str,
-        choices=["default", "inverse", "light", "dark", "black", "white", "custom"],
-        help_="The color scheme to use",
-        default="default",
-        description="""
-            The color scheme to use: `auto` means euporie will try to use your
-            terminal's color scheme, `light` means black text on a white background,
-            and `dark` means white text on a black background.
-        """,
-    )
-
-    add_setting(
-        name="custom_background_color",
-        flags=["--custom-background-color", "--custom-bg-color", "--bg"],
-        type_=str,
-        help_='Background color for "Custom" color theme',
-        default="#073642",
-        schema={
-            "maxLength": 7,
-        },
-        description="""
-            The hex code of the color to use for the background in the "Custom" color
-            scheme.
-        """,
-    )
-
-    add_setting(
-        name="custom_foreground_color",
-        flags=["--custom-foreground-color", "--custom-fg-color", "--fg"],
-        type_=str,
-        help_='Foreground color for "Custom" color theme',
-        default="#839496",
-        schema={
-            "maxLength": 7,
-        },
-        description="""
-            The hex code of the color to use for the foreground in the "Custom" color
-            scheme.
-        """,
-    )
-
-    add_setting(
-        name="accent_color",
-        flags=["--accent-color"],
-        type_=str,
-        help_="Accent color to use in the app",
-        default="ansiblue",
-        description="""
-            The hex code of a color to use for the accent color in the application.
-        """,
-    )
-
-    add_setting(
-        name="key_bindings",
-        flags=["--key-bindings"],
-        type_=json.loads,
-        help_="Additional key binding definitions",
-        default={},
-        description="""
-            A mapping of component names to mappings of command name to key-binding lists.
-    """,
-        schema={
-            "type": "object",
-        },
-    )
-
-    add_setting(
-        name="graphics",
-        flags=["--graphics"],
-        choices=["none", "sixel", "kitty", "iterm"],
-        type_=str,
-        default=None,
-        help_="The preferred graphics protocol",
-        description="""
-            The graphics protocol to use, if supported by the terminal.
-            If set to "none", terminal graphics will not be used.
-    """,
-    )
-
-    add_setting(
-        name="force_graphics",
-        flags=["--force-graphics"],
-        type_=bool,
-        default=False,
-        help_="Force use of specified graphics protocol",
-        description="""
-            When set to :py:const:`True`, the graphics protocol specified by the
-            :option:`graphics` configuration option will be used even if the terminal
-            does not support it.
-
-            This is also useful if you want to use graphics in :command:`euporie-hub`.
-    """,
-    )
-
-    add_setting(
-        name="enable_language_servers",
-        flags=["--enable-language-servers", "--lsp"],
-        menu_title="Language servers",
-        type_=bool,
-        default=False,
-        help_="Enable language server support",
-        description="""
-            When set to :py:const:`True`, language servers will be used for liniting,
-            code inspection, and code formatting.
-
-            Additional language servers can be added using the
-            :option:`language-servers` option.
-    """,
-    )
-
-    add_setting(
-        name="language_servers",
-        flags=["--language-servers"],
-        type_=json.loads,
-        help_="Language server configurations",
-        default={},
-        schema={
-            "type": "object",
-            "items": {
-                "type": "object",
-                "patternProperties": {
-                    "^[0-9]+$": {
-                        "type": "object",
-                        "properties": {
-                            "command": {
-                                "type": "array",
-                                "items": [{"type": "string"}],
-                            },
-                            "language": {
-                                "type": "array",
-                                "items": [{"type": "string", "unique": True}],
-                            },
-                        },
-                        "required": ["command"],
-                    }
-                },
-            },
-        },
-        description="""
-            Additional language servers can be defined here, e.g.:
-
-               {
-                "ruff": {"command": ["ruff-lsp"], "languages": ["python"]},
-                "pylsp": {"command": ["pylsp"], "languages": ["python"]},
-                "typos": {"command": ["typos-lsp"], "languages": []}
-               }
-
-            The following properties are required:
-            - The name to be given to the the language server, must be unique
-            - The command list consists of the process to launch, followed by any
-              command line arguments
-            - A list of language the language server supports. If no languages are
-            given, the language server will be used for documents of any language.
-
-            To disable one of the default language servers, its name can be set to an
-            empty dictionary. For example, the following would disable the awk language
-            server:
-
-               {
-                 "awk-language-server": {},
-               }
-        """,
-    )
-
     # ################################# Key Bindings ##################################
 
     register_bindings(
         {
-            "euporie.core.app.BaseApp": {
+            "euporie.core.app.app:BaseApp": {
                 "quit": ["c-q", "<sigint>"],
                 "close-tab": "c-w",
                 "next-tab": "c-pagedown",
                 "previous-tab": "c-pageup",
-                "focus-next": "s-tab",
-                "focus-previous": "tab",
+                "focus-next": "tab",
+                "focus-previous": "s-tab",
                 "clear-screen": "c-l",
             }
         }