dar-backup 0.6.18__py3-none-any.whl → 0.6.19__py3-none-any.whl

dar_backup/Changelog.md

@@ -1,6 +1,21 @@
 <!-- markdownlint-disable MD024 -->
 # dar-backup Changelog
 
+## v2-beta-0.6.19 - 2025-04-21
+
+Github link: [v2-beta-0.6.19](https://github.com/per2jensen/dar-backup/tree/v2-beta-0.6.19/v2)
+
+### Added
+
+- removed a BackupError in the verify() to reduce noise in logs and let the rest of "compares" run.
+- Added bash and zsh auto completion for a nicer CLI experience.
+  
+  -- See [README for details](https://github.com/per2jensen/dar-backup?tab=readme-ov-file#shell-autocompletion)  
+
+- Improvement to command_runner.run(), more robust decoding
+
+- Manager --add-specific-archive now gives a prompt with a warning if user attempts to add a catalog that breaks chronology. The user is allowed to go forward and ignore the warning or can choose to abort. The program times out after a little while and discards the operation.
+
 ## v2-beta-0.6.18 - 2025-04-05
 
 Github link: [v2-beta-0.6.18](https://github.com/per2jensen/dar-backup/tree/v2-beta-0.6.18/v2)

dar_backup/README.md

@@ -2,12 +2,18 @@
 # Full, differential or incremental backups using 'dar'
 
 [![codecov](https://codecov.io/gh/per2jensen/dar-backup/branch/main/graph/badge.svg)](https://codecov.io/gh/per2jensen/dar-backup)
+[![PyPI monthly downloads](https://img.shields.io/pypi/dm/dar-backup)](https://pypi.org/project/dar-backup/)
+[![Total Downloads](https://img.shields.io/badge/dynamic/json?color=blue&label=Total%20Downloads&query=total&url=https%3A%2F%2Fraw.githubusercontent.com%2Fper2jensen%2Fdar-backup%2Fmain%2Fdownloads.json)](https://pypi.org/project/dar-backup/)
 
 The wonderful 'dar' [Disk Archiver](https://github.com/Edrusb/DAR) is used for
 the heavy lifting, together with the par2 suite in these scripts.
 
 This is the `Python` based **version 2** of `dar-backup`.
 
+## TL;DR
+
+`dar-backup` is a Python-powered CLI for creating and validating full, differential, and incremental backups using dar and par2. Designed for long-term restore integrity, even on user-space filesystems like FUSE.
+
 ## Table of Contents
 
 - [Full, differential or incremental backups using 'dar'](#full-differential-or-incremental-backups-using-dar)
@@ -33,6 +39,7 @@ This is the `Python` based **version 2** of `dar-backup`.
   - [Generate systemd files](#generate-systemd-files)
   - [Service: dar-back --incremental-backup](#service-dar-backup---incremental-backup)
   - [Timer: dar-back --incremental-backup](#timer-dar-backup---incremental-backup)
+  - [Systemd timer note](#systemd-timer-note)
 - [List contents of an archive](#list-contents-of-an-archive)
 - [dar file selection examples](#dar-file-selection-examples)
   - [Select a directory](#select-a-directory)
@@ -58,7 +65,9 @@ This is the `Python` based **version 2** of `dar-backup`.
   - [Skipping cache directories](#skipping-cache-directories)
   - [Progress bar + current directory](#progress-bar-and-current-directory)
 - [Todo](#todo)
+- [Known Limitations / Edge Cases](#known-limitations--edge-cases)
 - [Reference](#reference)
+  - [CLI Tools Overview](#cli-tools-overview)
   - [Test coverage report](#test-coverage)
   - [dar-backup](#dar-backup-options)
   - [manager](#manager-options)
@@ -651,6 +660,10 @@ Persistent=true
 WantedBy=timers.target
 ````
 
+## systemd timer note
+
+📅 OnCalendar syntax is flexible — you can tweak backup schedules easily. Run systemd-analyze calendar to preview timers.
+
 ## list contents of an archive
 
 ```` bash
@@ -941,8 +954,27 @@ The indicators are not shown if dar-backup is run from systemd or if it is used
 - Look into a way to move the .par2 files away from the `dar` slices, to maximize chance of good redundancy.
 - Add option to dar-backup to use the `dar` option `--fsa-scope none`
 
+## Known Limitations / Edge Cases
+
+Does not currently encrypt data (by design — relies on encrypted storage)
+
+One backup definition per file
+
+.par2 files created for each slice (may be moved in future)
+
 ## Reference
 
+### CLI Tools Overview
+
+| Command               | Description                               |
+|-----------------------|-------------------------------------------|
+| `dar-backup`          | Perform full, differential, or incremental backups with verification and restore testing |
+| `manager`             | Maintain and query catalog databases for archives |
+| `cleanup`             | Remove outdated DIFF/INCR archives (and optionally FULLs) |
+| `clean-log`           | Clean up excessive log output from dar command logs |
+| `installer`           | Set up required directories and default config files |
+| `dar-backup-systemd`  | Generate (and optionally install) systemd timers and services for automated backups |
+
 ### test coverage
 
 Running
@@ -951,23 +983,26 @@ Running
 pytest --cov=dar_backup tests/
 ````
 
-results for version 0.6.17 in this report:
+results for a dev version 0.6.19 in this report:
 
 ```` code
 ---------- coverage: platform linux, python 3.12.3-final-0 -----------
-Name                                                              Stmts   Miss  Cover
--------------------------------------------------------------------------------------
-venv/lib/python3.12/site-packages/dar_backup/__about__.py             1      0   100%
-venv/lib/python3.12/site-packages/dar_backup/__init__.py              0      0   100%
-venv/lib/python3.12/site-packages/dar_backup/clean_log.py            68     14    79%
-venv/lib/python3.12/site-packages/dar_backup/cleanup.py             196     53    73%
-venv/lib/python3.12/site-packages/dar_backup/config_settings.py      66      8    88%
-venv/lib/python3.12/site-packages/dar_backup/dar_backup.py          464     99    79%
-venv/lib/python3.12/site-packages/dar_backup/installer.py            46     46     0%
-venv/lib/python3.12/site-packages/dar_backup/manager.py             316     72    77%
-venv/lib/python3.12/site-packages/dar_backup/util.py                162     34    79%
--------------------------------------------------------------------------------------
-TOTAL                                                              1319    326    75%
+Name                                   Stmts   Miss  Cover
+----------------------------------------------------------
+src/dar_backup/__about__.py                1      0   100%
+src/dar_backup/__init__.py                 0      0   100%
+src/dar_backup/clean_log.py               68     13    81%
+src/dar_backup/cleanup.py                193     17    91%
+src/dar_backup/command_runner.py          73      1    99%
+src/dar_backup/config_settings.py         66      8    88%
+src/dar_backup/dar_backup.py             535     56    90%
+src/dar_backup/dar_backup_systemd.py      56      7    88%
+src/dar_backup/installer.py               59      6    90%
+src/dar_backup/manager.py                351     56    84%
+src/dar_backup/rich_progress.py           70      7    90%
+src/dar_backup/util.py                   130     15    88%
+----------------------------------------------------------
+TOTAL                                   1602    186    88%
 ````
 
 ### dar-backup options

dar_backup/__about__.py

@@ -1 +1 @@
-__version__ = "0.6.18"
+__version__ = "0.6.19"

dar_backup/clean_log.py

@@ -11,6 +11,8 @@ See section 15 and section 16 in the supplied "LICENSE" file
 
 This script can be used to remove (much of) the logged output from `dar`.
 When `dar` verbose options are enabled, quite a lot of information is emitted.
+
+If a rerex is matched, the entire line is removed (change in v2-beta-0.6.19).
 """
 
 
@@ -19,7 +21,7 @@ import re
 import os
 import sys 
 
-from . import __about__ as about
+from dar_backup import __about__ as about
 from dar_backup.config_settings import ConfigSettings
 
 LICENSE = '''Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
@@ -32,7 +34,7 @@ def clean_log_file(log_file_path, dry_run=False):
 
     if not os.path.isfile(log_file_path):
         print(f"File '{log_file_path}' not found!")
-        sys.exit(1)
+        sys.exit(127)
 
     if not os.access(log_file_path, os.R_OK):
         print(f"No read permission for '{log_file_path}'")
@@ -49,13 +51,18 @@ def clean_log_file(log_file_path, dry_run=False):
     temp_file_path = log_file_path + ".tmp"
     
     patterns = [
+        r"INFO\s*-\s*Inspecting\s*directory",
+        r"INFO\s*-\s*Finished\s*Inspecting",
         r"INFO\s*-\s*<File",
+        r"INFO\s*-\s*</File",
         r"INFO\s*-\s*<Attributes",
+        r"INFO\s*-\s*</Attributes",
         r"INFO\s*-\s*</Directory",
         r"INFO\s*-\s*<Directory",
-        r"INFO\s*-\s*</File",
-        r"INFO\s*-\s*Inspecting\s*directory",
-        r"INFO\s*-\s*Finished\s*Inspecting"
+        r"INFO\s*-\s*<Catalog",
+        r"INFO\s*-\s*</Catalog",
+        r"INFO\s*-\s*<Symlink",
+        r"INFO\s*-\s*</Symlink",
     ]
 
     try:
@@ -70,9 +77,9 @@ def clean_log_file(log_file_path, dry_run=False):
                         if dry_run:
                             print(f"Would remove: {original_line.strip()}")  # Print full line for dry-run
                         matched = True  # Mark that a pattern matched
-                        line = re.sub(pattern, "", line).strip()  # Remove only matched part
+                        break  # No need to check other patterns if one matches
 
-                if not dry_run and line:  # In normal mode, only write non-empty lines
+                if not dry_run and not matched:  # In normal mode, only write non-empty lines
                     outfile.write(line.rstrip() + "\n")
 
                 if dry_run and matched:

dar_backup/cleanup.py

@@ -13,6 +13,7 @@ This script removes old DIFF and INCR archives + accompanying .par2 files accord
 [AGE] settings in the configuration file.
 """
 
+import argcomplete
 import argparse
 import logging
 import os
@@ -31,6 +32,7 @@ from dar_backup.util import list_backups
 from dar_backup.util import setup_logging
 from dar_backup.util import get_logger
 from dar_backup.util import requirements
+from dar_backup.util import backup_definition_completer, list_archive_completer
 
 from dar_backup.command_runner import CommandRunner   
 from dar_backup.command_runner import CommandResult
@@ -186,16 +188,19 @@ def main():
     global logger, runner
 
     parser = argparse.ArgumentParser(description="Cleanup old archives according to AGE configuration.")
-    parser.add_argument('-d', '--backup-definition', help="Specific backup definition to cleanup.")
+    parser.add_argument('-d', '--backup-definition', help="Specific backup definition to cleanup.").completer = backup_definition_completer
     parser.add_argument('-c', '--config-file', '-c', type=str, help="Path to 'dar-backup.conf'", default='~/.config/dar-backup/dar-backup.conf')
     parser.add_argument('-v', '--version', action='store_true', help="Show version information.")
     parser.add_argument('--alternate-archive-dir', type=str, help="Cleanup in this directory instead of the default one.")
-    parser.add_argument('--cleanup-specific-archives', type=str, help="Comma separated list of archives to cleanup") 
+    parser.add_argument('--cleanup-specific-archives', type=str, help="Comma separated list of archives to cleanup").completer = list_archive_completer 
     parser.add_argument('-l', '--list', action='store_true', help="List available archives.")
     parser.add_argument('--verbose', action='store_true', help="Print various status messages to screen")
     parser.add_argument('--log-level', type=str, help="`debug` or `trace`, default is `info`", default="info")
     parser.add_argument('--log-stdout', action='store_true', help='also print log messages to stdout')
     parser.add_argument('--test-mode', action='store_true', help='Read envvars in order to run some pytest cases')
+
+    argcomplete.autocomplete(parser)
+
     args = parser.parse_args()
 
     args.config_file = os.path.expanduser(os.path.expandvars(args.config_file))

dar_backup/command_runner.py

@@ -3,8 +3,11 @@ import logging
 import threading
 import os
 import sys
+import tempfile
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../src")))
 from typing import List, Optional
+from dar_backup.util import get_logger
+
 
 class CommandResult:
     def __init__(self, returncode: int, stdout: str, stderr: str):
@@ -15,6 +18,7 @@ class CommandResult:
     def __repr__(self):
         return f"<CommandResult returncode={self.returncode}>"
 
+
 class CommandRunner:
     def __init__(
         self,
@@ -22,10 +26,41 @@ class CommandRunner:
         command_logger: Optional[logging.Logger] = None,
         default_timeout: int = 30
     ):
-        self.logger = logger or logging.getLogger(__name__)
-        self.command_logger = command_logger or self.logger
+        self.logger = logger or get_logger()
+        self.command_logger = command_logger or get_logger(command_output_logger=True)
         self.default_timeout = default_timeout
 
+        if not self.logger or not self.command_logger:
+            self.logger_fallback()
+
+    def logger_fallback(self):
+        """
+        Setup temporary log files
+        """
+        main_log = tempfile.NamedTemporaryFile(delete=False)
+        command_log = tempfile.NamedTemporaryFile(delete=False)
+
+        logger = logging.getLogger("command_runner_fallback_main_logger")
+        command_logger = logging.getLogger("command_runner_fallback_command_logger")
+        logger.setLevel(logging.DEBUG)
+        command_logger.setLevel(logging.DEBUG)
+
+        main_handler = logging.FileHandler(main_log.name)
+        command_handler = logging.FileHandler(command_log.name)
+
+        logger.addHandler(main_handler)
+        command_logger.addHandler(command_handler)
+
+        self.logger = logger
+        self.command_logger = command_logger
+        self.default_timeout = 30
+        self.logger.info("CommandRunner initialized with fallback loggers")
+        self.command_logger.info("CommandRunner initialized with fallback loggers")
+
+        print(f"[WARN] Using fallback loggers:\n  Main log: {main_log.name}\n  Command log: {command_log.name}", file=sys.stderr)
+
+
+
     def run(
         self,
         cmd: List[str],
@@ -36,24 +71,39 @@ class CommandRunner:
         text: bool = True
     ) -> CommandResult:
         timeout = timeout or self.default_timeout
-        self.logger.debug(f"Executing command: {' '.join(cmd)} (timeout={timeout}s)")
+
+        #log the command to be executed
+        command = f"Executing command: {' '.join(cmd)} (timeout={timeout}s)"
+        self.command_logger.info(command) # log to command logger
+        self.logger.debug(command)        # log to main logger if "--log-level debug"
 
         process = subprocess.Popen(
             cmd,
             stdout=subprocess.PIPE if capture_output else None,
             stderr=subprocess.PIPE if capture_output else None,
-            text=text,
-            bufsize=1
+            text=False,
+            bufsize=-1
         )
 
         stdout_lines = []
         stderr_lines = []
 
+
         def stream_output(stream, lines, level):
-            for line in iter(stream.readline, ''):
-                lines.append(line)
-                self.command_logger.log(level, line.strip())
-            stream.close()
+            try:
+                while True:
+                    chunk = stream.read(1024)
+                    if not chunk:
+                        break
+                    decoded = chunk.decode('utf-8', errors='replace')
+                    lines.append(decoded)
+                    self.command_logger.log(level, decoded.strip())
+            except Exception as e:
+                self.logger.warning(f"stream_output decode error: {e}")
+            finally:
+                stream.close()
+
+
 
         threads = []
         if capture_output and process.stdout:

dar_backup/dar_backup.py

@@ -14,6 +14,8 @@ This script can be used to control `dar` to backup parts of or the whole system.
 """
 
 
+
+import argcomplete
 import argparse
 import filecmp
 
@@ -46,12 +48,15 @@ from dar_backup.util import get_logger
 from dar_backup.util import BackupError
 from dar_backup.util import RestoreError
 from dar_backup.util import requirements
+from dar_backup.util import get_binary_info
+from dar_backup.util import backup_definition_completer, list_archive_completer
 
 from dar_backup.command_runner import CommandRunner   
 from dar_backup.command_runner import CommandResult
 
 from dar_backup.rich_progress import show_log_driven_bar
 
+from argcomplete.completers import FilesCompleter
 
 logger = None
 runner = None
@@ -312,7 +317,8 @@ def verify(args: argparse.Namespace, backup_file: str, backup_definition: str, c
             if filecmp.cmp(os.path.join(config_settings.test_restore_dir, restored_file_path.lstrip("/")), os.path.join(root_path, restored_file_path.lstrip("/")), shallow=False):
                 args.verbose and logger.info(f"Success: file '{restored_file_path}' matches the original")
             else:
-                raise BackupError(f"Failure: file '{restored_file_path}' did not match the original")
+                result = False
+                logger.error(f"Failure: file '{restored_file_path}' did not match the original")
         except PermissionError:
             result = False
             logger.exception(f"Permission error while comparing files, continuing....")
@@ -523,6 +529,10 @@ def perform_backup(args: argparse.Namespace, config_settings: ConfigSettings, ba
 
             # Perform backup
             backup_result = generic_backup(backup_type, command, backup_file, backup_definition_path, args.darrc, config_settings, args)
+            if not isinstance(backup_result, list) or not all(isinstance(i, tuple) and len(i) == 2 for i in backup_result):
+                logger.error("Unexpected return format from generic_backup")
+                backup_result = [("Unexpected return format from generic_backup", 1)]
+
             results.extend(backup_result)
 
             logger.info("Starting verification...")
@@ -752,15 +762,15 @@ def main():
     parser.add_argument('-F', '--full-backup', action='store_true', help="Perform a full backup.")
     parser.add_argument('-D', '--differential-backup', action='store_true', help="Perform differential backup.")
     parser.add_argument('-I', '--incremental-backup', action='store_true', help="Perform incremental backup.")
-    parser.add_argument('-d', '--backup-definition', help="Specific 'recipe' to select directories and files.")
-    parser.add_argument('--alternate-reference-archive', help="DIFF or INCR compared to specified archive.")
+    parser.add_argument('-d', '--backup-definition', help="Specific 'recipe' to select directories and files.").completer = backup_definition_completer
+    parser.add_argument('--alternate-reference-archive', help="DIFF or INCR compared to specified archive.").completer = list_archive_completer
     parser.add_argument('-c', '--config-file', type=str, help="Path to 'dar-backup.conf'", default='~/.config/dar-backup/dar-backup.conf')
     parser.add_argument('--darrc', type=str, help='Optional path to .darrc')
-    parser.add_argument('-l', '--list', action='store_true', help="List available archives.")
-    parser.add_argument('--list-contents', help="List the contents of the specified archive.")
+    parser.add_argument('-l', '--list', action='store_true', help="List available archives.").completer = list_archive_completer
+    parser.add_argument('--list-contents', help="List the contents of the specified archive.").completer = list_archive_completer
     parser.add_argument('--selection', help="dar file selection for listing/restoring specific files/directories.")
 #    parser.add_argument('-r', '--restore', nargs=1, type=str, help="Restore specified archive.")
-    parser.add_argument('-r', '--restore', type=str, help="Restore specified archive.")
+    parser.add_argument('-r', '--restore', type=str, help="Restore specified archive.").completer = list_archive_completer
     parser.add_argument('--restore-dir',   type=str, help="Directory to restore files to.")
     parser.add_argument('--verbose', action='store_true', help="Print various status messages to screen")
     parser.add_argument('--suppress-dar-msg', action='store_true', help="cancel dar options in .darrc: -vt, -vs, -vd, -vf and -va")
@@ -773,6 +783,8 @@ def main():
     parser.add_argument("--changelog", action="store_true", help="Print Changelog.md to stdout and exit.")
     parser.add_argument("--changelog-pretty", action="store_true", help="Print Changelog.md to stdout with Markdown styling and exit.")
     parser.add_argument('-v', '--version', action='store_true', help="Show version and license information.")
+    
+    argcomplete.autocomplete(parser)
     args = parser.parse_args()
 
     if args.version:
@@ -840,6 +852,9 @@ def main():
         logger.info(f"START TIME: {start_time}")
         logger.debug(f"`args`:\n{args}")
         logger.debug(f"`config_settings`:\n{config_settings}")
+        dar_manager_properties = get_binary_info(command='dar')
+        logger.debug(f"dar path: {dar_manager_properties['path']}")
+        logger.debug(f"dar version: {dar_manager_properties['version']}")
 
         file_dir =  os.path.normpath(os.path.dirname(__file__))
         args.verbose and (print(f"Script directory:  {file_dir}"))

dar_backup/manager.py

@@ -20,11 +20,14 @@
    This script creates and maintains `dar` databases with catalogs.
 """
 
-
+import argcomplete
 import argparse
 import os
 import re
 import sys
+import subprocess
+
+from inputimeout import inputimeout, TimeoutOccurred
 
 
 from . import __about__ as about
@@ -32,9 +35,11 @@ from dar_backup.config_settings import ConfigSettings
 from dar_backup.util import setup_logging
 from dar_backup.util import CommandResult
 from dar_backup.util import get_logger
+from dar_backup.util import get_binary_info
 
 from dar_backup.command_runner import CommandRunner   
 from dar_backup.command_runner import CommandResult
+from dar_backup.util import backup_definition_completer, list_archive_completer, archive_content_completer, add_specific_archive_completer
 
 from datetime import datetime
 from time import time
@@ -82,43 +87,58 @@ def create_db(backup_def: str, config_settings: ConfigSettings):
 
     return process.returncode
 
-
-def list_catalogs(backup_def: str, config_settings: ConfigSettings) -> NamedTuple:
+def list_catalogs(backup_def: str, config_settings: ConfigSettings, suppress_output=False) -> CommandResult:
     """
+    List catalogs from the database for the given backup definition.
+
     Returns:
-       a typing.NamedTuple of class dar-backup.util.CommandResult with the following properties:
-        - process: of type subprocess.CompletedProcess: The result of the command execution.
-        - stdout: of type str: The standard output of the command.
-        - stderr: of type str: The standard error of the command.
-        - returncode: of type int: The return code of the command.
-        - timeout: of type int: The timeout value in seconds used to run the command.
-        - command: of type list[str): The command executed.
+        A CommandResult containing the raw stdout/stderr and return code.
     """
     database = f"{backup_def}{DB_SUFFIX}"
     database_path = os.path.join(config_settings.backup_dir, database)
+
     if not os.path.exists(database_path):
         error_msg = f'Database not found: "{database_path}"'
         logger.error(error_msg)
         return CommandResult(1, '', error_msg)
 
-        # commandResult = CommandResult(
-        # process=None,
-        # stdout='',
-        # stderr=error_msg,
-        # returncode=1,
-        # timeout=1,
-        # command=[])
-
-        # return commandResult
     command = ['dar_manager', '--base', database_path, '--list']
     process = runner.run(command)
-    stdout, stderr = process.stdout, process.stderr 
+    stdout, stderr = process.stdout, process.stderr
+
     if process.returncode != 0:
         logger.error(f'Error listing catalogs for: "{database_path}"')
-        logger.error(f"stderr: {stderr}")  
+        logger.error(f"stderr: {stderr}")
         logger.error(f"stdout: {stdout}")
-    else:
-        print(stdout)
+        return process
+
+    # Extract only archive basenames from stdout
+    archive_names = []
+    for line in stdout.splitlines():
+        line = line.strip()
+        if not line or "archive #" in line or "dar path" in line or "compression" in line:
+            continue
+        parts = line.split("\t")
+        if len(parts) >= 3:
+            archive_names.append(parts[2].strip())
+
+    # Sort by prefix and date
+    def extract_date(arch_name):
+        match = re.search(r"(\d{4}-\d{2}-\d{2})", arch_name)
+        if match:
+            return datetime.strptime(match.group(1), "%Y-%m-%d")
+        return datetime.min
+
+    def sort_key(name):
+        prefix = name.split("_", 1)[0]
+        return (prefix, extract_date(name))
+
+    archive_names = sorted(archive_names, key=sort_key)
+
+    if not suppress_output:
+        for name in archive_names:
+            print(name)
+
     return process
 
 
@@ -130,47 +150,65 @@ def cat_no_for_name(archive: str, config_settings: ConfigSettings) -> int:
       - the found number, if the archive catalog is present in the database
       - "-1" if the archive is not found
     """
+    
     backup_def = backup_def_from_archive(archive)
-    process = list_catalogs(backup_def, config_settings)
+    process = list_catalogs(backup_def, config_settings, suppress_output=True)
     if process.returncode != 0:
         logger.error(f"Error listing catalogs for backup def: '{backup_def}'")
         return -1
     line_no = 1
     for line in process.stdout.splitlines():
-        #print(f"{line_no}: '{line}'")
         line_no += 1
         search = re.search(rf".*?(\d+)\s+.*?({archive}).*", line)
         if search:
-            #print(f"FOUND: archive: {search.group(2)}, catalog #: '{search.group(1)}'")
             logger.info(f"Found archive: '{archive}', catalog #: '{search.group(1)}'")
             return int(search.group(1))
     return -1
 
 
-
-def list_archive_contents(archive: str, config_settings: ConfigSettings) -> int :
+def list_archive_contents(archive: str, config_settings: ConfigSettings) -> int:
     """
-    List the contents of a specific archive, given the archive name
+    List the contents of a specific archive, given the archive name.
+    Prints only actual file entries (lines beginning with '[ Saved ]').
+    If none are found, a notice is printed instead.
     """
     backup_def = backup_def_from_archive(archive)
     database = f"{backup_def}{DB_SUFFIX}"
     database_path = os.path.join(config_settings.backup_dir, database)
+
     if not os.path.exists(database_path):
         logger.error(f'Database not found: "{database_path}"')
         return 1
+
     cat_no = cat_no_for_name(archive, config_settings)
     if cat_no < 0:
         logger.error(f"archive: '{archive}' not found in database: '{database_path}'")
         return 1
+
+
     command = ['dar_manager', '--base', database_path, '-u', f"{cat_no}"]
-    process = runner.run(command)
-    stdout, stderr = process.stdout, process.stderr 
+    process = runner.run(command, timeout = 10)
+
+
+    stdout = process.stdout or ""
+    stderr = process.stderr or ""
+
+
     if process.returncode != 0:
         logger.error(f'Error listing catalogs for: "{database_path}"')
-        logger.error(f"stderr: {stderr}")  
+        logger.error(f"stderr: {stderr}")
         logger.error(f"stdout: {stdout}")
+
+
+    combined_lines = (stdout + "\n" + stderr).splitlines()
+    file_lines = [line for line in combined_lines if line.strip().startswith("[ Saved ]")]
+
+    if file_lines:
+        for line in file_lines:
+            print(line)
     else:
-        print(stdout)
+        print(f"[info] Archive '{archive}' is empty.")
+
     return process.returncode
 
 
@@ -217,42 +255,82 @@ def find_file(file, backup_def, config_settings):
     return process.returncode
 
 
-def add_specific_archive(archive: str, config_settings: ConfigSettings, directory: str =None) -> int:    
-    # sanity check - does dar backup exist?
+def add_specific_archive(archive: str, config_settings: ConfigSettings, directory: str = None) -> int:
+    """
+    Adds the specified archive to its catalog database. Prompts for confirmation if it's older than existing entries.
+
+    Returns:
+        0 on success
+        1 on failure
+    """
+    # Determine archive path
     if not directory:
         directory = config_settings.backup_dir
-    archive = os.path.basename(archive)  # remove path if it was given
-    archive_path = os.path.join(directory, f'{archive}')
+    archive = os.path.basename(archive)  # strip path if present
+    archive_path = os.path.join(directory, archive)
+    archive_test_path = os.path.join(directory, f'{archive}.1.dar')
 
-    archive_test_path =  os.path.join(directory, f'{archive}.1.dar')
     if not os.path.exists(archive_test_path):
         logger.error(f'dar backup: "{archive_test_path}" not found, exiting')
         return 1
-        
-    # sanity check - does backup definition exist?
+
+    # Validate backup definition
     backup_definition = archive.split('_')[0]
     backup_def_path = os.path.join(config_settings.backup_d_dir, backup_definition)
     if not os.path.exists(backup_def_path):
         logger.error(f'backup definition "{backup_definition}" not found (--add-specific-archive option probably not correct), exiting')
         return 1
-    
+
+    # Determine catalog DB path
     database = f"{backup_definition}{DB_SUFFIX}"
     database_path = os.path.realpath(os.path.join(config_settings.backup_dir, database))
+
+    # Safety check: is archive older than latest in catalog?
+    try:
+        result = subprocess.run(
+            ["dar_manager", "--base", database_path, "--list"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            check=True
+        )
+        all_lines = result.stdout.splitlines()
+        date_pattern = re.compile(r"\d{4}-\d{2}-\d{2}")
+
+        catalog_dates = [
+            datetime.strptime(date_match.group(), "%Y-%m-%d")
+            for line in all_lines
+            if (date_match := date_pattern.search(line))
+        ]
+
+        if catalog_dates:
+            latest_date = max(catalog_dates)
+            archive_date_match = date_pattern.search(archive)
+            if archive_date_match:
+                archive_date = datetime.strptime(archive_date_match.group(), "%Y-%m-%d")
+                if archive_date < latest_date:
+                    if not confirm_add_old_archive(archive, latest_date.strftime("%Y-%m-%d")):
+                        logger.info(f"Archive {archive} skipped due to user declining to add older archive.")
+                        return 1
+
+    except subprocess.CalledProcessError:
+        logger.warning("Could not determine latest catalog date for chronological check.")
+
     logger.info(f'Add "{archive_path}" to catalog: "{database}"')
-    
-    command = ['dar_manager', '--base', database_path, "--add", archive_path, "-Q"]
+
+    command = ['dar_manager', '--base', database_path, "--add", archive_path, "-Q", "--alter=ignore-order"]
     process = runner.run(command)
     stdout, stderr = process.stdout, process.stderr
 
     if process.returncode == 0:
-        logger.info(f'"{archive_path}" added to it\'s catalog')
+        logger.info(f'"{archive_path}" added to its catalog')
     elif process.returncode == 5:
-        logger.warning(f'Something did not go completely right adding "{archive_path}" to it\'s catalog, dar_manager error: "{process.returncode}"')
-    else: 
-        logger.error(f'something went wrong adding "{archive_path}" to it\'s catalog, dar_manager error: "{process.returncode}"')
+        logger.warning(f'Something did not go completely right adding "{archive_path}" to its catalog, dar_manager error: "{process.returncode}"')
+    else:
+        logger.error(f'something went wrong adding "{archive_path}" to its catalog, dar_manager error: "{process.returncode}"')
         logger.error(f"stderr: {stderr}")
         logger.error(f"stdout: {stdout}")
-     
+
     return process.returncode
 
 
@@ -330,6 +408,31 @@ def backup_def_from_archive(archive: str) -> str:
     return None
 
 
+def confirm_add_old_archive(archive_name: str, latest_known_date: str, timeout_secs: int = 20) -> bool:
+    """
+    Confirm with the user if they want to proceed with adding an archive older than the most recent in the catalog.
+    Returns True if the user confirms with "yes", False otherwise.
+    """
+    try:
+        prompt = (
+            f"⚠️ Archive '{archive_name}' is older than the latest in the catalog ({latest_known_date}).\n"
+            f"Adding older archives may lead to inconsistent restore chains.\n"
+            f"Are you sure you want to continue? (yes/no): "
+        )
+        confirmation = inputimeout(prompt=prompt, timeout=timeout_secs)
+
+        if confirmation is None:
+            logger.info(f"No confirmation received for old archive: {archive_name}. Skipping.")
+            return False
+        return confirmation.strip().lower() == "yes"
+
+    except TimeoutOccurred:
+        logger.info(f"Timeout waiting for confirmation for old archive: {archive_name}. Skipping.")
+        return False
+    except KeyboardInterrupt:
+        logger.info(f"User interrupted confirmation for old archive: {archive_name}. Skipping.")
+        return False
+
 
 def remove_specific_archive(archive: str, config_settings: ConfigSettings) -> int:
     """
@@ -366,12 +469,11 @@ def build_arg_parser():
     parser.add_argument('--create-db', action='store_true', help='Create missing databases for all backup definitions')
     parser.add_argument('--alternate-archive-dir', type=str, help='Use this directory instead of BACKUP_DIR in config file')
     parser.add_argument('--add-dir', type=str, help='Add all archive catalogs in this directory to databases')
-    parser.add_argument('-d', '--backup-def', type=str, help='Restrict to work only on this backup definition')
-    parser.add_argument('--add-specific-archive', type=str, help='Add this archive to catalog database')
-    parser.add_argument('--remove-specific-archive', type=str, help='Remove this archive from catalog database')
+    parser.add_argument('-d', '--backup-def', type=str, help='Restrict to work only on this backup definition').completer = backup_definition_completer
+    parser.add_argument('--add-specific-archive', type=str, help='Add this archive to catalog database').completer = add_specific_archive_completer
+    parser.add_argument('--remove-specific-archive', type=str, help='Remove this archive from catalog database').completer = archive_content_completer
     parser.add_argument('-l', '--list-catalogs', action='store_true', help='List catalogs in databases for all backup definitions')
-    parser.add_argument('--list-catalog-contents', type=int, help="List contents of a catalog. Argument is the 'archive #', '-d <definition>' argument is also required")
-    parser.add_argument('--list-archive-contents', type=str, help="List contents of the archive's catalog.")
+    parser.add_argument('--list-archive-contents', type=str, help="List contents of the archive's catalog. Argument is the archive name.").completer = archive_content_completer
     parser.add_argument('--find-file', type=str, help="List catalogs containing <path>/file. '-d <definition>' argument is also required")
     parser.add_argument('--verbose', action='store_true', help='Be more verbose')
     parser.add_argument('--log-level', type=str, help="`debug` or `trace`, default is `info`", default="info")
@@ -394,9 +496,10 @@ def main():
         return
 
     parser = argparse.ArgumentParser(description="Creates/maintains `dar` database catalogs")
-    # [parser.add_argument(...) as before...]
-
     parser = build_arg_parser()
+
+    argcomplete.autocomplete(parser)
+
     args = parser.parse_args()
 
     if args.more_help:
@@ -426,11 +529,14 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
     runner = CommandRunner(logger=logger, command_logger=command_logger)
 
     start_time = int(time())
-    logger.info(f"=====================================")
     logger.info(f"{SCRIPTNAME} started, version: {about.__version__}")
     logger.info(f"START TIME: {start_time}")
     logger.debug(f"`args`:\n{args}")
     logger.debug(f"`config_settings`:\n{config_settings}")
+    dar_manager_properties = get_binary_info(command='dar_manager')
+    logger.debug(f"dar_manager location: {dar_manager_properties['path']}")
+    logger.debug(f"dar_manager version: {dar_manager_properties['version']}")
+    
 
     # --- Sanity checks ---
     if args.add_dir and not args.add_dir.strip():
@@ -475,11 +581,6 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
         sys.exit(1)
         return
 
-    if args.list_catalog_contents and not args.backup_def:
-        logger.error(f"--list-catalog-contents requires the --backup-def, exiting")
-        sys.exit(1)
-        return
-
     if args.find_file and not args.backup_def:
         logger.error(f"--find-file requires the --backup-def, exiting")
         sys.exit(1)
@@ -538,10 +639,6 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
         sys.exit(result)
         return
 
-    if args.list_catalog_contents:
-        result = list_catalog_contents(args.list_catalog_contents, args.backup_def, config_settings)
-        sys.exit(result)
-        return
 
     if args.find_file:
         result = find_file(args.find_file, args.backup_def, config_settings)

dar_backup/util.py

@@ -9,6 +9,7 @@ See section 15 and section 16 in the supplied "LICENSE" file
 """
 import typing
 import locale
+import configparser
 import logging
 import os
 import re
@@ -18,11 +19,15 @@ import shutil
 import sys
 import threading
 import traceback
+from argcomplete.completers import ChoicesCompleter
 from datetime import datetime
 from dar_backup.config_settings import ConfigSettings
+import dar_backup.__about__ as about
 
 from typing import NamedTuple, List
 
+
+
 logger=None
 secondary_logger=None   
 
@@ -72,11 +77,9 @@ def setup_logging(log_file: str, command_output_log_file: str, log_level: str =
             stdout_handler = logging.StreamHandler(sys.stdout)
             stdout_handler.setFormatter(formatter)
             logger.addHandler(stdout_handler)
-            #secondary_logger.addHandler(stdout_handler)
 
         return logger
     except Exception as e:
-        print("Logging initialization failed.")
         traceback.print_exc()
         sys.exit(1)
 
@@ -98,6 +101,66 @@ def get_logger(command_output_logger: bool = False) -> logging.Logger:
 
 
 
+def extract_version(output):
+    match = re.search(r'(\d+\.\d+(\.\d+)?)', output)
+    return match.group(1) if match else "unknown"
+
+def get_binary_info(command):
+    """
+    Return information about a binary command.
+    Args:
+        command (str): The command to check.
+    Returns:
+        dict: A dictionary containing the command, path, version, and full output.
+        Dict structure:
+            {
+                "command": str,
+                "path": str,
+                "version": str,
+                "full_output": str
+            }
+    Raises:
+        Exception: If there is an error running the command.
+    """
+    path = shutil.which(command)
+    if path is None:
+        return {
+            "command": command,
+            "path": "Not found",
+            "version": "unknown",
+            "full_output": ""
+        }
+
+    try:
+        result = subprocess.run(
+            [path, '--version'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+
+        # Combine output regardless of return code
+        combined_output = (result.stdout + result.stderr).strip()
+
+        # Even if returncode != 0, the version info may still be valid
+        version = extract_version(combined_output)
+
+        return {
+            "command": command,
+            "path": path,
+            "version": version if version else "unknown",
+            "full_output": combined_output
+        }
+
+    except Exception as e:
+        return {
+            "command": command,
+            "path": path,
+            "version": "error",
+            "full_output": str(e)
+        }
+
+
 def requirements(type: str, config_setting: ConfigSettings):
     """
     Perform PREREQ or POSTREQ requirements.
@@ -238,4 +301,186 @@ def list_backups(backup_dir, backup_definition=None):
         print(f"{backup.ljust(max_name_length)} : {formatted_size.rjust(max_size_length)} MB")
 
 
+def expand_path(path: str) -> str:
+    """
+    Expand ~ and environment variables like $HOME in a path.
+    """
+    return os.path.expanduser(os.path.expandvars(path))
+
+
+
+def backup_definition_completer(prefix, parsed_args, **kwargs):
+    config_path = getattr(parsed_args, 'config_file', '~/.config/dar-backup/dar-backup.conf')
+    config_path = expand_path(config_path)
+    config_file = os.path.expanduser(config_path)
+    try:
+        config = ConfigSettings(config_file)
+        backup_d_dir = os.path.expanduser(config.backup_d_dir)
+        return [f for f in os.listdir(backup_d_dir) if f.startswith(prefix)]
+    except Exception:
+        return []
+
+
+def extract_backup_definition_fallback() -> str:
+    """
+    Extracts --backup-definition or -d value directly from COMP_LINE.
+    This is needed because argcomplete doesn't always populate parsed_args fully.
+
+    Returns:
+        str: The value of the --backup-definition argument if found, else an empty string.
+    """
+    comp_line = os.environ.get("COMP_LINE", "")
+    # Match both "--backup-definition VALUE" and "-d VALUE"
+    match = re.search(r"(--backup-definition|-d)\s+([^\s]+)", comp_line)
+    if match:
+        return match.group(2)
+    return ""
+
+
+
+def list_archive_completer(prefix, parsed_args, **kwargs):
+    import os
+    import configparser
+    from dar_backup.util import extract_backup_definition_fallback
+
+    backup_def = getattr(parsed_args, "backup_definition", None) or extract_backup_definition_fallback()
+    config_path = getattr(parsed_args, "config_file", None) or "~/.config/dar-backup/dar-backup.conf"
+
+    config_path = os.path.expanduser(os.path.expandvars(config_path))
+    if not os.path.exists(config_path):
+        return []
+
+    config = configparser.ConfigParser()
+    config.read(config_path)
+    backup_dir = config.get("DIRECTORIES", "BACKUP_DIR", fallback="")
+    backup_dir = os.path.expanduser(os.path.expandvars(backup_dir))
+
+    if not os.path.isdir(backup_dir):
+        return []
+
+    files = os.listdir(backup_dir)
+    archive_re = re.compile(rf"^{re.escape(backup_def)}_.+_\d{{4}}-\d{{2}}-\d{{2}}\.1\.dar$") if backup_def else re.compile(r".+_\d{4}-\d{2}-\d{2}\.1\.dar$")
+
+    return [
+        f.rsplit(".1.dar", 1)[0]
+        for f in files
+        if archive_re.match(f)
+    ]
+
+
+def archive_content_completer(prefix, parsed_args, **kwargs):
+    """
+    Completes archive names from all available *.db files.
+    If --backup-def is given, only that one is used.
+    Only entries found in the catalog database (via `dar_manager --list`) are shown.
+    """
+
+    from dar_backup.config_settings import ConfigSettings
+    import subprocess
+    import re
+    import os
+    from datetime import datetime
+
+    # Expand config path
+    config_file = expand_path(getattr(parsed_args, "config_file", "~/.config/dar-backup/dar-backup.conf"))
+    config = ConfigSettings(config_file=config_file)
+    backup_dir = config.backup_dir
+
+    # Which db files to inspect?
+    backup_def = getattr(parsed_args, "backup_def", None)
+    db_files = (
+        [os.path.join(backup_dir, f"{backup_def}.db")]
+        if backup_def
+        else [os.path.join(backup_dir, f) for f in os.listdir(backup_dir) if f.endswith(".db")]
+    )
+
+    completions = []
+
+    for db_path in db_files:
+        if not os.path.exists(db_path):
+            continue
+
+        try:
+            result = subprocess.run(
+                ["dar_manager", "--base", db_path, "--list"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                text=True,
+                check=True
+            )
+        except subprocess.CalledProcessError:
+            continue
+
+        for line in result.stdout.splitlines():
+            parts = line.strip().split("\t")
+            if len(parts) >= 3:
+                archive = parts[2].strip()
+                if archive.startswith(prefix):
+                    completions.append(archive)
+
+    # Sort: first by name (before first '_'), then by date (YYYY-MM-DD)
+    def sort_key(archive):
+        name_part = archive.split("_")[0]
+        date_match = re.search(r"\d{4}-\d{2}-\d{2}", archive)
+        date = datetime.strptime(date_match.group(0), "%Y-%m-%d") if date_match else datetime.min
+        return (name_part, date)
+
+    completions = sorted(set(completions), key=sort_key)
+    return completions or ["[no matching archives]"]
+
+
+
+def add_specific_archive_completer(prefix, parsed_args, **kwargs):
+    """
+    Autocompletes archives that are present in the BACKUP_DIR
+    but not yet present in the <backup_def>.db catalog.
+    If --backup-def is provided, restrict suggestions to that.
+    """
+    from dar_backup.config_settings import ConfigSettings
+    import subprocess
+    import re
+    import os
+    from datetime import datetime
+
+    config_file = expand_path(getattr(parsed_args, "config_file", "~/.config/dar-backup/dar-backup.conf"))
+    config = ConfigSettings(config_file=config_file)
+    backup_dir = config.backup_dir
+    backup_def = getattr(parsed_args, "backup_def", None)
+
+    # Match pattern for archive base names: e.g. test_FULL_2025-04-01
+    dar_pattern = re.compile(r"^(.*?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2}))\.1\.dar$")
+
+    # Step 1: scan backup_dir for .1.dar files
+    all_archives = set()
+    for fname in os.listdir(backup_dir):
+        match = dar_pattern.match(fname)
+        if match:
+            base = match.group(1)
+            if base.startswith(prefix):
+                if not backup_def or base.startswith(f"{backup_def}_"):
+                    all_archives.add(base)
+
+    # Step 2: exclude ones already present in the .db
+    db_path = os.path.join(backup_dir, f"{backup_def}.db") if backup_def else None
+    existing = set()
+
+    if db_path and os.path.exists(db_path):
+        try:
+            result = subprocess.run(
+                ["dar_manager", "--base", db_path, "--list"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                text=True,
+                check=True
+            )
+            for line in result.stdout.splitlines():
+                parts = line.strip().split("\t")
+                if len(parts) >= 3:
+                    existing.add(parts[2].strip())
+        except subprocess.CalledProcessError:
+            pass
+
+    # Step 3: return filtered list
+    candidates = sorted(archive for archive in all_archives if archive not in existing)
+    return candidates or ["[no new archives]"]
 

{dar_backup-0.6.18.dist-info → dar_backup-0.6.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dar-backup
-Version: 0.6.18
+Version: 0.6.19
 Summary: A script to do full, differential and incremental backups using dar.     Some files are restored from the backups during verification, after which par2 redundancy files are created.     The script also has a cleanup feature to remove old backups and par2 files.
 Project-URL: GPG Public Key, https://keys.openpgp.org/search?q=dar-backup@pm.me
 Project-URL: Homepage, https://github.com/per2jensen/dar-backup/tree/main/v2
@@ -689,6 +689,7 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: System :: Archiving :: Backup
 Requires-Python: >=3.9
+Requires-Dist: argcomplete>=3.6.2
 Requires-Dist: inputimeout>=1.0.4
 Requires-Dist: rich>=13.0.0
 Description-Content-Type: text/markdown
@@ -697,12 +698,18 @@ Description-Content-Type: text/markdown
 # Full, differential or incremental backups using 'dar'
 
 [![codecov](https://codecov.io/gh/per2jensen/dar-backup/branch/main/graph/badge.svg)](https://codecov.io/gh/per2jensen/dar-backup)
+[![PyPI monthly downloads](https://img.shields.io/pypi/dm/dar-backup)](https://pypi.org/project/dar-backup/)
+[![Total Downloads](https://img.shields.io/badge/dynamic/json?color=blue&label=Total%20Downloads&query=total&url=https%3A%2F%2Fraw.githubusercontent.com%2Fper2jensen%2Fdar-backup%2Fmain%2Fdownloads.json)](https://pypi.org/project/dar-backup/)
 
 The wonderful 'dar' [Disk Archiver](https://github.com/Edrusb/DAR) is used for
 the heavy lifting, together with the par2 suite in these scripts.
 
 This is the `Python` based **version 2** of `dar-backup`.
 
+## TL;DR
+
+`dar-backup` is a Python-powered CLI for creating and validating full, differential, and incremental backups using dar and par2. Designed for long-term restore integrity, even on user-space filesystems like FUSE.
+
 ## Table of Contents
 
 - [Full, differential or incremental backups using 'dar'](#full-differential-or-incremental-backups-using-dar)
@@ -728,6 +735,7 @@ This is the `Python` based **version 2** of `dar-backup`.
   - [Generate systemd files](#generate-systemd-files)
   - [Service: dar-back --incremental-backup](#service-dar-backup---incremental-backup)
   - [Timer: dar-back --incremental-backup](#timer-dar-backup---incremental-backup)
+  - [Systemd timer note](#systemd-timer-note)
 - [List contents of an archive](#list-contents-of-an-archive)
 - [dar file selection examples](#dar-file-selection-examples)
   - [Select a directory](#select-a-directory)
@@ -753,7 +761,9 @@ This is the `Python` based **version 2** of `dar-backup`.
   - [Skipping cache directories](#skipping-cache-directories)
   - [Progress bar + current directory](#progress-bar-and-current-directory)
 - [Todo](#todo)
+- [Known Limitations / Edge Cases](#known-limitations--edge-cases)
 - [Reference](#reference)
+  - [CLI Tools Overview](#cli-tools-overview)
   - [Test coverage report](#test-coverage)
   - [dar-backup](#dar-backup-options)
   - [manager](#manager-options)
@@ -1346,6 +1356,10 @@ Persistent=true
 WantedBy=timers.target
 ````
 
+## systemd timer note
+
+📅 OnCalendar syntax is flexible — you can tweak backup schedules easily. Run systemd-analyze calendar to preview timers.
+
 ## list contents of an archive
 
 ```` bash
@@ -1636,8 +1650,27 @@ The indicators are not shown if dar-backup is run from systemd or if it is used
 - Look into a way to move the .par2 files away from the `dar` slices, to maximize chance of good redundancy.
 - Add option to dar-backup to use the `dar` option `--fsa-scope none`
 
+## Known Limitations / Edge Cases
+
+Does not currently encrypt data (by design — relies on encrypted storage)
+
+One backup definition per file
+
+.par2 files created for each slice (may be moved in future)
+
 ## Reference
 
+### CLI Tools Overview
+
+| Command               | Description                               |
+|-----------------------|-------------------------------------------|
+| `dar-backup`          | Perform full, differential, or incremental backups with verification and restore testing |
+| `manager`             | Maintain and query catalog databases for archives |
+| `cleanup`             | Remove outdated DIFF/INCR archives (and optionally FULLs) |
+| `clean-log`           | Clean up excessive log output from dar command logs |
+| `installer`           | Set up required directories and default config files |
+| `dar-backup-systemd`  | Generate (and optionally install) systemd timers and services for automated backups |
+
 ### test coverage
 
 Running
@@ -1646,23 +1679,26 @@ Running
 pytest --cov=dar_backup tests/
 ````
 
-results for version 0.6.17 in this report:
+results for a dev version 0.6.19 in this report:
 
 ```` code
 ---------- coverage: platform linux, python 3.12.3-final-0 -----------
-Name                                                              Stmts   Miss  Cover
--------------------------------------------------------------------------------------
-venv/lib/python3.12/site-packages/dar_backup/__about__.py             1      0   100%
-venv/lib/python3.12/site-packages/dar_backup/__init__.py              0      0   100%
-venv/lib/python3.12/site-packages/dar_backup/clean_log.py            68     14    79%
-venv/lib/python3.12/site-packages/dar_backup/cleanup.py             196     53    73%
-venv/lib/python3.12/site-packages/dar_backup/config_settings.py      66      8    88%
-venv/lib/python3.12/site-packages/dar_backup/dar_backup.py          464     99    79%
-venv/lib/python3.12/site-packages/dar_backup/installer.py            46     46     0%
-venv/lib/python3.12/site-packages/dar_backup/manager.py             316     72    77%
-venv/lib/python3.12/site-packages/dar_backup/util.py                162     34    79%
--------------------------------------------------------------------------------------
-TOTAL                                                              1319    326    75%
+Name                                   Stmts   Miss  Cover
+----------------------------------------------------------
+src/dar_backup/__about__.py                1      0   100%
+src/dar_backup/__init__.py                 0      0   100%
+src/dar_backup/clean_log.py               68     13    81%
+src/dar_backup/cleanup.py                193     17    91%
+src/dar_backup/command_runner.py          73      1    99%
+src/dar_backup/config_settings.py         66      8    88%
+src/dar_backup/dar_backup.py             535     56    90%
+src/dar_backup/dar_backup_systemd.py      56      7    88%
+src/dar_backup/installer.py               59      6    90%
+src/dar_backup/manager.py                351     56    84%
+src/dar_backup/rich_progress.py           70      7    90%
+src/dar_backup/util.py                   130     15    88%
+----------------------------------------------------------
+TOTAL                                   1602    186    88%
 ````
 
 ### dar-backup options

dar_backup-0.6.19.dist-info/RECORD

@@ -0,0 +1,21 @@
+dar_backup/.darrc,sha256=-aerqivZmOsW_XBCh9IfbYTUvw0GkzDSr3Vx4GcNB1g,2113
+dar_backup/Changelog.md,sha256=PbR2JupEHiWdRNP8ApuWEYIrRQEeJQUnlkVR7N4JJHg,8591
+dar_backup/README.md,sha256=PcZQRaBw9i_GbRoA786OFKI0PwY87E7D30UzovWqEQQ,44902
+dar_backup/__about__.py,sha256=1xdEgfhhUWpssnr_9DTiORat5DDv6NUXRtydGkm-Aog,22
+dar_backup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dar_backup/clean_log.py,sha256=uQ_9HomK7RRkskXrgMPbAC84RgNlCFJ8RHL9KHeAMvc,5447
+dar_backup/cleanup.py,sha256=mrpu9xAy6AKcEbjMetscEh-IzJp0xVFObdrwaXncFtA,12712
+dar_backup/command_runner.py,sha256=PQA968EXssSGjSs_16psFkdxRZi9-YK4TrBKFz0ss3k,4455
+dar_backup/config_settings.py,sha256=Rh4T35-w_5tpRAViMfv3YP3GBpG4mQy7Do8cNBzYAR0,4912
+dar_backup/dar-backup.conf,sha256=64O3bGlzqupneT2gVeaETJ1qS6-3Exet9Zto27jgwPQ,897
+dar_backup/dar_backup.py,sha256=Uy0VAFRbOAmZCyZyyEfWuIM4he2WivfQXhKzVGhWbHc,41939
+dar_backup/dar_backup_systemd.py,sha256=oehD_t9CFu0CsMgDWRH-Gt74Ynl1m29yqQEh5Kxv7aw,3807
+dar_backup/installer.py,sha256=fl2LHHWxuXRT814M_zuZh_YqqLk6nuNg9BI9HpLzdUU,4841
+dar_backup/manager.py,sha256=t-CWxvxzhMHCOCU99px6heL3dRmil2JDOyw9PHL96xY,25712
+dar_backup/rich_progress.py,sha256=jTwM-4VlqHHzKqIfyXjL1pWEriobSJwCdN3YXzXzRdo,3105
+dar_backup/util.py,sha256=REZANvqLqczx3MvGszpVaesrpW03NuH_GPGjDllpT4Q,16877
+dar_backup-0.6.19.dist-info/METADATA,sha256=jQwLE815tTEXjKh7l0rUd5SprMF_czZ3QPRXn8TNMnM,86624
+dar_backup-0.6.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dar_backup-0.6.19.dist-info/entry_points.txt,sha256=NSCYoG5Dvh1UhvKWOQPgcHdFv4--R4Sre3d9FwJra3E,258
+dar_backup-0.6.19.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+dar_backup-0.6.19.dist-info/RECORD,,

dar_backup-0.6.18.dist-info/RECORD

@@ -1,21 +0,0 @@
-dar_backup/.darrc,sha256=-aerqivZmOsW_XBCh9IfbYTUvw0GkzDSr3Vx4GcNB1g,2113
-dar_backup/Changelog.md,sha256=ZRK03WnSbNWkMQAVNvfflKs06TGmkB4wBOm0Lp4ft1c,7830
-dar_backup/README.md,sha256=b4eoXh8fo7Li1mJqMKbrW-SrI2gDYkczCtL8G9-KoFE,43261
-dar_backup/__about__.py,sha256=g-mDk6iCtdmWAx2-NGjdBzw-GF98McMHGx0wkhbKFM4,22
-dar_backup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dar_backup/clean_log.py,sha256=cGhtKYnQJ2ceNQfw5XcCln_WNBasbmlfhO3kRydjDNk,5196
-dar_backup/cleanup.py,sha256=BAiztBL0Dpr3fs6WZU_9oR5jUWumHua4dS37JtSxi-Q,12499
-dar_backup/command_runner.py,sha256=74Fsylz1NN-dn8lbdRhkL6LA1r527QJeojBlniGrPuo,2708
-dar_backup/config_settings.py,sha256=Rh4T35-w_5tpRAViMfv3YP3GBpG4mQy7Do8cNBzYAR0,4912
-dar_backup/dar-backup.conf,sha256=64O3bGlzqupneT2gVeaETJ1qS6-3Exet9Zto27jgwPQ,897
-dar_backup/dar_backup.py,sha256=THZmKZgOWxtYo9HaysU38GZ1hnpTcziJ45sPQ4HvJoE,41003
-dar_backup/dar_backup_systemd.py,sha256=oehD_t9CFu0CsMgDWRH-Gt74Ynl1m29yqQEh5Kxv7aw,3807
-dar_backup/installer.py,sha256=fl2LHHWxuXRT814M_zuZh_YqqLk6nuNg9BI9HpLzdUU,4841
-dar_backup/manager.py,sha256=HRuWeDB1sd14HwMEM6dk6OVqpj2KDTk6y55OKw7vUHE,22420
-dar_backup/rich_progress.py,sha256=jTwM-4VlqHHzKqIfyXjL1pWEriobSJwCdN3YXzXzRdo,3105
-dar_backup/util.py,sha256=2V4ONpoGh_W6wFv2RbJoUIEDxcY6_ot4frtzEBWsu7U,8798
-dar_backup-0.6.18.dist-info/METADATA,sha256=My1Utkqgj1iYhfC4OfWXzzzrU2bPasbWl9usZqS_7bw,84949
-dar_backup-0.6.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dar_backup-0.6.18.dist-info/entry_points.txt,sha256=NSCYoG5Dvh1UhvKWOQPgcHdFv4--R4Sre3d9FwJra3E,258
-dar_backup-0.6.18.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-dar_backup-0.6.18.dist-info/RECORD,,