evolver-tools 30.0.0__tar.gz → 31.0.0__tar.gz

{evolver_tools-30.0.0/src/evolver_tools.egg-info → evolver_tools-31.0.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: evolver-tools
-Version: 30.0.0
-Summary: 233 CLI tools + 9 flagship projects — one pip install
+Version: 31.0.0
+Summary: 238 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-30.0.0 → evolver_tools-31.0.0}/pyproject.toml

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

{evolver_tools-30.0.0 → evolver_tools-31.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 v30.0.0 =====\x1b[0m')
+    print(f'\x1b[1;36m===== EVOLVER Tools v31.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-31.0.0/src/evolver_tools/vendor/_test_find_empty.py

@@ -0,0 +1 @@
+

evolver_tools-31.0.0/src/evolver_tools/vendor/csv_filter.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""csv_filter.py — Filter CSV rows by column value matching.
+
+Usage:
+    cat data.csv | python csv_filter.py --column name --value Alice
+    python csv_filter.py data.csv --column age --value 30
+    python csv_filter.py data.csv --column city --value "New York" --delimiter ';'
+    python csv_filter.py data.csv --column status --value active --invert
+"""
+
+from __future__ import annotations
+
+import csv
+import sys
+import argparse
+from typing import Dict, List, Sequence, TextIO
+
+
+TOOL_META = {
+    "name": "csv-filter",
+    "func": "main",
+    "desc": "Filter CSV rows by column value",
+}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Filter CSV rows by column value matching.",
+    )
+    parser.add_argument(
+        "file",
+        nargs="?",
+        default=None,
+        help="CSV file path (omit or use '-' to read from stdin)",
+    )
+    parser.add_argument(
+        "--column",
+        required=True,
+        help="Column name to filter on",
+    )
+    parser.add_argument(
+        "--value",
+        required=True,
+        help="Value to match (exact string match)",
+    )
+    parser.add_argument(
+        "--delimiter",
+        default=",",
+        help="CSV delimiter character (default: ',')",
+    )
+    parser.add_argument(
+        "--invert",
+        action="store_true",
+        default=False,
+        help="Invert match — print rows where column does NOT equal value",
+    )
+    return parser
+
+
+def open_input(file_arg: str | None) -> TextIO:
+    """Return a file handle for the given argument or stdin."""
+    if file_arg is None or file_arg == "-":
+        return sys.stdin
+    return open(file_arg, newline="")
+
+
+def filter_rows(
+    reader: csv.DictReader,
+    column: str,
+    value: str,
+    invert: bool,
+) -> List[Dict[str, str]]:
+    """Filter rows from a DictReader where column matches (or doesn't match) value."""
+    results: List[Dict[str, str]] = []
+    for row in reader:
+        cell = row.get(column, "")
+        if invert:
+            if cell != value:
+                results.append(row)
+        else:
+            if cell == value:
+                results.append(row)
+    return results
+
+
+def write_rows(rows: List[Dict[str, str]], fieldnames: Sequence[str], delimiter: str) -> None:
+    """Write filtered rows to stdout as CSV."""
+    writer = csv.DictWriter(sys.stdout, fieldnames=fieldnames, delimiter=delimiter)
+    writer.writeheader()
+    writer.writerows(rows)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    fh = open_input(args.file)
+    try:
+        reader = csv.DictReader(fh, delimiter=args.delimiter)
+        if not reader.fieldnames:
+            sys.exit("error: CSV has no header row (column names required)")
+
+        fieldnames = reader.fieldnames
+
+        if args.column not in fieldnames:
+            sys.exit(
+                f"error: column '{args.column}' not found in CSV header. "
+                f"Available columns: {', '.join(fieldnames)}"
+            )
+
+        rows = filter_rows(reader, args.column, args.value, args.invert)
+    finally:
+        if fh is not sys.stdin:
+            fh.close()
+
+    write_rows(rows, fieldnames, args.delimiter)
+
+
+if __name__ == "__main__":
+    main()

evolver_tools-31.0.0/src/evolver_tools/vendor/env_sorter.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""env-sorter — Sort environment variables in .env files alphabetically.
+
+Usage:
+  env-sorter --file .env
+  env-sorter --file .env --in-place
+  env-sorter --file .env --sort-by value
+  env-sorter --file .env --group
+  env-sorter --file .env --remove-dups
+  env-sorter --file .env --in-place --group --sort-by value --remove-dups
+
+Sorts the content of dotenv-style files while preserving comments and
+blank lines as best possible. Supports grouping by common prefix,
+sorting by name or value, and deduplication.
+"""
+
+import sys
+import os
+
+
+TOOL_META = {
+    "name": "env-sorter",
+    "func": "main",
+    "desc": "Sort environment variables in .env files",
+}
+
+
+# ---------------------------------------------------------------------------
+# .env parsing & writing
+# ---------------------------------------------------------------------------
+
+def parse_env(text):
+    """Parse .env text into a list of (kind, key, value) tuples.
+
+    Each tuple is one of:
+      ('blank', None, None)      — empty line
+      ('comment', None, text)    — comment line (includes leading ``#``)
+      ('var', key, value)        — KEY=VALUE assignment
+    Order is preserved as-is.
+    """
+    entries = []
+    for line in text.splitlines(keepends=True):
+        stripped = line.strip()
+        if stripped == "":
+            entries.append(("blank", None, None))
+        elif stripped.startswith("#"):
+            entries.append(("comment", None, line))
+        elif "=" in stripped:
+            # Split on first '=' only
+            key, _, val = line.partition("=")
+            entries.append(("var", key.rstrip(), val))
+        else:
+            # Lines that don't match any pattern — treat as literal
+            entries.append(("comment", None, line))
+    return entries
+
+
+def _get_prefix(key, sep="_"):
+    """Return the prefix of *key* (everything before the first separator)."""
+    idx = key.find(sep)
+    if idx == -1:
+        return ""
+    return key[:idx]
+
+
+def group_sort(entries, sort_key="name", group=True, remove_dups=False):
+    """Sort *entries* by variable key/value with optional grouping & dedup.
+
+    Parameters
+    ----------
+    entries : list[tuple]
+        Parsed entries from :func:`parse_env`.
+    sort_key : str
+        ``"name"`` (default) sorts by variable name; ``"value"`` sorts by
+        value (ties broken by name).
+    group : bool
+        When *True*, entries are grouped by prefix (everything before the
+        first ``_``).  Blank lines and comments stay in their relative
+        position between groups.
+    remove_dups : bool
+        When *True*, only the *last* occurrence of a variable name is kept.
+    """
+    # Separate non-variable entries and variable entries
+    non_vars = [(i, e) for i, e in enumerate(entries) if e[0] != "var"]
+    var_entries = [(i, e) for i, e in enumerate(entries) if e[0] == "var"]
+
+    if remove_dups:
+        seen = {}
+        # Iterate in original order so the *last* occurrence wins
+        for idx, e in var_entries:
+            seen[e[1]] = (idx, e)
+        var_entries = sorted(seen.values(), key=lambda x: x[0])
+
+    # Build sort key for each variable entry
+    def _sort_key(item):
+        idx, e = item
+        key = e[1]
+        val = e[2].lstrip()
+        if sort_key == "value":
+            primary = val.lower() if val else ""
+            secondary = key.lower()
+        else:
+            primary = key.lower()
+            secondary = ""
+        if group:
+            prefix = _get_prefix(key)
+            return (prefix, primary, secondary, idx)
+        return (primary, secondary, idx)
+
+    var_entries.sort(key=_sort_key)
+
+    if group:
+        return _interleave_groups(var_entries, non_vars, entries)
+    else:
+        return _rebuild(var_entries, non_vars)
+
+
+def _interleave_groups(var_entries, non_vars, original_entries):
+    """Interleave non-variable lines between groups of variable entries.
+
+    Non-variable lines (blanks, comments) that appeared *between* groups
+    in the original file are placed before each group.  Trailing
+    non-variable lines are appended at the end.
+    """
+    # Determine groups
+    groups = []
+    current_group_key = None
+    current_group = []
+    for idx, e in var_entries:
+        prefix = _get_prefix(e[1])
+        if prefix != current_group_key:
+            if current_group:
+                groups.append((current_group_key, current_group))
+            current_group_key = prefix
+            current_group = []
+        current_group.append((idx, e))
+    if current_group:
+        groups.append((current_group_key, current_group))
+
+    # Map original index to its entry
+    original_by_idx = {i: e for i, e in enumerate(original_entries)}
+
+    # Assign non-var lines to groups based on proximity in original file
+    # Simple approach: split non_vars at the boundaries between groups
+    if not groups:
+        return [e for _, e in sorted(non_vars, key=lambda x: x[0])]
+
+    # Collect boundaries: the indices where each group started in the original
+    group_boundaries = [(g[0][0], g) for g in groups]  # (start_idx, group_data)
+
+    result = []
+    non_var_iter = iter(sorted(non_vars, key=lambda x: x[0]))
+    consumed = set()
+
+    for g_idx, (g_start, (g_prefix, g_entries)) in enumerate(group_boundaries):
+        # Add non-var lines that appeared before this group in the original
+        while True:
+            try:
+                nv_idx, nv_entry = next(non_var_iter)
+            except StopIteration:
+                break
+            if nv_idx > g_start and g_idx > 0:
+                # This non-var belongs to the previous group, put it back
+                # Actually let's just insert any non-var that's before the group start
+                if nv_idx < g_start:
+                    result.append(nv_entry)
+                    consumed.add(nv_idx)
+                else:
+                    # Put it back by recreating the iterator
+                    # Simple: just add all remaining non-vars at the end
+                    non_var_iter = iter([(nv_idx, nv_entry)] + list(non_var_iter))
+                    break
+            else:
+                if nv_idx < g_start:
+                    result.append(nv_entry)
+                    consumed.add(nv_idx)
+                else:
+                    non_var_iter = iter([(nv_idx, nv_entry)] + list(non_var_iter))
+                    break
+
+        # Add the group entries
+        for _, e in g_entries:
+            result.append(e)
+
+    # Add any remaining non-var lines
+    for nv_idx, nv_entry in sorted(non_vars, key=lambda x: x[0]):
+        if nv_idx not in consumed and nv_idx not in {id(e) for e in result}:
+            result.append(nv_entry)
+
+    return result
+
+
+def _rebuild(var_entries, non_vars):
+    """Merge sorted variable entries with non-variable lines.
+
+    Non-variable lines are inserted in their original relative positions
+    where possible; otherwise appended at the end.
+    """
+    result = []
+    non_var_sorted = sorted(non_vars, key=lambda x: x[0])
+    nv_idx = 0
+
+    # Place non-var lines that appeared before the first variable at top
+    while nv_idx < len(non_var_sorted) and non_var_sorted[nv_idx][0] < var_entries[0][0]:
+        result.append(non_var_sorted[nv_idx][1])
+        nv_idx += 1
+
+    for idx, e in var_entries:
+        result.append(e)
+        # Add any non-var lines that sit between this var and the next
+        while nv_idx < len(non_var_sorted) and (
+            nv_idx + 1 >= len(non_var_sorted)
+            or (
+                idx < non_var_sorted[nv_idx][0]
+                and (
+                    nv_idx + 1 >= len(var_entries)
+                    or non_var_sorted[nv_idx][0] < var_entries[nv_idx + 1][0]
+                    if nv_idx + 1 < len(var_entries)
+                    else True
+                )
+            )
+        ):
+            result.append(non_var_sorted[nv_idx][1])
+            nv_idx += 1
+
+    # Any leftover non-var lines
+    while nv_idx < len(non_var_sorted):
+        result.append(non_var_sorted[nv_idx][1])
+        nv_idx += 1
+
+    return result
+
+
+def serialize_entries(entries):
+    """Convert a list of entry tuples back into a single string."""
+    lines = []
+    for e in entries:
+        kind = e[0]
+        if kind == "blank":
+            lines.append("\n")
+        elif kind == "comment":
+            lines.append(e[2])  # e[2] is the full line
+        elif kind == "var":
+            lines.append(f"{e[1]}={e[2]}")
+    return "".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    args = sys.argv[1:]
+
+    if "-h" in args or "--help" in args:
+        print(__doc__)
+        return
+
+    filepath = None
+    in_place = False
+    sort_by = "name"
+    group = False
+    remove_dups = False
+
+    i = 0
+    while i < len(args):
+        a = args[i]
+        if a == "--file" and i + 1 < len(args):
+            filepath = args[i + 1]
+            i += 2
+        elif a == "--in-place":
+            in_place = True
+            i += 1
+        elif a == "--sort-by" and i + 1 < len(args):
+            val = args[i + 1].lower()
+            if val not in ("name", "value"):
+                print(f"Error: --sort-by must be 'name' or 'value', got '{val}'", file=sys.stderr)
+                sys.exit(1)
+            sort_by = val
+            i += 2
+        elif a == "--group":
+            group = True
+            i += 1
+        elif a == "--remove-dups":
+            remove_dups = True
+            i += 1
+        else:
+            print(f"Error: unknown argument '{a}'", file=sys.stderr)
+            sys.exit(1)
+
+    # Read input
+    if filepath:
+        try:
+            with open(filepath, "r") as f:
+                text = f.read()
+        except FileNotFoundError:
+            print(f"Error: file not found '{filepath}'", file=sys.stderr)
+            sys.exit(1)
+        except PermissionError:
+            print(f"Error: permission denied '{filepath}'", file=sys.stderr)
+            sys.exit(1)
+    else:
+        # Read from stdin
+        text = sys.stdin.read()
+
+    entries = parse_env(text)
+    sorted_entries = group_sort(entries, sort_by, group, remove_dups)
+    output = serialize_entries(sorted_entries)
+
+    if in_place:
+        if not filepath:
+            print("Error: --in-place requires --file", file=sys.stderr)
+            sys.exit(1)
+        with open(filepath, "w") as f:
+            f.write(output)
+    else:
+        sys.stdout.write(output)
+
+
+if __name__ == "__main__":
+    main()

evolver_tools-31.0.0/src/evolver_tools/vendor/file_patch.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""file-patch — Apply simple text patches (find/replace) to files.
+
+Performs a single find-and-replace operation on a text file.
+Supports dry-run mode and automatic backup creation.
+
+Usage:
+    file-patch --file README.md --old "foo" --new "bar"
+    file-patch --file config.py --old "DEBUG = True" --new "DEBUG = False" --dry-run
+    file-patch --file settings.ini --old "port=8080" --new "port=9090" --backup
+    file-patch --file script.sh --old "some old text" --new ""
+
+Options:
+    --file PATH      Path to the file to patch (required)
+    --old TEXT       Text to find (required)
+    --new TEXT       Replacement text (required, may be empty string)
+    --dry-run        Show what would be changed without modifying the file
+    --backup         Create a .bak backup of the original file
+    -h, --help       Show this help message
+"""
+
+import sys
+import os
+import argparse
+
+
+TOOL_META = {
+    "name": "file-patch",
+    "func": "main",
+    "desc": "Apply text patches to files",
+}
+
+
+def apply_patch(
+    filepath: str,
+    old_text: str,
+    new_text: str,
+    dry_run: bool = False,
+    backup: bool = False,
+) -> int:
+    """Apply a find/replace patch to a file.
+
+    Reads the file, performs exactly one replacement of *old_text* with
+    *new_text*, and writes the result back.  If *old_text* is not found,
+    or is found more than once, the function exits with an error.
+
+    Args:
+        filepath: Path to the file to patch.
+        old_text: The exact text to search for.
+        new_text: The text to replace it with.
+        dry_run: If True, only display what would change.
+        backup: If True, create a .bak copy before modifying.
+
+    Returns:
+        0 on success, 1 on failure.
+    """
+    if not os.path.isfile(filepath):
+        print(f"Error: file not found: {filepath}", file=sys.stderr)
+        return 1
+
+    # Read the file
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            content = f.read()
+    except (OSError, UnicodeDecodeError) as e:
+        print(f"Error: cannot read '{filepath}': {e}", file=sys.stderr)
+        return 1
+
+    # Count occurrences
+    count = content.count(old_text)
+
+    if count == 0:
+        print(f"Error: string not found in '{filepath}'", file=sys.stderr)
+        return 1
+
+    if count > 1:
+        print(
+            f"Error: found {count} occurrences of the search string in "
+            f"'{filepath}'.  Expected exactly 1.  Use a more specific "
+            f"--old string.",
+            file=sys.stderr,
+        )
+        return 1
+
+    # Perform the replacement
+    new_content = content.replace(old_text, new_text, 1)
+
+    # Show diff-style output
+    _show_patch(filepath, old_text, new_text, count)
+
+    if dry_run:
+        print(f"[DRY-RUN] No changes written to '{filepath}'.")
+        return 0
+
+    # Create backup if requested
+    if backup:
+        backup_path = filepath + ".bak"
+        try:
+            # Avoid overwriting an existing backup
+            if os.path.exists(backup_path):
+                base, ext = backup_path, ""
+                idx = 1
+                while os.path.exists(f"{base}.{idx}"):
+                    idx += 1
+                backup_path = f"{filepath}.bak.{idx}"
+            with open(backup_path, "w", encoding="utf-8") as bf:
+                bf.write(content)
+            print(f"Backup created: {backup_path}")
+        except OSError as e:
+            print(f"Error: cannot create backup '{backup_path}': {e}", file=sys.stderr)
+            return 1
+
+    # Write the patched file
+    try:
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(new_content)
+        print(f"Patched: {filepath}")
+    except OSError as e:
+        print(f"Error: cannot write '{filepath}': {e}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+def _show_patch(filepath: str, old_text: str, new_text: str, count: int) -> None:
+    """Print a human-readable summary of the patch."""
+    print(f"File: {filepath}  ({count} occurrence{'s' if count != 1 else ''})")
+    # Show context: first line of old text
+    old_first = old_text.split("\n")[0]
+    new_first = new_text.split("\n")[0]
+    if old_text == new_text:
+        print("  (no change — old and new text are identical)")
+    else:
+        print(f"  -{old_first}")
+        print(f"  +{new_first}")
+    print()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Apply a simple text find/replace patch to a file.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  file-patch --file README.md --old \"foo\" --new \"bar\"\n"
+            "  file-patch --file config.py --old \"DEBUG = True\" "
+            "--new \"DEBUG = False\" --dry-run\n"
+            "  file-patch --file settings.ini --old \"port=8080\" "
+            "--new \"port=9090\" --backup\n"
+            "  file-patch --file script.sh --old \"some old text\" --new \"\"\n"
+        ),
+    )
+    parser.add_argument(
+        "--file", required=True,
+        help="Path to the file to patch",
+    )
+    parser.add_argument(
+        "--old", required=True,
+        help="Text to find (exact match)",
+    )
+    parser.add_argument(
+        "--new", required=True,
+        default="",
+        help="Replacement text (may be empty string)",
+    )
+    parser.add_argument(
+        "--dry-run", action="store_true",
+        help="Show what would be changed without modifying the file",
+    )
+    parser.add_argument(
+        "--backup", action="store_true",
+        help="Create a .bak backup of the original file before patching",
+    )
+    args = parser.parse_args()
+
+    filepath = os.path.abspath(args.file)
+
+    exit_code = apply_patch(
+        filepath=filepath,
+        old_text=args.old,
+        new_text=args.new,
+        dry_run=args.dry_run,
+        backup=args.backup,
+    )
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()