@scemoon/cdh 1.0.9 → 1.0.10-beta.1

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)

package/tui/widgets/model_status.py

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