evolver-tools 1.4.0__py3-none-any.whl

evolver_tools/vendor/sqlite_cli/__init__.py

@@ -0,0 +1,326 @@
+"""sqlite-cli: Zero-dependency SQLite query tool (pure Python stdlib).
+
+A user-friendly SQLite CLI that works without installing sqlite3 separately.
+Python's sqlite3 module is always available (stdlib since Python 2.5).
+"""
+
+import sys
+import os
+import json
+import textwrap
+import sqlite3
+from pathlib import Path
+
+
+__version__ = "1.0.0"
+
+
+def detect_columns(cursor):
+    """Get column names and types from cursor description."""
+    if cursor.description:
+        return [desc[0] for desc in cursor.description]
+    return []
+
+
+def format_table(rows, headers, fmt="table"):
+    """Format query results in various modes."""
+    if not rows and not headers:
+        return "(no results)"
+
+    if fmt == "json":
+        if not headers:
+            return json.dumps(rows, ensure_ascii=False) if rows else "[]"
+        result = [dict(zip(headers, row)) for row in rows]
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    if fmt == "csv":
+        output = ",".join(headers) if headers else ""
+        for row in rows:
+            output += "\n" + ",".join(
+                str(v) if v is not None else "NULL"
+                for v in row
+            )
+        return output
+
+    if fmt == "line":
+        lines = []
+        for i, row in enumerate(rows):
+            if headers:
+                lines.append(f"  row {i+1}:")
+                for h, v in zip(headers, row):
+                    lines.append(f"    {h} = {v}")
+            else:
+                lines.append(f"  row {i+1}: {row}")
+            lines.append("")
+        return "\n".join(lines).rstrip()
+
+    if fmt == "tabs":
+        output = "\t".join(headers) if headers else ""
+        for row in rows:
+            output += "\n" + "\t".join(
+                str(v) if v is not None else "NULL"
+                for v in row
+            )
+        return output
+
+    # Default: table format
+    if not headers:
+        lines = [str(row) for row in rows]
+        return "\n".join(lines)
+
+    # Calculate column widths
+    col_widths = [len(h) for h in headers]
+    for row in rows:
+        for i, v in enumerate(row):
+            if i < len(col_widths):
+                s = str(v) if v is not None else "NULL"
+                col_widths[i] = max(col_widths[i], len(s))
+
+    # Cap widths at 80 for readability
+    max_width = 80
+    total = sum(col_widths) + 3 * len(col_widths) - 1
+    if total > 120:
+        for i in range(len(col_widths)):
+            col_widths[i] = min(col_widths[i], max_width)
+
+    # Build separator
+    sep = "+" + "+".join("-" * (w + 2) for w in col_widths) + "+"
+
+    def fmt_row(vals):
+        parts = []
+        for i, val in enumerate(vals):
+            s = str(val) if val is not None else "NULL"
+            if i < len(col_widths):
+                w = col_widths[i]
+                if len(s) > w:
+                    s = s[:w - 3] + "..."
+                parts.append(f" {s:<{w}} ")
+            else:
+                parts.append(f" {s} ")
+        return "|" + "|".join(parts) + "|"
+
+    lines = [sep, fmt_row(headers), sep]
+    for row in rows:
+        lines.append(fmt_row(row))
+    lines.append(sep)
+    lines.append(f"({len(rows)} rows)")
+
+    return "\n".join(lines)
+
+
+def run_dot_command(cursor, cmd: str, db_path: str):
+    """Handle SQLite dot commands."""
+    cmd = cmd.strip().lower()
+
+    if cmd == ".tables":
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+        tables = [r[0] for r in cursor.fetchall()]
+        if tables:
+            # Print in columns
+            cols = 4
+            for i in range(0, len(tables), cols):
+                print("  ".join(tables[i:i+cols]))
+        else:
+            print("(no tables)")
+        return True
+
+    if cmd == ".schema":
+        cursor.execute("SELECT sql FROM sqlite_master WHERE sql IS NOT NULL")
+        schemas = [r[0] for r in cursor.fetchall()]
+        for s in schemas:
+            print(s + ";")
+            print()
+        if not schemas:
+            print("(no schema)")
+        return True
+
+    if cmd == ".databases":
+        print(f"  {db_path or ':memory:'}")
+        return True
+
+    if cmd == ".indexes":
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='index' ORDER BY name")
+        indexes = [r[0] for r in cursor.fetchall()]
+        if indexes:
+            print("\n".join(indexes))
+        else:
+            print("(no indexes)")
+        return True
+
+    if cmd.startswith(".schema "):
+        table = cmd[8:].strip()
+        cursor.execute("SELECT sql FROM sqlite_master WHERE type='table' AND name=? AND sql IS NOT NULL", (table,))
+        row = cursor.fetchone()
+        if row:
+            print(row[0] + ";")
+        else:
+            print(f"Error: no such table: {table}", file=sys.stderr)
+        return True
+
+    if cmd.startswith(".mode "):
+        # This is handled before execution, not here
+        return True
+
+    if cmd == ".help":
+        print("""Dot commands:
+  .tables                  List all tables
+  .schema [table]          Show CREATE statement(s)
+  .indexes                 List all indexes
+  .databases               Show connected database
+  .mode MODE               Set output mode (table|csv|json|line|tabs|column)
+  .exit                    Quit
+  .help                    Show this help""")
+        return True
+
+    return False
+
+
+def exec_query(cursor, sql: str, mode: str = "table"):
+    """Execute a SQL query and print results."""
+    sql = sql.strip().rstrip(";")
+    if not sql:
+        return
+
+    try:
+        cursor.execute(sql)
+    except sqlite3.Error as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return
+
+    # For SELECT-like queries, fetch and display results
+    if sql.upper().lstrip().startswith(("SELECT", "PRAGMA", "EXPLAIN")):
+        rows = cursor.fetchall()
+        headers = detect_columns(cursor)
+        output = format_table(rows, headers, fmt=mode)
+        if output:
+            print(output)
+    else:
+        # DML/DDL: show affected rows
+        print(f"({cursor.rowcount} rows affected)" if cursor.rowcount >= 0 else "OK")
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="sqlite-cli — Zero-dependency SQLite query tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  sqlite-cli db.sqlite3 "SELECT * FROM users"
+  sqlite-cli db.sqlite3 --mode json "SELECT id, name FROM users"
+  echo "SELECT count(*) FROM users" | sqlite-cli db.sqlite3
+  sqlite-cli --init schema.sql db.sqlite3
+  sqlite-cli --tables db.sqlite3
+  sqlite-cli db.sqlite3 ".tables"
+  sqlite-cli db.sqlite3 ".schema users"
+  sqlite-cli --schema users db.sqlite3
+  sqlite-cli --schema-all db.sqlite3
+        """
+    )
+    parser.add_argument("database", help="Path to SQLite database file")
+    parser.add_argument("query", nargs="*", help="SQL query or dot command")
+    parser.add_argument("--mode", "-m", default="table", choices=["table", "csv", "json", "line", "tabs", "column"],
+                        help="Output format (default: table)")
+    parser.add_argument("--init", "-i", help="SQL file to execute before query (e.g., CREATE TABLE)")
+    parser.add_argument("--tables", action="store_true", help="List all tables (shortcut)")
+    parser.add_argument("--schema", nargs=1, metavar="TABLE", default=None,
+                        help="Show schema for a specific table (omit for all)")
+    parser.add_argument("--schema-all", action="store_true",
+                        help="Show schema for all tables")
+
+    args = parser.parse_intermixed_args()
+
+    # Resolve DB path
+    db_path = args.database
+
+    # Handle .sqlite or .db shortcuts
+    if not os.path.exists(db_path) and not db_path == ":memory:":
+        print(f"Warning: database not found: {db_path}", file=sys.stderr)
+        print("Creating new database...", file=sys.stderr)
+
+    # Connect
+    try:
+        conn = sqlite3.connect(db_path)
+        conn.execute("PRAGMA journal_mode=WAL")
+    except sqlite3.Error as e:
+        print(f"Error connecting to database: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    cursor = conn.cursor()
+
+    # Run init file if provided
+    if args.init:
+        try:
+            with open(args.init) as f:
+                init_sql = f.read()
+            cursor.executescript(init_sql)
+            conn.commit()
+            print(f"Executed init script: {args.init}", file=sys.stderr)
+        except FileNotFoundError:
+            print(f"Error: init file not found: {args.init}", file=sys.stderr)
+            sys.exit(1)
+        except sqlite3.Error as e:
+            print(f"Error executing init script: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Handle --tables shortcut
+    if args.tables:
+        run_dot_command(cursor, ".tables", db_path)
+        conn.close()
+        return
+
+    # Handle --schema shortcut
+    if args.schema is not None:
+        run_dot_command(cursor, f".schema {args.schema[0]}", db_path)
+        conn.close()
+        return
+
+    # Handle --schema-all
+    if args.schema_all:
+        run_dot_command(cursor, ".schema", db_path)
+        conn.close()
+        return
+
+    # Get query
+    if args.query:
+        query_text = " ".join(args.query)
+    elif args.init:
+        # init only - no query needed
+        conn.close()
+        return
+    else:
+        # Read from stdin (non-interactive only)
+        stdin_data = sys.stdin.read()
+        if stdin_data and stdin_data.strip():
+            query_text = stdin_data.strip()
+        else:
+            print("Error: no query provided (provide as argument or pipe from stdin)", file=sys.stderr)
+            print("Usage: sqlite-cli database.sqlite3 'SELECT * FROM table'", file=sys.stderr)
+            conn.close()
+            sys.exit(1)
+
+    # Handle dot commands
+    if query_text.startswith("."):
+        if query_text.startswith(".mode "):
+            mode = query_text[6:].strip()
+            print(f"  Mode set to: {mode}")
+        elif not run_dot_command(cursor, query_text, db_path):
+            print(f"Unknown dot command: {query_text.split()[0]}", file=sys.stderr)
+            sys.exit(1)
+        conn.close()
+        return
+
+    # Execute SQL query
+    try:
+        exec_query(cursor, query_text, mode=args.mode)
+        conn.commit()
+    except sqlite3.Error as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

evolver_tools/vendor/sqlite_cli/__main__.py

@@ -0,0 +1,5 @@
+"""sqlite-cli entry point."""
+from . import main
+
+if __name__ == "__main__":
+    main()

evolver_tools/vendor/sysmon/__init__.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""
+sysmon — 终端系统监控仪
+实时显示 CPU、内存、磁盘、进程、网络、uptime
+使用 curses TUI 渲染
+"""
+
+import curses
+import psutil
+import time
+import os
+import socket
+import subprocess
+from datetime import datetime, timedelta
+
+def get_hostname():
+    try:
+        return socket.gethostname()
+    except:
+        return "unknown"
+
+def get_uptime():
+    try:
+        with open('/proc/uptime') as f:
+            seconds = float(f.read().split()[0])
+        days = int(seconds // 86400)
+        hours = int((seconds % 86400) // 3600)
+        mins = int((seconds % 3600) // 60)
+        parts = []
+        if days > 0: parts.append(f"{days}d")
+        if hours > 0: parts.append(f"{hours}h")
+        parts.append(f"{mins}m")
+        return ''.join(parts)
+    except:
+        return "N/A"
+
+def get_sysinfo():
+    return {
+        'hostname': get_hostname(),
+        'uptime': get_uptime(),
+        'boot_time': datetime.fromtimestamp(psutil.boot_time()).strftime('%m/%d %H:%M'),
+    }
+
+def get_cpu():
+    return {
+        'percent': psutil.cpu_percent(interval=0.1),
+        'per_cpu': psutil.cpu_percent(interval=0.05, percpu=True),
+        'count': psutil.cpu_count(),
+        'freq': psutil.cpu_freq(),
+        'load': psutil.getloadavg(),
+    }
+
+def get_memory():
+    mem = psutil.virtual_memory()
+    swap = psutil.swap_memory()
+    return {
+        'total': mem.total,
+        'used': mem.used,
+        'percent': mem.percent,
+        'swap_total': swap.total,
+        'swap_used': swap.used,
+        'swap_percent': swap.percent,
+    }
+
+def get_disk():
+    parts = []
+    for p in psutil.disk_partitions():
+        try:
+            usage = psutil.disk_usage(p.mountpoint)
+            parts.append({
+                'mount': p.mountpoint,
+                'device': p.device,
+                'total': usage.total,
+                'used': usage.used,
+                'percent': usage.percent,
+            })
+        except:
+            pass
+    return parts
+
+def get_network():
+    net = psutil.net_io_counters()
+    return {
+        'sent': net.bytes_sent,
+        'recv': net.bytes_recv,
+    }
+
+def get_top_processes(n=8):
+    procs = []
+    for p in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent', 'status']):
+        try:
+            info = p.info
+            if info['cpu_percent'] is None: continue
+            procs.append({
+                'pid': info['pid'],
+                'name': info['name'][:20] if info['name'] else '?',
+                'cpu': info['cpu_percent'],
+                'mem': info['memory_percent'] or 0,
+                'status': info['status'],
+            })
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+    procs.sort(key=lambda x: x['cpu'], reverse=True)
+    return procs[:n]
+
+def format_bytes(b):
+    for unit in ['B', 'K', 'M', 'G', 'T']:
+        if b < 1024:
+            return f"{b:.1f}{unit}"
+        b /= 1024
+    return f"{b:.1f}P"
+
+def draw_bar(win, y, x, width, percent, color_pair=2):
+    """Draw a horizontal bar"""
+    fill = int(width * percent / 100)
+    bar = '█' * fill + '░' * (width - fill)
+    try:
+        win.addstr(y, x, bar[:width], curses.color_pair(color_pair))
+    except:
+        pass
+
+def main(stdscr):
+    curses.curs_set(0)
+    curses.use_default_colors()
+    curses.init_pair(1, curses.COLOR_CYAN, -1)    # headers
+    curses.init_pair(2, curses.COLOR_GREEN, -1)   # good
+    curses.init_pair(3, curses.COLOR_YELLOW, -1)  # warning
+    curses.init_pair(4, curses.COLOR_RED, -1)     # critical
+    curses.init_pair(5, curses.COLOR_WHITE, -1)   # normal
+    curses.init_pair(6, curses.COLOR_MAGENTA, -1) # labels
+
+    prev_net = get_network()
+    prev_time = time.time()
+
+    while True:
+        h, w = stdscr.getmaxyx()
+        stdscr.erase()
+
+        sysinfo = get_sysinfo()
+        cpu = get_cpu()
+        mem = get_memory()
+        disks = get_disk()
+        net = get_network()
+        procs = get_top_processes()
+        now = time.time()
+
+        # Network rate
+        dt = now - prev_time
+        net_speed_sent = (net['sent'] - prev_net['sent']) / dt if dt > 0 else 0
+        net_speed_recv = (net['recv'] - prev_net['recv']) / dt if dt > 0 else 0
+        prev_net = net
+        prev_time = now
+
+        line = 0
+
+        # ---- Header ----
+        if line < h:
+            stdscr.addstr(line, 2, f"╔══════════════════════════════════════╗", curses.color_pair(5))
+            line += 1
+        if line < h:
+            stdscr.addstr(line, 2, f"║  sysmon — {sysinfo['hostname']:<15}  ║", curses.color_pair(1))
+            line += 1
+        if line < h:
+            stdscr.addstr(line, 2, f"╚══════════════════════════════════════╝", curses.color_pair(5))
+            line += 1
+
+        # ---- Uptime & Load ----
+        if line < h:
+            stdscr.addstr(line, 2, f"Up {sysinfo['uptime']}  ", curses.color_pair(6))
+            stdscr.addstr(f"(since {sysinfo['boot_time']})  ", curses.color_pair(5))
+            stdscr.addstr(f"Load: {cpu['load'][0]:.2f} {cpu['load'][1]:.2f} {cpu['load'][2]:.2f}")
+            line += 1
+
+        line += 1  # blank
+
+        # ---- CPU ----
+        if line < h:
+            stdscr.addstr(line, 2, "CPU", curses.color_pair(1))
+            line += 1
+        cpu_color = 2 if cpu['percent'] < 50 else (3 if cpu['percent'] < 80 else 4)
+        if line < h:
+            stdscr.addstr(line, 2, f" {cpu['percent']:5.1f}% ", curses.color_pair(cpu_color))
+            draw_bar(stdscr, line, 12, min(w - 16, 30), cpu['percent'], cpu_color)
+            if cpu['freq']:
+                stdscr.addstr(f"  {cpu['freq'].current/1000:.1f}GHz")
+            line += 1
+
+        # Per-core
+        if line < h:
+            n_cols = min(4, cpu['count'])
+            n_rows = (cpu['count'] + n_cols - 1) // n_cols
+            for r in range(n_rows):
+                if line >= h: break
+                stdscr.addstr(line, 2, " ")
+                for c in range(n_cols):
+                    idx = r * n_cols + c
+                    if idx >= len(cpu['per_cpu']): break
+                    p = cpu['per_cpu'][idx]
+                    pc = 2 if p < 50 else (3 if p < 80 else 4)
+                    stdscr.addstr(f" [{idx}]", curses.color_pair(pc))
+                    draw_bar(stdscr, line, 8 + c * 14, 8, p, pc)
+                    stdscr.addstr(f"{p:4.0f}%", curses.color_pair(pc))
+                line += 1
+
+        line += 1
+
+        # ---- Memory ----
+        if line < h:
+            stdscr.addstr(line, 2, "MEM", curses.color_pair(1))
+            line += 1
+        mem_color = 2 if mem['percent'] < 50 else (3 if mem['percent'] < 80 else 4)
+        if line < h:
+            used_s = format_bytes(mem['used'])
+            total_s = format_bytes(mem['total'])
+            stdscr.addstr(line, 2, f" {used_s:>7} / {total_s:<7}", curses.color_pair(mem_color))
+            draw_bar(stdscr, line, 20, min(w - 28, 30), mem['percent'], mem_color)
+            stdscr.addstr(f" {mem['percent']:.0f}%")
+            line += 1
+
+        if mem['swap_total'] > 0 and line < h:
+            swap_s = format_bytes(mem['swap_used'])
+            swap_t = format_bytes(mem['swap_total'])
+            sw_color = 2 if mem['swap_percent'] < 50 else (3 if mem['swap_percent'] < 80 else 4)
+            stdscr.addstr(line, 2, f" SWP {swap_s:>7} / {swap_t:<7}", curses.color_pair(sw_color))
+            line += 1
+
+        line += 1
+
+        # ---- Disk ----
+        if line < h:
+            stdscr.addstr(line, 2, "DISK", curses.color_pair(1))
+            line += 1
+        for dsk in disks:
+            if line >= h: break
+            d_color = 2 if dsk['percent'] < 50 else (3 if dsk['percent'] < 80 else 4)
+            mount = dsk['mount']
+            if len(mount) > 8: mount = mount[:7] + '~'
+            used_s = format_bytes(dsk['used'])
+            total_s = format_bytes(dsk['total'])
+            stdscr.addstr(line, 2, f" {mount:>8}", curses.color_pair(6))
+            stdscr.addstr(f" {used_s:>7} / {total_s:<7}", curses.color_pair(d_color))
+            draw_bar(stdscr, line, 30, min(w - 38, 25), dsk['percent'], d_color)
+            stdscr.addstr(f" {dsk['percent']:.0f}%")
+            line += 1
+
+        line += 1
+
+        # ---- Network ----
+        if line < h:
+            stdscr.addstr(line, 2, "NET", curses.color_pair(1))
+            line += 1
+        if line < h:
+            stdscr.addstr(line, 4, f"↓ {format_bytes(net_speed_recv)}/s  ↑ {format_bytes(net_speed_sent)}/s", curses.color_pair(5))
+            stdscr.addstr(f"   Total: ↓{format_bytes(net['recv'])}  ↑{format_bytes(net['sent'])}")
+            line += 1
+
+        line += 1
+
+        # ---- Top Processes ----
+        if line < h:
+            stdscr.addstr(line, 2, "PROCESSES", curses.color_pair(1))
+            line += 1
+        if line < h:
+            stdscr.addstr(line, 2, f" {'PID':>5}  {'CPU':>5}  {'MEM':>5}  STATUS  NAME", curses.color_pair(6))
+            line += 1
+        for proc in procs:
+            if line >= h: break
+            p_cpu_color = 2 if proc['cpu'] < 10 else (3 if proc['cpu'] < 30 else 4)
+            stdscr.addstr(line, 2, f" {proc['pid']:>5}", curses.color_pair(5))
+            stdscr.addstr(f"  {proc['cpu']:4.1f}%", curses.color_pair(p_cpu_color))
+            stdscr.addstr(f"  {proc['mem']:4.1f}%", curses.color_pair(5))
+            stdscr.addstr(f"  {proc['status'][:6]:<6}", curses.color_pair(6))
+            stdscr.addstr(f"  {proc['name']}", curses.color_pair(5))
+            line += 1
+
+        # ---- Footer ----
+        if line < h - 1:
+            stdscr.addstr(h - 1, 2, f" {datetime.now().strftime('%H:%M:%S')}  |  q:quit  r:refresh", curses.color_pair(6))
+
+        stdscr.refresh()
+
+        # Wait for key with timeout (update interval ~1s)
+        stdscr.timeout(1000)
+        key = stdscr.getch()
+        if key == ord('q'):
+            break
+        elif key == ord('r'):
+            continue
+
+def entry():
+    try:
+        curses.wrapper(main)
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        print(f"sysmon error: {e}")
+
+if __name__ == '__main__':
+    entry()

evolver_tools/vendor/sysmon/__main__.py

@@ -0,0 +1,3 @@
+"""CLI entry point for `python -m sysmon`"""
+from sysmon import main
+main()