PyHardLinkBackup 1.1.0__tar.gz → 1.3.0__tar.gz

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.3.0}/.pre-commit-config.yaml

@@ -2,6 +2,6 @@
 # See https://pre-commit.com for more information
 repos:
   - repo: https://github.com/jedie/cli-base-utilities
-    rev: v0.26.0
+    rev: v0.27.0
     hooks:
       - id: update-readme-history

pyhardlinkbackup-1.1.0/README.md → pyhardlinkbackup-1.3.0/PKG-INFO

@@ -1,3 +1,18 @@
+Metadata-Version: 2.4
+Name: PyHardLinkBackup
+Version: 1.3.0
+Summary: HardLink/Deduplication Backups with Python
+Project-URL: Documentation, https://github.com/jedie/PyHardLinkBackup
+Project-URL: Source, https://github.com/jedie/PyHardLinkBackup
+Author-email: Jens Diemer <PyHardLinkBackup@jensdiemer.de>
+License: GPL-3.0-or-later
+Requires-Python: >=3.12
+Requires-Dist: bx-py-utils
+Requires-Dist: cli-base-utilities>=0.27.0
+Requires-Dist: rich
+Requires-Dist: tyro
+Description-Content-Type: text/markdown
+
 # PyHardLinkBackup
 
 [![tests](https://github.com/jedie/PyHardLinkBackup/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/jedie/PyHardLinkBackup/actions/workflows/tests.yml)
@@ -10,6 +25,8 @@ HardLink/Deduplication Backups with Python
 
 **WIP:** v1.0.0 is a complete rewrite of PyHardLinkBackup.
 
+It's similar to `rsync --link-dest` but the deduplication is done globally for all backups and all paths.
+
 ## installation
 
 You can use [pipx](https://pipx.pypa.io/stable/installation/) to install and use PyHardLinkBackup, e.g.:
@@ -46,22 +63,36 @@ Backup the source directory to the destination directory using hard links for de
 
 
 
+Running a backup looks like:
+
+![2026-01-15-phlb1.png](https://raw.githubusercontent.com/jedie/jedie.github.io/main/screenshots/PyHardLinkBackup/2026-01-15-phlb1.png "2026-01-15-phlb1.png")
+
+
+
+If it's finished it display a summary:
+
+![2026-01-15-phlb2.png](https://raw.githubusercontent.com/jedie/jedie.github.io/main/screenshots/PyHardLinkBackup/2026-01-15-phlb2.png "2026-01-15-phlb2.png")
+
+
+
 complete help for main CLI app:
 
 [comment]: <> (✂✂✂ auto generated main help start ✂✂✂)
 ```
-usage: phlb [-h] {backup,version}
+usage: phlb [-h] {backup,rebuild,version}
 
 
 
-╭─ options ─────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ -h, --help   show this help message and exit                                                              │
-╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ subcommands ─────────────────────────────────────────────────────────────────────────────────────────────╮
-│ (required)                                                                                                │
-│   • backup   Backup the source directory to the destination directory using hard links for deduplication. │
-│   • version  Print version and exit                                                                       │
-╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ options ────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ -h, --help   show this help message and exit                                                                         │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ subcommands ────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ (required)                                                                                                           │
+│   • backup   Backup the source directory to the destination directory using hard links for deduplication.            │
+│   • 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                                                                                  │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
 ```
 [comment]: <> (✂✂✂ auto generated main help end ✂✂✂)
 
@@ -197,11 +228,26 @@ Overview of main changes:
 
 [comment]: <> (✂✂✂ auto generated history start ✂✂✂)
 
+* [v1.3.0](https://github.com/jedie/PyHardLinkBackup/compare/v1.2.0...v1.3.0)
+  * 2026-01-15 - Verify SHA256SUMS files in "rebuild" command, too.
+  * 2026-01-15 - Code cleanup: use more generic names for and in BackupProgress
+  * 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
+* [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
+  * 2026-01-14 - Enhance progress bars
+  * 2026-01-14 - A a note to rsync --link-dest
+  * 2026-01-14 - Use cli_base.cli_tools.test_utils.base_testcases
 * [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
 * [v1.0.1](https://github.com/jedie/PyHardLinkBackup/compare/v1.0.0...v1.0.1)
   * 2026-01-13 - Store SHA256SUMS files in backup directories
+
+<details><summary>Expand older history entries ...</summary>
+
 * [v1.0.0](https://github.com/jedie/PyHardLinkBackup/compare/v0.13.0...v1.0.0)
   * 2026-01-13 - Change "./cli.py" to "phlb" (because it's the name installed via pipx)
   * 2026-01-13 - Update README
@@ -230,9 +276,6 @@ Overview of main changes:
   * 2020-03-17 - dynamic chunk size
   * 2020-03-17 - ignore *.sha512 by default
   * 2020-03-17 - Update boot_pyhardlinkbackup.sh
-
-<details><summary>Expand older history entries ...</summary>
-
 * [v0.12.3](https://github.com/jedie/PyHardLinkBackup/compare/v0.12.2...v0.12.3)
   * 2020-03-17 - update README.rst
   * 2020-03-17 - don't publish if tests fail

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.3.0}/PyHardLinkBackup/__init__.py

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

pyhardlinkbackup-1.3.0/PyHardLinkBackup/backup.py

@@ -0,0 +1,239 @@
+import dataclasses
+import logging
+import os
+import shutil
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+from rich import print  # noqa
+
+from PyHardLinkBackup.constants import CHUNK_SIZE
+from PyHardLinkBackup.utilities.file_hash_database import FileHashDatabase
+from PyHardLinkBackup.utilities.file_size_database import FileSizeDatabase
+from PyHardLinkBackup.utilities.filesystem import (
+    copy_and_hash,
+    hash_file,
+    humanized_fs_scan,
+    iter_scandir_files,
+    read_and_hash_file,
+    supports_hardlinks,
+)
+from PyHardLinkBackup.utilities.humanize import human_filesize
+from PyHardLinkBackup.utilities.rich_utils import DisplayFileTreeProgress
+from PyHardLinkBackup.utilities.sha256sums import store_hash
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class BackupResult:
+    backup_dir: Path
+    #
+    backup_count: int = 0
+    backup_size: int = 0
+    #
+    symlink_files: int = 0
+    hardlinked_files: int = 0
+    hardlinked_size: int = 0
+    #
+    copied_files: int = 0
+    copied_size: int = 0
+    #
+    copied_small_files: int = 0
+    copied_small_size: int = 0
+    #
+    error_count: int = 0
+
+
+def backup_one_file(
+    *,
+    src_root: Path,
+    entry: os.DirEntry,
+    size_db: FileSizeDatabase,
+    hash_db: FileHashDatabase,
+    backup_dir: Path,
+    backup_result: BackupResult,
+) -> None:
+    backup_result.backup_count += 1
+    src_path = Path(entry.path)
+
+    dst_path = backup_dir / src_path.relative_to(src_root)
+    dst_dir_path = dst_path.parent
+    if not dst_dir_path.exists():
+        dst_dir_path.mkdir(parents=True, exist_ok=False)
+
+    try:
+        size = entry.stat().st_size
+    except FileNotFoundError:
+        # e.g.: Handle broken symlink
+        target = os.readlink(src_path)
+        dst_path.symlink_to(target)
+        backup_result.symlink_files += 1
+        return
+
+    backup_result.backup_size += size
+
+    if entry.name == 'SHA256SUMS':
+        # Skip existing SHA256SUMS files in source tree,
+        # because we create our own SHA256SUMS files.
+        logger.debug('Skip existing SHA256SUMS file: %s', src_path)
+        return
+
+    if entry.is_symlink():
+        logger.debug('Copy symlink: %s to %s', src_path, dst_path)
+        target = os.readlink(src_path)
+        dst_path.symlink_to(target)
+        backup_result.symlink_files += 1
+        return
+
+    # Process regular files
+    assert entry.is_file(follow_symlinks=False), f'Unexpected non-file: {src_path}'
+
+    # Deduplication logic
+
+    if size < size_db.MIN_SIZE:
+        # Small file -> always copy without deduplication
+        logger.info('Copy small file: %s to %s', src_path, dst_path)
+        file_hash = copy_and_hash(src_path, dst_path)
+        backup_result.copied_files += 1
+        backup_result.copied_size += size
+        backup_result.copied_small_files += 1
+        backup_result.copied_small_size += size
+        store_hash(dst_path, file_hash)
+        return
+
+    if size in size_db:
+        logger.debug('File with size %iBytes found before -> hash: %s', size, src_path)
+
+        if size <= CHUNK_SIZE:
+            # File can be read complete into memory
+            logger.debug('File size %iBytes <= CHUNK_SIZE (%iBytes) -> read complete into memory', size, CHUNK_SIZE)
+            file_content, file_hash = read_and_hash_file(src_path)
+            if existing_path := hash_db.get(file_hash):
+                logger.info('Hardlink duplicate file: %s to %s', dst_path, existing_path)
+                os.link(existing_path, dst_path)
+                backup_result.hardlinked_files += 1
+                backup_result.hardlinked_size += size
+            else:
+                logger.info('Store unique file: %s to %s', src_path, dst_path)
+                dst_path.write_bytes(file_content)
+                hash_db[file_hash] = dst_path
+                backup_result.copied_files += 1
+                backup_result.copied_size += size
+
+        else:
+            # Large file
+            file_hash = hash_file(src_path)  # Calculate hash without copying
+
+            if existing_path := hash_db.get(file_hash):
+                logger.info('Hardlink duplicate file: %s to %s', dst_path, existing_path)
+                os.link(existing_path, dst_path)
+                backup_result.hardlinked_files += 1
+                backup_result.hardlinked_size += size
+            else:
+                logger.info('Copy unique file: %s to %s', 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)
+    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)
+        size_db.add(size)
+        hash_db[file_hash] = dst_path
+        backup_result.copied_files += 1
+        backup_result.copied_size += size
+
+    store_hash(dst_path, file_hash)
+
+
+def backup_tree(*, src_root: Path, backup_root: Path, excludes: set[str]) -> BackupResult:
+    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()
+    if not backup_root.is_dir():
+        print('Error: Backup directory does not exist!')
+        print(f'Please create "{backup_root}" directory first and start again!\n')
+        sys.exit(1)
+
+    if not os.access(backup_root, os.W_OK):
+        print('Error: No write access to backup directory!')
+        print(f'Please check permissions for backup directory: "{backup_root}"\n')
+        sys.exit(1)
+
+    if not supports_hardlinks(backup_root):
+        print('Error: Filesystem for backup directory does not support hardlinks!')
+        print(f'Please check backup directory: "{backup_root}"\n')
+        sys.exit(1)
+
+    # Step 1: Scan source directory:
+    src_file_count, src_total_size = humanized_fs_scan(src_root, excludes)
+
+    phlb_conf_dir = backup_root / '.phlb'
+    phlb_conf_dir.mkdir(parents=False, exist_ok=True)
+
+    backup_dir = backup_root / src_root.name / datetime.now().strftime('%Y-%m-%d-%H%M%S')
+    logger.info('Backup %s to %s', src_root, backup_dir)
+    backup_dir.mkdir(parents=True, exist_ok=False)
+
+    print(f'\nBackup to {backup_dir}...\n')
+
+    with DisplayFileTreeProgress(src_file_count, src_total_size) as progress:
+        # "Databases" for deduplication
+        size_db = FileSizeDatabase(phlb_conf_dir)
+        hash_db = FileHashDatabase(backup_root, phlb_conf_dir)
+
+        backup_result = BackupResult(backup_dir=backup_dir)
+
+        next_update = 0
+        for entry in iter_scandir_files(src_root, excludes=excludes):
+            try:
+                backup_one_file(
+                    src_root=src_root,
+                    entry=entry,
+                    size_db=size_db,
+                    hash_db=hash_db,
+                    backup_dir=backup_dir,
+                    backup_result=backup_result,
+                )
+            except Exception as err:
+                logger.exception(f'Backup {entry.path} {err.__class__.__name__}: {err}')
+                backup_result.error_count += 1
+            else:
+                now = time.monotonic()
+                if now >= next_update:
+                    progress.update(
+                        completed_file_count=backup_result.backup_count, completed_size=backup_result.backup_size
+                    )
+                    next_update = now + 0.5
+
+        # Finalize progress indicator values:
+        progress.update(completed_file_count=backup_result.backup_count, completed_size=backup_result.backup_size)
+
+    print(f'\nBackup complete: {backup_dir} (total size {human_filesize(backup_result.backup_size)})\n')
+    print(f'  Total files processed: {backup_result.backup_count}')
+    print(f'   * Symlinked files: {backup_result.symlink_files}')
+    print(
+        f'   * Hardlinked files: {backup_result.hardlinked_files}'
+        f' (saved {human_filesize(backup_result.hardlinked_size)})'
+    )
+    print(f'   * Copied files: {backup_result.copied_files} (total {human_filesize(backup_result.copied_size)})')
+    print(
+        f'     of which small (<{size_db.MIN_SIZE} Bytes)'
+        f' files: {backup_result.copied_small_files}'
+        f' (total {human_filesize(backup_result.copied_small_size)})'
+    )
+    if backup_result.error_count > 0:
+        print(f'  Errors during backup: {backup_result.error_count} (see log for details)')
+    print()
+
+    return backup_result

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.3.0}/PyHardLinkBackup/cli_app/phlb.py

@@ -7,6 +7,7 @@ from cli_base.cli_tools.verbosity import setup_logging
 from cli_base.tyro_commands import TyroVerbosityArgType
 from rich import print  # noqa
 
+from PyHardLinkBackup import rebuild_databases
 from PyHardLinkBackup.backup import backup_tree
 from PyHardLinkBackup.cli_app import app
 
@@ -48,3 +49,23 @@ def backup(
         backup_root=dst,
         excludes=set(excludes),
     )
+
+
+@app.command
+def rebuild(
+    backup_root: Annotated[
+        Path,
+        tyro.conf.arg(
+            metavar='backup-directory',
+            help='Root directory of the the backups.',
+        ),
+    ],
+    /,
+    verbosity: TyroVerbosityArgType = 2,
+) -> None:
+    """
+    Rebuild the file hash and size database by scanning all backup files. And also verify SHA256SUMS
+    and/or store missing hashes in SHA256SUMS files.
+    """
+    setup_logging(verbosity=verbosity)
+    rebuild_databases.rebuild(backup_root=backup_root)

pyhardlinkbackup-1.3.0/PyHardLinkBackup/rebuild_databases.py

@@ -0,0 +1,147 @@
+import dataclasses
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+
+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 human_filesize
+from PyHardLinkBackup.utilities.rich_utils import DisplayFileTreeProgress
+from PyHardLinkBackup.utilities.sha256sums import check_sha256sums, store_hash
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class RebuildResult:
+    process_count: int = 0
+    process_size: int = 0
+    #
+    added_size_count: int = 0
+    added_hash_count: int = 0
+    #
+    error_count: int = 0
+    #
+    hash_verified_count: int = 0
+    hash_mismatch_count: int = 0
+    hash_not_found_count: int = 0
+
+
+def rebuild_one_file(
+    *,
+    entry: os.DirEntry,
+    size_db: FileSizeDatabase,
+    hash_db: FileHashDatabase,
+    rebuild_result: RebuildResult,
+):
+    rebuild_result.process_count += 1
+
+    if entry.name == 'SHA256SUMS':
+        # Skip existing SHA256SUMS files
+        return
+
+    size = entry.stat().st_size
+    rebuild_result.process_size += size
+
+    if size < size_db.MIN_SIZE:
+        # Small files will never deduplicate, skip them
+        return
+
+    file_path = Path(entry.path)
+    file_hash = hash_file(file_path)
+
+    if size not in size_db:
+        size_db.add(size)
+        rebuild_result.added_size_count += 1
+
+    if file_hash not in hash_db:
+        hash_db[file_hash] = file_path
+        rebuild_result.added_hash_count += 1
+
+    # We have calculated the current hash of the file,
+    # Let's check if we can verify it, too:
+    file_path = Path(entry.path)
+    compare_result = check_sha256sums(
+        file_path=file_path,
+        file_hash=file_hash,
+    )
+    if compare_result is True:
+        rebuild_result.hash_verified_count += 1
+    elif compare_result is False:
+        rebuild_result.hash_mismatch_count += 1
+    elif compare_result is None:
+        rebuild_result.hash_not_found_count += 1
+        store_hash(
+            file_path=file_path,
+            file_hash=file_hash,
+        )
+
+
+def rebuild(backup_root: Path) -> RebuildResult:
+    backup_root = backup_root.resolve()
+    if not backup_root.is_dir():
+        print(f'Error: Backup directory "{backup_root}" does not exist!')
+        sys.exit(1)
+
+    phlb_conf_dir = backup_root / '.phlb'
+    if not phlb_conf_dir.is_dir():
+        print(
+            f'Error: Backup directory "{backup_root}" seems to be wrong:'
+            f' Our hidden ".phlb" configuration directory is missing!'
+        )
+        sys.exit(1)
+
+    file_count, total_size = humanized_fs_scan(backup_root, excludes={'.phlb'})
+
+    with DisplayFileTreeProgress(file_count, total_size) as progress:
+        # "Databases" for deduplication
+        size_db = FileSizeDatabase(phlb_conf_dir)
+        hash_db = FileHashDatabase(backup_root, phlb_conf_dir)
+
+        rebuild_result = RebuildResult()
+
+        next_update = 0
+        for entry in iter_scandir_files(backup_root, excludes={'.phlb'}):
+            try:
+                rebuild_one_file(
+                    entry=entry,
+                    size_db=size_db,
+                    hash_db=hash_db,
+                    rebuild_result=rebuild_result,
+                )
+            except Exception as err:
+                logger.exception(f'Backup {entry.path} {err.__class__.__name__}: {err}')
+                rebuild_result.error_count += 1
+            else:
+                now = time.monotonic()
+                if now >= next_update:
+                    progress.update(
+                        completed_file_count=rebuild_result.process_count, completed_size=rebuild_result.process_size
+                    )
+                    next_update = now + 0.5
+
+        # Finalize progress indicator values:
+        progress.update(completed_file_count=rebuild_result.process_count, completed_size=rebuild_result.process_size)
+
+    print(f'\nRebuild "{backup_root}" completed:')
+    print(f'  Total files processed: {rebuild_result.process_count}')
+    print(f'  Total size processed: {human_filesize(rebuild_result.process_size)}')
+
+    print(f'  Added file size information entries: {rebuild_result.added_size_count}')
+    print(f'  Added file hash entries: {rebuild_result.added_hash_count}')
+
+    if rebuild_result.error_count > 0:
+        print(f'  Errors during rebuild: {rebuild_result.error_count} (see log for details)')
+
+    print('\nSHA256SUMS verification results:')
+    print(f'  Successfully verified files: {rebuild_result.hash_verified_count}')
+    print(f'  File hash mismatches: {rebuild_result.hash_mismatch_count}')
+    print(f'  File hashes not found, newly stored: {rebuild_result.hash_not_found_count}')
+
+    print()
+
+    return rebuild_result

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.3.0}/PyHardLinkBackup/tests/test_backup.py

@@ -13,14 +13,14 @@ from bx_py_utils.test_utils.assertion import assert_text_equal
 from bx_py_utils.test_utils.datetime import parse_dt
 from bx_py_utils.test_utils.log_utils import NoLogs
 from bx_py_utils.test_utils.redirect import RedirectOut
+from cli_base.cli_tools.test_utils.base_testcases import BaseTestCase
 from freezegun import freeze_time
 from tabulate import tabulate
 
 from PyHardLinkBackup.backup import BackupResult, backup_tree
 from PyHardLinkBackup.constants import CHUNK_SIZE
 from PyHardLinkBackup.utilities.file_size_database import FileSizeDatabase
-from PyHardLinkBackup.utilities.filesystem import iter_scandir_files
-from PyHardLinkBackup.utilities.tests.base_testcases import BaseTestCase
+from PyHardLinkBackup.utilities.filesystem import copy_and_hash, iter_scandir_files
 from PyHardLinkBackup.utilities.tests.test_file_hash_database import assert_hash_db_info
 
 
@@ -184,6 +184,7 @@ class BackupTreeTestCase(BaseTestCase):
                     copied_size=67109915,
                     copied_small_files=3,
                     copied_small_size=50,
+                    error_count=0,
                 ),
             )
 
@@ -267,6 +268,7 @@ class BackupTreeTestCase(BaseTestCase):
                     copied_size=50,
                     copied_small_files=3,
                     copied_small_size=50,
+                    error_count=0,
                 ),
             )
             # The second backup:
@@ -360,6 +362,7 @@ class BackupTreeTestCase(BaseTestCase):
                     copied_size=1050,
                     copied_small_files=3,
                     copied_small_size=50,
+                    error_count=0,
                 ),
             )
 
@@ -454,6 +457,7 @@ class BackupTreeTestCase(BaseTestCase):
                     copied_size=31,
                     copied_small_files=1,
                     copied_small_size=31,
+                    error_count=0,
                 ),
             )
 
@@ -474,3 +478,65 @@ class BackupTreeTestCase(BaseTestCase):
             Symlinks are not stored in our FileHashDatabase, because they are not considered for hardlinking."""
             with self.assertLogs('PyHardLinkBackup', level=logging.DEBUG):
                 assert_hash_db_info(backup_root=backup_root, expected='')
+
+    def test_error_handling(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            src_root = temp_path / 'source'
+            backup_root = temp_path / 'backup'
+
+            src_root.mkdir()
+            backup_root.mkdir()
+
+            (src_root / 'file1.txt').write_text('File 1')
+            (src_root / 'file2.txt').write_text('File 2')
+            (src_root / 'file3.txt').write_text('File 3')
+
+            # Set modification times to a fixed time for easier testing:
+            set_file_times(src_root, dt=parse_dt('2026-01-01T12:00:00+0000'))
+
+            def mocked_copy_and_hash(src: Path, dst: Path):
+                if src.name == 'file2.txt':
+                    raise PermissionError('Bam!')
+                else:
+                    return copy_and_hash(src, dst)
+
+            with (
+                self.assertLogs(level=logging.ERROR) as logs,
+                patch('PyHardLinkBackup.backup.iter_scandir_files', SortedIterScandirFiles),
+                patch('PyHardLinkBackup.backup.copy_and_hash', mocked_copy_and_hash),
+                freeze_time('2026-01-01T12:34:56Z', auto_tick_seconds=0),
+                RedirectOut() as redirected_out,
+            ):
+                result = backup_tree(
+                    src_root=src_root,
+                    backup_root=backup_root,
+                    excludes={'.cache'},
+                )
+            self.assertEqual(redirected_out.stderr, '')
+            self.assertIn('Backup complete', redirected_out.stdout)
+            self.assertIn('Errors during backup:', redirected_out.stdout)
+
+            logs = ''.join(logs.output)
+            self.assertIn(
+                f'ERROR:PyHardLinkBackup.backup:Backup {src_root / "file2.txt"} PermissionError: Bam!\n',
+                logs,
+            )
+            self.assertIn('\nTraceback (most recent call last):\n', logs)
+            self.assertEqual(
+                result,
+                BackupResult(
+                    backup_dir=result.backup_dir,
+                    backup_count=3,
+                    backup_size=18,
+                    symlink_files=0,
+                    hardlinked_files=0,
+                    hardlinked_size=0,
+                    copied_files=2,
+                    copied_size=12,
+                    copied_small_files=2,
+                    copied_small_size=12,
+                    error_count=1,
+                ),
+            )

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.3.0}/PyHardLinkBackup/tests/test_doc_write.py

@@ -19,7 +19,8 @@ class DocuWriteApiTestCase(TestCase):
         """
         assert_is_file(PACKAGE_ROOT / 'pyproject.toml')
 
-        info: GeneratedInfo = generate(base_path=PACKAGE_ROOT)
+        with self.assertLogs():
+            info: GeneratedInfo = generate(base_path=PACKAGE_ROOT)
         self.assertGreaterEqual(len(info.paths), 1)
         self.assertEqual(info.update_count, 0, 'No files should be updated, commit the changes')
         self.assertEqual(info.remove_count, 0, 'No files should be removed, commit the changes')

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.3.0}/PyHardLinkBackup/tests/test_readme_history.py

@@ -5,4 +5,5 @@ from cli_base.cli_tools.git_history import update_readme_history
 
 class ReadmeHistoryTestCase(TestCase):
     def test_readme_history(self):
-        update_readme_history(raise_update_error=True)
+        with self.assertLogs():
+            update_readme_history(raise_update_error=True)