sync_dirs.py

#!/usr/bin/env python3
# Most code here was mostly generated by Grok 4.5, then cobbled together by human.

"""
Compare files under directory A against the same relative paths under directory B.

For each file found under A:
  - "duplicate: <path>"  if the file exists under B and is byte-identical
  - "different: <path>"  if the file exists under B but differs
  - "missing: <path>"    if the file does not exist under B

Binary comparison is performed by reading both files in blocks of L MiB
(default: 16 MiB).
"""

import argparse
import os
import sys, shutil

DEFAULT_BLOCK_SIZE_MB = 16

def move_missing_items(dir_a: str, dir_b: str) -> None:
    """
    Recursively scan under A.  For every file or subdirectory that does
    not exist at the same relative path under B, move it from A to B.

    The roots A and B themselves are never moved.
    """
    dir_a = os.path.abspath(dir_a)
    dir_b = os.path.abspath(dir_b)

    if not os.path.isdir(dir_a):
        raise NotADirectoryError(f"'{dir_a}' is not a directory")
    if not os.path.isdir(dir_b):
        raise NotADirectoryError(f"'{dir_b}' is not a directory")

    for root, dirs, files in os.walk(dir_a, topdown=True):
        # --- directories ---
        # Iterate over a copy so we can safely modify dirs (for pruning)
        for name in list(dirs):
            rel = os.path.relpath(os.path.join(root, name), dir_a)
            path_a = os.path.join(dir_a, rel)
            path_b = os.path.join(dir_b, rel)

            if not os.path.exists(path_b):
                # Parent of path_b is guaranteed to exist (top-down processing)
                print(f"moving dir {path_a} -> {path_b}")
                shutil.move(path_a, path_b)
                # Prevent os.walk from descending into the moved tree
                dirs.remove(name)

        # --- files ---
        for name in files:
            rel = os.path.relpath(os.path.join(root, name), dir_a)
            path_a = os.path.join(dir_a, rel)
            path_b = os.path.join(dir_b, rel)

            if not os.path.exists(path_b):
                print(f"moving file {path_a} -> {path_b}")
                # Ensure the target parent directory exists
                os.makedirs(os.path.dirname(path_b), exist_ok=True)
                shutil.move(path_a, path_b)

def remove_empty_dirs(path: str) -> None:
    """
    Recursively remove all empty subdirectories under the given path.
    The root directory itself is never removed.
    """
    path = os.path.abspath(path)
    if not os.path.isdir(path):
        raise NotADirectoryError(f"'{path}' is not a directory")

    # Walk bottom-up so children are processed before parents
    for root, dirs, _files in os.walk(path, topdown=False):
        for name in dirs:
            dir_path = os.path.join(root, name)
            try:
                print("removing empty dir:",dir_path)
                os.rmdir(dir_path)  # succeeds only if the directory is empty
            except OSError:
                # Directory is not empty (or permission error, etc.) — leave it
                pass
                
def files_identical(path_a: str, path_b: str, block_size: int) -> bool:
    """Return True if the two files are byte-for-byte identical."""
    try:
        size_a = os.path.getsize(path_a)
        size_b = os.path.getsize(path_b)
    except OSError:
        return False

    if size_a != size_b:
        return False

    with open(path_a, "rb") as fa, open(path_b, "rb") as fb:
        while True:
            block_a = fa.read(block_size)
            block_b = fb.read(block_size)
            if block_a != block_b:
                return False
            if not block_a:  # both files exhausted
                return True


def compare_directories(dir_a: str, dir_b: str, block_size: int) -> None:
    dir_a = os.path.abspath(dir_a)
    dir_b = os.path.abspath(dir_b)

    if not os.path.isdir(dir_a):
        print(f"Error: '{dir_a}' is not a directory", file=sys.stderr)
        sys.exit(1)
    if not os.path.isdir(dir_b):
        print(f"Error: '{dir_b}' is not a directory", file=sys.stderr)
        sys.exit(1)

    for root, _dirs, files in os.walk(dir_a):
        for name in files:
            path_a = os.path.join(root, name)
            rel = os.path.relpath(path_a, dir_a)
            path_b = os.path.join(dir_b, rel)

            if not os.path.isfile(path_b):
                print(f"missing: {rel}")
            elif files_identical(path_a, path_b, block_size):
                print(f"duplicate: {rel}")
                os.remove(path_a)
            else:
                print(f"different: {rel}")


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Recursively compare files under directory A with the same relative paths under B."
    )
    parser.add_argument("A", help="Source directory to scan")
    parser.add_argument("B", help="Directory to compare against")
    parser.add_argument(
        "-L",
        "--block-size",
        type=int,
        default=DEFAULT_BLOCK_SIZE_MB,
        metavar="MB",
        help=f"Block size for binary comparison in MiB (default: {DEFAULT_BLOCK_SIZE_MB})",
    )
    args = parser.parse_args()

    if args.block_size <= 0:
        print("Error: block size must be positive", file=sys.stderr)
        sys.exit(1)
    move_missing_items(args.A, args.B)
    block_size_bytes = args.block_size * 1024 * 1024
    compare_directories(args.A, args.B, block_size_bytes)
    remove_empty_dirs(args.A)

if __name__ == "__main__":
    main()