PyHardLinkBackup 1.1.0__tar.gz → 1.2.0__tar.gz

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.2.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 → pyhardlinkbackup-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyHardLinkBackup
-Version: 1.1.0
+Version: 1.2.0
 Summary: HardLink/Deduplication Backups with Python
 Project-URL: Documentation, https://github.com/jedie/PyHardLinkBackup
 Project-URL: Source, https://github.com/jedie/PyHardLinkBackup
@@ -8,7 +8,7 @@ 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
+Requires-Dist: cli-base-utilities>=0.27.0
 Requires-Dist: rich
 Requires-Dist: tyro
 Description-Content-Type: text/markdown
@@ -25,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.:
@@ -212,6 +214,12 @@ Overview of main changes:
 
 [comment]: <> (✂✂✂ auto generated history start ✂✂✂)
 
+* [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
@@ -227,6 +235,9 @@ Overview of main changes:
   * 2026-01-13 - Add DocWrite, handle broken symlinks, keep file meta, handle missing hardlink sources
   * 2026-01-12 - First working iteration with rich progess bar
   * 2026-01-08 - Rewrite everything
+
+<details><summary>Expand older history entries ...</summary>
+
 * [v0.13.0](https://github.com/jedie/PyHardLinkBackup/compare/v0.12.3...v0.13.0)
   * 2020-03-18 - release v0.13.0
   * 2020-03-17 - deactivate pypy tests in travis, because of SQLite errors, like:
@@ -245,9 +256,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.2.0}/PyHardLinkBackup/__init__.py

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

pyhardlinkbackup-1.2.0/PyHardLinkBackup/backup.py

@@ -0,0 +1,252 @@
+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 BackupProgress
+
+
+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 store_hash(file_path: Path, file_hash: str):
+    """DocWrite: README.md ## SHA256SUMS
+    A `SHA256SUMS` file is stored in each backup directory containing the SHA256 hashes of all files in that directory.
+    It's the same format as e.g.: `sha256sum * > SHA256SUMS` command produces.
+    So it's possible to verify the integrity of the backup files later.
+    e.g.:
+    ```bash
+    cd .../your/backup/foobar/20240101_120000/
+    sha256sum -c SHA256SUMS
+    ```
+    """
+    hash_file_path = file_path.parent / 'SHA256SUMS'
+    with hash_file_path.open('a') as f:
+        f.write(f'{file_hash}  {file_path.name}\n')
+
+
+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 BackupProgress(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(backup_count=backup_result.backup_count, backup_size=backup_result.backup_size)
+                    next_update = now + 0.5
+
+        # Finalize progress indicator values:
+        progress.update(backup_count=backup_result.backup_count, backup_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.2.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.2.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.2.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)

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.2.0}/PyHardLinkBackup/utilities/filesystem.py

@@ -6,6 +6,7 @@ import time
 from pathlib import Path
 from typing import Iterable
 
+from bx_py_utils.path import assert_is_dir
 from rich.progress import (
     Progress,
     SpinnerColumn,
@@ -80,8 +81,10 @@ def humanized_fs_scan(path: Path, excludes: set[str]) -> tuple[int, int]:
         '{task.description}',
         SpinnerColumn('simpleDots'),
         TextColumn('[green]{task.fields[file_count]} Files'),
+        '|',
         HumanFileSizeColumn(field_name='total_size'),
-        TextColumn('| [cyan]{task.fields[files_per_sec]} Files/sec'),
+        '|',
+        TextColumn('[cyan]{task.fields[files_per_sec]} Files/sec'),
     )
 
     file_count = 0
@@ -131,3 +134,25 @@ def humanized_fs_scan(path: Path, excludes: set[str]) -> tuple[int, int]:
         )
 
     return file_count, total_size
+
+
+def supports_hardlinks(directory: Path) -> bool:
+    logger.debug('Checking hardlink support in %s', directory)
+    assert_is_dir(directory)
+    test_src_file = directory / '.phlb_test'
+    test_dst_file = directory / '.phlb_test_link'
+    hardlinks_supported = False
+    try:
+        test_src_file.write_text('test')
+        os.link(test_src_file, test_dst_file)
+        assert test_dst_file.read_text() == 'test'
+        hardlinks_supported = True
+    except OSError as err:
+        # e.g.: FAT/exFAT filesystems ;)
+        logger.exception('Hardlink test failed in %s: %s', directory, err)
+    finally:
+        test_src_file.unlink(missing_ok=True)
+        test_dst_file.unlink(missing_ok=True)
+
+    logger.info('Hardlink support in %s: %s', directory, hardlinks_supported)
+    return hardlinks_supported

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.2.0}/PyHardLinkBackup/utilities/rich_utils.py

@@ -29,13 +29,14 @@ class HumanFileSizeColumn(ProgressColumn):
                 file_size = task.fields[self.field_name]
             except KeyError:
                 raise KeyError(f'Field {self.field_name=} not found in: {task.fields.keys()=}') from None
-        return Text(f'| {human_filesize(file_size)}')
+        return Text(human_filesize(file_size))
 
 
 class BackupProgress:
     def __init__(self, src_file_count: int, src_total_size: int):
+        percentage_format = '[progress.percentage]{task.percentage:>3.1f}%'
         self.overall_progress = Progress(
-            TaskProgressColumn(),
+            TaskProgressColumn(text_format=percentage_format),
             BarColumn(bar_width=50),
             TextColumn('Elapsed:'),
             TimeElapsedColumn(),
@@ -45,15 +46,15 @@ class BackupProgress:
         self.overall_progress_task_id = self.overall_progress.add_task(description='', total=100)
 
         self.file_count_progress = Progress(
-            TaskProgressColumn(),
+            TaskProgressColumn(text_format=percentage_format),
             BarColumn(bar_width=50),
-            TextColumn('{task.completed} Files'),
+            TextColumn('{task.completed}/{task.total} Files'),
         )
         self.file_count_progress_task_id = self.file_count_progress.add_task(description='', total=src_file_count)
         self.file_count_progress_task = self.file_count_progress.tasks[0]
 
         self.file_size_progress = Progress(
-            TaskProgressColumn(),
+            TaskProgressColumn(text_format=percentage_format),
             BarColumn(bar_width=50),
             HumanFileSizeColumn(),
             '|',

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.2.0}/PyHardLinkBackup/utilities/tests/test_file_hash_database.py

@@ -6,10 +6,10 @@ from pathlib import Path
 from bx_py_utils.path import assert_is_dir
 from bx_py_utils.test_utils.assertion import assert_text_equal
 from bx_py_utils.test_utils.log_utils import NoLogs
+from cli_base.cli_tools.test_utils.base_testcases import BaseTestCase
 
 from PyHardLinkBackup.utilities.file_hash_database import FileHashDatabase, HashAlreadyExistsError
 from PyHardLinkBackup.utilities.filesystem import iter_scandir_files
-from PyHardLinkBackup.utilities.tests.base_testcases import BaseTestCase
 
 
 class TemporaryFileHashDatabase(tempfile.TemporaryDirectory):

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.2.0}/PyHardLinkBackup/utilities/tests/test_file_size_database.py

@@ -4,10 +4,10 @@ from collections.abc import Iterable
 from pathlib import Path
 
 from bx_py_utils.test_utils.log_utils import NoLogs
+from cli_base.cli_tools.test_utils.base_testcases import BaseTestCase
 
 from PyHardLinkBackup.utilities.file_size_database import FileSizeDatabase
 from PyHardLinkBackup.utilities.filesystem import iter_scandir_files
-from PyHardLinkBackup.utilities.tests.base_testcases import BaseTestCase
 
 
 class TemporaryFileSizeDatabase(tempfile.TemporaryDirectory):

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.2.0}/PyHardLinkBackup/utilities/tests/test_filesystem.py

@@ -1,14 +1,25 @@
 import hashlib
+import logging
 import os
 import tempfile
 from pathlib import Path
+from unittest.mock import patch
+
+from cli_base.cli_tools.test_utils.base_testcases import BaseTestCase
 
 from PyHardLinkBackup.constants import HASH_ALGO
-from PyHardLinkBackup.utilities.filesystem import copy_and_hash, hash_file, iter_scandir_files, read_and_hash_file
-from PyHardLinkBackup.utilities.tests.base_testcases import BaseTestCase
+from PyHardLinkBackup.utilities.filesystem import (
+    copy_and_hash,
+    hash_file,
+    iter_scandir_files,
+    read_and_hash_file,
+    supports_hardlinks,
+)
 
 
 class TestHashFile(BaseTestCase):
+    maxDiff = None
+
     def test_hash_file(self):
         self.assertEqual(
             hashlib.new(HASH_ALGO, b'test content').hexdigest(),
@@ -92,3 +103,24 @@ class TestHashFile(BaseTestCase):
         logs = ''.join(logs.output)
         self.assertIn('Scanning directory ', logs)
         self.assertIn('Excluding directory ', logs)
+
+    def test_supports_hardlinks(self):
+        with tempfile.TemporaryDirectory() as temp:
+            with self.assertLogs(level=logging.INFO) as logs:
+                self.assertTrue(supports_hardlinks(Path(temp)))
+            self.assertEqual(
+                ''.join(logs.output),
+                f'INFO:PyHardLinkBackup.utilities.filesystem:Hardlink support in {temp}: True',
+            )
+
+            with (
+                self.assertLogs(level=logging.ERROR) as logs,
+                patch('PyHardLinkBackup.utilities.filesystem.os.link', side_effect=OSError),
+            ):
+                self.assertFalse(supports_hardlinks(Path(temp)))
+            logs = ''.join(logs.output)
+            self.assertIn(f'Hardlink test failed in {temp}:', logs)
+            self.assertIn('OSError', logs)
+
+        with self.assertLogs(level=logging.DEBUG), self.assertRaises(NotADirectoryError):
+            supports_hardlinks(Path('/not/existing/directory'))

{pyhardlinkbackup-1.1.0 → pyhardlinkbackup-1.2.0}/README.md

@@ -10,6 +10,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.:
@@ -197,6 +199,12 @@ Overview of main changes:
 
 [comment]: <> (✂✂✂ auto generated history start ✂✂✂)
 
+* [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
@@ -212,6 +220,9 @@ Overview of main changes:
   * 2026-01-13 - Add DocWrite, handle broken symlinks, keep file meta, handle missing hardlink sources
   * 2026-01-12 - First working iteration with rich progess bar
   * 2026-01-08 - Rewrite everything
+
+<details><summary>Expand older history entries ...</summary>
+
 * [v0.13.0](https://github.com/jedie/PyHardLinkBackup/compare/v0.12.3...v0.13.0)
   * 2020-03-18 - release v0.13.0
   * 2020-03-17 - deactivate pypy tests in travis, because of SQLite errors, like:
@@ -230,9 +241,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.2.0}/pyproject.toml

@@ -9,7 +9,7 @@ authors = [
 ]
 requires-python = ">=3.12"
 dependencies = [
-    "cli-base-utilities",  # https://github.com/jedie/cli-base-utilities
+    "cli-base-utilities>=0.27.0",  # https://github.com/jedie/cli-base-utilities
     "bx_py_utils",  # https://github.com/boxine/bx_py_utils
     "tyro",  # https://github.com/brentyi/tyro
     "rich",  # https://github.com/Textualize/rich