@scemoon/cdh 1.0.8 → 1.0.9-beta.2

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)

package/tui/widgets/model_status.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Optional
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import Button, Static, ProgressBar
+
+
+class OllamaModelStatus(Static):
+    class DownloadStarted(Message):
+        def __init__(self, model_id: str) -> None:
+            self.model_id = model_id
+            super().__init__()
+
+    class DownloadCompleted(Message):
+        def __init__(self, model_id: str, success: bool) -> None:
+            self.model_id = model_id
+            self.success = success
+            super().__init__()
+
+    downloading: reactive[bool] = reactive(False)
+    progress: reactive[float] = reactive(0.0)
+
+    def __init__(self, model_id: str, ollama_name: str, description: str = ""):
+        super().__init__()
+        self.model_id = model_id
+        self.ollama_name = ollama_name
+        self.description = description
+        self._installed = False
+
+    def set_installed(self, installed: bool) -> None:
+        self._installed = installed
+        self.refresh()
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="model-row"):
+            yield Static(self._status_icon(), id=f"icon-{self.model_id}")
+            yield Static(self.model_id, classes="model-name")
+            if self.description:
+                yield Static(f"({self.description})", classes="model-desc")
+            if self._installed:
+                yield Static("已安装", classes="status-ready")
+            elif self.downloading:
+                yield ProgressBar(
+                    total=100,
+                    show_eta=False,
+                    id=f"progress-{self.model_id}",
+                )
+                yield Static(
+                    f"{self.progress:.0f}%",
+                    id=f"pct-{self.model_id}",
+                    classes="progress-text",
+                )
+            else:
+                yield Button(
+                    "下载",
+                    id=f"dl-{self.model_id}",
+                    classes="dl-btn small",
+                )
+
+    def _status_icon(self) -> str:
+        if self._installed:
+            return "[green]✓[/green]"
+        elif self.downloading:
+            return "[yellow]⏬[/yellow]"
+        return "[dim]○[/dim]"
+
+    def watch_downloading(self, value: bool) -> None:
+        self.refresh()
+
+    def watch_progress(self, value: float) -> None:
+        if self.downloading:
+            try:
+                bar = self.query_one(f"#progress-{self.model_id}", ProgressBar)
+                bar.update(progress=min(value, 100))
+                pct = self.query_one(f"#pct-{self.model_id}", Static)
+                pct.update(f"{value:.0f}%")
+            except Exception:
+                pass
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id
+        if btn_id and btn_id.startswith(f"dl-{self.model_id}"):
+            self.post_message(self.DownloadStarted(self.model_id))
+
+
+class OllamaStatusPanel(Static):
+    DEFAULT_CSS = """
+    OllamaStatusPanel {
+        height: auto;
+        padding: 1 2;
+        border: solid $secondary-muted;
+        margin: 1 0;
+        background: $surface;
+    }
+
+    .panel-title {
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+
+    .model-row {
+        height: auto;
+        layout: horizontal;
+        spacing: 1;
+        padding: 0 1;
+    }
+
+    .model-name {
+        color: $text;
+    }
+
+    .model-desc {
+        color: $text-muted;
+    }
+
+    .status-ready {
+        color: green;
+    }
+
+    .dl-btn {
+        max-width: 8;
+    }
+
+    .progress-text {
+        color: $text-muted;
+    }
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._model_widgets: dict[str, OllamaModelStatus] = {}
+        self._manager = None
+
+    def set_manager(self, manager) -> None:
+        self._manager = manager
+
+    def add_model(self, model_id: str, ollama_name: str, description: str = "") -> OllamaModelStatus:
+        widget = OllamaModelStatus(model_id, ollama_name, description)
+        self._model_widgets[model_id] = widget
+        return widget
+
+    def compose(self) -> ComposeResult:
+        yield Static("本地模型", classes="panel-title")
+        yield Static("检测 Ollama 服务中...", id="ollama-status")
+        yield Horizontal(
+            id="models-container",
+            classes="models-container",
+        )
+
+    async def refresh_status(self) -> None:
+        if not self._manager:
+            return
+
+        status_text = self.query_one("#ollama-status", Static)
+        container = self.query_one("#models-container", Horizontal)
+
+        if not await self._manager.check_running():
+            status_text.update("[red]✗ Ollama 服务未运行[/red]")
+            status_text.update("请先安装并启动 Ollama\n安装: curl -fsSL https://ollama.com/install.sh | sh\n启动: ollama serve")
+            container.display = False
+            return
+
+        status_text.update("[green]✓ Ollama 正常[/green]")
+        container.display = True
+
+        hardware = self._manager.detect_hardware()
+        hardware_info = self._manager.get_hardware_info(hardware)
+        recommended = self._manager.recommend(hardware)
+
+        status_text.update(
+            f"[green]✓ Ollama 正常[/green] | {hardware_info} | "
+            f"推荐: [bold]{recommended or '无'}[/bold]"
+        )
+
+        installed = await self._manager.list_installed()
+
+        if not self._model_widgets:
+            for model_id, spec in self._manager.MODEL_SPECS.items():
+                widget = self.add_model(
+                    model_id,
+                    spec["ollama_name"],
+                    spec.get("description", ""),
+                )
+                await container.mount(widget)
+
+        for model_id, widget in self._model_widgets.items():
+            widget.set_installed(model_id in installed)
+
+    async def on_download_started(self, event: OllamaModelStatus.DownloadStarted) -> None:
+        model_id = event.model_id
+        widget = self._model_widgets.get(model_id)
+        if not widget or not self._manager:
+            return
+
+        widget.downloading = True
+        widget.progress = 0.0
+
+        try:
+
+            async def progress_callback(data: dict) -> None:
+                status = data.get("status", "")
+                if "downloading" in status:
+                    total = data.get("total", 0)
+                    completed = data.get("completed", 0)
+                    if total > 0:
+                        pct = (completed / total) * 100
+                    else:
+                        pct = 50.0
+                elif "verifying" in status:
+                    pct = 90.0
+                elif "success" in data:
+                    pct = 100.0
+                else:
+                    pct = 30.0
+                widget.progress = pct
+
+            await self._manager.pull_model(model_id, progress_callback=progress_callback)
+            widget.downloading = False
+            widget.set_installed(True)
+            self.post_message(OllamaModelStatus.DownloadCompleted(model_id, True))
+        except Exception as e:
+            widget.downloading = False
+            widget.set_installed(False)
+            self.post_message(OllamaModelStatus.DownloadCompleted(model_id, False))