iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/marquee.py

@@ -0,0 +1,101 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Small, render-agnostic state machine for horizontally scrolling text."""
+
+from __future__ import annotations
+
+from rich.cells import split_graphemes
+from textual.content import Content
+
+
+class OverflowMarquee:
+    """Cycle overflowing styled content while preserving its original form.
+
+    Timer ownership deliberately stays with the consuming widget. This class
+    only models the current frame and the delay before the next one, making it
+    reusable without creating a timer (or mounted child widget) per row.
+    """
+
+    def __init__(
+        self,
+        *,
+        start_delay: float = 0.8,
+        step_interval: float = 0.08,
+        end_delay: float = 0.8,
+    ) -> None:
+        self.start_delay = start_delay
+        self.step_interval = step_interval
+        self.end_delay = end_delay
+        self._original = Content()
+        self._prefix = Content()
+        self._content = Content()
+        self._offsets: tuple[int, ...] = ()
+        self._position = 0
+
+    @property
+    def active(self) -> bool:
+        """Whether the activated content overflows its viewport."""
+        return len(self._offsets) > 1
+
+    @property
+    def frame(self) -> Content:
+        """Return the fixed prefix plus current suffix, or the static content."""
+        if not self.active or self._position == 0:
+            return self._original
+        return self._prefix + self._content[self._offsets[self._position] :]
+
+    def activate(
+        self,
+        content: Content,
+        viewport_width: int,
+        *,
+        fixed_prefix_end: int = 0,
+    ) -> float | None:
+        """Reset to *content* and return the delay before scrolling starts.
+
+        ``fixed_prefix_end`` is a character offset into *content*. Everything
+        before it remains pinned while the remaining content scrolls within
+        the cells left over after rendering the prefix.
+
+        Offsets follow grapheme boundaries rather than Python characters, so
+        emoji sequences and combining marks are never split between frames.
+        """
+        self.reset()
+        self._original = content
+        prefix_end = min(max(fixed_prefix_end, 0), len(content.plain))
+        self._prefix = content[:prefix_end]
+        self._content = content[prefix_end:]
+        scrolling_width = viewport_width - self._prefix.cell_length
+        if scrolling_width <= 0 or self._content.cell_length <= scrolling_width:
+            return None
+
+        graphemes, total_width = split_graphemes(self._content.plain)
+        offsets = [0]
+        removed_width = 0
+        for _start, end, cell_width in graphemes:
+            removed_width += cell_width
+            if cell_width:
+                offsets.append(end)
+            if total_width - removed_width <= scrolling_width:
+                break
+
+        self._offsets = tuple(offsets)
+        return self.start_delay if self.active else None
+
+    def advance(self) -> float | None:
+        """Advance one frame and return the delay before the following frame."""
+        if not self.active:
+            return None
+        if self._position == len(self._offsets) - 1:
+            self._position = 0
+            return self.start_delay
+        self._position += 1
+        return self.end_delay if self._position == len(self._offsets) - 1 else self.step_interval
+
+    def reset(self) -> None:
+        """Release active content and restore the static position."""
+        self._original = Content()
+        self._prefix = Content()
+        self._content = Content()
+        self._offsets = ()
+        self._position = 0

chrys/app/tui/widgets/option_menu.py

@@ -0,0 +1,82 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Compact menu layout and width-aware option descriptions."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from textwrap import fill
+
+from rich.text import Text
+from textual.containers import VerticalGroup
+from textual.events import Resize
+from textual.widgets import OptionList
+from textual.widgets.option_list import Option
+
+
+class OptionMenu(VerticalGroup):
+    DEFAULT_CSS = """
+    OptionMenu {
+        width: 60; max-width: 90%; height: auto; max-height: 90%;
+        background: $surface; border: round $tui-border-primary $border-opacity;
+        border-title-align: left; border-title-color: $primary; padding: 0;
+        overflow-x: hidden;
+    }
+    """
+
+
+@dataclass(frozen=True)
+class MenuOption:
+    label: str
+    description: str = ""
+    id: str | None = None
+    current: bool = False
+    disabled: bool = False
+    dim: bool = False
+
+    def render(self, width: int) -> Text:
+        title = ("◦ " if self.current else "") + self.label
+        content = Text(title, style="dim" if self.current or self.dim else "")
+        content.stylize("bold", 0, len(title))
+        if self.description:
+            content.append(
+                "\n" + fill(self.description, max(8, width), initial_indent="  - ", subsequent_indent="    ")
+            )
+        return content
+
+
+class MenuOptionList(OptionList):
+    DEFAULT_CSS = """
+    MenuOptionList {
+        height: auto; max-height: 100%; border: none;
+        padding: 0 0 0 1; scrollbar-size: 1 1;
+    }
+    MenuOptionList:focus { border: none; }
+    """
+
+    def __init__(self, items: Sequence[MenuOption] = (), *, id: str | None = None) -> None:
+        self._items = tuple(items)
+        self._description_width = 0
+        super().__init__(id=id)
+        self.set_items(items)
+
+    def set_items(self, items: Sequence[MenuOption]) -> None:
+        self._items = tuple(items)
+        self._description_width = self.scrollable_content_region.width or 54
+        options: list[Option | None] = []
+        for item in items:
+            if options:
+                options.append(None)
+            options.append(
+                Option(item.render(self._description_width), id=item.id, disabled=item.disabled or item.current)
+            )
+        self.set_options(options)
+
+    def on_resize(self, _event: Resize) -> None:
+        width = self.scrollable_content_region.width
+        if width <= 0 or width == self._description_width:
+            return
+        self._description_width = width
+        for index, item in enumerate(self._items):
+            self.replace_option_prompt_at_index(index, item.render(width))

chrys/app/tui/widgets/page_navigator.py

@@ -0,0 +1,118 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Previous / "Page X of Y" / Next controls shared by paged views."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.text import Text
+from textual import on
+from textual.containers import Horizontal
+from textual.message import Message
+from textual.widgets import Button, Static
+
+from chrys.app.tui.i18n import render_text, widget_localizer
+from chrys.foundation.i18n import msg
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+    from chrys.app.tui.i18n import LocaleController
+    from chrys.foundation.i18n import MessageRef
+
+PREVIOUS_PAGE = msg("tui.page_navigator.previous", fallback="Previous")
+NEXT_PAGE = msg("tui.page_navigator.next", fallback="Next")
+PAGE_OF = msg("tui.page_navigator.page", fallback="Page {page} of {pages}")
+
+
+class PageNavigator(Horizontal):
+    """Previous and Next around "Page X of Y", disabled at either end.
+
+    The owner loads the page a :class:`Changed` asks for and reports it
+    through :meth:`show`. It moves focus to its content first (see
+    :meth:`disables_focused`): disabling a focused boundary button would
+    otherwise hand focus to the button's sibling.
+    """
+
+    # Ids outrank Button's own `.-style-default` rules, whose tall borders would fill the one-row button.
+    DEFAULT_CSS = """
+    PageNavigator { width: auto; height: 1; align: right middle; }
+    PageNavigator > #previous-page, PageNavigator > #next-page {
+        min-width: 10; width: auto; height: 1; border: none; padding: 0 1;
+        background: $primary 20%; color: $primary; text-style: none;
+    }
+    PageNavigator > #previous-page:hover, PageNavigator > #previous-page:focus,
+    PageNavigator > #next-page:hover, PageNavigator > #next-page:focus {
+        background: $primary 40%; text-style: none;
+    }
+    PageNavigator > #previous-page:disabled, PageNavigator > #next-page:disabled {
+        background: transparent; color: $text-muted;
+    }
+    PageNavigator > #page-number { width: auto; margin: 0 2; }
+    """
+
+    class Changed(Message):
+        """The user asked for another page."""
+
+        def __init__(self, navigator: PageNavigator, page: int) -> None:
+            super().__init__()
+            self.navigator = navigator
+            self.page = page
+            """1-based."""
+
+        @property
+        def control(self) -> PageNavigator:
+            return self.navigator
+
+    def __init__(self, locale: LocaleController | None = None, *, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self._locale = locale
+        self._page = 1
+        self._pages = 1
+
+    @property
+    def page(self) -> int:
+        return self._page
+
+    @property
+    def pages(self) -> int:
+        return self._pages
+
+    def compose(self) -> ComposeResult:
+        yield Button(self._text(PREVIOUS_PAGE.bind()), id="previous-page", disabled=True)
+        yield Static(self._text(PAGE_OF.bind(page=1, pages=1)), id="page-number")
+        yield Button(self._text(NEXT_PAGE.bind()), id="next-page", disabled=True)
+
+    def disables_focused(self, page: int, pages: int) -> bool:
+        """Whether showing *page* of *pages* would disable the button that has focus."""
+        focused = self.screen.focused
+        return (page <= 1 and focused is self.query_one("#previous-page", Button)) or (
+            page >= pages and focused is self.query_one("#next-page", Button)
+        )
+
+    def show(self, page: int, pages: int) -> None:
+        """Show *page* of *pages*, both 1-based."""
+        if (page, pages) == (self._page, self._pages):
+            return
+        self._page, self._pages = page, pages
+        self.query_one("#previous-page", Button).disabled = page <= 1
+        self.query_one("#next-page", Button).disabled = page >= pages
+        self.query_one("#page-number", Static).update(self._text(PAGE_OF.bind(page=page, pages=pages)))
+
+    def refresh_localization(self) -> None:
+        self.query_one("#previous-page", Button).label = self._text(PREVIOUS_PAGE.bind())
+        self.query_one("#next-page", Button).label = self._text(NEXT_PAGE.bind())
+        self.query_one("#page-number", Static).update(self._text(PAGE_OF.bind(page=self._page, pages=self._pages)))
+
+    @on(Button.Pressed, "#previous-page")
+    @on(Button.Pressed, "#next-page")
+    def _on_page_button(self, event: Button.Pressed) -> None:
+        event.stop()
+        page = self._page + (1 if event.button.id == "next-page" else -1)
+        if 1 <= page <= self._pages:
+            self.post_message(self.Changed(self, page))
+
+    def _text(self, reference: MessageRef) -> Text:
+        localizer = self._locale.localizer if self._locale is not None else widget_localizer(self)
+        return render_text(localizer, reference)

chrys/app/tui/widgets/select.py

@@ -0,0 +1,196 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Select widget that tolerates Textual's mount-time child-lookup races."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from rich.text import Text
+from textual.css.query import NoMatches
+from textual.widgets import Select as TextualSelect
+from textual.widgets._select import NoSelection, SelectCurrent, SelectOverlay, SelectType
+from textual.widgets.option_list import Option
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from rich.console import RenderableType
+    from textual.app import ComposeResult
+    from textual.geometry import Region
+    from textual.strip import Strip
+
+
+class Select(TextualSelect[SelectType]):
+    """Select variant that tolerates Textual's mount-time child-lookup races.
+
+    Textual's ``Select._on_mount`` queries the composed ``SelectOverlay``
+    unguarded, which crashes the whole app with ``NoMatches`` in two race
+    flavors (both seen on CI under xdist load):
+
+    * the children have not finished mounting when the ``Mount`` event
+      dispatches (Windows CI) — recovered by a deferred retry once the
+      overlay exists;
+    * the children never mount at all because the widget is already being
+      pruned: ``Widget.mount()`` silently no-ops while ``_pruning`` is set,
+      but the already-queued ``Mount`` event still dispatches (Linux CI,
+      app teardown racing a fresh panel remount) — the deferred retries
+      then no-op harmlessly against their cap.
+
+    Textual itself guards the same lookup in ``_watch_value`` and
+    ``_watch_expanded`` but not in ``_on_mount``; re-check this class when
+    upgrading Textual.
+    """
+
+    def __init__(self, *args: Any, separators_before: Iterable[SelectType] = (), **kwargs: Any) -> None:
+        self._separators_before = frozenset(separators_before)
+        super().__init__(*args, **kwargs)
+        self._deferred_setup_options: bool = False
+        self._setup_options_retries: int = 0
+        self._deferred_visual_sync: bool = False
+        self._visual_sync_retries: int = 0
+
+    def set_options(
+        self,
+        options: Iterable[tuple[RenderableType, SelectType]],
+        *,
+        separators_before: Iterable[SelectType] = (),
+    ) -> None:
+        """Replace choices and dividers without adding selectable values.
+
+        Omitting ``separators_before`` clears all existing dividers.
+        """
+        self._separators_before = frozenset(separators_before)
+        super().set_options(options)
+
+    def _populate_options(self) -> None:
+        if not self._separators_before:
+            super()._setup_options_renderables()
+            return
+        overlay = self.query_one(SelectOverlay)
+        options: list[Option | None] = []
+        for prompt, value in self._options:
+            if options and value in self._separators_before:
+                options.append(None)
+            options.append(Option(Text(self.prompt, style="dim") if value is self.NULL else prompt))
+        # OptionList dividers consume display rows, never option indices. This
+        # preserves Select's value mapping, keyboard search and mouse messages.
+        overlay.clear_options()
+        overlay.add_options(options)
+
+    def _setup_options_renderables(self) -> None:
+        # Wraps Textual's Select._setup_options_renderables so that the SelectOverlay-
+        # not-yet-mounted race during _on_mount is recovered via a deferred retry
+        # instead of crashing the app's exception handler.  Leaves _on_mount and
+        # _watch_value's existing flow intact; once the retry succeeds, _watch_value
+        # re-runs to populate the visual.
+        try:
+            self._populate_options()
+        except NoMatches:
+            self._defer_setup_options()
+            return
+        self._setup_options_retries = 0
+
+    def _defer_setup_options(self) -> None:
+        if self._deferred_setup_options or self._setup_options_retries >= 3:
+            return
+        self._deferred_setup_options = True
+        self._setup_options_retries += 1
+        self.call_after_refresh(self._sync_deferred_setup_options)
+
+    def _sync_deferred_setup_options(self) -> None:
+        self._deferred_setup_options = False
+        try:
+            self._populate_options()
+        except NoMatches:
+            self._defer_setup_options()
+            return
+        self._setup_options_retries = 0
+        # Re-fire the watcher so the visual catches up now that the overlay exists.
+        self._watch_value(self._value)
+
+    def _watch_value(self, value: SelectType | NoSelection) -> None:
+        """Update current value, deferring visual sync if children are still mounting."""
+        # Mirrors Textual's Select._watch_value, with only the current-label update deferred on mount races.
+        self._value = value
+        try:
+            select_current = self.query_one(SelectCurrent)
+        except NoMatches:
+            return
+
+        if value == self.NULL:
+            if self._try_update_current(select_current, self.NULL):
+                self.post_message(self.Changed(self, value))
+            return
+
+        for index, (prompt, option_value) in enumerate(self._options):
+            if option_value != value:
+                continue
+            try:
+                select_overlay = self.query_one(SelectOverlay)
+            except NoMatches:
+                self._defer_visual_sync()
+                return
+            select_overlay.highlighted = index
+            if self._try_update_current(select_current, prompt):
+                self.post_message(self.Changed(self, value))
+            return
+
+        self.post_message(self.Changed(self, value))
+
+    def _try_update_current(self, select_current: SelectCurrent, label: RenderableType | NoSelection) -> bool:
+        try:
+            select_current.update(label)
+        except NoMatches:
+            self._defer_visual_sync()
+            return False
+        self._visual_sync_retries = 0
+        return True
+
+    def _defer_visual_sync(self) -> None:
+        if self._deferred_visual_sync or self._visual_sync_retries >= 3:
+            return
+        self._deferred_visual_sync = True
+        self._visual_sync_retries += 1
+        self.call_after_refresh(self._sync_deferred_visual)
+
+    def _sync_deferred_visual(self) -> None:
+        self._deferred_visual_sync = False
+        self._watch_value(self._value)
+
+
+class _LazySelectOverlay(SelectOverlay):
+    """Keep options ready without querying screen geometry while collapsed."""
+
+    def render_lines(self, crop: Region) -> list[Strip]:
+        # The compositor keeps the open overlay in its map until the next
+        # layout, so a pointer move in between still hit-tests this widget. A
+        # closed overlay has no hover style to report, and rendering one would
+        # read its geometry while collapsed.
+        return super().render_lines(crop) if self.display else []
+
+    def _update_lines(self) -> None:
+        # OptionList calls this on mount, option changes and highlight changes.
+        # Even an empty region lookup can synchronously lay out the whole Screen.
+        # Its normal Show/render paths populate the cache once displayed.
+        if self.display:
+            super()._update_lines()
+
+    def scroll_to_highlight(self, top: bool = False) -> None:
+        # A previously opened overlay may still have cached line positions.
+        # Do not use them to look up geometry while the menu is closed again.
+        if self.display:
+            super().scroll_to_highlight(top)
+
+
+class LazySelect(Select[SelectType]):
+    """Select for dynamically mounted panels that defer hidden menu layout.
+
+    When upgrading Textual, re-check ``compose`` and the overlay's
+    ``render_lines`` / ``_update_lines`` / ``scroll_to_highlight`` overrides against its internal
+    Select composition and OptionList display/cache lifecycle.
+    """
+
+    def compose(self) -> ComposeResult:
+        yield SelectCurrent(self.prompt)
+        yield _LazySelectOverlay(type_to_search=self._type_to_search).data_bind(compact=TextualSelect.compact)

chrys/app/tui/widgets/selection.py

@@ -0,0 +1,59 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Selection helpers for selectable content and excluded chrome."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from rich.style import Style as RichStyle
+from textual.selection import Selection
+from textual.widgets import Static
+
+
+class NonSelectableTextMixin:
+    """Prevent a text-rendering widget from participating in selection."""
+
+    ALLOW_SELECT: ClassVar[bool] = False
+
+    @property
+    def text_selection(self) -> None:
+        """Ignore Textual endpoint selections that bypass ``allow_select``."""
+        return None
+
+    def get_selection(self, selection: Selection) -> tuple[str, str] | None:
+        """Exclude this widget from copied screen-selection text."""
+        _ = selection
+        return None
+
+    def selection_updated(self, selection: Selection | None) -> None:
+        """Avoid repainting chrome for an ignored selection update."""
+        _ = selection
+
+
+class NonSelectableStatic(NonSelectableTextMixin, Static):
+    """Static chrome that cannot start, render, or export text selection."""
+
+
+def normalize_selection_rich_style(style: RichStyle) -> RichStyle:
+    """Preserve text color when Textual's transparent selection foreground resolves to background."""
+    if style.color is None or style.bgcolor is None or style.color != style.bgcolor:
+        return style
+    return RichStyle(
+        bgcolor=style.bgcolor,
+        bold=style.bold,
+        dim=style.dim,
+        italic=style.italic,
+        underline=style.underline,
+        blink=style.blink,
+        blink2=style.blink2,
+        reverse=style.reverse,
+        conceal=style.conceal,
+        strike=style.strike,
+        underline2=style.underline2,
+        frame=style.frame,
+        encircle=style.encircle,
+        overline=style.overline,
+        link=style.link,
+        meta=style.meta,
+    )

chrys/app/tui/widgets/sidebar/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Right-side sidebar panels — debug, context, settings."""