evolver-tools 19.0.0__tar.gz → 21.0.0__tar.gz

{evolver_tools-19.0.0/src/evolver_tools.egg-info → evolver_tools-21.0.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: evolver-tools
-Version: 19.0.0
-Summary: 181 CLI tools + 9 flagship projects — one pip install
+Version: 21.0.0
+Summary: 191 CLI tools + 9 flagship projects — one pip install
 Author: EVOLVER
 License-Expression: MIT
 Project-URL: Homepage, https://evolver-dev.github.io/evolver-tools

{evolver_tools-19.0.0 → evolver_tools-21.0.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "evolver-tools"
-version = "19.0.0"
-description = "181 CLI tools + 9 flagship projects — one pip install"
+version = "21.0.0"
+description = "191 CLI tools + 9 flagship projects — one pip install"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.8"

{evolver_tools-19.0.0 → evolver_tools-21.0.0}/src/evolver_tools/cli.py

@@ -14,7 +14,7 @@ from evolver_tools.autoreg import auto_discover
 def list_tools():
     """Display all available tools."""
     tools = auto_discover()
-    print(f'\x1b[1;36m===== EVOLVER Tools v19.0.0 =====\x1b[0m')
+    print(f'\x1b[1;36m===== EVOLVER Tools v21.0.0 =====\x1b[0m')
     print()
     for name, info in sorted(tools.items()):
         print(f'  \033[1;33m{name:<18}\033[0m {info["desc"]}')

evolver_tools-21.0.0/src/evolver_tools/vendor/csv_merge.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""csv_merge — Merge multiple CSV files by a common column.
+
+Usage: csv_merge file1.csv file2.csv --on id
+       csv_merge file1.csv file2.csv --on id --how outer
+       csv_merge *.csv --on user_id --output merged.csv
+
+Joins CSV files on a common key column, like SQL JOIN.
+Supports inner, left, and outer joins.
+Zero external dependencies.
+"""
+
+import csv
+import sys
+import os
+from collections import OrderedDict
+
+TOOL_META = {
+    "name": "csv_merge",
+    "func": "main",
+    "desc": "Merge CSV files by common column (inner/left/outer join)",
+}
+
+def load_csv(path):
+    with open(path, newline='', encoding='utf-8-sig') as f:
+        reader = csv.DictReader(f)
+        rows = list(reader)
+    if not rows:
+        return [], []
+    return rows, list(rows[0].keys())
+
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ('-h', '--help'):
+        print(__doc__)
+        return
+
+    # Parse --on, --how, --output
+    on_col = None
+    how = 'inner'
+    output = None
+    files = []
+
+    i = 0
+    while i < len(args):
+        if args[i] == '--on' and i + 1 < len(args):
+            on_col = args[i + 1]
+            i += 2
+        elif args[i] == '--how' and i + 1 < len(args):
+            how = args[i + 1].lower()
+            i += 2
+        elif args[i] == '--output' and i + 1 < len(args):
+            output = args[i + 1]
+            i += 2
+        else:
+            files.append(args[i])
+            i += 1
+
+    if len(files) < 2:
+        print("Error: need at least 2 CSV files", file=sys.stderr)
+        sys.exit(1)
+
+    if not on_col:
+        print("Error: --on <column> required", file=sys.stderr)
+        sys.exit(1)
+
+    # Load all CSVs
+    tables = []
+    for f in files:
+        if not os.path.exists(f):
+            print(f"Error: file not found: {f}", file=sys.stderr)
+            sys.exit(1)
+        rows, cols = load_csv(f)
+        tables.append((os.path.basename(f), rows, cols))
+
+    # Build lookup from first file
+    lookup = {}
+    for row in tables[0][1]:
+        key = row.get(on_col, '')
+        lookup[key] = row
+
+    # Merge subsequent files
+    merged = []
+    all_cols_set = OrderedDict()
+    for t in tables:
+        for c in t[2]:
+            all_cols_set[c] = True
+
+    all_cols = list(all_cols_set.keys())
+
+    if how == 'inner':
+        for t in tables[1:]:
+            for row in t[1]:
+                key = row.get(on_col, '')
+                if key in lookup:
+                    merged_row = OrderedDict()
+                    for c in all_cols:
+                        merged_row[c] = lookup[key].get(c, '') or row.get(c, '')
+                    merged.append(merged_row)
+        # For inner, merge first two then subsequent
+        if len(tables) > 2:
+            # Re-merge with remaining tables
+            temp = merged
+            for t in tables[2:]:
+                merged2 = []
+                t_lookup = {r.get(on_col, ''): r for r in t[1]}
+                for row in temp:
+                    key = row.get(on_col, '')
+                    if key in t_lookup:
+                        merged_row = OrderedDict(row)
+                        for c in t_lookup[key]:
+                            if c != on_col and c not in merged_row:
+                                merged_row[c] = t_lookup[key][c]
+                        merged2.append(merged_row)
+                temp = merged2
+            merged = temp
+    elif how == 'left':
+        merged = list(lookup.values())
+        for t in tables[1:]:
+            t_lookup = {r.get(on_col, ''): r for r in t[1]}
+            for row in merged:
+                key = row.get(on_col, '')
+                if key in t_lookup:
+                    for c, v in t_lookup[key].items():
+                        if c != on_col and c not in row:
+                            row[c] = v
+    elif how == 'outer':
+        all_keys = set()
+        for t in tables:
+            for r in t[1]:
+                all_keys.add(r.get(on_col, ''))
+        key_rows = {}
+        for t in tables:
+            for r in t[1]:
+                k = r.get(on_col, '')
+                if k not in key_rows:
+                    key_rows[k] = OrderedDict()
+                    key_rows[k][on_col] = k
+                for c, v in r.items():
+                    if c != on_col and v:
+                        key_rows[k][c] = v
+        merged = list(key_rows.values())
+    else:
+        print(f"Error: unknown join type: {how} (use inner/left/outer)", file=sys.stderr)
+        sys.exit(1)
+
+    # Write output
+    if output:
+        with open(output, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.DictWriter(f, fieldnames=list(all_cols_set.keys()))
+            writer.writeheader()
+            writer.writerows(merged)
+        print(f"Merged {len(merged)} rows -> {output}")
+    else:
+        writer = csv.DictWriter(sys.stdout, fieldnames=list(all_cols_set.keys()))
+        writer.writeheader()
+        writer.writerows(merged)

evolver_tools-21.0.0/src/evolver_tools/vendor/diff_files.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""diff_files — Line-by-line file comparison.
+
+Usage: diff_files file1.txt file2.txt
+       diff_files file1.txt file2.txt --context 3
+       diff_files file1.txt file2.txt --brief
+
+Simple diff tool. Shows added/removed lines with +/- markers.
+Zero external dependencies (pure Python difflib).
+"""
+
+import difflib
+import sys
+import os
+
+TOOL_META = {
+    "name": "diff_files",
+    "func": "main",
+    "desc": "Line-by-line file comparison",
+}
+
+
+def main():
+    args = sys.argv[1:]
+    context = 3
+    brief = False
+    files = []
+
+    i = 0
+    while i < len(args):
+        if args[i] == '--context' and i + 1 < len(args):
+            context = int(args[i + 1])
+            i += 2
+        elif args[i] == '--brief' or args[i] == '-q':
+            brief = True
+            i += 1
+        elif args[i] in ('-h', '--help'):
+            print(__doc__)
+            return
+        else:
+            files.append(args[i])
+            i += 1
+
+    if len(files) != 2:
+        print("Error: need exactly 2 files", file=sys.stderr)
+        print(__doc__)
+        sys.exit(1)
+
+    file1, file2 = files
+    for f in (file1, file2):
+        if not os.path.exists(f):
+            print(f"Error: file not found: {f}", file=sys.stderr)
+            sys.exit(1)
+
+    with open(file1) as f:
+        lines1 = f.readlines()
+    with open(file2) as f:
+        lines2 = f.readlines()
+
+    if brief:
+        if lines1 != lines2:
+            print(f"Files {file1} and {file2} differ")
+        else:
+            print(f"Files {file1} and {file2} are identical")
+        return
+
+    diff = difflib.unified_diff(
+        lines1, lines2,
+        fromfile=file1, tofile=file2,
+        n=context
+    )
+
+    output = list(diff)
+    if not output:
+        print("Files are identical.")
+        return
+
+    for line in output:
+        if line.startswith('+') and not line.startswith('+++'):
+            sys.stdout.write(f'\033[32m{line}\033[0m')
+        elif line.startswith('-') and not line.startswith('---'):
+            sys.stdout.write(f'\033[31m{line}\033[0m')
+        elif line.startswith('@@'):
+            sys.stdout.write(f'\033[36m{line}\033[0m')
+        else:
+            sys.stdout.write(line)

evolver_tools-21.0.0/src/evolver_tools/vendor/fold.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""fold — Wrap input lines to a specified width.
+
+Usage: fold <file>          # wrap at 80
+       fold -w 40 <file>    # wrap at 40
+       echo "long text" | fold -w 20 -s   # break at spaces
+
+Like standard Unix 'fold' command.
+Zero-dependency (stdlib only).
+"""
+
+import sys
+
+
+def fold_line(line, width, spaces=False):
+    """Fold a single line to given width."""
+    if len(line) <= width or (len(line) == width + 1 and line.endswith('\n')):
+        return line
+
+    result = []
+    while line:
+        if len(line) <= width:
+            result.append(line)
+            break
+
+        chunk = line[:width]
+        if spaces:
+            # Find last space in the chunk
+            last_space = chunk.rfind(' ')
+            if last_space > 0:
+                result.append(line[:last_space] + '\n')
+                line = line[last_space:].lstrip()
+                continue
+
+        result.append(chunk.rstrip('\n') + '\n')
+        line = line[width:]
+    return ''.join(result)
+
+
+def main():
+    args = sys.argv[1:]
+    width = 80
+    spaces = False
+
+    filtered = []
+    i = 0
+    while i < len(args):
+        if args[i] == '-w' and i + 1 < len(args):
+            width = int(args[i + 1])
+            i += 2
+        elif args[i].startswith('-w'):
+            width = int(args[i][2:])
+            i += 1
+        elif args[i] == '-s':
+            spaces = True
+            i += 1
+        elif args[i] in ('-h', '--help'):
+            print(__doc__)
+            return
+        else:
+            filtered.append(args[i])
+            i += 1
+
+    if filtered:
+        for path in filtered:
+            with open(path) as f:
+                for line in f:
+                    print(fold_line(line.rstrip('\n'), width, spaces))
+    elif not sys.stdin.isatty():
+        for line in sys.stdin:
+            print(fold_line(line.rstrip('\n'), width, spaces))
+    else:
+        print("Usage: fold [-w <width>] [-s] <file>")
+        print("       cat <file> | fold [-w 40]")
+
+
+# === Auto-registration metadata ===
+TOOL_META = {
+    "name": "fold",
+    "func": "main",
+    "desc": 'Wrap input lines to specified width',
+}
+
+if __name__ == '__main__':
+    main()

evolver_tools-21.0.0/src/evolver_tools/vendor/http_server.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""http_server — Simple static file HTTP server.
+
+Usage: http_server              # Port 8080, current dir
+       http_server 3000         # Port 3000
+       http_server 8080 ./docs  # Port 8080, serve ./docs
+       http_server --bind 0.0.0.0 9090
+
+Lightweight alternative to 'python -m http.server' with
+better defaults and cleaner output.
+"""
+
+import os
+import sys
+import http.server
+import socketserver
+
+TOOL_META = {
+    "name": "http_server",
+    "func": "main",
+    "desc": "Simple static file HTTP server",
+}
+
+
+def main():
+    args = sys.argv[1:]
+    port = 8080
+    directory = os.getcwd()
+    bind = '127.0.0.1'
+
+    i = 0
+    while i < len(args):
+        if args[i] == '--bind' and i + 1 < len(args):
+            bind = args[i + 1]
+            i += 2
+        elif args[i] in ('-h', '--help'):
+            print(__doc__)
+            return
+        else:
+            try:
+                port = int(args[i])
+            except ValueError:
+                directory = os.path.abspath(args[i])
+            i += 1
+
+    if not os.path.isdir(directory):
+        print(f"Error: directory not found: {directory}", file=sys.stderr)
+        sys.exit(1)
+
+    os.chdir(directory)
+    handler = http.server.SimpleHTTPRequestHandler
+
+    class SilentHandler(handler):
+        def log_message(self, fmt, *args):
+            sys.stderr.write(f"[HTTP] {args[0]} {args[1]} {args[2]}\n")
+
+    try:
+        with socketserver.TCPServer((bind, port), SilentHandler) as httpd:
+            print(f"Serving {directory} at http://{bind}:{port}")
+            print("Press Ctrl+C to stop")
+            httpd.serve_forever()
+    except OSError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nStopped.")

evolver_tools-21.0.0/src/evolver_tools/vendor/json_flatten.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""json_flatten — Flatten nested JSON to dot-notation key=value pairs.
+
+Usage: json_flatten data.json
+       json_flatten data.json --sep /
+       cat data.json | json_flatten
+
+Useful for converting nested JSON to flat key-value format
+for CSV export, env files, or debugging.
+"""
+
+import json
+import sys
+import os
+
+TOOL_META = {
+    "name": "json_flatten",
+    "func": "main",
+    "desc": "Flatten nested JSON to dot-notation key=value pairs",
+}
+
+def flatten(obj, parent_key='', sep='.'):
+    items = []
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            new_key = f"{parent_key}{sep}{k}" if parent_key else k
+            if isinstance(v, (dict, list)):
+                items.extend(flatten(v, new_key, sep=sep))
+            else:
+                items.append((new_key, v))
+    elif isinstance(obj, list):
+        for i, v in enumerate(obj):
+            new_key = f"{parent_key}{sep}{i}" if parent_key else str(i)
+            if isinstance(v, (dict, list)):
+                items.extend(flatten(v, new_key, sep=sep))
+            else:
+                items.append((new_key, v))
+    else:
+        items.append((parent_key, obj))
+    return items
+
+
+def main():
+    args = sys.argv[1:]
+    sep = '.'
+    files = []
+
+    i = 0
+    while i < len(args):
+        if args[i] == '--sep' and i + 1 < len(args):
+            sep = args[i + 1]
+            i += 2
+        elif args[i] in ('-h', '--help'):
+            print(__doc__)
+            return
+        else:
+            files.append(args[i])
+            i += 1
+
+    if files:
+        data = []
+        for f in files:
+            if not os.path.exists(f):
+                print(f"Error: file not found: {f}", file=sys.stderr)
+                sys.exit(1)
+            with open(f) as fp:
+                data.append(json.load(fp))
+        if len(data) == 1:
+            data = data[0]
+    else:
+        data = json.load(sys.stdin)
+
+    items = flatten(data, sep=sep)
+    for key, val in items:
+        if val is None:
+            val = 'null'
+        elif isinstance(val, bool):
+            val = str(val).lower()
+        elif isinstance(val, (int, float)):
+            val = str(val)
+        print(f"{key}={val}")

evolver_tools-21.0.0/src/evolver_tools/vendor/pdf_info.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""pdf_info — Extract PDF metadata (pages, author, title, size, etc.)
+
+Usage: pdf_info file.pdf
+       pdf_info --json file.pdf
+
+Zero-dependency PDF parser (basic metadata from PDF header/objects).
+Full metadata requires PyMuPDF or similar — shows what's available.
+"""
+
+import os
+import re
+import sys
+
+TOOL_META = {
+    "name": "pdf_info",
+    "func": "main",
+    "desc": "Extract PDF metadata — pages, title, author, size",
+}
+
+def _scan_objects(data):
+    """Scan PDF for key metadata objects."""
+    info = {}
+    # Find /Info dictionary
+    m = re.search(rb'/Info\s+(\d+)\s+(\d+)\s+R', data)
+    if m:
+        obj_num = int(m.group(1))
+        gen_num = int(m.group(2))
+        # Find the actual Info object
+        pattern = rf'{obj_num}\s+{gen_num}\s+obj.*?endobj'.encode()
+        om = re.search(pattern, data, re.DOTALL)
+        if om:
+            chunk = om.group().decode('latin-1', errors='replace')
+            for key in ['Title', 'Author', 'Subject', 'Keywords', 'Creator', 'Producer']:
+                m2 = re.search(rf'/{key}\s+\(([^)]*)\)', chunk)
+                if m2:
+                    info[key.lower()] = m2.group(1)
+            # Creation/Mod date
+            m2 = re.search(r'/CreationDate\s+\(D:([^)]*)\)', chunk)
+            if m2:
+                info['creation_date'] = m2.group(1)
+            m2 = re.search(r'/ModDate\s+\(D:([^)]*)\)', chunk)
+            if m2:
+                info['mod_date'] = m2.group(1)
+    return info
+
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ('-h', '--help'):
+        print(__doc__)
+        return
+
+    path = args[0]
+    json_mode = '--json' in args or '-j' in args
+
+    if not os.path.exists(path):
+        print(f"Error: file not found: {path}", file=sys.stderr)
+        sys.exit(1)
+
+    size = os.path.getsize(path)
+    with open(path, 'rb') as f:
+        data = f.read()
+
+    # Basic info
+    result = {
+        'file': os.path.basename(path),
+        'size_bytes': size,
+        'size_kb': round(size / 1024, 1),
+    }
+
+    # PDF version
+    m = re.search(rb'%PDF-(\d+\.\d+)', data)
+    if m:
+        result['pdf_version'] = m.group(1).decode()
+
+    # Page count (count Pages objects)
+    pages = re.findall(rb'/Type\s*/Pages[^}]*/Count\s+(\d+)', data)
+    if pages:
+        result['pages'] = int(pages[0])
+
+    # Encrypted?
+    result['encrypted'] = '/Encrypt' in data.decode('latin-1', errors='replace')
+
+    # Metadata from Info dict
+    info = _scan_objects(data)
+    result.update(info)
+
+    if json_mode:
+        import json
+        print(json.dumps(result, indent=2))
+        return
+
+    print(f"  File:      {result['file']}")
+    print(f"  Size:      {result['size_kb']} KB ({result['size_bytes']} bytes)")
+    if 'pdf_version' in result:
+        print(f"  PDF:       {result['pdf_version']}")
+    if 'pages' in result:
+        print(f"  Pages:     {result['pages']}")
+    print(f"  Encrypted: {result['encrypted']}")
+    for key in ('title', 'author', 'subject', 'creator', 'producer'):
+        if key in result:
+            print(f"  {key.title()}: {result[key]}")
+    for key in ('creation_date', 'mod_date'):
+        if key in result:
+            print(f"  {key.replace('_', ' ').title()}: {result[key]}")