129 lines
3.8 KiB
Python
129 lines
3.8 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Find duplicate files that share the same base ID (e.g., [LETTERS]-[DIGITS])
|
|
but differ only by extra suffix characters.
|
|
|
|
Examples:
|
|
NACR-996.mp4 vs NACR-996J.mp4 -> same base: NACR-996
|
|
NDWQ-008-C.mp4 vs NDWQ-008.mp4 -> same base: NDWQ-008
|
|
"""
|
|
|
|
import os
|
|
import re
|
|
import argparse
|
|
from collections import defaultdict
|
|
|
|
|
|
def extract_base_id(filename: str) -> str | None:
|
|
"""
|
|
Extract the base ID from a filename.
|
|
Matches pattern: [letters]-[digits], case-insensitive.
|
|
Returns the matched base ID (uppercased for case-insensitive comparison),
|
|
or None if no match.
|
|
"""
|
|
# Remove file extension first so suffixes in the stem don't confuse matching.
|
|
# But we need to match within the full filename (without extension).
|
|
stem, _ = os.path.splitext(filename)
|
|
|
|
# Match: one or more letters, a hyphen, one or more digits
|
|
# This is the core ID. We take the FIRST such match in the stem.
|
|
match = re.search(r'[a-zA-Z]+-\d+', stem)
|
|
if not match:
|
|
return None
|
|
|
|
return match.group(0).upper()
|
|
|
|
|
|
def find_duplicates(
|
|
folder: str,
|
|
extensions: set[str] | None = None,
|
|
skip_extensions: set[str] | None = None,
|
|
) -> dict[str, list[str]]:
|
|
"""
|
|
Scan `folder` for files, group by base ID, and return groups with >1 file.
|
|
|
|
Args:
|
|
folder: Path to the directory to scan.
|
|
extensions: If provided, only consider files with these extensions
|
|
(e.g., {'.mp4', '.mkv', '.avi'}). Case-insensitive.
|
|
skip_extensions: Extensions to always ignore (e.g., {'.srt'}).
|
|
|
|
Returns:
|
|
Dict mapping base_id -> list of filenames (duplicate groups).
|
|
"""
|
|
if skip_extensions is None:
|
|
skip_extensions = set()
|
|
|
|
groups: dict[str, list[str]] = defaultdict(list)
|
|
|
|
for entry in sorted(os.listdir(folder)):
|
|
full_path = os.path.join(folder, entry)
|
|
if not os.path.isfile(full_path):
|
|
continue
|
|
|
|
_, ext = os.path.splitext(entry)
|
|
ext_lower = ext.lower()
|
|
|
|
if ext_lower in skip_extensions:
|
|
continue
|
|
|
|
if extensions and ext_lower not in extensions:
|
|
continue
|
|
|
|
base_id = extract_base_id(entry)
|
|
if base_id:
|
|
groups[base_id].append(entry)
|
|
|
|
# Only return groups with duplicates
|
|
return {bid: files for bid, files in groups.items() if len(files) > 1}
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(
|
|
description="Find duplicate files by base ID (e.g., NACR-996 / NACR-996J)"
|
|
)
|
|
parser.add_argument(
|
|
"folder",
|
|
nargs="?",
|
|
default=".",
|
|
help="Folder to scan (default: current directory)",
|
|
)
|
|
parser.add_argument(
|
|
"-e", "--extensions",
|
|
nargs="+",
|
|
default=None,
|
|
help="Only check files with these extensions (e.g., -e .mp4 .mkv)",
|
|
)
|
|
parser.add_argument(
|
|
"-s", "--skip",
|
|
nargs="+",
|
|
default=[".srt"],
|
|
help="Extensions to ignore (default: .srt)",
|
|
)
|
|
args = parser.parse_args()
|
|
|
|
folder = os.path.abspath(args.folder)
|
|
if not os.path.isdir(folder):
|
|
print(f"Error: '{folder}' is not a directory.", flush=True)
|
|
return
|
|
|
|
exts = {e.lower() if e.startswith('.') else f'.{e.lower()}' for e in args.extensions} if args.extensions else None
|
|
skips = {e.lower() if e.startswith('.') else f'.{e.lower()}' for e in args.skip}
|
|
|
|
dupes = find_duplicates(folder, exts, skips)
|
|
|
|
if not dupes:
|
|
print("No duplicate files found.", flush=True)
|
|
return
|
|
|
|
print(f"Found {len(dupes)} duplicate group(s):\n", flush=True)
|
|
for base_id, files in sorted(dupes.items()):
|
|
print(f" Base ID: {base_id}", flush=True)
|
|
for f in files:
|
|
print(f" -> {f}", flush=True)
|
|
print(flush=True)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|