252 lines
8.8 KiB
Python
Executable File
252 lines
8.8 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Fast manual grouping helper.
|
|
|
|
Run without arguments to enter paths/ranges interactively, or run:
|
|
python3 grouping.py path/to/file/or/directory [...]
|
|
|
|
Files are sorted by their current path and moved into one folder named
|
|
[first stem]-[last stem] inside the working directory.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import glob
|
|
import os
|
|
import shlex
|
|
import shutil
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
from tools.console import launch_terminal_if_needed, pause_if_interactive, prompt_input
|
|
from tools.filenames import group_stem
|
|
from tools.filesystem import (
|
|
cleanup_roots_from_args,
|
|
collect_files,
|
|
determine_working_dir,
|
|
entered_path,
|
|
path_completion,
|
|
path_completions,
|
|
remove_empty_dirs,
|
|
unique_path,
|
|
)
|
|
|
|
|
|
def range_lexer(value: str) -> shlex.shlex:
|
|
lexer = shlex.shlex(value, posix=True)
|
|
lexer.whitespace_split = True
|
|
lexer.commenters = lexer.escape = ""
|
|
return lexer
|
|
|
|
|
|
def sibling_items(source: Path) -> list[Path]:
|
|
folders = source.is_dir()
|
|
return sorted(
|
|
(item for item in source.parent.iterdir() if (item.is_dir() if folders else item.is_file())),
|
|
key=lambda item: (item.name.casefold(), item.name),
|
|
)
|
|
|
|
|
|
def range_completions(text: str) -> list[str]:
|
|
lexer = range_lexer(text)
|
|
try:
|
|
first = lexer.get_token()
|
|
except ValueError: # Completing inside an unfinished quote.
|
|
first = lexer.token
|
|
if first and "*" in first:
|
|
return []
|
|
if lexer.state != " ":
|
|
return [shlex.quote(path) for path in path_completions(first or "")]
|
|
|
|
boundary = lexer.instream.tell()
|
|
prefix = text[:boundary]
|
|
remainder = text[boundary:]
|
|
prefix += remainder[:len(remainder) - len(remainder.lstrip())]
|
|
second = range_lexer(remainder)
|
|
tokens: list[str] = []
|
|
try:
|
|
tokens.extend(second)
|
|
except ValueError:
|
|
tokens.append(second.token)
|
|
if len(tokens) > 1:
|
|
return []
|
|
value = tokens[0] if tokens else ""
|
|
if value.lstrip("+-").isdecimal() or "*" in value:
|
|
return []
|
|
source = entered_path(first).absolute()
|
|
if not (source.is_file() or source.is_dir()):
|
|
return []
|
|
|
|
directory = ""
|
|
if value.startswith(("/", "~")) or Path(value).is_absolute():
|
|
directory = os.path.join(str(source.parent), "")
|
|
if value.startswith("~"):
|
|
home = str(Path.home()) + os.sep
|
|
if not directory.startswith(home):
|
|
return []
|
|
directory = "~/" + directory[len(home):]
|
|
if directory != value and directory.startswith(value):
|
|
return [prefix + shlex.quote(directory)]
|
|
if not value.startswith(directory):
|
|
return []
|
|
value = value[len(directory):]
|
|
|
|
return [
|
|
prefix + shlex.quote(directory + item.name)
|
|
for item in sibling_items(source)
|
|
if item.name.startswith(value)
|
|
]
|
|
|
|
|
|
def expand_range(value: str) -> tuple[Path, list[Path]]:
|
|
tokens = list(range_lexer(value))
|
|
if len(tokens) not in {1, 2}:
|
|
raise ValueError("Enter a path/pattern, two range endpoints, or a path and count; quote names containing spaces.")
|
|
first = entered_path(tokens[0]).absolute()
|
|
if any("*" in token for token in tokens):
|
|
if len(tokens) != 1:
|
|
raise ValueError("Wildcards are only supported in a single-path entry, not a range or count.")
|
|
pattern = glob.escape(str(first)).replace("[*]", "*")
|
|
matches = sorted(
|
|
(path for name in glob.glob(pattern) if (path := Path(name)).is_file() or path.is_dir()),
|
|
key=lambda path: (str(path).casefold(), str(path)),
|
|
)
|
|
if not matches:
|
|
raise ValueError(f"No files or directories match: {first}")
|
|
return Path(os.path.commonpath([path.parent for path in matches])).resolve(), matches
|
|
if not (first.is_file() or first.is_dir()):
|
|
raise ValueError(f"File or directory not found: {first}")
|
|
parent = first.parent
|
|
if len(tokens) == 1:
|
|
return parent.resolve(), [first]
|
|
|
|
siblings = sibling_items(first)
|
|
names = [item.name for item in siblings]
|
|
start = names.index(first.name)
|
|
if tokens[1].lstrip("+-").isdecimal():
|
|
count = int(tokens[1])
|
|
if count < 1:
|
|
raise ValueError("Count must be a positive integer, including the starting item.")
|
|
if count > len(siblings) - start:
|
|
raise ValueError(f"Requested {count} items, but only {len(siblings) - start} remain from {first.name}.")
|
|
return parent.resolve(), siblings[start:start + count]
|
|
|
|
last = entered_path(tokens[1])
|
|
if not last.is_absolute():
|
|
if last.parent != Path("."):
|
|
raise ValueError("The second endpoint must be a name or an absolute path.")
|
|
last = parent / last
|
|
if last.parent.resolve() != parent.resolve():
|
|
raise ValueError("Range endpoints must be in the same directory.")
|
|
if not (last.is_file() or last.is_dir()):
|
|
raise ValueError(f"File or directory not found: {last}")
|
|
if first.is_dir() != last.is_dir():
|
|
raise ValueError("Range endpoints must both be files or both be directories.")
|
|
|
|
start, end = sorted((start, names.index(last.name)))
|
|
return parent.resolve(), siblings[start:end + 1]
|
|
|
|
|
|
def prompt_group_ranges() -> tuple[list[str], Path | None]:
|
|
print("Enter selections, one per line:")
|
|
print(" /photos/A.jpg One file or folder (folders are collected recursively)")
|
|
print(" /photos/DSC*.JPG Wildcard: * matches zero or more characters in a name")
|
|
print(" /photos/A.jpg C.jpg Inclusive range, in either order, both files or both folders")
|
|
print(" /photos/A.jpg 5 Five files starting at A.jpg (or five folders if A is a folder)")
|
|
print("Ranges/counts use alphabetical order and skip the other type; counts include A.")
|
|
print("Range endpoints must share a directory; B can be a name or an absolute path.")
|
|
print("Wildcards cannot be combined with ranges/counts. Use an absolute path for a numeric endpoint name.")
|
|
print('Quote paths/names containing spaces: "/photos/Trip A" "Trip C". Tab completes paths.')
|
|
print("Leave the line empty to group all selections together.")
|
|
args: list[str] = []
|
|
working_dir = None
|
|
with path_completion(range_completions):
|
|
while True:
|
|
value = prompt_input("Selection: ").strip()
|
|
if not value:
|
|
return args, working_dir
|
|
try:
|
|
parent, paths = expand_range(value)
|
|
if working_dir is not None and parent != working_dir:
|
|
raise ValueError(f"Use entries from the working directory: {working_dir}")
|
|
except ValueError as exc:
|
|
print(exc)
|
|
continue
|
|
if working_dir is None:
|
|
working_dir = parent
|
|
print(f"Working directory: {working_dir}")
|
|
args.extend(str(path) for path in paths)
|
|
print(f"Selected {len(paths)} file(s)/folder(s).")
|
|
|
|
|
|
def collect_group_files(args: list[str]) -> list[Path]:
|
|
return collect_files(args, sort_by_name=True)
|
|
|
|
|
|
def group_files(files: list[Path], working_dir: Path) -> Path | None:
|
|
if not files:
|
|
return None
|
|
|
|
sorted_files = sorted(files, key=lambda item: item.name.lower())
|
|
first = group_stem(sorted_files[0])
|
|
last = group_stem(sorted_files[-1])
|
|
target_dir = working_dir / f"{first}-{last}"
|
|
target_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
for source in sorted_files:
|
|
if source.parent == target_dir:
|
|
continue
|
|
destination = unique_path(target_dir / source.name)
|
|
shutil.move(str(source), str(destination))
|
|
|
|
return target_dir
|
|
|
|
|
|
def print_removed_dirs(removed_dirs: list[Path]) -> None:
|
|
if not removed_dirs:
|
|
return
|
|
print("Removed empty director" + ("y:" if len(removed_dirs) == 1 else "ies:"))
|
|
for directory in removed_dirs:
|
|
print(f" - {directory}")
|
|
|
|
|
|
def run(argv: list[str]) -> int:
|
|
try:
|
|
if argv[1:]:
|
|
args = argv[1:]
|
|
working_dir = determine_working_dir(args)
|
|
else:
|
|
args, working_dir = prompt_group_ranges()
|
|
if not args:
|
|
print("No inputs selected.")
|
|
return 0
|
|
except RuntimeError as exc:
|
|
print(exc)
|
|
return 1
|
|
|
|
cleanup_roots = cleanup_roots_from_args(args)
|
|
files = collect_group_files(args)
|
|
if not files:
|
|
print("No files to group.")
|
|
|
|
assert working_dir is not None
|
|
target_dir = group_files(files, working_dir)
|
|
if target_dir is not None:
|
|
print(f"Moved {len(files)} file(s) into {target_dir}")
|
|
removed_dirs = remove_empty_dirs(cleanup_roots, keep_dirs={working_dir.resolve()})
|
|
print_removed_dirs(removed_dirs)
|
|
return 0
|
|
|
|
|
|
def main(argv: list[str]) -> int:
|
|
if launch_terminal_if_needed(argv):
|
|
return 0
|
|
try:
|
|
return run(argv)
|
|
finally:
|
|
pause_if_interactive()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main(sys.argv))
|