sqlide 0.1.0__py3-none-any.whl

sqlide/ui/screens/dialogs.py

@@ -0,0 +1,110 @@
+"""Small reusable modals: confirm, password prompt, progress."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, ProgressBar
+
+
+class ConfirmScreen(ModalScreen[bool]):
+    BINDINGS = [Binding("escape", "no", "No"), Binding("y", "yes", "Yes"), Binding("n", "no", "No")]
+
+    def __init__(self, message: str, yes: str = "Yes", no: str = "No") -> None:
+        super().__init__()
+        self._message, self._yes, self._no = message, yes, no
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog"):
+            yield Label(self._message)
+            with Horizontal(classes="buttons"):
+                yield Button(self._yes, variant="primary", id="yes")
+                yield Button(self._no, id="no")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id == "yes")
+
+    def action_yes(self) -> None:
+        self.dismiss(True)
+
+    def action_no(self) -> None:
+        self.dismiss(False)
+
+
+class PasswordPrompt(ModalScreen[str | None]):
+    BINDINGS = [Binding("escape", "cancel", "Cancel")]
+
+    def __init__(self, title: str) -> None:
+        super().__init__()
+        self._title = title
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog"):
+            yield Label(self._title)
+            yield Input(password=True, id="pw", placeholder="password")
+            with Horizontal(classes="buttons"):
+                yield Button("Connect", variant="primary", id="ok")
+                yield Button("Cancel", id="cancel")
+
+    def on_mount(self) -> None:
+        self.query_one("#pw", Input).focus()
+
+    def on_input_submitted(self, _: Input.Submitted) -> None:
+        self.dismiss(self.query_one("#pw", Input).value)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(self.query_one("#pw", Input).value if event.button.id == "ok" else None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class ProgressScreen(ModalScreen[None]):
+    """Shown while a download runs; the caller dismisses it."""
+
+    def __init__(self, title: str) -> None:
+        super().__init__()
+        self._title = title
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog"):
+            yield Label(self._title)
+            yield ProgressBar(total=None, show_eta=False, id="bar")
+
+    def advance(self, done: int, total: int | None) -> None:
+        self.query_one("#bar", ProgressBar).update(total=total, progress=done)
+
+
+class PathPrompt(ModalScreen[str | None]):
+    """Ask for a file path (open / save as)."""
+
+    BINDINGS = [Binding("escape", "cancel", "Cancel")]
+
+    def __init__(self, title: str, default: str = "", ok: str = "OK") -> None:
+        super().__init__()
+        self._title, self._default, self._ok = title, default, ok
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog wide"):
+            yield Label(self._title)
+            yield Input(self._default, id="path")
+            with Horizontal(classes="buttons"):
+                yield Button(self._ok, variant="primary", id="ok")
+                yield Button("Cancel", id="cancel")
+
+    def on_mount(self) -> None:
+        self.query_one("#path", Input).focus()
+
+    def _value(self) -> str | None:
+        return self.query_one("#path", Input).value.strip() or None
+
+    def on_input_submitted(self, _: Input.Submitted) -> None:
+        self.dismiss(self._value())
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(self._value() if event.button.id == "ok" else None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

sqlide/ui/screens/driver_manager.py

@@ -0,0 +1,195 @@
+"""Driver manager: see what is installed, download, remove, add custom drivers."""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual import work
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, OptionList, Select
+from textual.widgets.option_list import Option
+
+from sqlide.config._toml import ConfigError
+from sqlide.drivers.custom import build_custom_driver
+from sqlide.drivers.maven import MavenError
+from sqlide.drivers.registry import DriverDef
+from sqlide.sql.dialects import RULES
+from sqlide.ui.screens.dialogs import ConfirmScreen, ProgressScreen
+from sqlide.workspace import Workspace
+
+
+class DriverEditor(ModalScreen[DriverDef | None]):
+    """Add a custom driver from jar files or Maven coordinates."""
+
+    BINDINGS = [Binding("escape", "cancel", "Cancel")]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog wide"):
+            yield Label("Custom driver", classes="title")
+            yield Label("Id (e.g. my-db)")
+            yield Input(id="id")
+            yield Label("Name")
+            yield Input(id="name")
+            yield Label("Jar files (comma separated)  — or —  Maven group:artifact[:classifier]")
+            yield Input(id="source", placeholder="/path/a.jar, /path/b.jar   or   com.foo:bar")
+            yield Label("Driver class (empty: detect from jars)")
+            yield Input(id="class")
+            yield Label("URL template")
+            yield Input(id="url", placeholder="jdbc:foo://{host}:{port}/{database}")
+            with Horizontal(classes="row"):
+                yield Label("Port")
+                yield Input("0", type="integer", id="port")
+                yield Label("Dialect")
+                yield Select(
+                    [(d, d) for d in sorted(RULES)],
+                    value="generic",
+                    allow_blank=False,
+                    id="dialect",
+                )
+            with Horizontal(classes="buttons"):
+                yield Button("Add", variant="primary", id="ok")
+                yield Button("Cancel", id="cancel")
+            yield Label("", id="driver-error", classes="error")
+
+    def on_mount(self) -> None:
+        self.query_one("#id", Input).focus()
+
+    def _text(self, widget_id: str) -> str:
+        return self.query_one(f"#{widget_id}", Input).value
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id != "ok":
+            self.dismiss(None)
+            return
+        source = self._text("source").strip()
+        is_maven = ":" in source and "/" not in source and "\\" not in source
+        try:
+            driver = build_custom_driver(
+                self._text("id"),
+                self._text("name"),
+                maven=source if is_maven else "",
+                jars=[] if is_maven else source.split(","),
+                class_name=self._text("class"),
+                url_template=self._text("url"),
+                default_port=int(self._text("port") or 0),
+                dialect=str(self.query_one("#dialect", Select).value),
+            )
+        except ConfigError as e:
+            self.query_one("#driver-error", Label).update(str(e))
+            return
+        self.dismiss(driver)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class DriverManager(ModalScreen[None]):
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+        Binding("enter,d", "download", "Download"),
+        Binding("x", "uninstall", "Remove"),
+        Binding("a", "add", "Add custom"),
+    ]
+
+    def __init__(self, ws: Workspace) -> None:
+        super().__init__()
+        self.ws = ws
+        self._ids: list[str] = []
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="drivers", classes="dialog wide"):
+            yield Label("Drivers", classes="title")
+            yield OptionList(id="driver-list")
+            yield Label("Enter/d download · x remove · a add custom · Esc close", classes="hint")
+            yield Label("", id="driver-message")
+
+    def on_mount(self) -> None:
+        self._reload()
+        self.query_one("#driver-list", OptionList).focus()
+
+    # --- view ---
+    def _state(self, d: DriverDef) -> Text:
+        reg = self.ws.registry
+        text = Text(f"{d.name}  ")
+        if d.jars:
+            ok = reg.is_installed(d.id)
+            text.append(
+                "custom jars" if ok else "custom: jar missing", style="cyan" if ok else "red"
+            )
+        elif versions := reg.installed_versions(d.id):
+            text.append(f"✔ {versions[-1]}", style="green")
+        else:
+            text.append("not installed", style="yellow")
+        return text
+
+    def _reload(self, keep: str | None = None) -> None:
+        drivers = self.ws.registry.all()
+        self._ids = list(drivers)
+        lst = self.query_one("#driver-list", OptionList)
+        lst.clear_options()
+        lst.add_options([Option(self._state(d)) for d in drivers.values()])
+        if self._ids:
+            lst.highlighted = self._ids.index(keep) if keep in self._ids else 0
+
+    def _selected(self) -> DriverDef | None:
+        i = self.query_one("#driver-list", OptionList).highlighted
+        return self.ws.registry.all().get(self._ids[i]) if i is not None else None
+
+    def _say(self, text: str, error: bool = False) -> None:
+        self.query_one("#driver-message", Label).update(Text(text, style="red" if error else ""))
+
+    # --- actions ---
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        event.stop()
+        self.action_download()
+
+    @work(exclusive=True, group="driver")
+    async def action_download(self) -> None:
+        d = self._selected()
+        if d is None:
+            return
+        if not d.is_maven:
+            self._say(f"'{d.name}' uses local jars: nothing to download")
+            return
+        progress = ProgressScreen(f"Downloading {d.name}…")
+        await self.app.push_screen(progress)
+        try:
+            await self.ws.install_driver(
+                d.id, lambda done, total: self.app.call_from_thread(progress.advance, done, total)
+            )
+        except (MavenError, OSError) as e:
+            self._say(str(e), error=True)
+        else:
+            self._say(f"{d.name} installed")
+        finally:
+            progress.dismiss()
+        self._reload(d.id)
+
+    @work(exclusive=True, group="driver")
+    async def action_uninstall(self) -> None:
+        d = self._selected()
+        if d is None or not d.is_maven or not self.ws.registry.installed_versions(d.id):
+            return
+        if await self.app.push_screen_wait(ConfirmScreen(f"Remove downloaded jars of {d.name}?")):
+            self.ws.registry.uninstall(d.id)
+            self._reload(d.id)
+
+    @work(exclusive=True, group="driver")
+    async def action_add(self) -> None:
+        driver = await self.app.push_screen_wait(DriverEditor())
+        if driver is None:
+            return
+        try:
+            self.ws.registry.add_custom(driver)
+        except ConfigError as e:
+            self._say(str(e), error=True)
+            return
+        self._reload(driver.id)
+        self._say(
+            f"Added {driver.name}" + (" (press Enter to download)" if driver.is_maven else "")
+        )
+
+    def action_close(self) -> None:
+        self.dismiss(None)

sqlide/ui/screens/export_dialog.py

@@ -0,0 +1,158 @@
+"""Export dialog: format, scope, path, per-format options. Returns an ExportRequest."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, RadioButton, RadioSet, Select, Static, Switch
+
+from sqlide import export
+
+
+@dataclass(frozen=True, slots=True)
+class ExportContext:
+    n_view: int
+    selection: tuple[int, int] | None  # (rows, cols) when more than one cell is selected
+    can_requery: bool
+    more_rows: bool  # the loaded rows are only part of the result
+
+
+@dataclass(frozen=True, slots=True)
+class ExportRequest:
+    format: str
+    scope: str  # "view" | "selection" | "all"
+    path: Path
+    header: bool
+    delimiter: str
+    bom: bool
+    table_name: str
+
+
+def default_path(ext: str) -> str:
+    return str(Path.cwd() / f"result_{datetime.now():%Y%m%d_%H%M%S}{ext}")
+
+
+class ExportScreen(ModalScreen[ExportRequest | None]):
+    BINDINGS = [Binding("escape", "cancel", "Cancel")]
+
+    def __init__(self, ctx: ExportContext) -> None:
+        super().__init__()
+        self._ctx = ctx
+        self._prev_ext = export.get("csv").extension
+
+    def compose(self) -> ComposeResult:
+        c = self._ctx
+        default_scope = "all" if c.more_rows and c.can_requery else "view"
+        with Vertical(classes="dialog wide"):
+            yield Label("Export result", classes="title")
+            yield Label("Format")
+            yield Select(
+                [(e.label, e.name) for e in export.all_exporters()],
+                value="csv",
+                allow_blank=False,
+                id="format",
+            )
+            yield Label("Data")
+            with RadioSet(id="scope"):
+                view_label = f"Loaded rows, as shown ({c.n_view})" + (
+                    "  - more rows exist" if c.more_rows else ""
+                )
+                yield RadioButton(view_label, id="view", value=default_scope == "view")
+                if c.selection:
+                    yield RadioButton(
+                        f"Selection ({c.selection[0]} x {c.selection[1]})", id="selection"
+                    )
+                if c.can_requery:
+                    yield RadioButton(
+                        "Whole result (re-run the query)", id="all", value=default_scope == "all"
+                    )
+            yield Label("File")
+            yield Input(default_path(self._prev_ext), id="path")
+            with Horizontal(classes="row", id="opt-header"):
+                yield Label("Header row")
+                yield Switch(True, id="header")
+            with Horizontal(classes="row", id="opt-csv"):
+                yield Label("Delimiter")
+                yield Input(",", id="delimiter", max_length=1)
+                yield Label("  UTF-8 BOM (for Excel)")
+                yield Switch(False, id="bom")
+            with Horizontal(classes="row", id="opt-sql"):
+                yield Label("Table name")
+                yield Input("table_name", id="table_name")
+            with Horizontal(classes="row"):
+                yield Label("Overwrite existing file")
+                yield Switch(False, id="overwrite")
+            yield Static("", id="error", classes="error")
+            with Horizontal(classes="buttons"):
+                yield Button("Export", variant="primary", id="export")
+                yield Button("Cancel", id="cancel")
+
+    def on_mount(self) -> None:
+        self._sync_options("csv")
+        self.query_one("#path", Input).focus()
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        if event.select.id == "format" and isinstance(event.value, str):
+            self._swap_extension(event.value)
+            self._sync_options(event.value)
+
+    def _swap_extension(self, fmt: str) -> None:
+        path = self.query_one("#path", Input)
+        new_ext = export.get(fmt).extension
+        if path.value.endswith(self._prev_ext):
+            path.value = path.value[: -len(self._prev_ext)] + new_ext
+        self._prev_ext = new_ext
+
+    def _sync_options(self, fmt: str) -> None:
+        shows = {
+            "opt-header": fmt in ("csv", "tsv", "xlsx", "html", "markdown"),
+            "opt-csv": fmt == "csv",
+            "opt-sql": fmt == "sql",
+        }
+        for id_, visible in shows.items():
+            self.query_one(f"#{id_}").display = visible
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "cancel":
+            self.dismiss(None)
+        else:
+            self._submit()
+
+    def on_input_submitted(self, _: Input.Submitted) -> None:
+        self._submit()
+
+    def _submit(self) -> None:
+        error = self.query_one("#error", Static)
+        raw = self.query_one("#path", Input).value.strip()
+        if not raw:
+            error.update("Path is empty")
+            return
+        path = Path(raw).expanduser()
+        if path.is_dir():
+            error.update(f"{path} is a directory")
+            return
+        if path.exists() and not self.query_one("#overwrite", Switch).value:
+            error.update("File exists: switch on 'Overwrite existing file'")
+            return
+        scope_set = self.query_one("#scope", RadioSet)
+        scope = scope_set.pressed_button.id if scope_set.pressed_button else "view"
+        self.dismiss(
+            ExportRequest(
+                format=str(self.query_one("#format", Select).value),
+                scope=scope or "view",
+                path=path,
+                header=self.query_one("#header", Switch).value,
+                delimiter=self.query_one("#delimiter", Input).value or ",",
+                bom=self.query_one("#bom", Switch).value,
+                table_name=self.query_one("#table_name", Input).value.strip() or "table_name",
+            )
+        )
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

sqlide/ui/screens/grid_dialogs.py

@@ -0,0 +1,92 @@
+"""Dialogs opened from the result grid: copy-as menu and full value viewer."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Label, OptionList, TextArea
+from textual.widgets.option_list import Option
+
+COPY_FORMATS: list[tuple[str, str]] = [
+    ("tsv", "Values (TSV)"),
+    ("tsv_header", "Values with header (TSV)"),
+    ("csv", "CSV with header"),
+    ("markdown", "Markdown table"),
+    ("json", "JSON"),
+    ("insert", "SQL INSERT statements"),
+    ("cell", "Current cell value"),
+]
+
+
+class CopyMenu(ModalScreen[str | None]):
+    BINDINGS = [Binding("escape", "dismiss_none", "Cancel")]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog"):
+            yield Label("Copy selection as", classes="title")
+            yield OptionList(*(Option(label, id=key) for key, label in COPY_FORMATS))
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        self.dismiss(event.option.id)
+
+    def action_dismiss_none(self) -> None:
+        self.dismiss(None)
+
+
+def pretty_if_json(text: str) -> tuple[str, bool]:
+    """Pretty-print text that is a JSON object/array; otherwise return it unchanged."""
+    stripped = text.strip()
+    if stripped[:1] in "{[":
+        try:
+            return json.dumps(json.loads(stripped), indent=2, ensure_ascii=False), True
+        except ValueError:
+            pass
+    return text, False
+
+
+class ValueViewer(ModalScreen[None]):
+    BINDINGS = [
+        Binding("escape,q", "close", "Close"),
+        Binding("c", "copy", "Copy"),
+    ]
+
+    def __init__(self, title: str, text: str) -> None:
+        super().__init__()
+        self._title = title
+        self._text, self._is_json = pretty_if_json(text)
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog viewer"):
+            yield Label(self._title, classes="title")
+            yield TextArea(
+                self._text,
+                read_only=True,
+                language="json" if self._is_json else None,
+                show_line_numbers=True,
+                soft_wrap=True,
+                id="value",
+            )
+            yield Label("c copy · esc close", classes="hint")
+
+    def on_mount(self) -> None:
+        self.query_one("#value", TextArea).focus()
+
+    def action_close(self) -> None:
+        self.dismiss(None)
+
+    def action_copy(self) -> None:
+        from sqlide import clipboard
+
+        name = clipboard.copy_native(self._text)
+        if name is None:
+            self.app.copy_to_clipboard(self._text)
+        self.app.notify(f"Copied value ({name or 'terminal clipboard'})")
+
+
+def describe_cell(column: str, type_name: str, value: Any) -> str:
+    return f"{column}  ·  {type_name}" + ("  ·  NULL" if value is None else "")

sqlide/ui/screens/history.py

@@ -0,0 +1,130 @@
+"""Query history browser: search, preview, insert into the editor or run again."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Input, Label, OptionList, Static
+from textual.widgets.option_list import Option
+
+from sqlide.history import HistoryEntry, HistoryStore
+
+
+class HistoryChoice:
+    """What the user picked: the statement, and whether to run it right away."""
+
+    __slots__ = ("run", "sql")
+
+    def __init__(self, sql: str, run: bool) -> None:
+        self.sql, self.run = sql, run
+
+
+def _line(e: HistoryEntry) -> Text:
+    when = datetime.fromtimestamp(e.ts).strftime("%m-%d %H:%M")
+    t = Text(f"{when}  ")
+    t.append("✔ " if e.ok else "✖ ", style="green" if e.ok else "red")
+    t.append(f"[{e.connection}] ", style="cyan")
+    t.append(" ".join(e.sql.split())[:200])
+    return t
+
+
+class HistoryScreen(ModalScreen[HistoryChoice | None]):
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+        Binding("down", "move(1)", show=False),
+        Binding("up", "move(-1)", show=False),
+        Binding("pagedown", "move(10)", show=False),
+        Binding("pageup", "move(-10)", show=False),
+        Binding("enter", "insert", "Insert"),
+        Binding("f5,ctrl+j", "run", "Run"),
+        Binding("alt+c", "toggle_scope", "This connection only", priority=True),
+        Binding("alt+d", "delete", "Delete entry", priority=True),
+    ]
+
+    def __init__(self, store: HistoryStore, connection: str = "") -> None:
+        super().__init__()
+        self._store = store
+        self._connection = connection
+        self._only_current = False
+        self._entries: list[HistoryEntry] = []
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="history"):
+            yield Label(id="history-title")
+            yield Input(placeholder="type to filter (all words must match)", id="history-filter")
+            yield OptionList(id="history-list")
+            yield Static(id="history-preview")
+
+    def on_mount(self) -> None:
+        self.query_one("#history-filter", Input).focus()
+        self._reload()
+
+    # --- data ---
+    def _reload(self) -> None:
+        text = self.query_one("#history-filter", Input).value
+        scope = self._connection if self._only_current and self._connection else None
+        self._entries = self._store.search(text, connection=scope)
+        lst = self.query_one("#history-list", OptionList)
+        lst.clear_options()
+        lst.add_options([Option(_line(e)) for e in self._entries])
+        if self._entries:
+            lst.highlighted = 0
+        title = "History" + (f" · {self._connection} only" if scope else " · all connections")
+        self.query_one("#history-title", Label).update(f"{title} · {len(self._entries)} entries")
+        self._preview()
+
+    def _current(self) -> HistoryEntry | None:
+        i = self.query_one("#history-list", OptionList).highlighted
+        return self._entries[i] if i is not None and 0 <= i < len(self._entries) else None
+
+    def _preview(self) -> None:
+        e = self._current()
+        text = "" if e is None else e.sql + (f"\n\n-- {e.error}" if e.error else "")
+        self.query_one("#history-preview", Static).update(Text(text))
+
+    # --- events ---
+    def on_input_changed(self, _: Input.Changed) -> None:
+        self._reload()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        event.stop()
+        self.action_insert()
+
+    def on_option_list_option_highlighted(self, _: OptionList.OptionHighlighted) -> None:
+        self._preview()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        event.stop()
+        self.action_insert()
+
+    # --- actions ---
+    def action_move(self, step: int) -> None:
+        lst = self.query_one("#history-list", OptionList)
+        if self._entries:
+            current = lst.highlighted or 0
+            lst.highlighted = max(0, min(len(self._entries) - 1, current + step))
+
+    def action_insert(self) -> None:
+        if e := self._current():
+            self.dismiss(HistoryChoice(e.sql, run=False))
+
+    def action_run(self) -> None:
+        if e := self._current():
+            self.dismiss(HistoryChoice(e.sql, run=True))
+
+    def action_toggle_scope(self) -> None:
+        self._only_current = not self._only_current
+        self._reload()
+
+    def action_delete(self) -> None:
+        if e := self._current():
+            self._store.delete(e.id)
+            self._reload()
+
+    def action_close(self) -> None:
+        self.dismiss(None)