PyHardLinkBackup 1.4.0__tar.gz → 1.5.0__tar.gz

{pyhardlinkbackup-1.4.0 → pyhardlinkbackup-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyHardLinkBackup
-Version: 1.4.0
+Version: 1.5.0
 Summary: HardLink/Deduplication Backups with Python
 Project-URL: Documentation, https://github.com/jedie/PyHardLinkBackup
 Project-URL: Source, https://github.com/jedie/PyHardLinkBackup
@@ -80,7 +80,7 @@ complete help for main CLI app:
 
 [comment]: <> (✂✂✂ auto generated main help start ✂✂✂)
 ```
-usage: phlb [-h] {backup,rebuild,version}
+usage: phlb [-h] {backup,compare,rebuild,version}
 
 
 
@@ -90,6 +90,7 @@ usage: phlb [-h] {backup,rebuild,version}
 ╭─ subcommands ────────────────────────────────────────────────────────────────────────────────────────────────────────╮
 │ (required)                                                                                                           │
 │   • backup   Backup the source directory to the destination directory using hard links for deduplication.            │
+│   • compare  Compares a source tree with the last backup and validates all known file hashes.                        │
 │   • rebuild  Rebuild the file hash and size database by scanning all backup files. And also verify SHA256SUMS and/or │
 │              store missing hashes in SHA256SUMS files.                                                               │
 │   • version  Print version and exit                                                                                  │
@@ -231,6 +232,10 @@ Overview of main changes:
 
 [comment]: <> (✂✂✂ auto generated history start ✂✂✂)
 
+* [v1.5.0](https://github.com/jedie/PyHardLinkBackup/compare/v1.4.1...v1.5.0)
+  * 2026-01-17 - NEW: Compare command to verify source tree with last backup
+* [v1.4.1](https://github.com/jedie/PyHardLinkBackup/compare/v1.4.0...v1.4.1)
+  * 2026-01-16 - Bugfix large file handling
 * [v1.4.0](https://github.com/jedie/PyHardLinkBackup/compare/v1.3.0...v1.4.0)
   * 2026-01-16 - Create log file in backup and a summary.txt
   * 2026-01-16 - Run CI tests on macos, too.
@@ -241,6 +246,9 @@ Overview of main changes:
   * 2026-01-15 - Add tests for rebuild
   * 2026-01-15 - Add command to "rebuld" the size and hash filesystem database
   * 2026-01-15 - Add screenshots in the README
+
+<details><summary>Expand older history entries ...</summary>
+
 * [v1.2.0](https://github.com/jedie/PyHardLinkBackup/compare/v1.1.0...v1.2.0)
   * 2026-01-15 - Add error handling: Log exception but continue with the backup
   * 2026-01-15 - Check permission and hadlink support on destination path
@@ -250,9 +258,6 @@ Overview of main changes:
 * [v1.1.0](https://github.com/jedie/PyHardLinkBackup/compare/v1.0.1...v1.1.0)
   * 2026-01-14 - Change backup timestamp directory to old schema: '%Y-%m-%d-%H%M%S'
   * 2026-01-14 - Add "Overview of main changes" to README
-
-<details><summary>Expand older history entries ...</summary>
-
 * [v1.0.1](https://github.com/jedie/PyHardLinkBackup/compare/v1.0.0...v1.0.1)
   * 2026-01-13 - Store SHA256SUMS files in backup directories
 * [v1.0.0](https://github.com/jedie/PyHardLinkBackup/compare/v0.13.0...v1.0.0)

{pyhardlinkbackup-1.4.0 → pyhardlinkbackup-1.5.0}/PyHardLinkBackup/__init__.py

@@ -3,5 +3,5 @@
 """
 
 # See https://packaging.python.org/en/latest/specifications/version-specifiers/
-__version__ = '1.4.0'
+__version__ = '1.5.0'
 __author__ = 'Jens Diemer <PyHardLinkBackup@jensdiemer.de>'

{pyhardlinkbackup-1.4.0 → pyhardlinkbackup-1.5.0}/PyHardLinkBackup/backup.py

@@ -138,12 +138,13 @@ def backup_one_file(
                 backup_result.hardlinked_size += size
             else:
                 logger.info('Copy unique file: %s to %s', src_path, dst_path)
+                file_hash = copy_and_hash(src_path, dst_path)
                 hash_db[file_hash] = dst_path
                 backup_result.copied_files += 1
                 backup_result.copied_size += size
 
         # Keep original file metadata (permission bits, time stamps, and flags)
-        shutil.copy2(src_path, dst_path)
+        shutil.copystat(src_path, dst_path)
     else:
         # A file with this size not backuped before -> Can't be duplicate -> copy and hash
         file_hash = copy_and_hash(src_path, dst_path)

{pyhardlinkbackup-1.4.0 → pyhardlinkbackup-1.5.0}/PyHardLinkBackup/cli_app/phlb.py

@@ -5,7 +5,7 @@ from typing import Annotated
 import tyro
 from rich import print  # noqa
 
-from PyHardLinkBackup import rebuild_databases
+from PyHardLinkBackup import compare_backup, rebuild_databases
 from PyHardLinkBackup.backup import backup_tree
 from PyHardLinkBackup.cli_app import app
 from PyHardLinkBackup.logging_setup import (
@@ -60,6 +60,42 @@ def backup(
     )
 
 
+@app.command
+def compare(
+    src: Annotated[
+        Path,
+        tyro.conf.arg(
+            metavar='source',
+            help='Source directory that should be compared with the last backup.',
+        ),
+    ],
+    dst: Annotated[
+        Path,
+        tyro.conf.arg(
+            metavar='destination',
+            help='Destination directory with the backups. Will pick the last backup for comparison.',
+        ),
+    ],
+    /,
+    excludes: TyroExcludeDirectoriesArgType = DEFAULT_EXCLUDE_DIRECTORIES,
+    verbosity: TyroConsoleLogLevelArgType = DEFAULT_CONSOLE_LOG_LEVEL,
+    log_file_level: TyroLogFileLevelArgType = DEFAULT_LOG_FILE_LEVEL,
+) -> None:
+    """
+    Compares a source tree with the last backup and validates all known file hashes.
+    """
+    log_manager = LoggingManager(
+        console_level=verbosity,
+        file_level=log_file_level,
+    )
+    compare_backup.compare_tree(
+        src_root=src,
+        backup_root=dst,
+        excludes=excludes,
+        log_manager=log_manager,
+    )
+
+
 @app.command
 def rebuild(
     backup_root: Annotated[

pyhardlinkbackup-1.5.0/PyHardLinkBackup/compare_backup.py

@@ -0,0 +1,212 @@
+import dataclasses
+import datetime
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+
+from rich import print  # noqa
+
+from PyHardLinkBackup.logging_setup import LoggingManager
+from PyHardLinkBackup.utilities.file_hash_database import FileHashDatabase
+from PyHardLinkBackup.utilities.file_size_database import FileSizeDatabase
+from PyHardLinkBackup.utilities.filesystem import (
+    hash_file,
+    humanized_fs_scan,
+    iter_scandir_files,
+)
+from PyHardLinkBackup.utilities.humanize import PrintTimingContextManager, human_filesize
+from PyHardLinkBackup.utilities.rich_utils import DisplayFileTreeProgress
+from PyHardLinkBackup.utilities.tee import TeeStdoutContext
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class CompareResult:
+    compare_dir: Path
+    log_file: Path
+    #
+    total_file_count: int = 0
+    total_size: int = 0
+    #
+    src_file_new_count: int = 0
+    file_size_missmatch: int = 0
+    file_hash_missmatch: int = 0
+    #
+    small_file_count: int = 0
+    size_db_missing_count: int = 0
+    hash_db_missing_count: int = 0
+    #
+    successful_file_count: int = 0
+    error_count: int = 0
+
+
+def compare_one_file(
+    *,
+    src_root: Path,
+    entry: os.DirEntry,
+    size_db: FileSizeDatabase,
+    hash_db: FileHashDatabase,
+    compare_dir: Path,
+    compare_result: CompareResult,
+) -> None:
+    src_size = entry.stat().st_size
+
+    # For the progress bars:
+    compare_result.total_file_count += 1
+    compare_result.total_size += src_size
+
+    src_path = Path(entry.path)
+    dst_path = compare_dir / src_path.relative_to(src_root)
+
+    if not dst_path.exists():
+        logger.warning('Source file %s not found in compare %s', src_path, dst_path)
+        compare_result.src_file_new_count += 1
+        return
+
+    dst_size = dst_path.stat().st_size
+    if src_size != dst_size:
+        logger.warning(
+            'Source file %s size (%i Bytes) differs from compare file %s size (%iBytes)',
+            src_path,
+            src_size,
+            dst_path,
+            dst_size,
+        )
+        compare_result.file_size_missmatch += 1
+        return
+
+    src_hash = hash_file(src_path)
+    dst_hash = hash_file(dst_path)
+
+    if src_hash != dst_hash:
+        logger.warning(
+            'Source file %s hash %r differs from compare file %s hash (%s)',
+            src_path,
+            src_hash,
+            dst_path,
+            dst_hash,
+        )
+        compare_result.file_hash_missmatch += 1
+        return
+
+    if src_size < size_db.MIN_SIZE:
+        # Small file -> Not in deduplication database
+        compare_result.small_file_count += 1
+    else:
+        if src_size not in size_db:
+            logger.warning(
+                'Source file %s size (%i Bytes) not found in deduplication database',
+                src_path,
+                src_size,
+            )
+            compare_result.size_db_missing_count += 1
+
+        if src_hash not in hash_db:
+            logger.warning(
+                'Source file %s hash %r not found in deduplication database',
+                src_path,
+                src_hash,
+            )
+            compare_result.hash_db_missing_count += 1
+
+    # Everything is ok
+    compare_result.successful_file_count += 1
+
+
+def compare_tree(
+    *,
+    src_root: Path,
+    backup_root: Path,
+    excludes: tuple[str, ...],
+    log_manager: LoggingManager,
+) -> CompareResult:
+    src_root = src_root.resolve()
+    if not src_root.is_dir():
+        print('Error: Source directory does not exist!')
+        print(f'Please check source directory: "{src_root}"\n')
+        sys.exit(1)
+
+    backup_root = backup_root.resolve()
+    phlb_conf_dir = backup_root / '.phlb'
+    if not phlb_conf_dir.is_dir():
+        print('Error: Compare directory seems to be wrong! (No .phlb configuration directory found)')
+        print(f'Please check backup directory: "{backup_root}"\n')
+        sys.exit(1)
+
+    compare_main_dir = backup_root / src_root.name
+    timestamps = sorted(
+        path.name for path in compare_main_dir.iterdir() if path.is_dir() and path.name.startswith('20')
+    )
+    print(f'Found {len(timestamps)} compare(s) in {compare_main_dir}:')
+    for timestamp in timestamps:
+        print(f' * {timestamp}')
+    last_timestamp = timestamps[-1]
+    compare_dir = compare_main_dir / last_timestamp
+    print(f'\nComparing source tree {src_root} with {last_timestamp} compare:')
+    print(f'  {compare_dir}\n')
+
+    now_timestamp = datetime.datetime.now().strftime('%Y-%m-%d-%H%M%S')
+    log_file = compare_main_dir / f'{now_timestamp}-compare.log'
+    log_manager.start_file_logging(log_file)
+
+    excludes: set = set(excludes)
+    with PrintTimingContextManager('Filesystem scan completed in'):
+        src_file_count, src_total_size = humanized_fs_scan(src_root, excludes=excludes)
+
+    with DisplayFileTreeProgress(src_file_count, src_total_size) as progress:
+        # init "databases":
+        size_db = FileSizeDatabase(phlb_conf_dir)
+        hash_db = FileHashDatabase(backup_root, phlb_conf_dir)
+
+        compare_result = CompareResult(compare_dir=compare_dir, log_file=log_file)
+
+        next_update = 0
+        for entry in iter_scandir_files(src_root, excludes=excludes):
+            try:
+                compare_one_file(
+                    src_root=src_root,
+                    entry=entry,
+                    size_db=size_db,
+                    hash_db=hash_db,
+                    compare_dir=compare_dir,
+                    compare_result=compare_result,
+                )
+            except Exception as err:
+                logger.exception(f'Compare {entry.path} {err.__class__.__name__}: {err}')
+                compare_result.error_count += 1
+            else:
+                now = time.monotonic()
+                if now >= next_update:
+                    progress.update(
+                        completed_file_count=compare_result.total_file_count,
+                        completed_size=compare_result.total_size,
+                    )
+                    next_update = now + 0.5
+
+        # Finalize progress indicator values:
+        progress.update(completed_file_count=compare_result.total_file_count, completed_size=compare_result.total_size)
+
+    summary_file = compare_main_dir / f'{now_timestamp}-summary.txt'
+    with TeeStdoutContext(summary_file):
+        print(f'\nCompare complete: {compare_dir} (total size {human_filesize(compare_result.total_size)})\n')
+        print(f'  Total files processed: {compare_result.total_file_count}')
+        print(f'   * Successful compared files: {compare_result.successful_file_count}')
+        print(f'   * New source files: {compare_result.src_file_new_count}')
+        print(f'   * File size missmatch: {compare_result.file_size_missmatch}')
+        print(f'   * File hash missmatch: {compare_result.file_hash_missmatch}')
+
+        print(f'   * Small (<{size_db.MIN_SIZE} Bytes) files: {compare_result.small_file_count}')
+        print(f'   * Missing in size DB: {compare_result.size_db_missing_count}')
+        print(f'   * Missing in hash DB: {compare_result.hash_db_missing_count}')
+
+        if compare_result.error_count > 0:
+            print(f'  Errors during compare: {compare_result.error_count} (see log for details)')
+        print()
+
+    logger.info('Compare completed. Summary created: %s', summary_file)
+
+    return compare_result

{pyhardlinkbackup-1.4.0 → pyhardlinkbackup-1.5.0}/PyHardLinkBackup/tests/test_backup.py

@@ -144,16 +144,13 @@ class BackupTreeTestCase(
             (sub_dir / 'file.txt').write_text('This is file in subdir')
 
             # Only files bigger than MIN_SIZE will be considered for hardlinking:
-            size_db_min_file = src_root / 'min_sized_file1.bin'
-            size_db_min_file.write_bytes(b'X' * FileSizeDatabase.MIN_SIZE)
+            (src_root / 'min_sized_file1.bin').write_bytes(b'X' * FileSizeDatabase.MIN_SIZE)
 
             # Same content and big enough to be considered for hardlinking:
-            size_db_min_file = src_root / 'min_sized_file2.bin'
-            size_db_min_file.write_bytes(b'X' * FileSizeDatabase.MIN_SIZE)
+            (src_root / 'min_sized_file2.bin').write_bytes(b'X' * FileSizeDatabase.MIN_SIZE)
 
             # Larger then CHUNK_SIZE file will be handled differently:
-            large_file = src_root / 'large_file.bin'
-            large_file.write_bytes(b'Y' * (CHUNK_SIZE + 1))
+            (src_root / 'large_file1.bin').write_bytes(b'Y' * (CHUNK_SIZE + 1))
 
             excluded_dir = src_root / '.cache'
             excluded_dir.mkdir()
@@ -176,7 +173,7 @@ class BackupTreeTestCase(
                     backup_root=backup_root,
                     excludes=('.cache',),
                     log_manager=LoggingManager(
-                        console_level=DEFAULT_CONSOLE_LOG_LEVEL,
+                        console_level='info',
                         file_level=DEFAULT_LOG_FILE_LEVEL,
                     ),
                 )
@@ -208,6 +205,7 @@ class BackupTreeTestCase(
                     copied_small_size=50,
                     error_count=0,
                 ),
+                redirected_out.stdout,
             )
 
             # The sources:
@@ -219,7 +217,7 @@ class BackupTreeTestCase(
                         .cache/tempfile.tmp  12:00:00     file            1        38  41d7a2c9
                         file2.txt            12:00:00     hardlink        2        14  8a11514a
                         hardlink2file1       12:00:00     hardlink        2        14  8a11514a
-                        large_file.bin       12:00:00     file            1  67108865  9671eaac
+                        large_file1.bin      12:00:00     file            1  67108865  9671eaac
                         min_sized_file1.bin  12:00:00     file            1      1000  f0d93de4
                         min_sized_file2.bin  12:00:00     file            1      1000  f0d93de4
                         subdir/file.txt      12:00:00     file            1        22  c0167e63
@@ -234,10 +232,10 @@ class BackupTreeTestCase(
                     root=backup_dir,
                     expected_overview="""
                         path                 birthtime    type        nlink      size  CRC32
-                        SHA256SUMS           <mock>       file            1       410  45c07cf7
+                        SHA256SUMS           <mock>       file            1       411  b02da51e
                         file2.txt            12:00:00     file            1        14  8a11514a
                         hardlink2file1       12:00:00     file            1        14  8a11514a
-                        large_file.bin       12:00:00     file            1  67108865  9671eaac
+                        large_file1.bin      12:00:00     file            1  67108865  9671eaac
                         min_sized_file1.bin  12:00:00     hardlink        2      1000  f0d93de4
                         min_sized_file2.bin  12:00:00     hardlink        2      1000  f0d93de4
                         subdir/SHA256SUMS    <mock>       file            1        75  1af5ecc7
@@ -252,12 +250,31 @@ class BackupTreeTestCase(
                     backup_root=backup_root,
                     expected="""
                         bb/c4/bbc4de2ca238d1… -> source/2026-01-01-123456/min_sized_file1.bin
-                        e6/37/e6374ac11d9049… -> source/2026-01-01-123456/large_file.bin
+                        e6/37/e6374ac11d9049… -> source/2026-01-01-123456/large_file1.bin
                     """,
                 )
 
             #######################################################################################
-            # Just backup again:
+            # Backup again with new added files:
+
+            # New small file with different size and different content:
+            (src_root / 'small_file_newA.txt').write_text('A new file')
+
+            # Add small file that size exists, but has different content:
+            (src_root / 'small_file_newB.txt').write_text('This is file 2')
+
+            # Bigger file with new size and new content:
+            (src_root / 'min_sized_file_newA.bin').write_bytes(b'A' * (FileSizeDatabase.MIN_SIZE + 1))
+
+            # Bigger file with existing size, but different content:
+            (src_root / 'min_sized_file_newB.bin').write_bytes(b'B' * FileSizeDatabase.MIN_SIZE)
+
+            # Add a larger then CHUNK_SIZE file with same existing size, but different content:
+            (src_root / 'large_file2.bin').write_bytes(b'Y' * (CHUNK_SIZE + 1))
+
+            # FIXME: freezegun doesn't handle this, see: https://github.com/spulec/freezegun/issues/392
+            # Set modification times to a fixed time for easier testing:
+            set_file_times(src_root, dt=parse_dt('2026-01-01T12:00:00+0000'))
 
             with (
                 patch('PyHardLinkBackup.backup.iter_scandir_files', SortedIterScandirFiles),
@@ -269,7 +286,7 @@ class BackupTreeTestCase(
                     backup_root=backup_root,
                     excludes=('.cache',),
                     log_manager=LoggingManager(
-                        console_level=DEFAULT_CONSOLE_LOG_LEVEL,
+                        console_level='info',
                         file_level=DEFAULT_LOG_FILE_LEVEL,
                     ),
                 )
@@ -280,23 +297,6 @@ class BackupTreeTestCase(
                 str(Path(backup_dir).relative_to(temp_path)),
                 'backup/source/2026-01-02-123456',
             )
-            self.assertEqual(
-                result,
-                BackupResult(
-                    backup_dir=backup_dir,
-                    log_file=result.log_file,
-                    backup_count=7,
-                    backup_size=67110929,
-                    symlink_files=1,
-                    hardlinked_files=3,  # <<< More hardlinks this time!
-                    hardlinked_size=67110865,
-                    copied_files=3,
-                    copied_size=50,
-                    copied_small_files=3,
-                    copied_small_size=50,
-                    error_count=0,
-                ),
-            )
             # The second backup:
             # * /.cache/ -> excluded
             # * min_sized_file1.bin and min_sized_file2.bin -> hardlinked
@@ -304,26 +304,51 @@ class BackupTreeTestCase(
                 assert_fs_tree_overview(
                     root=backup_dir,
                     expected_overview="""
-                        path                 birthtime    type        nlink      size  CRC32
-                        SHA256SUMS           <mock>       file            1       410  45c07cf7
-                        file2.txt            12:00:00     file            1        14  8a11514a
-                        hardlink2file1       12:00:00     file            1        14  8a11514a
-                        large_file.bin       12:00:00     hardlink        2  67108865  9671eaac
-                        min_sized_file1.bin  12:00:00     hardlink        4      1000  f0d93de4
-                        min_sized_file2.bin  12:00:00     hardlink        4      1000  f0d93de4
-                        subdir/SHA256SUMS    <mock>       file            1        75  1af5ecc7
-                        subdir/file.txt      12:00:00     file            1        22  c0167e63
-                        symlink2file1        12:00:00     symlink         2        14  8a11514a
+                        path                     birthtime    type        nlink      size  CRC32
+                        SHA256SUMS               <mock>       file            1       845  6596856a
+                        file2.txt                12:00:00     file            1        14  8a11514a
+                        hardlink2file1           12:00:00     file            1        14  8a11514a
+                        large_file1.bin          12:00:00     hardlink        3  67108865  9671eaac
+                        large_file2.bin          12:00:00     hardlink        3  67108865  9671eaac
+                        min_sized_file1.bin      12:00:00     hardlink        4      1000  f0d93de4
+                        min_sized_file2.bin      12:00:00     hardlink        4      1000  f0d93de4
+                        min_sized_file_newA.bin  12:00:00     file            1      1001  a48f0e33
+                        min_sized_file_newB.bin  12:00:00     file            1      1000  7d9c564d
+                        small_file_newA.txt      12:00:00     file            1        10  76d1acf1
+                        small_file_newB.txt      12:00:00     file            1        14  131800f0
+                        subdir/SHA256SUMS        <mock>       file            1        75  1af5ecc7
+                        subdir/file.txt          12:00:00     file            1        22  c0167e63
+                        symlink2file1            12:00:00     symlink         2        14  8a11514a
                     """,
                 )
+            self.assertEqual(
+                result,
+                BackupResult(
+                    backup_dir=backup_dir,
+                    log_file=result.log_file,
+                    backup_count=12,
+                    backup_size=134221819,
+                    symlink_files=1,
+                    hardlinked_files=4,
+                    hardlinked_size=134219730,
+                    copied_files=7,
+                    copied_size=2075,
+                    copied_small_files=5,
+                    copied_small_size=74,
+                    error_count=0,
+                ),
+                redirected_out.stdout,
+            )
 
             # The FileHashDatabase remains the same:
             with self.assertLogs('PyHardLinkBackup', level=logging.DEBUG):
                 assert_hash_db_info(
                     backup_root=backup_root,
                     expected="""
+                        23/d2/23d2ce40d26211… -> source/2026-01-02-123456/min_sized_file_newA.bin
+                        9a/56/9a567077114134… -> source/2026-01-02-123456/min_sized_file_newB.bin
                         bb/c4/bbc4de2ca238d1… -> source/2026-01-01-123456/min_sized_file1.bin
-                        e6/37/e6374ac11d9049… -> source/2026-01-01-123456/large_file.bin
+                        e6/37/e6374ac11d9049… -> source/2026-01-01-123456/large_file1.bin
                     """,
                 )
 
@@ -365,16 +390,21 @@ class BackupTreeTestCase(
                 assert_fs_tree_overview(
                     root=backup_dir,
                     expected_overview="""
-                        path                 birthtime    type        nlink      size  CRC32
-                        SHA256SUMS           <mock>       file            1       410  45c07cf7
-                        file2.txt            12:00:00     file            1        14  8a11514a
-                        hardlink2file1       12:00:00     file            1        14  8a11514a
-                        large_file.bin       12:00:00     hardlink        3  67108865  9671eaac
-                        min_sized_file1.bin  12:00:00     hardlink        2      1000  f0d93de4
-                        min_sized_file2.bin  12:00:00     hardlink        2      1000  f0d93de4
-                        subdir/SHA256SUMS    <mock>       file            1        75  1af5ecc7
-                        subdir/file.txt      12:00:00     file            1        22  c0167e63
-                        symlink2file1        12:00:00     symlink         2        14  8a11514a
+                        path                     birthtime    type        nlink      size  CRC32
+                        SHA256SUMS               <mock>       file            1       845  6596856a
+                        file2.txt                12:00:00     file            1        14  8a11514a
+                        hardlink2file1           12:00:00     file            1        14  8a11514a
+                        large_file1.bin          12:00:00     hardlink        5  67108865  9671eaac
+                        large_file2.bin          12:00:00     hardlink        5  67108865  9671eaac
+                        min_sized_file1.bin      12:00:00     hardlink        2      1000  f0d93de4
+                        min_sized_file2.bin      12:00:00     hardlink        2      1000  f0d93de4
+                        min_sized_file_newA.bin  12:00:00     hardlink        2      1001  a48f0e33
+                        min_sized_file_newB.bin  12:00:00     hardlink        2      1000  7d9c564d
+                        small_file_newA.txt      12:00:00     file            1        10  76d1acf1
+                        small_file_newB.txt      12:00:00     file            1        14  131800f0
+                        subdir/SHA256SUMS        <mock>       file            1        75  1af5ecc7
+                        subdir/file.txt          12:00:00     file            1        22  c0167e63
+                        symlink2file1            12:00:00     symlink         2        14  8a11514a
                     """,
                 )
 
@@ -383,16 +413,16 @@ class BackupTreeTestCase(
                 BackupResult(
                     backup_dir=backup_dir,
                     log_file=result.log_file,
-                    backup_count=7,
-                    backup_size=67110929,
+                    backup_count=12,
+                    backup_size=134221819,
                     symlink_files=1,
-                    hardlinked_files=2,  # <<< Less hardlinks this time, because of missing link source!
-                    hardlinked_size=67109865,
-                    copied_files=4,
-                    copied_size=1050,
-                    copied_small_files=3,
-                    copied_small_size=50,
-                    error_count=0,
+                    hardlinked_files=5,
+                    hardlinked_size=134220731,
+                    copied_files=6,
+                    copied_size=1074,
+                    copied_small_files=5,
+                    copied_small_size=74,
+                    error_count=0
                 ),
             )
 
@@ -402,8 +432,10 @@ class BackupTreeTestCase(
                 assert_hash_db_info(
                     backup_root=backup_root,
                     expected="""
+                        23/d2/23d2ce40d26211… -> source/2026-01-02-123456/min_sized_file_newA.bin
+                        9a/56/9a567077114134… -> source/2026-01-02-123456/min_sized_file_newB.bin
                         bb/c4/bbc4de2ca238d1… -> source/2026-01-03-123456/min_sized_file1.bin
-                        e6/37/e6374ac11d9049… -> source/2026-01-01-123456/large_file.bin
+                        e6/37/e6374ac11d9049… -> source/2026-01-01-123456/large_file1.bin
                     """,
                 )
 

pyhardlinkbackup-1.5.0/PyHardLinkBackup/tests/test_compare_backup.py

@@ -0,0 +1,86 @@
+import shutil
+import tempfile
+from pathlib import Path
+from unittest import TestCase
+
+from bx_py_utils.test_utils.redirect import RedirectOut
+from cli_base.cli_tools.test_utils.base_testcases import OutputMustCapturedTestCaseMixin
+
+from PyHardLinkBackup.compare_backup import CompareResult, LoggingManager, compare_tree
+from PyHardLinkBackup.logging_setup import DEFAULT_LOG_FILE_LEVEL
+from PyHardLinkBackup.utilities.file_hash_database import FileHashDatabase
+from PyHardLinkBackup.utilities.file_size_database import FileSizeDatabase
+from PyHardLinkBackup.utilities.filesystem import hash_file
+
+
+class CompareBackupTestCase(OutputMustCapturedTestCaseMixin, TestCase):
+    def test_happy_path(self):
+        with tempfile.TemporaryDirectory() as src_dir, tempfile.TemporaryDirectory() as backup_dir:
+            src_root = Path(src_dir).resolve()
+            backup_root = Path(backup_dir).resolve()
+
+            # Setup backup structure
+            phlb_conf_dir = backup_root / '.phlb'
+            phlb_conf_dir.mkdir()
+
+            compare_main_dir = backup_root / src_root.name
+            compare_main_dir.mkdir()
+
+            timestamp = '2026-01-17-120000'
+            compare_dir = compare_main_dir / timestamp
+            compare_dir.mkdir()
+
+            # Create source files
+            (src_root / 'small_file.txt').write_text('hello world')
+            (src_root / 'large_file_missing.txt').write_bytes(b'X' * FileSizeDatabase.MIN_SIZE)
+            large_file_in_dbs = src_root / 'large_file_in_dbs.txt'
+            large_file_in_dbs.write_bytes(b'Y' * (FileSizeDatabase.MIN_SIZE + 1))
+
+            # Copy files to backup
+            total_size = 0
+            total_file_count = 0
+            for file_path in src_root.iterdir():
+                shutil.copy2(file_path, compare_dir / file_path.name)
+                total_size += file_path.stat().st_size
+                total_file_count += 1
+            self.assertEqual(total_file_count, 3)
+            self.assertEqual(total_size, 2012)
+
+            # Create databases and add values from 'large_file_in_dbs.txt'
+            size_db = FileSizeDatabase(phlb_conf_dir)
+            size_db.add(FileSizeDatabase.MIN_SIZE + 1)
+            hash_db = FileHashDatabase(backup_root, phlb_conf_dir)
+            src_hash = hash_file(large_file_in_dbs)
+            hash_db[src_hash] = compare_dir / 'large_file_in_dbs.txt'
+
+            # Run compare_tree
+            with RedirectOut() as redirected_out:
+                result = compare_tree(
+                    src_root=src_root,
+                    backup_root=backup_root,
+                    excludes=(),
+                    log_manager=LoggingManager(
+                        console_level='info',
+                        file_level=DEFAULT_LOG_FILE_LEVEL,
+                    ),
+                )
+            self.assertEqual(redirected_out.stderr, '')
+            self.assertIn('Compare completed.', redirected_out.stdout)
+            self.assertEqual(
+                result,
+                CompareResult(
+                    compare_dir=compare_dir,
+                    log_file=result.log_file,
+                    total_file_count=total_file_count,
+                    total_size=total_size,
+                    src_file_new_count=0,
+                    file_size_missmatch=0,
+                    file_hash_missmatch=0,
+                    small_file_count=1,
+                    size_db_missing_count=1,
+                    hash_db_missing_count=1,
+                    successful_file_count=total_file_count,
+                    error_count=0,
+                ),
+                redirected_out.stdout,
+            )

{pyhardlinkbackup-1.4.0 → pyhardlinkbackup-1.5.0}/README.md

@@ -65,7 +65,7 @@ complete help for main CLI app:
 
 [comment]: <> (✂✂✂ auto generated main help start ✂✂✂)
 ```
-usage: phlb [-h] {backup,rebuild,version}
+usage: phlb [-h] {backup,compare,rebuild,version}
 
 
 
@@ -75,6 +75,7 @@ usage: phlb [-h] {backup,rebuild,version}
 ╭─ subcommands ────────────────────────────────────────────────────────────────────────────────────────────────────────╮
 │ (required)                                                                                                           │
 │   • backup   Backup the source directory to the destination directory using hard links for deduplication.            │
+│   • compare  Compares a source tree with the last backup and validates all known file hashes.                        │
 │   • rebuild  Rebuild the file hash and size database by scanning all backup files. And also verify SHA256SUMS and/or │
 │              store missing hashes in SHA256SUMS files.                                                               │
 │   • version  Print version and exit                                                                                  │
@@ -216,6 +217,10 @@ Overview of main changes:
 
 [comment]: <> (✂✂✂ auto generated history start ✂✂✂)
 
+* [v1.5.0](https://github.com/jedie/PyHardLinkBackup/compare/v1.4.1...v1.5.0)
+  * 2026-01-17 - NEW: Compare command to verify source tree with last backup
+* [v1.4.1](https://github.com/jedie/PyHardLinkBackup/compare/v1.4.0...v1.4.1)
+  * 2026-01-16 - Bugfix large file handling
 * [v1.4.0](https://github.com/jedie/PyHardLinkBackup/compare/v1.3.0...v1.4.0)
   * 2026-01-16 - Create log file in backup and a summary.txt
   * 2026-01-16 - Run CI tests on macos, too.
@@ -226,6 +231,9 @@ Overview of main changes:
   * 2026-01-15 - Add tests for rebuild
   * 2026-01-15 - Add command to "rebuld" the size and hash filesystem database
   * 2026-01-15 - Add screenshots in the README
+
+<details><summary>Expand older history entries ...</summary>
+
 * [v1.2.0](https://github.com/jedie/PyHardLinkBackup/compare/v1.1.0...v1.2.0)
   * 2026-01-15 - Add error handling: Log exception but continue with the backup
   * 2026-01-15 - Check permission and hadlink support on destination path
@@ -235,9 +243,6 @@ Overview of main changes:
 * [v1.1.0](https://github.com/jedie/PyHardLinkBackup/compare/v1.0.1...v1.1.0)
   * 2026-01-14 - Change backup timestamp directory to old schema: '%Y-%m-%d-%H%M%S'
   * 2026-01-14 - Add "Overview of main changes" to README
-
-<details><summary>Expand older history entries ...</summary>
-
 * [v1.0.1](https://github.com/jedie/PyHardLinkBackup/compare/v1.0.0...v1.0.1)
   * 2026-01-13 - Store SHA256SUMS files in backup directories
 * [v1.0.0](https://github.com/jedie/PyHardLinkBackup/compare/v0.13.0...v1.0.0)