@scemoon/cdh 1.0.6 → 1.0.8

package/tui/widgets/highlighted_textarea.py

@@ -1,180 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass
-import re
-from typing import Sequence
-
-from rich.text import Text
-
-from textual import on
-from textual.reactive import reactive
-from textual.content import Content
-from textual.highlight import highlight, HighlightTheme, TokenType
-from textual.message import Message
-from textual.widgets import TextArea
-from textual.widgets.text_area import Selection
-
-from pygments.token import Token
-
-
-RE_MATCH_FILE_PROMPT = re.compile(r"(@\S+)|@\"(.*)\"")
-RE_SLASH_COMMAND = re.compile(r"(\/\S*)(\W.*)?$")
-
-
-class TextualHighlightTheme(HighlightTheme):
-    """Contains the style definition for user with the highlight method."""
-
-    STYLES: dict[TokenType, str] = {
-        Token.Comment: "$text 60%",
-        Token.Error: "$text-error on $error-muted",
-        Token.Generic.Strong: "bold",
-        Token.Generic.Emph: "italic",
-        Token.Generic.Error: "$text-error on $error-muted",
-        Token.Generic.Heading: "$text-primary underline",
-        Token.Generic.Subheading: "$text-primary",
-        Token.Keyword: "$text-accent",
-        Token.Keyword.Constant: "bold $text-success 80%",
-        Token.Keyword.Namespace: "$text-error",
-        Token.Keyword.Type: "bold",
-        Token.Literal.Number: "$text-warning",
-        Token.Literal.String.Backtick: "$text 60%",
-        Token.Literal.String: "$text-success 90%",
-        Token.Literal.String.Doc: "$text-success 80% italic",
-        Token.Literal.String.Double: "$text-success 90%",
-        Token.Name: "$text-primary",
-        Token.Name.Attribute: "$text-warning",
-        Token.Name.Builtin: "$text-accent",
-        Token.Name.Builtin.Pseudo: "italic",
-        Token.Name.Class: "$text-warning bold",
-        Token.Name.Constant: "$text-error",
-        Token.Name.Decorator: "$text-primary bold",
-        Token.Name.Entity: "$text",
-        Token.Name.Function: "$text-warning underline",
-        Token.Name.Function.Magic: "$text-warning underline",
-        Token.Name.Tag: "$text-primary bold",
-        Token.Name.Variable: "$text-secondary",
-        Token.Number: "$text-warning",
-        Token.Operator: "bold",
-        Token.Operator.Word: "bold $text-error",
-        Token.String: "$text-success",
-        Token.Whitespace: "",
-    }
-
-
-class HighlightedTextArea(TextArea):
-    highlight_language = reactive("markdown")
-
-    @dataclass
-    class CursorMove(Message):
-        selection: Selection
-
-    def __init__(
-        self,
-        text: str = "",
-        *,
-        name: str | None = None,
-        id: str | None = None,
-        classes: str | None = None,
-        disabled: bool = False,
-        placeholder: str | Content = "",
-    ):
-        self._text_cache: dict[int, Text] = {}
-        self._highlight_lines: list[Content] | None = None
-        super().__init__(
-            text,
-            name=name,
-            id=id,
-            classes=classes,
-            disabled=disabled,
-            highlight_cursor_line=False,
-            placeholder=placeholder,
-        )
-        self.compact = True
-
-    def _clear_caches(self) -> None:
-        self._highlight_lines = None
-        self._text_cache.clear()
-
-    def notify_style_update(self) -> None:
-        self._clear_caches()
-        return super().notify_style_update()
-
-    def _watch_selection(
-        self, previous_selection: Selection, selection: Selection
-    ) -> None:
-        self.post_message(self.CursorMove(selection))
-        super()._watch_selection(previous_selection, selection)
-
-    @property
-    def highlight_lines(self) -> Sequence[Content]:
-        if self._highlight_lines is None:
-            text = self.text
-            if text.startswith("/") and "\n" not in text:
-                content = self.highlight_slash_command(text)
-                self._highlight_lines = [content]
-                return self._highlight_lines
-
-            language = self.highlight_language
-            if language == "markdown":
-                content = self.highlight_markdown(text)
-                content_lines = content.split("\n", allow_blank=True)[:-1]
-                self._highlight_lines = content_lines
-            elif language == "shell":
-                content = self.highlight_shell(text)
-                content_lines = content.split("\n", allow_blank=True)
-                self._highlight_lines = content_lines
-            else:
-                raise ValueError("highlight_language must be `markdown` or `shell`")
-        return self._highlight_lines
-
-    def highlight_slash_command(self, text: str) -> Content:
-        return Content.styled(text, "$text-success")
-
-    def highlight_markdown(self, text: str) -> Content:
-        """Highlight markdown content.
-
-        Args:
-            text: Text containing Markdown.
-
-        Returns:
-            Highlighted content.
-        """
-        content = highlight(
-            text + "\n```",
-            language="markdown",
-            theme=TextualHighlightTheme,
-        )
-        content = content.highlight_regex(RE_MATCH_FILE_PROMPT, style="$primary")
-        return content
-
-    def highlight_shell(self, text: str) -> Content:
-        """Highlight text with a bash shell command.
-
-        Args:
-            text: Text containing shell command.
-
-        Returns:
-            Highlighted content.
-        """
-        content = highlight(text, language="sh")
-        return content
-
-    @on(TextArea.Changed)
-    def _on_changed(self) -> None:
-        self._highlight_lines = None
-        self._text_cache.clear()
-
-    def get_line(self, line_index: int) -> Text:
-        if (cached_line := self._text_cache.get(line_index)) is not None:
-            return cached_line.copy()
-        try:
-            line = self.highlight_lines[line_index]
-        except IndexError:
-            return Text("", end="", no_wrap=True)
-        rendered_line = list(line.render_segments(self.visual_style))
-        text = Text.assemble(
-            *[(text, style) for text, style, _ in rendered_line],
-            end="",
-            no_wrap=True,
-        )
-        self._text_cache[line_index] = text.copy()
-        return text

package/tui/widgets/load_more.py

@@ -1,24 +0,0 @@
-from __future__ import annotations
-
-from textual.binding import Binding
-from textual.message import Message
-from textual.widgets import Static
-
-
-class LoadMoreIndicator(Static, can_focus=True):
-    """Clickable 'load earlier messages' indicator at top of conversation."""
-
-    class LoadMorePressed(Message):
-        pass
-
-    BINDINGS = [
-        Binding("enter", "press", "Load"),
-    ]
-
-    def __init__(self, count: int, batch: int = 50) -> None:
-        self.count = count
-        label = f"  ▲  Load {min(count, batch)} earlier messages ({count} remaining)  ▲  "
-        super().__init__(label)
-
-    def action_press(self) -> None:
-        self.post_message(self.LoadMorePressed())

package/tui/widgets/mandelbrot.py

@@ -1,294 +0,0 @@
-from typing import NamedTuple
-
-from rich.segment import Segment
-from rich.color import Color as RichColor
-from rich.style import Style as RichStyle
-
-from textual import events
-from textual.color import Color
-from textual.content import Content
-from textual.geometry import NULL_SIZE, Offset
-from textual.reactive import reactive, var
-from textual.strip import Strip
-from textual.app import App, ComposeResult
-from textual.widget import Widget
-from textual.timer import Timer
-
-
-COLORS = [
-    Color.parse(color).rgb
-    for color in [
-        "#881177",
-        "#aa3355",
-        "#cc6666",
-        "#ee9944",
-        "#eedd00",
-        "#99dd55",
-        "#44dd88",
-        "#22ccbb",
-        "#00bbcc",
-        "#0099cc",
-        "#3366bb",
-        "#663399",
-    ]
-]
-
-
-class MandelbrotRegion(NamedTuple):
-    """Defines the extents of the mandelbrot set."""
-
-    x_min: float
-    x_max: float
-    y_min: float
-    y_max: float
-
-    def zoom(
-        self, focal_x: float, focal_y: float, zoom_factor: float
-    ) -> "MandelbrotRegion":
-        """
-        Return a new region zoomed in or out from a focal point.
-
-        Args:
-            focal_x: X coordinate of the point to zoom around (in complex plane coordinates)
-            focal_y: Y coordinate of the point to zoom around (in complex plane coordinates)
-            zoom_factor: Zoom factor (>1 to zoom in, <1 to zoom out, =1 for no change)
-
-        Returns:
-            A new MandelbrotRegion with the focal point at the same relative position
-        """
-        # Calculate current dimensions
-        width = self.x_max - self.x_min
-        height = self.y_max - self.y_min
-
-        # Calculate new dimensions
-        new_width = width / zoom_factor
-        new_height = height / zoom_factor
-
-        # Calculate focal point's relative position in current region
-        fx = (focal_x - self.x_min) / width
-        fy = (focal_y - self.y_min) / height
-
-        # Calculate new bounds maintaining the focal point's relative position
-        new_x_min = focal_x - fx * new_width
-        new_x_max = focal_x + (1 - fx) * new_width
-        new_y_min = focal_y - fy * new_height
-        new_y_max = focal_y + (1 - fy) * new_height
-
-        return MandelbrotRegion(new_x_min, new_x_max, new_y_min, new_y_max)
-
-
-class Mandelbrot(Widget):
-    ALLOW_SELECT = False
-    DEFAULT_CSS = """
-    Mandelbrot {        
-        border: block black 20%;
-        text-wrap: nowrap;
-        text-overflow: clip;
-        overflow: hidden;
-    }
-    """
-
-    set_region = reactive(MandelbrotRegion(-2, 1.0, -1.0, 1.0), init=False)
-    max_iterations = var(64)
-    rendered_size = var(NULL_SIZE)
-    rendered_set = var(Content(""))
-    zoom_position = var(Offset(0, 0))
-    zoom_timer: var[Timer | None] = var(None)
-    zoom_scale = var(0.99)
-
-    BRAILLE_CHARACTERS = [chr(0x2800 + i) for i in range(256)]
-
-    # (BIT, X_OFFSET, Y_OFFSET)
-    PATCH_COORDS = [
-        (1, 0, 0),
-        (2, 0, 1),
-        (4, 0, 2),
-        (8, 1, 0),
-        (16, 1, 1),
-        (32, 1, 2),
-        (64, 0, 3),
-        (128, 1, 3),
-    ]
-
-    def __init__(
-        self,
-        name: str | None = None,
-        id: str | None = None,
-        classes: str | None = None,
-    ) -> None:
-        self._strip_cache: dict[int, Strip] = {}
-        super().__init__(name=name, id=id, classes=classes)
-
-    @staticmethod
-    def mandelbrot(c_real: float, c_imag: float, max_iterations: int):
-        """
-        Determine the smooth iteration count for a point in the Mandelbrot set.
-        Uses continuous (smooth) iteration counting for better detail outside the set.
-
-        Args:
-            c_real: The real part of the complex number.
-            c_imag: The imaginary part of the complex number.
-
-        Returns:
-            A float representing the smooth iteration count, or MAX_ITER for points in the set.
-        """
-        # Early escape: check if point is in main cardioid
-        # The main cardioid can be detected with: q(q + (x - 1/4)) < 1/4 * y^2
-        # where q = (x - 1/4)^2 + y^2
-        x_shifted = c_real - 0.25
-        q = x_shifted * x_shifted + c_imag * c_imag
-        if q * (q + x_shifted) < 0.25 * c_imag * c_imag:
-            return max_iterations
-
-        # Early escape: check if point is in period-2 bulb
-        # The period-2 bulb is the circle: (x + 1)^2 + y^2 < 1/16
-        x_plus_one = c_real + 1.0
-        if x_plus_one * x_plus_one + c_imag * c_imag < 0.0625:
-            return max_iterations
-
-        z_real = 0.0
-        z_imag = 0.0
-        for i in range(max_iterations):
-            z_real_new = z_real * z_real - z_imag * z_imag + c_real
-            z_imag_new = 2 * z_real * z_imag + c_imag
-            z_real = z_real_new
-            z_imag = z_imag_new
-            if z_real * z_real + z_imag * z_imag > 4:
-                return i
-        return max_iterations
-
-    def on_mount(self):
-        self.call_after_refresh(self.refresh)
-
-    def on_resize(self) -> None:
-        self._strip_cache.clear()
-
-    def on_mouse_down(self, event: events.Click) -> None:
-        if self.zoom_timer:
-            self.zoom_timer.stop()
-        self.zoom_position = event.offset
-        self.zoom_scale = 0.95 if event.ctrl else 1.05
-        self.zoom_timer = self.set_interval(1 / 20, self.zoom)
-        self.capture_mouse()
-
-    def on_mouse_up(self, event: events.Click) -> None:
-        self.release_mouse()
-        if self.zoom_timer:
-            self.zoom_timer.stop()
-
-    def on_mouse_move(self, event: events.MouseMove) -> None:
-        self.zoom_position = event.offset
-
-    def zoom(self) -> None:
-        zoom_x, zoom_y = self.zoom_position
-        width, height = self.content_size
-        x_min, x_max, y_min, y_max = self.set_region
-
-        set_width = x_max - x_min
-        set_height = y_max - y_min
-
-        x = x_min + (zoom_x / width) * set_width
-        y = y_min + (zoom_y / height) * set_height
-
-        self.set_region = self.set_region.zoom(x, y, self.zoom_scale)
-
-    def notify_style_update(self) -> None:
-        self._strip_cache.clear()
-        return super().notify_style_update()
-
-    def watch_set_region(self) -> None:
-        self._strip_cache.clear()
-        self.refresh()
-
-    def render_line(self, y: int) -> Strip:
-        if (cached_line := self._strip_cache.get(y)) is not None:
-            return cached_line
-
-        width, height = self.content_size
-        x_min, x_max, y_min, y_max = self.set_region
-        mandelbrot_width = x_max - x_min
-        mandelbrot_height = y_max - y_min
-
-        mandelbrot = self.mandelbrot
-
-        max_iterations = self.max_iterations
-        set_width = width * 2
-        set_height = height * 4
-        BRAILLE_MAP = self.BRAILLE_CHARACTERS
-        PATCH_COORDS = self.PATCH_COORDS
-        max_color = len(COLORS) - 1
-
-        row = y * 4
-
-        colors: list[tuple[int, int, int]] = []
-
-        segments: list[Segment] = []
-        base_style = self.rich_style
-
-        for column in range(0, width * 2, 2):
-            braille_key = 0
-            for bit, dot_x, dot_y in PATCH_COORDS:
-                patch_x: int = column + dot_x
-                patch_y: int = row + dot_y
-                c_real: float = x_min + mandelbrot_width * patch_x / set_width
-                c_imag: float = y_min + mandelbrot_height * patch_y / set_height
-                if (
-                    iterations := mandelbrot(c_real, c_imag, max_iterations)
-                ) < max_iterations:
-                    braille_key |= bit
-                    colors.append(
-                        COLORS[round((iterations / max_iterations) * max_color)]
-                    )
-
-            if colors:
-                patch_red = 0
-                patch_green = 0
-                patch_blue = 0
-                for red, green, blue in colors:
-                    patch_red += red
-                    patch_green += green
-                    patch_blue += blue
-
-                color_count = len(colors)
-                patch_color = RichColor.from_rgb(
-                    patch_red // color_count,
-                    patch_green // color_count,
-                    patch_blue // color_count,
-                )
-                segments.append(
-                    Segment(
-                        BRAILLE_MAP[braille_key],
-                        base_style + RichStyle.from_color(patch_color),
-                    )
-                )
-                colors.clear()
-            else:
-                segments.append(Segment(" ", base_style))
-
-        strip = Strip(segments, cell_length=width)
-        strip.simplify()
-        self._strip_cache[y] = strip
-        return strip
-
-
-if __name__ == "__main__":
-
-    class MApp(App):
-        CSS = """
-        Screen {
-            align: center middle;
-            background: $panel;
-            Mandelbrot {
-                background: black 20%;                
-                width: 40;
-                height: 16;
-            }
-        }
-
-        """
-
-        def compose(self) -> ComposeResult:
-            yield Mandelbrot()
-
-    app = MApp()
-    app.run()

package/tui/widgets/markdown_note.py

@@ -1,13 +0,0 @@
-from typing import Iterable
-from textual.widgets import Markdown
-
-from tui.menus import MenuItem
-
-
-class MarkdownNote(Markdown):
-    def get_block_menu(self) -> Iterable[MenuItem]:
-        return
-        yield
-
-    def get_block_content(self, destination: str) -> str | None:
-        return self.source

package/tui/widgets/menu.py

@@ -1,147 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from textual import on
-from textual.app import ComposeResult
-from textual.binding import Binding
-from textual.message import Message
-from textual.widgets import ListView, ListItem, Label
-from textual._partition import partition
-from textual import events
-from textual.widget import Widget
-
-from tui.menus import MenuItem
-
-
-class NonSelectableLabel(Label):
-    ALLOW_SELECT = False
-
-
-class MenuOption(ListItem):
-    ALLOW_SELECT = False
-
-    def __init__(self, action: str | None, description: str, key: str | None) -> None:
-        self._action = action
-        self._description = description
-        self._key = key
-        super().__init__(classes="-has-key" if key else "-no_key")
-
-    def compose(self) -> ComposeResult:
-        yield NonSelectableLabel(self._key or " ", id="key")
-        yield NonSelectableLabel(self._description, id="description")
-
-
-class Menu(ListView, can_focus=True):
-    BINDINGS = [Binding("escape", "dismiss", "Dismiss")]
-
-    DEFAULT_CSS = """
-    Menu {
-        margin: 1 1;
-        width: auto;
-        height: auto;        
-        max-width: 100%;
-        overlay: screen;  
-        position: absolute;
-        color: $foreground;
-        background: $panel;
-        border: block $panel;
-        constrain: inside inside;
-   
-        & > MenuOption {         
-            
-            layout: horizontal;            
-            width: 1fr;            
-            padding: 0 1;
-            height: auto !important;
-            overflow: auto;
-            expand: optimal;            
-            #description {                        
-                color: $text 80%;
-                width: 1fr;                    
-            }
-            #key {                
-                padding-right: 1;                
-                text-style: bold;
-            }                            
-           
-        }
-
-        &:blur {
-            background-tint: transparent;
-            & > ListItem.-highlight {
-                color: $block-cursor-blurred-foreground;
-                background: $block-cursor-blurred-background 30%;
-                text-style: $block-cursor-blurred-text-style;
-            }
-        }
-        
-        &:focus {
-            background-tint: transparent;
-            & > ListItem.-highlight {
-                color: $block-cursor-blurred-foreground;
-                background: $block-cursor-blurred-background;
-                text-style: $block-cursor-blurred-text-style;
-            }
-        }
-    }
-    """
-
-    @dataclass
-    class OptionSelected(Message):
-        """The user selected on of the options."""
-
-        menu: Menu
-        owner: Widget
-        action: str | None
-
-    @dataclass
-    class Dismissed(Message):
-        """Menu was dismissed."""
-
-        menu: Menu
-
-    def __init__(self, owner: Widget, options: list[MenuItem], *args, **kwargs) -> None:
-        self._owner = owner
-        self._options = options
-        super().__init__(*args, **kwargs)
-
-    def _insert_options(self) -> None:
-        with_keys, without_keys = partition(
-            lambda option: option.key is None, self._options
-        )
-        self.extend(
-            MenuOption(menu_item.action, menu_item.description, menu_item.key)
-            for menu_item in with_keys
-        )
-        self.extend(
-            MenuOption(menu_item.action, menu_item.description, menu_item.key)
-            for menu_item in without_keys
-        )
-
-    def on_mount(self) -> None:
-        self._insert_options()
-
-    async def activate_index(self, index: int) -> None:
-        action = self._options[index].action
-        self.post_message(self.OptionSelected(self, self._owner, action))
-
-    async def action_dismiss(self) -> None:
-        self.post_message(self.Dismissed(self))
-
-    async def on_blur(self) -> None:
-        self.post_message(self.Dismissed(self))
-
-    @on(events.Key)
-    async def on_key(self, event: events.Key) -> None:
-        for index, option in enumerate(self._options):
-            if event.key == option.key:
-                self.index = index
-                event.stop()
-                await self.activate_index(index)
-                break
-
-    @on(ListView.Selected)
-    async def on_list_view_selected(self, event: ListView.Selected) -> None:
-        event.stop()
-        await self.activate_index(event.index)