@scemoon/cdh 1.0.0

package/tui/widgets/highlighted_textarea.py

@@ -0,0 +1,180 @@
+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/mandelbrot.py

@@ -0,0 +1,294 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,147 @@
+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)