evolver-tools 1.4.0__py3-none-any.whl

evolver_tools/vendor/timer/__init__.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""timer — 终端计时器 / Terminal countdown timer & stopwatch.
+
+Zero-dependency CLI timer with countdown, stopwatch, and alarm modes.
+"""
+
+import sys
+import os
+import time
+import argparse
+import itertools
+
+
+def entry():
+    args = parse_args()
+
+    if args.stopwatch:
+        run_stopwatch()
+    elif args.countdown:
+        run_countdown(parse_duration(args.countdown))
+    elif args.countdown_from:
+        run_countdown(args.countdown_from)
+    else:
+        # Default: show help
+        print("Use --stopwatch, --countdown <time>, or --timer <seconds>")
+        sys.exit(0)
+
+
+def format_time(seconds: float) -> str:
+    """Format seconds as HH:MM:SS or MM:SS."""
+    mins, secs = divmod(int(seconds), 60)
+    hours, mins = divmod(mins, 60)
+    if hours > 0:
+        return f"{hours:02d}:{mins:02d}:{secs:02d}"
+    return f"{mins:02d}:{secs:02d}"
+
+
+def parse_duration(s: str) -> int:
+    """Parse duration like '90', '1m30s', '2h' to seconds."""
+    s = s.strip().lower()
+    if s.isdigit():
+        return int(s)
+
+    total = 0
+    num = ""
+    for ch in s:
+        if ch.isdigit() or ch == ".":
+            num += ch
+        else:
+            if num:
+                val = float(num)
+                if ch == "h":
+                    total += int(val * 3600)
+                elif ch == "m":
+                    total += int(val * 60)
+                elif ch == "s":
+                    total += int(val)
+                num = ""
+    if num:
+        total += int(num)
+    return max(total, 1)
+
+
+def run_stopwatch():
+    """Run an interactive stopwatch."""
+    print("Stopwatch started. Press Ctrl+C to stop.")
+    print()
+    start = time.time()
+    try:
+        for _ in itertools.count():
+            elapsed = time.time() - start
+            print(f"\r  {format_time(elapsed)}", end="", flush=True)
+            time.sleep(0.1)
+    except KeyboardInterrupt:
+        elapsed = time.time() - start
+        print(f"\n\n  Stopped at {format_time(elapsed)}")
+        print(f"  ({elapsed:.1f} seconds)")
+
+
+def run_countdown(seconds: int):
+    """Run a countdown timer."""
+    print(f"Countdown: {format_time(seconds)}")
+    print()
+    try:
+        remaining = seconds
+        while remaining > 0:
+            print(f"\r  {format_time(remaining)}", end="", flush=True)
+            time.sleep(1)
+            remaining -= 1
+        print(f"\r  00:00")
+        print()
+        # Alarm notification
+        bell = "\a" * 3
+        print(f"{bell}  TIME'S UP! ({format_time(seconds)})")
+        # Keep beeping for a bit
+        for _ in range(5):
+            print("\a", end="", flush=True)
+            time.sleep(0.5)
+    except KeyboardInterrupt:
+        elapsed = seconds - (remaining if 'remaining' in dir() else seconds)
+        print(f"\n\n  Stopped at {format_time(elapsed)}")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="timer — 终端计时器 / Terminal timer & stopwatch",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""Examples:
+  timer --stopwatch                 # Start stopwatch
+  timer --countdown 90              # Countdown 90 seconds
+  timer --countdown 5m              # Countdown 5 minutes
+  timer --countdown 1h30m           # Countdown 1 hour 30 minutes
+  timer -t 300                      # Countdown 300 seconds
+""")
+    parser.add_argument("-s", "--stopwatch", action="store_true",
+                        help="Start stopwatch mode")
+    parser.add_argument("-c", "--countdown", type=str, nargs="?", const="60",
+                        metavar="DURATION",
+                        help="Countdown timer (default: 60s). Format: 90, 5m, 1h30m")
+    parser.add_argument("-t", "--timer", dest="countdown_from", type=int,
+                        metavar="SECONDS",
+                        help="Countdown from N seconds")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    entry()

evolver_tools/vendor/treedir/__init__.py

@@ -0,0 +1,2 @@
+"""treedir — 目录树可视化"""
+__version__ = "1.0.0"

evolver_tools/vendor/treedir/__main__.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""treedir — 目录树可视化工具。零外部依赖（替代 tree 命令）。"""
+import os
+import sys
+
+PIPE = "│   "
+BRANCH = "├── "
+LAST = "└── "
+
+def build_tree(root_path, max_depth=3, show_hidden=False, dirs_only=False):
+    """递归构建目录树"""
+    root_path = os.path.abspath(root_path)
+    if not os.path.isdir(root_path):
+        print(f"❌ 不是目录: {root_path}", file=sys.stderr)
+        return
+    
+    basename = os.path.basename(root_path) or root_path
+    print(basename)
+    
+    def _walk(dirpath, prefix="", depth=0):
+        if depth >= max_depth:
+            return
+        
+        try:
+            entries = sorted(os.listdir(dirpath))
+        except PermissionError:
+            print(f"{prefix}{LAST} [权限不足]")
+            return
+        
+        if not show_hidden:
+            entries = [e for e in entries if not e.startswith(".")]
+        
+        # Separate dirs and files
+        dirs = []
+        files = []
+        for e in entries:
+            full = os.path.join(dirpath, e)
+            if os.path.isdir(full):
+                dirs.append(e)
+            else:
+                files.append(e)
+        
+        if dirs_only:
+            items = dirs
+        else:
+            items = dirs + files
+        
+        for i, entry in enumerate(items):
+            is_last = (i == len(items) - 1)
+            connector = LAST if is_last else BRANCH
+            full = os.path.join(dirpath, entry)
+            
+            if os.path.isdir(full):
+                print(f"{prefix}{connector}{entry}/")
+                next_prefix = prefix + ("    " if is_last else PIPE)
+                _walk(full, next_prefix, depth + 1)
+            else:
+                # Show file size
+                try:
+                    size = os.path.getsize(full)
+                    size_str = format_size(size)
+                    print(f"{prefix}{connector}{entry}  ({size_str})")
+                except OSError:
+                    print(f"{prefix}{connector}{entry}")
+    
+    _walk(root_path)
+    print(f"\n{count_items(root_path, show_hidden, dirs_only)}")
+
+def count_items(root_path, show_hidden=False, dirs_only=False):
+    """统计目录内容"""
+    dcount = 0
+    fcount = 0
+    for root, dirs, files in os.walk(root_path):
+        if not show_hidden:
+            dirs[:] = [d for d in dirs if not d.startswith(".")]
+            files = [f for f in files if not f.startswith(".")]
+        dcount += len(dirs)
+        if not dirs_only:
+            fcount += len(files)
+        # Only first level for dirs_only
+        if dirs_only:
+            break
+    if dirs_only:
+        return f"{dcount} 个目录"
+    return f"{dcount} 个目录, {fcount} 个文件"
+
+def format_size(size):
+    for unit in ("B", "KB", "MB", "GB"):
+        if size < 1024:
+            return f"{size:.0f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+def main():
+    args = sys.argv[1:]
+    
+    if "-h" in args or "--help" in args:
+        print("用法: treedir [选项] [目录]")
+        print("选项:")
+        print("  -d, --max-depth N   最大深度 (默认: 3)")
+        print("  -a, --all           显示隐藏文件")
+        print("  --dirs-only         只显示目录")
+        print("  如果不指定目录，使用当前目录")
+        return
+    
+    root = "."
+    max_depth = 3
+    show_hidden = False
+    dirs_only = False
+    
+    i = 0
+    while i < len(args):
+        if args[i] in ("-d", "--max-depth"):
+            i += 1
+            if i < len(args):
+                max_depth = int(args[i])
+        elif args[i] in ("-a", "--all"):
+            show_hidden = True
+        elif args[i] == "--dirs-only":
+            dirs_only = True
+        else:
+            root = args[i]
+        i += 1
+    
+    build_tree(root, max_depth, show_hidden, dirs_only)
+
+if __name__ == "__main__":
+    main()

evolver_tools/vendor/urlparse_tool/__init__.py

@@ -0,0 +1,3 @@
+"""urlparse_tool — URL parser/debugger CLI tool (stdlib only)."""
+
+__version__ = "0.1.0"

evolver_tools/vendor/urlparse_tool/cli.py

@@ -0,0 +1,212 @@
+"""CLI entry point for urlparse — URL parser/debugger.
+
+Usage:
+    urlparse https://user:pass@example.com:8080/path;params?a=1&b=2#frag
+    echo 'https://example.com/path?q=hello' | urlparse
+    urlparse --encode 'hello world'
+    urlparse --decode 'hello+world'
+"""
+
+import argparse
+import sys
+from urllib.parse import (
+    urlparse,
+    urlencode,
+    parse_qs,
+    parse_qsl,
+    quote,
+    unquote,
+    urlunparse,
+)
+
+
+def parse_url(url: str) -> dict:
+    """Parse a URL and return all components."""
+    parsed = urlparse(url)
+    result = {
+        "url": url,
+        "scheme": parsed.scheme or "",
+        "netloc": parsed.netloc or "",
+        "username": parsed.username or "",
+        "password": parsed.password or "",
+        "hostname": parsed.hostname or "",
+        "port": parsed.port,
+        "path": parsed.path or "",
+        "params": parsed.params or "",
+        "query": parsed.query or "",
+        "fragment": parsed.fragment or "",
+    }
+
+    # Parse query string into key-value pairs
+    if parsed.query:
+        result["query_pairs"] = parse_qs(parsed.query, keep_blank_values=True)
+        result["query_pairs_ordered"] = parse_qsl(parsed.query, keep_blank_values=True)
+    else:
+        result["query_pairs"] = {}
+        result["query_pairs_ordered"] = []
+
+    # Reconstruct the URL (canonical form)
+    reconstructed = urlunparse(
+        (
+            parsed.scheme,
+            parsed.netloc,
+            parsed.path,
+            parsed.params,
+            parsed.query,
+            parsed.fragment,
+        )
+    )
+    result["reconstructed"] = reconstructed
+
+    return result
+
+
+def format_parse_result(result: dict) -> str:
+    """Format parsed URL components into a human-readable string."""
+    lines = []
+    lines.append(f"  URL:            {result['url']}")
+    lines.append(f"  Reconstructed:  {result['reconstructed']}")
+    lines.append("  ───────────────────────────────────────────")
+    lines.append(f"  Scheme:         {result['scheme']}")
+    lines.append(f"  Netloc:         {result['netloc']}")
+    lines.append(f"    Username:     {result['username']}")
+    lines.append(f"    Password:     {'●' * max(1, len(result['password'])) if result['password'] else ''}")
+    lines.append(f"    Hostname:     {result['hostname']}")
+    lines.append(f"    Port:         {result['port'] if result['port'] is not None else ''}")
+    lines.append(f"  Path:           {result['path']}")
+    lines.append(f"  Params:         {result['params']}")
+    lines.append(f"  Query:          {result['query']}")
+    lines.append(f"  Fragment:       {result['fragment']}")
+
+    if result["query_pairs"]:
+        lines.append("  ───────────────────────────────────────────")
+        lines.append("  Query parameters:")
+        for key, values in result["query_pairs"].items():
+            for val in values:
+                lines.append(f"    {key} = {val}")
+
+    return "\n".join(lines)
+
+
+def format_parse_result_json(result: dict) -> str:
+    """Format parsed URL components as JSON."""
+    import json
+
+    output = {
+        "url": result["url"],
+        "scheme": result["scheme"],
+        "netloc": result["netloc"],
+        "username": result["username"],
+        "password": result["password"],
+        "hostname": result["hostname"],
+        "port": result["port"],
+        "path": result["path"],
+        "params": result["params"],
+        "query": result["query"],
+        "fragment": result["fragment"],
+    }
+
+    if result["query_pairs"]:
+        output["query_parameters"] = dict(result["query_pairs"])
+
+    return json.dumps(output, indent=2)
+
+
+def do_encode(text: str) -> str:
+    """URL-encode a string."""
+    return quote(text, safe="")
+
+
+def do_decode(text: str) -> str:
+    """URL-decode a string."""
+    return unquote(text, encoding="utf-8", errors="replace")
+
+
+def read_stdin() -> str:
+    """Read raw input from stdin (pipe mode)."""
+    if not sys.stdin.isatty():
+        return sys.stdin.read().strip()
+    return ""
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="URL parser/debugger — parse, encode, and decode URLs.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  urlparse https://example.com/path?q=hello#section\n"
+            "  echo 'https://example.com/search?q=hello+world' | urlparse\n"
+            "  urlparse --encode 'hello world'\n"
+            "  urlparse --decode 'hello+world%21'\n"
+            "  urlparse --json https://example.com?foo=1&bar=2\n"
+        ),
+    )
+
+    parser.add_argument(
+        "url",
+        nargs="?",
+        help="URL to parse (omit to read from stdin)",
+    )
+    parser.add_argument(
+        "--encode",
+        nargs="?",
+        const=True,
+        metavar="TEXT",
+        help="URL-encode the given text (or pipe input)",
+    )
+    parser.add_argument(
+        "--decode",
+        nargs="?",
+        const=True,
+        metavar="TEXT",
+        help="URL-decode the given text (or pipe input)",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output parse results as JSON",
+    )
+
+    args = parser.parse_args()
+
+    # --- Encode mode ---
+    if args.encode is not None:
+        text = args.encode if isinstance(args.encode, str) else read_stdin()
+        if not text:
+            # If --encode was used as a flag with pipe, read_stdin already tried
+            text = read_stdin()
+        if not text:
+            print("error: --encode requires text argument or pipe input", file=sys.stderr)
+            sys.exit(1)
+        print(do_encode(text))
+        return
+
+    # --- Decode mode ---
+    if args.decode is not None:
+        text = args.decode if isinstance(args.decode, str) else read_stdin()
+        if not text:
+            text = read_stdin()
+        if not text:
+            print("error: --decode requires text argument or pipe input", file=sys.stderr)
+            sys.exit(1)
+        print(do_decode(text))
+        return
+
+    # --- Parse mode ---
+    url = args.url or read_stdin()
+
+    if not url:
+        parser.print_help()
+        sys.exit(1)
+
+    result = parse_url(url)
+
+    if args.json:
+        print(format_parse_result_json(result))
+    else:
+        print(format_parse_result(result))
+
+
+if __name__ == "__main__":
+    main()