evolver-tools 1.4.0__py3-none-any.whl

evolver_tools/vendor/http_live/__init__.py

@@ -0,0 +1,265 @@
+"""
+http-live — 零依赖热重载 HTTP 服务器
+
+一个纯 Python 的静态文件服务器，当文件变化时自动刷新浏览器。
+零外部依赖，仅使用 Python 标准库。
+
+Usage:
+    http-live                    # 当前目录，端口 8000
+    http-live --port 3000        # 自定义端口
+    http-live --dir ./dist       # 自定义目录
+    http-live --poll 1.0         # 轮询间隔(秒)
+    http-live --no-browser       # 不自动打开浏览器
+"""
+
+import argparse
+import http.server
+import json
+import os
+import queue
+import socket
+import sys
+import threading
+import time
+import webbrowser
+from pathlib import Path
+
+
+REFRESH_SCRIPT = """
+<script>
+(function() {
+    var es = new EventSource('/__http_live/reload');
+    es.onmessage = function(e) {
+        if (e.data === 'refresh') {
+            location.reload();
+        }
+    };
+    es.onerror = function() {
+        // 如果 SSE 连接断开，静默重连
+        es.close();
+        setTimeout(function() {
+            location.reload();
+        }, 2000);
+    };
+})();
+</script>
+"""
+
+
+class LiveHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
+    """在 HTML 响应中注入热重载脚本的请求处理器"""
+
+    def __init__(self, *args, **kwargs):
+        self._directory = kwargs.pop("live_dir", None) or os.getcwd()
+        self._event_queue = kwargs.pop("event_queue")
+        super().__init__(*args, directory=self._directory, **kwargs)
+
+    def send_head(self):
+        path = self.translate_path(self.path)
+        if self.path.endswith("/__http_live/reload"):
+            return self._handle_sse()
+        return super().send_head()
+
+    def _handle_sse(self):
+        """处理 SSE 连接"""
+        self.send_response(200)
+        self.send_header("Content-Type", "text/event-stream")
+        self.send_header("Cache-Control", "no-cache")
+        self.send_header("Connection", "keep-alive")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+
+        def stream():
+            try:
+                while True:
+                    try:
+                        msg = self._event_queue.get(timeout=30)
+                        self.wfile.write(f"data: {msg}\n\n".encode())
+                        self.wfile.flush()
+                    except queue.Empty:
+                        # 发送心跳保持连接
+                        self.wfile.write(b": heartbeat\n\n")
+                        self.wfile.flush()
+            except (BrokenPipeError, ConnectionResetError, OSError):
+                pass
+
+        threading.Thread(target=stream, daemon=True).start()
+        return None  # 阻止默认响应
+
+    def copyfile(self, source, outputfile):
+        content = source.read()
+        source.seek(0)
+        path = self.translate_path(self.path)
+
+        if self.path.endswith(".html"):
+            modified = source.read().decode("utf-8", errors="replace")
+            # 在 </body> 前注入刷新脚本
+            if "</body>" in modified:
+                modified = modified.replace("</body>", REFRESH_SCRIPT + "\n</body>")
+            else:
+                modified += REFRESH_SCRIPT
+            outputfile.write(modified.encode("utf-8"))
+        else:
+            super().copyfile(source, outputfile)
+
+
+class FileWatcher(threading.Thread):
+    """基于轮询的文件变化检测器"""
+
+    def __init__(self, watch_dir, poll_interval=0.5, event_queue=None):
+        super().__init__(daemon=True)
+        self.watch_dir = Path(watch_dir).resolve()
+        self.poll_interval = poll_interval
+        self.event_queue = event_queue
+        self._mtime_cache = {}
+        self._running = True
+        self.name = "FileWatcher"
+
+    def run(self):
+        self._scan_initial()
+        while self._running:
+            time.sleep(self.poll_interval)
+            self._check_changes()
+
+    def stop(self):
+        self._running = False
+
+    def _scan_initial(self):
+        for path in self._walk():
+            try:
+                self._mtime_cache[str(path)] = path.stat().st_mtime
+            except OSError:
+                pass
+
+    def _walk(self):
+        for root, dirs, files in os.walk(self.watch_dir):
+            # 跳过隐藏目录和 __pycache__
+            dirs[:] = [d for d in dirs
+                       if not d.startswith(".")
+                       and d != "__pycache__"
+                       and d != "node_modules"
+                       and d != ".git"]
+            for f in files:
+                if f.startswith("."):
+                    continue
+                yield Path(root) / f
+
+    def _check_changes(self):
+        current = {}
+        changed = False
+        for path in self._walk():
+            try:
+                mtime = path.stat().st_mtime
+                current[str(path)] = mtime
+                cached = self._mtime_cache.get(str(path))
+                if cached is None or abs(mtime - cached) > 0.01:
+                    changed = True
+                    # 打印日志到 stderr（不干扰 SSE 流）
+                    relative = path.relative_to(self.watch_dir)
+                    print(f"  \u2728 Changed: {relative}", file=sys.stderr)
+            except OSError:
+                continue
+
+        # 检测文件删除
+        for path_str in list(self._mtime_cache.keys()):
+            if path_str not in current:
+                changed = True
+                try:
+                    rel = Path(path_str).relative_to(self.watch_dir)
+                    print(f"  \u274c Removed: {rel}", file=sys.stderr)
+                except ValueError:
+                    pass
+
+        if changed:
+            self._mtime_cache = current
+            if self.event_queue:
+                self.event_queue.put("refresh")
+
+
+def _find_open_port(start=8000, end=9999):
+    """找到可用端口"""
+    for port in range(start, end + 1):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(("127.0.0.1", port))
+                return port
+            except OSError:
+                continue
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="http-live — 零依赖热重载 HTTP 服务器",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  http-live                    # 当前目录，端口 8000
+  http-live --port 3000        # 自定义端口
+  http-live --dir ./dist       # 自定义目录
+  http-live --poll 1.0         # 轮询间隔 1 秒
+        """,
+    )
+    parser.add_argument("--port", "-p", type=int, default=8000, help="端口号 (默认: 8000)")
+    parser.add_argument("--dir", "-d", type=str, default=".", help="服务目录 (默认: 当前目录)")
+    parser.add_argument("--poll", type=float, default=0.5, help="文件轮询间隔秒数 (默认: 0.5)")
+    parser.add_argument("--no-browser", action="store_true", help="不自动打开浏览器")
+    parser.add_argument("--version", "-v", action="version", version="http-live 1.0.0")
+
+    args = parser.parse_args()
+
+    serve_dir = os.path.abspath(args.dir)
+    if not os.path.isdir(serve_dir):
+        print(f"错误: 目录不存在: {serve_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    port = _find_open_port(args.port)
+    if port == 0:
+        print("错误: 找不到可用端口", file=sys.stderr)
+        sys.exit(1)
+
+    event_queue = queue.Queue()
+
+    # 启动文件监控
+    watcher = FileWatcher(
+        watch_dir=serve_dir,
+        poll_interval=args.poll,
+        event_queue=event_queue,
+    )
+    watcher.start()
+
+    # 创建服务器
+    handler = lambda *h_args, **h_kwargs: LiveHTTPRequestHandler(
+        *h_args, live_dir=serve_dir, event_queue=event_queue, **h_kwargs
+    )
+
+    server = http.server.HTTPServer(("127.0.0.1", port), handler)
+
+    url = f"http://127.0.0.1:{port}"
+
+    print(f"")
+    print(f"  \U0001f525 http-live started")
+    print(f"  \ud83d\udcc1 Serving: {serve_dir}")
+    print(f"  \ud83c\udf10 URL:      {url}")
+    print(f"  \u23f3 Watching:  every {args.poll}s")
+    print(f"  \u241b Quit:      Ctrl+C")
+    print(f"")
+
+    if not args.no_browser:
+        try:
+            webbrowser.open(url)
+        except Exception:
+            pass
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\n  \ud83d\udc4b Shutting down...")
+        watcher.stop()
+        server.shutdown()
+        print("  Done.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

evolver_tools/vendor/http_live/__main__.py

@@ -0,0 +1,2 @@
+from . import main
+main()

evolver_tools/vendor/ipinfo/__init__.py

@@ -0,0 +1,3 @@
+from evolver_tools.vendor.ipinfo.__main__ import main
+
+__all__ = ['main']

evolver_tools/vendor/ipinfo/__main__.py

@@ -0,0 +1,30 @@
+
+def main():
+    import urllib.request
+    import json
+    import sys
+    
+    try:
+        resp = urllib.request.urlopen("http://ip-api.com/json/", timeout=5)
+        data = json.loads(resp.read().decode())
+        if data.get("status") == "fail":
+            # fallback to ipify
+            ip = urllib.request.urlopen("https://api.ipify.org?format=json", timeout=5).read().decode()
+            data2 = json.loads(ip)
+            print(f"IP: {data2.get('ip', 'unknown')}")
+            print("Location: (geo lookup failed)")
+        else:
+            print(f"IP:       {data.get('query', '?')}")
+            print(f"Country:  {data.get('country', '?')}")
+            print(f"Region:   {data.get('regionName', '?')}")
+            print(f"City:     {data.get('city', '?')}")
+            print(f"ISP:      {data.get('isp', '?')}")
+            print(f"Org:      {data.get('org', '?')}")
+            print(f"AS:       {data.get('as', '?')}")
+            print(f"Lat/Lon:  {data.get('lat', '?')}, {data.get('lon', '?')}")
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

evolver_tools/vendor/jq_lite/__init__.py

@@ -0,0 +1,257 @@
+"""jq-lite: Zero-dependency JSON query tool (pure Python stdlib jq alternative)."""
+
+import sys
+import json
+import re
+import operator
+from pathlib import Path
+
+
+__version__ = "1.0.0"
+
+
+def parse_query(query: str):
+    """Parse a jq-like query string into a chain of filters."""
+    if not query:
+        return [("identity",)]
+
+    # Split by pipe
+    stages = []
+    for part in query.split("|"):
+        part = part.strip()
+        if not part:
+            continue
+        stages.append(part)
+
+    if not stages:
+        return [("identity",)]
+
+    filters = []
+    for stage in stages:
+        filters.append(parse_stage(stage))
+    return filters
+
+
+def parse_stage(stage: str):
+    """Parse a single pipeline stage."""
+    stage = stage.strip()
+
+    if stage == ".":
+        return ("identity",)
+
+    # Array iteration: .[]
+    m = re.match(r'^\.\[\]$', stage)
+    if m:
+        return ("iterate",)
+
+    # Array iteration with index: .[0], .[1:3], .[-1]
+    m = re.match(r'^\.\[([^\]]+)\]$', stage)
+    if m:
+        idx_str = m.group(1)
+        return parse_index(idx_str)
+
+    # Object key access: .key, .key.subkey, .key[0].subkey
+    if stage.startswith("."):
+        parts = stage[1:].split(".")
+        # Parse each part, handling key[index] patterns
+        chain = []
+        for p in parts:
+            # Check for array index suffix like [0], [1:3]
+            bracket_match = re.match(r'^([a-zA-Z_][a-zA-Z0-9_]*)(\[([^\]]+)\])?$', p)
+            if bracket_match and bracket_match.group(2):
+                # Part has both key and index: e.g. "users[0]"
+                chain.append(("key", bracket_match.group(1)))
+                idx_part = parse_index(bracket_match.group(3))
+                if isinstance(idx_part, tuple):
+                    chain.append(idx_part)
+                else:
+                    chain.append(idx_part)
+            else:
+                chain.append(("key", p))
+        if len(chain) == 1:
+            return chain[0]
+        return ("chain", chain)
+
+    # Key access without dot prefix
+    m = re.match(r'^"([^"]+)"$', stage)
+    if m:
+        return ("key", m.group(1))
+
+    return ("identity",)
+
+
+def parse_index(idx_str: str):
+    """Parse array index expression."""
+    idx_str = idx_str.strip()
+
+    # Slice: 0:2, :3, 1:, -1:
+    if ":" in idx_str:
+        parts = idx_str.split(":")
+        start = int(parts[0]) if parts[0] else None
+        end = int(parts[1]) if len(parts) > 1 and parts[1] else None
+        return ("slice", start, end)
+
+    # Negative index
+    return ("index", int(idx_str))
+
+
+def apply_filters(data, filters):
+    """Apply a chain of filters to data, yielding results."""
+    results = [data]
+
+    for filter_type, *args in filters:
+        new_results = []
+        for item in results:
+            try:
+                if filter_type == "identity":
+                    new_results.append(item)
+                elif filter_type == "key":
+                    key = args[0]
+                    if isinstance(item, dict):
+                        new_results.append(item[key])
+                    else:
+                        return []
+                elif filter_type == "index":
+                    idx = args[0]
+                    if isinstance(item, (list, tuple)):
+                        new_results.append(item[idx])
+                    else:
+                        return []
+                elif filter_type == "slice":
+                    start, end = args
+                    if isinstance(item, (list, tuple)):
+                        new_results.extend(item[start:end])
+                    else:
+                        return []
+                elif filter_type == "iterate":
+                    if isinstance(item, (list, tuple)):
+                        new_results.extend(item)
+                    elif isinstance(item, dict):
+                        new_results.extend(item.values())
+                    else:
+                        return []
+                elif filter_type == "chain":
+                    # Apply sub-filters in sequence
+                    sub_results = [item]
+                    for sub_filter in args[0]:
+                        tmp = []
+                        for sr in sub_results:
+                            ft, *fa = sub_filter
+                            try:
+                                if ft == "key":
+                                    if isinstance(sr, dict):
+                                        tmp.append(sr[fa[0]])
+                                elif ft == "index":
+                                    if isinstance(sr, (list, tuple)):
+                                        tmp.append(sr[fa[0]])
+                                else:
+                                    tmp.append(sr)
+                            except (KeyError, IndexError, TypeError):
+                                return []
+                        sub_results = tmp
+                    new_results.extend(sub_results)
+            except (KeyError, IndexError, TypeError):
+                return []
+        results = new_results
+        if not results:
+            return []
+
+    return results
+
+
+def format_result(value, raw=False):
+    """Format a single result value."""
+    if raw:
+        if isinstance(value, str):
+            return value
+        elif isinstance(value, (int, float)):
+            return str(value)
+        elif value is None:
+            return "null"
+        elif isinstance(value, bool):
+            return "true" if value else "false"
+        else:
+            return json.dumps(value, ensure_ascii=False)
+    else:
+        if isinstance(value, str):
+            return value
+        elif isinstance(value, (int, float, bool, type(None))):
+            return json.dumps(value, ensure_ascii=False)
+        else:
+            return json.dumps(value, ensure_ascii=False)
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="jq-lite — Zero-dependency JSON query tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  jq-lite '.name' data.json                # Extract key
+  jq-lite '.users[0].name' data.json        # Nested + array
+  jq-lite '.items[] | .id' data.json        # Iterate + pipe
+  echo '{"a":1,"b":2}' | jq-lite '.[]'      # Iterate values
+  jq-lite '.' data.json                     # Pretty-print entire file
+  jq-lite -r '.name' data.json              # Raw output (no string quotes)
+        """
+    )
+    parser.add_argument("query", help="jq-like query expression (e.g. '.key', '.key[0]', '.[] | .name')")
+    parser.add_argument("input", nargs="?", help="Input file (default: stdin)")
+    parser.add_argument("-r", "--raw-output", action="store_true", help="Output raw strings without JSON quoting")
+    parser.add_argument("--compact", action="store_true", help="Compact output (no pretty-print for objects)")
+
+    args = parser.parse_args()
+
+    # Read input
+    if args.input:
+        try:
+            with open(args.input, "r") as f:
+                data = json.load(f)
+        except FileNotFoundError:
+            print(f"Error: file not found: {args.input}", file=sys.stderr)
+            sys.exit(1)
+        except json.JSONDecodeError as e:
+            print(f"Error: invalid JSON: {e}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        stdin_data = sys.stdin.read()
+        if not stdin_data.strip():
+            print("Error: no input (pipe JSON or provide a file)", file=sys.stderr)
+            sys.exit(1)
+        try:
+            data = json.loads(stdin_data)
+        except json.JSONDecodeError as e:
+            print(f"Error: invalid JSON from stdin: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Parse and apply query
+    try:
+        filters = parse_query(args.query)
+    except Exception as e:
+        print(f"Error: invalid query: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        results = apply_filters(data, filters)
+    except Exception as e:
+        print(f"Error: query failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if not results:
+        sys.exit(0)
+
+    # Format and output
+    output_lines = []
+    for r in results:
+        formatted = format_result(r, raw=args.raw_output)
+        if isinstance(r, (dict, list)) and not args.compact:
+            formatted = json.dumps(r, ensure_ascii=False, indent=2)
+        output_lines.append(formatted)
+
+    print("\n".join(output_lines))
+
+
+if __name__ == "__main__":
+    main()

evolver_tools/vendor/jq_lite/__main__.py

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

evolver_tools/vendor/json2csv/__init__.py

@@ -0,0 +1,3 @@
+from evolver_tools.vendor.json2csv.__main__ import main
+
+__all__ = ['main']

evolver_tools/vendor/json2csv/__main__.py

@@ -0,0 +1,82 @@
+
+import sys
+import json
+import csv
+import io
+
+def flatten(obj, prefix=""):
+    """Flatten nested dict to single level"""
+    items = {}
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            key = f"{prefix}.{k}" if prefix else k
+            if isinstance(v, (dict,)):
+                items.update(flatten(v, key))
+            elif isinstance(v, (list, tuple)):
+                items[key] = json.dumps(v, ensure_ascii=False)
+            else:
+                items[key] = v
+    else:
+        items[prefix or "value"] = obj
+    return items
+
+def main():
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Convert JSON to CSV")
+    parser.add_argument("input", nargs="?", help="Input file (default: stdin)")
+    parser.add_argument("-o", "--output", help="Output file (default: stdout)")
+    parser.add_argument("--flatten", action="store_true", help="Flatten nested objects")
+    parser.add_argument("--delimiter", default=",", help="CSV delimiter (default: comma)")
+    parser.add_argument("--no-header", action="store_true", help="Do not write header row")
+    args = parser.parse_args()
+    
+    # Read input
+    if args.input:
+        with open(args.input, "r") as f:
+            data = json.load(f)
+    else:
+        data = json.load(sys.stdin)
+    
+    # Normalize to list
+    if isinstance(data, dict):
+        data = [data]
+    if not isinstance(data, list):
+        print("Error: JSON must be an array or object", file=sys.stderr)
+        sys.exit(1)
+    
+    # Flatten if requested
+    if args.flatten:
+        data = [flatten(item) for item in data]
+    
+    # Get all field names
+    fields = []
+    for item in data:
+        if isinstance(item, dict):
+            for k in item:
+                if k not in fields:
+                    fields.append(k)
+    
+    if not fields:
+        # Simple values list
+        fields = ["value"]
+        data = [{"value": v} for v in data]
+    
+    # Write CSV
+    out = open(args.output, "w", newline="") if args.output else sys.stdout
+    try:
+        writer = csv.DictWriter(out, fieldnames=fields, delimiter=args.delimiter,
+                                extrasaction="ignore", quoting=csv.QUOTE_MINIMAL)
+        if not args.no_header:
+            writer.writeheader()
+        for item in data:
+            if isinstance(item, dict):
+                writer.writerow(item)
+            else:
+                writer.writerow({"value": item})
+    finally:
+        if args.output:
+            out.close()
+
+if __name__ == "__main__":
+    main()