@codebend3r/che 1.0.0

package/bin/files/find-largest-files.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""📊 List the largest files under a path, biggest first.
+
+Usage:
+  find-largest-files.py [--path=.] [--length=10] [--full-path]
+
+Options:
+  --path=DIR      Directory to scan (default: .)
+  --length=N      How many files to list (default: 10)
+  --full-path     Print the whole path instead of just the basename
+  --help          Show help
+"""
+
+from __future__ import annotations
+
+import heapq
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from utils import (
+    add_bool_flag,
+    build_parser,
+    format_bytes,
+    info,
+    iter_files,
+    note,
+    run_cli,
+    scan_root,
+    warning,
+)
+
+__version__ = "2.0.4"
+
+_NON_NEGATIVE_INT = re.compile(r"[0-9]+")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser(
+        prog="find-largest-files",
+        description="📊 List the largest files under a path, biggest first.",
+    )
+    parser.add_argument("--path", default=".", metavar="DIR", help="Directory to scan (default: .)")
+    # Kept as a string, not `type=int`: argparse's int conversion would own the
+    # error and exit before the shell version's own message could be produced.
+    parser.add_argument(
+        "--length", default="10", metavar="N", help="How many files to list (default: 10)"
+    )
+    add_bool_flag(parser, "--full-path", dest="full_path", help="Print the whole path")
+
+    info(f"Running command in {Path.cwd()}")
+    args = parser.parse_args(argv)
+
+    if not _NON_NEGATIVE_INT.fullmatch(args.length):
+        warning("❌ --length must be a non-negative integer")
+        return 1
+    length = int(args.length)
+
+    if not args.path:
+        warning("❌ --path cannot be empty")
+        return 1
+
+    note(f"Searching in: {args.path}")
+    note(f"List length: {length}")
+    note(f"Show full path: {str(args.full_path).lower()}")
+
+    root = scan_root(args.path)
+
+    def sized() -> list[tuple[int, str, Path]]:
+        for path in iter_files(root, skip_macos_metadata=False):
+            try:
+                size = path.stat().st_size
+            except OSError:
+                continue
+            # The shell pipeline (find | xargs stat | sort) broke on any
+            # filename containing its '|' separator. Sizing in-process removes
+            # that failure mode entirely.
+            yield size, str(path), path
+
+    # `sort -nr | head -n N` ties break on the whole line DESCENDING, because
+    # -r reverses the last-resort comparison too. nlargest on (size, str) gives
+    # the same ordering, and holds only N entries rather than the whole tree -
+    # a million-file media root would otherwise cost about a gigabyte.
+    top = heapq.nlargest(length, sized(), key=lambda item: (item[0], item[1]))
+
+    for size, _, path in top:
+        if args.full_path:
+            # Rebuild from the user's own --path string so a default of "."
+            # still prints "./name", as `find .` did. Path() would normalise
+            # the "./" away and break anything piping this into xargs.
+            label = f"{args.path.rstrip('/')}/{path.relative_to(root)}"
+        else:
+            label = path.name
+        print(f"{format_bytes(size):>12}  {label}", flush=True)
+
+    return 0
+
+
+if __name__ == "__main__":
+    run_cli(main)

package/bin/files/make-alpha-dir.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""🔤 Create the alphabetical bucket folders: ``#`` and ``A`` through ``Z``.
+
+Usage:
+  make-alpha-dir.py [--path=/path/to/parent]   (defaults to .)
+
+Options:
+  --path=DIR   Parent directory to create the buckets in (default: .)
+  --help       Show help
+"""
+
+from __future__ import annotations
+
+import string
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from utils import build_parser, info, run_cli, warning
+
+BUCKETS = ("#", *string.ascii_uppercase)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser(
+        prog="make-alpha-dir",
+        description="🔤 Create '#' and A-Z bucket folders under a parent directory.",
+    )
+    parser.add_argument(
+        "--path",
+        default=".",
+        metavar="DIR",
+        help="Parent directory to create the buckets in (default: .)",
+    )
+
+    info(f"Running command in {Path.cwd()}")
+    args = parser.parse_args(argv)
+
+    root = Path(args.path or ".")
+    try:
+        root.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        warning(f"❌ Could not create {root}: {exc}")
+        return 1
+
+    # One `mkdir -p -- '#' {A..Z}` reported each failure and still created
+    # every other operand, so a parent already holding a FILE named "A" ended
+    # up with the remaining 26 buckets. Bailing on the first error would leave
+    # a half-built bucket set behind.
+    failures = 0
+    for bucket in BUCKETS:
+        try:
+            (root / bucket).mkdir(exist_ok=True)
+        except OSError as exc:
+            warning(f"mkdir: {bucket}: {exc.strerror or exc}")
+            failures += 1
+
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    run_cli(main)