openduck-cli 0.1.0__py3-none-any.whl

openduck/__init__.py

@@ -0,0 +1,42 @@
+"""OpenDuck - The Modern Terminal SQL IDE & Data Explorer for DuckDB."""
+
+__version__ = "0.1.0"
+
+from openduck.core.config import (
+    CWD,
+    CONFIG_FILE,
+    MAX_UI_ROWS,
+    DUCKDB_EXTENSIONS,
+    add_to_history,
+    delete_connection,
+    load_config,
+    save_config,
+    save_connection,
+    save_query,
+)
+from openduck.core.error_classifier import classify_file_error
+from openduck.core.sql_utils import is_duckdb_file, sql_for_file, toggle_sql_comment_lines
+from openduck.core.clipboard import copy_to_system_clipboard, get_system_clipboard
+from openduck.gui.app import DuckCLI
+from openduck.main import main
+
+__all__ = [
+    "DuckCLI",
+    "main",
+    "load_config",
+    "save_config",
+    "add_to_history",
+    "save_query",
+    "save_connection",
+    "delete_connection",
+    "classify_file_error",
+    "is_duckdb_file",
+    "sql_for_file",
+    "toggle_sql_comment_lines",
+    "copy_to_system_clipboard",
+    "get_system_clipboard",
+    "CWD",
+    "CONFIG_FILE",
+    "MAX_UI_ROWS",
+    "DUCKDB_EXTENSIONS",
+]

openduck/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running openduck as a module: python -m openduck."""
+
+from openduck.main import main
+
+if __name__ == "__main__":
+    main()

openduck/core/__init__.py

@@ -0,0 +1,36 @@
+"""Core modules for OpenDuck: config, clipboard, SQL utilities, and error classification."""
+
+from openduck.core.clipboard import copy_to_system_clipboard, get_system_clipboard
+from openduck.core.config import (
+    CONFIG_FILE,
+    CWD,
+    DUCKDB_EXTENSIONS,
+    MAX_UI_ROWS,
+    add_to_history,
+    delete_connection,
+    load_config,
+    save_config,
+    save_connection,
+    save_query,
+)
+from openduck.core.error_classifier import classify_file_error
+from openduck.core.sql_utils import is_duckdb_file, sql_for_file, toggle_sql_comment_lines
+
+__all__ = [
+    "CWD",
+    "CONFIG_FILE",
+    "MAX_UI_ROWS",
+    "DUCKDB_EXTENSIONS",
+    "load_config",
+    "save_config",
+    "add_to_history",
+    "save_query",
+    "save_connection",
+    "delete_connection",
+    "copy_to_system_clipboard",
+    "get_system_clipboard",
+    "is_duckdb_file",
+    "sql_for_file",
+    "toggle_sql_comment_lines",
+    "classify_file_error",
+]

openduck/core/clipboard.py

@@ -0,0 +1,57 @@
+"""Cross-platform system clipboard integration."""
+
+import logging
+import subprocess
+import sys
+
+logger = logging.getLogger(__name__)
+
+
+def copy_to_system_clipboard(text: str) -> bool:
+    """Copy text to system clipboard (macOS pbcopy, xclip/wl-copy on Linux, clip on Windows)."""
+    if not text:
+        return False
+    try:
+        if sys.platform == "darwin":
+            p = subprocess.Popen(["pbcopy"], stdin=subprocess.PIPE, text=True)
+            p.communicate(input=text)
+            return True
+        elif sys.platform.startswith("linux"):
+            for cmd in (
+                ["wl-copy"],
+                ["xclip", "-selection", "clipboard"],
+                ["xsel", "--clipboard", "--input"],
+            ):
+                try:
+                    p = subprocess.Popen(cmd, stdin=subprocess.PIPE, text=True)
+                    p.communicate(input=text)
+                    return True
+                except FileNotFoundError:
+                    continue
+        elif sys.platform == "win32":
+            p = subprocess.Popen(["clip"], stdin=subprocess.PIPE, text=True)
+            p.communicate(input=text)
+            return True
+    except Exception as e:
+        logger.error(f"Failed to copy to system clipboard: {e}")
+    return False
+
+
+def get_system_clipboard() -> str:
+    """Read text from system clipboard (macOS pbpaste, wl-paste/xclip on Linux)."""
+    try:
+        if sys.platform == "darwin":
+            return subprocess.check_output(["pbpaste"], text=True)
+        elif sys.platform.startswith("linux"):
+            for cmd in (
+                ["wl-paste"],
+                ["xclip", "-selection", "clipboard", "-o"],
+                ["xsel", "--clipboard", "--output"],
+            ):
+                try:
+                    return subprocess.check_output(cmd, text=True)
+                except FileNotFoundError:
+                    continue
+    except Exception as e:
+        logger.error(f"Failed to read from system clipboard: {e}")
+    return ""

openduck/core/config.py

@@ -0,0 +1,108 @@
+"""Configuration and persistence management for OpenDuck."""
+
+from datetime import datetime
+import json
+import logging
+import os
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+CWD = Path(os.getcwd())
+CONFIG_FILE = CWD / "openduck.json"
+MAX_UI_ROWS = 10000
+DUCKDB_EXTENSIONS = {
+    ".parquet", ".arrow", ".duckdb", ".csv", ".csv.gz",
+    ".json", ".jsonl", ".sqlite", ".sqlite3", ".db", ".xlsx", ".xls"
+}
+
+
+def load_config() -> dict:
+    """Load config from openduck.json, create if doesn't exist or is invalid."""
+    if CONFIG_FILE.exists():
+        try:
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                config = json.load(f)
+                if isinstance(config, dict):
+                    if "connections" not in config:
+                        config["connections"] = []
+                    if "history" not in config:
+                        config["history"] = []
+                    if "saved_queries" not in config:
+                        config["saved_queries"] = []
+                    return config
+        except Exception as e:
+            logger.error(f"Failed to read config file, falling back to default: {e}")
+
+    default_config = {
+        "history": [],
+        "saved_queries": [],
+        "connections": []
+    }
+    save_config(default_config)
+    return default_config
+
+
+def save_config(config: dict) -> None:
+    """Save config to openduck.json."""
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+
+
+def add_to_history(sql: str) -> dict:
+    """Add a query to history in the config file, capped at the last 200 queries."""
+    config = load_config()
+    timestamp = datetime.now().isoformat()
+    config["history"].append({
+        "sql": sql.strip(),
+        "timestamp": timestamp
+    })
+    # Keep only the last 200 queries to prevent boundless file growth
+    config["history"] = config["history"][-200:]
+    save_config(config)
+    return config
+
+
+def save_query(name: str, sql: str) -> dict:
+    """Save a query with a name to the config file."""
+    config = load_config()
+    timestamp = datetime.now().isoformat()
+    # Check if query with same name already exists and update it
+    for i, query in enumerate(config["saved_queries"]):
+        if query["name"] == name:
+            config["saved_queries"][i] = {
+                "name": name,
+                "sql": sql.strip(),
+                "timestamp": timestamp
+            }
+            save_config(config)
+            return config
+    # If not found, add as new query
+    config["saved_queries"].append({
+        "name": name,
+        "sql": sql.strip(),
+        "timestamp": timestamp
+    })
+    save_config(config)
+    return config
+
+
+def save_connection(conn_info: dict) -> dict:
+    """Save a database connection to config."""
+    config = load_config()
+    for i, c in enumerate(config["connections"]):
+        if c["id"] == conn_info["id"]:
+            config["connections"][i] = conn_info
+            save_config(config)
+            return config
+    config["connections"].append(conn_info)
+    save_config(config)
+    return config
+
+
+def delete_connection(conn_id: str) -> dict:
+    """Delete a database connection from config."""
+    config = load_config()
+    config["connections"] = [c for c in config["connections"] if c["id"] != conn_id]
+    save_config(config)
+    return config

openduck/core/error_classifier.py

@@ -0,0 +1,53 @@
+"""Diagnostic classification for file-related query errors."""
+
+
+def classify_file_error(e: Exception, file_path: str = "") -> str:
+    """Classify file-related errors and return user-friendly message."""
+    error_msg = str(e).lower()
+    original_error = str(e)
+
+    # CSV-specific errors
+    if 'csv' in error_msg or 'read_csv' in error_msg:
+        if 'no such file' in error_msg or 'could not open' in error_msg:
+            return f"❌ File not found: {file_path}\n→ Check if the file exists and the path is correct"
+        elif 'permission' in error_msg:
+            return f"❌ Permission denied: {file_path}\n→ Check file permissions"
+        elif 'encoding' in error_msg:
+            return f"❌ Encoding error in CSV file\n→ The CSV file may have encoding issues. Try saving it with UTF-8 encoding"
+        elif 'delimiter' in error_msg or 'separator' in error_msg:
+            return f"❌ CSV format error\n→ The file may have inconsistent delimiters. Check the CSV format"
+        elif 'empty' in error_msg or 'no columns' in error_msg or 'no rows' in error_msg:
+            return f"❌ Empty or invalid CSV file\n→ The file appears to be empty or has no valid columns"
+        else:
+            return f"❌ Cannot read CSV file: {file_path}\n→ The file may be corrupted, empty, or in an unsupported format\n\nDetails: {str(e)}"
+
+    # Excel-specific errors
+    elif 'excel' in error_msg or 'xlsx' in error_msg or 'xls' in error_msg:
+        if 'no such file' in error_msg:
+            return f"❌ Excel file not found: {file_path}"
+        elif 'permission' in error_msg:
+            return f"❌ Permission denied: {file_path}"
+        else:
+            return f"❌ Cannot read Excel file: {file_path}\n→ The file may be corrupted, password-protected, or in an unsupported format\n\nDetails: {str(e)}"
+
+    # Parquet/Arrow errors
+    elif 'parquet' in error_msg or 'arrow' in error_msg:
+        return f"❌ Cannot read Parquet/Arrow file: {file_path}\n→ The file may be corrupted or in an incompatible format\n\nDetails: {str(e)}"
+
+    # JSON errors
+    elif 'json' in error_msg:
+        return f"❌ Cannot read JSON file: {file_path}\n→ The file may have invalid JSON syntax\n\nDetails: {str(e)}"
+
+    # Generic file errors
+    elif 'no such file' in error_msg or 'does not exist' in error_msg:
+        return f"❌ File not found: {file_path}\n→ The file does not exist at this location"
+    elif 'permission' in error_msg:
+        return f"❌ Permission denied: {file_path}\n→ You don't have permission to access this file"
+    elif 'disk i/o' in error_msg or 'io error' in error_msg:
+        return f"❌ Disk I/O error\n→ There may be a problem with the disk or file system"
+    elif 'out of memory' in error_msg:
+        return f"❌ Out of memory\n→ The file is too large to load into memory"
+    elif 'empty' in original_error.lower() or 'no columns' in original_error.lower():
+        return f"❌ Empty or invalid file\n→ The file appears to be empty or has no valid data"
+    else:
+        return f"❌ Error loading file: {file_path}\n\nDetails: {str(e)}"

openduck/core/sql_utils.py

@@ -0,0 +1,63 @@
+"""SQL utilities, formatting, and file-query mappings."""
+
+from pathlib import Path
+import re
+from typing import List
+
+from openduck.core.config import DUCKDB_EXTENSIONS
+
+
+def is_duckdb_file(path: Path) -> bool:
+    """Check if the given path is a file supported by DuckDB/OpenDuck."""
+    return path.is_file() and any(path.name.lower().endswith(ext) for ext in DUCKDB_EXTENSIONS)
+
+
+def sql_for_file(path: Path) -> str:
+    """Generate the initial SQL query statement to preview a given file."""
+    p, s = path.as_posix(), path.suffix.lower()
+    if s == ".duckdb":
+        return f"ATTACH '{p}' AS other;\nSHOW TABLES;"
+    if s in {".sqlite", ".sqlite3", ".db"}:
+        return f"INSTALL sqlite;\nLOAD sqlite;\nATTACH '{p}' AS sqlite_db (TYPE SQLITE);\nSHOW TABLES FROM sqlite_db;"
+    if s in {".xlsx", ".xls"}:
+        table_name = re.sub(r'\W|^(?=\d)', '_', path.stem.replace(' ', '_').replace('-', '_'))
+        return f"SELECT * FROM {table_name} LIMIT 100;"
+    if s in {".csv", ".csv.gz"}:
+        return f"SELECT * FROM read_csv_auto('{p}') LIMIT 100;"
+    if s in {".json", ".jsonl"}:
+        return f"SELECT * FROM read_json_auto('{p}') LIMIT 100;"
+    return f"SELECT * FROM '{p}' LIMIT 100;"
+
+
+def toggle_sql_comment_lines(lines: List[str]) -> List[str]:
+    """Toggle SQL line comments (-- ) like in VS Code."""
+    non_empty = [l for l in lines if l.strip()]
+    if not non_empty:
+        return [("-- " + l if not l.startswith("--") else l) for l in lines]
+
+    all_commented = all(l.lstrip().startswith("--") for l in non_empty)
+    result = []
+    if all_commented:
+        for l in lines:
+            if not l.strip():
+                result.append(l)
+                continue
+            indent_len = len(l) - len(l.lstrip())
+            indent = l[:indent_len]
+            content = l[indent_len:]
+            if content.startswith("-- "):
+                result.append(indent + content[3:])
+            elif content.startswith("--"):
+                result.append(indent + content[2:])
+            else:
+                result.append(l)
+    else:
+        for l in lines:
+            if not l.strip():
+                result.append(l)
+                continue
+            indent_len = len(l) - len(l.lstrip())
+            indent = l[:indent_len]
+            content = l[indent_len:]
+            result.append(indent + "-- " + content)
+    return result

openduck/gui/__init__.py

@@ -0,0 +1,5 @@
+"""GUI module for OpenDuck containing application, screens, widgets, and dialogs."""
+
+from openduck.gui.app import DuckCLI
+
+__all__ = ["DuckCLI"]