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

dar_backup/Changelog.md

@@ -1,6 +1,31 @@
 <!-- markdownlint-disable MD024 -->
 # dar-backup Changelog
 
+## v2-beta-0.6.20.1 - 2025-05-04
+
+Github link: [v2-beta-0.6.20.1](https://github.com/per2jensen/dar-backup/tree/v2-beta-0.6.20.1/v2)
+
+### Added
+
+- FIX: bash/zsh completers fixed to support MANAGER_DB_DIR config if set
+- `cleanup` and `manager` completer now sorts archives by \<backup-definition> and \<archive date> (so not using \<type>)
+
+## v2-beta-0.6.20 - 2025-05-03
+
+Github link: [v2-beta-0.6.20](https://github.com/per2jensen/dar-backup/tree/v2-beta-0.6.20/v2)
+
+### Added
+
+- show_version() moved to util and tests for dar-backup, manager and cleanup
+- startup informational messages now works the same across the scripts
+- Improved ConfigSettings class to handle optional configuration keys
+
+  -- test cases added
+
+- Optional config parameter: MANAGER_DB_DIR, ideally to point to another disk for safe keeping backup catalogs
+
+  -- test cases added
+
 ## 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)

dar_backup/__about__.py

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

dar_backup/cleanup.py

@@ -20,11 +20,15 @@ import os
 import re
 import subprocess
 import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
+
+
 
 from datetime import datetime, timedelta
 from inputimeout import inputimeout, TimeoutOccurred
 from time import time
-from typing import Dict, List, NamedTuple
+from typing import Dict, List, NamedTuple, Tuple
+
 
 from . import __about__ as about
 from dar_backup.config_settings import ConfigSettings
@@ -32,6 +36,8 @@ 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 show_version
+from dar_backup.util import print_aligned_settings
 from dar_backup.util import backup_definition_completer, list_archive_completer
 
 from dar_backup.command_runner import CommandRunner   
@@ -152,21 +158,12 @@ def delete_catalog(catalog_name: str, args: NamedTuple) -> bool:
         return False
 
 
-def show_version():
-    script_name = os.path.basename(sys.argv[0])
-    print(f"{script_name} {about.__version__}")
-    print('''Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
-THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW, not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-See section 15 and section 16 in the supplied "LICENSE" file.''')
-
-
 def confirm_full_archive_deletion(archive_name: str, test_mode=False) -> bool:
     try:
         if test_mode:
-            confirmation = os.environ.get("CLEANUP_TEST_DELETE_FULL")
-            if confirmation is None:
-                raise RuntimeError("envvar 'CLEANUP_TEST_DELETE_FULL' not set")
-            print(f"Simulated confirmation for FULL archive: {confirmation}")
+            answer = os.getenv("CLEANUP_TEST_DELETE_FULL", "").lower()
+            print(f"Simulated confirmation for FULL archive '{archive_name}': {answer}")
+            return answer == "yes"
         else:
             confirmation = inputimeout(
                 prompt=f"Are you sure you want to delete the FULL archive '{archive_name}'? (yes/no): ",
@@ -220,21 +217,24 @@ def main():
     command_logger = get_logger(command_output_logger = True)
     runner = CommandRunner(logger=logger, command_logger=command_logger)
 
-    logger.info(f"=====================================")
-    logger.info(f"cleanup.py started, version: {about.__version__}")
+    start_msgs: List[Tuple[str, str]] = []
+
+    start_msgs.append(("cleanup.py:", about.__version__))
 
     logger.info(f"START TIME: {start_time}")
     logger.debug(f"`args`:\n{args}")
     logger.debug(f"`config_settings`:\n{config_settings}")
 
     file_dir =  os.path.normpath(os.path.dirname(__file__))
-    args.verbose and (print(f"Script directory:           {file_dir}"))
-    args.verbose and (print(f"Config file:                {args.config_file}"))
-    args.verbose and (print(f"Backup dir:                 {config_settings.backup_dir}"))
-    args.verbose and (print(f"Logfile location:           {config_settings.logfile_location}"))
-    args.verbose and (print(f"--alternate-archive-dir:    {args.alternate_archive_dir}"))
-    args.verbose and (print(f"--cleanup-specific-archives:{args.cleanup_specific_archives}")) 
-
+    args.verbose and start_msgs.append(("Script directory:", file_dir))
+    start_msgs.append(("Config file:", args.config_file))
+    args.verbose and start_msgs.append(("Backup dir:", config_settings.backup_dir))
+    start_msgs.append(("Logfile:", config_settings.logfile_location))
+    args.verbose and start_msgs.append(("--alternate-archive-dir:", args.alternate_archive_dir))
+    args.verbose and start_msgs.append(("--cleanup-specific-archives:", args.cleanup_specific_archives)) 
+
+    dangerous_keywords = ["--cleanup", "_FULL_"] # TODO: add more dangerous keywords
+    print_aligned_settings(start_msgs, highlight_keywords=dangerous_keywords)
 
     # run PREREQ scripts
     requirements('PREREQ', config_settings)

dar_backup/config_settings.py

@@ -1,33 +1,35 @@
-
 import configparser
-import logging
-import sys
-
 from dataclasses import dataclass, field, fields
 from os.path import expandvars, expanduser
 from pathlib import Path
 
+from dar_backup.exceptions import ConfigSettingsError
+
 @dataclass
 class ConfigSettings:
     """
-    A dataclass for holding configuration settings, initialized from a configuration file.
-
-    Attributes:
-        logfile_location (str): The location of the log file.
-        max_size_verification_mb (int): The maximum size for verification in megabytes.
-        min_size_verification_mb (int): The minimum size for verification in megabytes.
-        no_files_verification (int): The number of files for verification.
-        command_timeout_secs (int): The timeout in seconds for commands.
-        backup_dir (str): The directory for backups.
-        test_restore_dir (str): The directory for test restores.
-        backup_d_dir (str): The directory for backup.d.
-        diff_age (int): The age for differential backups before deletion.
-        incr_age (int): The age for incremental backups before deletion.
-        error_correction_percent (int): The error correction percentage for PAR2.
-        par2_enabled (bool): Whether PAR2 is enabled.
+    Parses and holds configuration values from a dar-backup.conf file.
+
+    Required fields are defined as dataclass attributes and must be present in the config file.
+    Optional fields can be declared in the OPTIONAL_CONFIG_FIELDS list. If a key is present in the
+    config file, the field is set to its parsed value; otherwise, it defaults to None.
+
+    The __repr__ method will only include optional fields if their value is not None,
+    keeping debug output clean and focused on explicitly configured values.
+
+    OPTIONAL_CONFIG_FIELDS = [
+        {
+            "section": "DIRECTORIES",
+            "key": "MANAGER_DB_DIR",
+            "attr": "manager_db_dir",
+            "type": str,
+            "default": None,
+        }
+    ]
     """
 
     config_file: str
+
     logfile_location: str = field(init=False)
     max_size_verification_mb: int = field(init=False)
     min_size_verification_mb: int = field(init=False)
@@ -41,17 +43,28 @@ class ConfigSettings:
     error_correction_percent: int = field(init=False)
     par2_enabled: bool = field(init=False)
 
+
+    OPTIONAL_CONFIG_FIELDS = [
+        {
+            "section": "DIRECTORIES",
+            "key": "MANAGER_DB_DIR",
+            "attr": "manager_db_dir",
+            "type": str,
+            "default": None,
+        },
+        # Add more optional fields here
+    ]
+
     def __post_init__(self):
-        """
-        Initializes the ConfigSettings instance by reading the specified configuration file
-        and expands environment variables for all string fields.
-        """
-        if self.config_file is None:
-            raise ValueError("`config_file` must be specified.")
-        
-        self.config = configparser.ConfigParser()
+        if not self.config_file:
+            raise ConfigSettingsError("`config_file` must be specified.")
+
         try:
-            self.config.read(self.config_file)
+            self.config = configparser.ConfigParser()
+            loaded_files = self.config.read(self.config_file)
+            if not loaded_files:
+                raise RuntimeError(f"Configuration file not found or unreadable: '{self.config_file}'")
+
             self.logfile_location = self.config['MISC']['LOGFILE_LOCATION']
             self.max_size_verification_mb = int(self.config['MISC']['MAX_SIZE_VERIFICATION_MB'])
             self.min_size_verification_mb = int(self.config['MISC']['MIN_SIZE_VERIFICATION_MB'])
@@ -63,37 +76,54 @@ class ConfigSettings:
             self.diff_age = int(self.config['AGE']['DIFF_AGE'])
             self.incr_age = int(self.config['AGE']['INCR_AGE'])
             self.error_correction_percent = int(self.config['PAR2']['ERROR_CORRECTION_PERCENT'])
+
             val = self.config['PAR2']['ENABLED'].strip().lower()
             if val in ('true', '1', 'yes'):
                 self.par2_enabled = True
             elif val in ('false', '0', 'no'):
                 self.par2_enabled = False
             else:
-                raise ValueError(f"Invalid boolean value for 'ENABLED' in [PAR2]: '{val}'")
-            
-            # Ensure the directories exist
-            Path(self.backup_dir).mkdir(parents=True, exist_ok=True)
-            Path(self.test_restore_dir).mkdir(parents=True, exist_ok=True)
-            Path(self.backup_d_dir).mkdir(parents=True, exist_ok=True)
-
-            # Expand environment variables for all string fields
+                raise ConfigSettingsError(f"Invalid boolean value for 'ENABLED' in [PAR2]: '{val}'")
+
+            # Load optional fields
+            for opt in self.OPTIONAL_CONFIG_FIELDS:
+                if self.config.has_option(opt['section'], opt['key']):
+                    raw_value = self.config.get(opt['section'], opt['key'])
+                    try:
+                        value = opt['type'](raw_value.strip())
+                        setattr(self, opt['attr'], value)
+                    except Exception as e:
+                        raise ConfigSettingsError(
+                            f"Failed to parse optional config '{opt['section']}::{opt['key']}': {e}"
+                        )
+                else:
+                    setattr(self, opt['attr'], opt.get('default', None))
+
+
+            # Expand paths in all string fields that exist
             for field in fields(self):
-                if isinstance(getattr(self, field.name), str):
-                    setattr(self, field.name, expanduser(expandvars(getattr(self, field.name))))
-
-        except FileNotFoundError as e:
-            logging.error(f"Configuration file not found: {self.config_file}")
-            logging.error(f"Error details: {e}")
-            sys.exit("Error: Configuration file not found.")
-        except PermissionError as e:
-            logging.error(f"Permission error while reading config file {self.config_file}")
-            logging.error(f"Error details: {e}")
-            sys.exit("Error: Permission error while reading config file.")
+                if hasattr(self, field.name):
+                    value = getattr(self, field.name)
+                    if isinstance(value, str):
+                        setattr(self, field.name, expanduser(expandvars(value)))
+
+        except RuntimeError as e:
+            raise ConfigSettingsError(f"RuntimeError: {e}")
         except KeyError as e:
-            logging.error(f"Missing mandatory configuration key: {e}")
-            logging.error(f"Error details: {e}")
-            sys.exit(f"Error: Missing mandatory configuration key: {e}.")
+            raise ConfigSettingsError(f"Missing mandatory configuration key: {e}")
+        except ValueError as e:
+            raise ConfigSettingsError(f"Invalid value in config: {e}")
         except Exception as e:
-            logging.exception(f"Unexpected error reading config file {self.config_file}: {e}")
-            logging.error(f"Error details: {e}")
-            sys.exit(f"Unexpected error reading config file: {e}.")
+            raise ConfigSettingsError(f"Unexpected error during config initialization: {e}")
+
+
+
+    def __repr__(self):
+        safe_fields = [
+            f"{field.name}={getattr(self, field.name)!r}"
+            for field in fields(self)
+            if hasattr(self, field.name) and getattr(self, field.name) is not None
+        ]
+        return f"<ConfigSettings({', '.join(safe_fields)})>"
+
+

dar_backup/dar-backup.conf

@@ -16,8 +16,12 @@ COMMAND_TIMEOUT_SECS = 86400
 BACKUP_DIR = ~/dar-backup/backups
 BACKUP.D_DIR = ~/.config/dar-backup/backup.d/
 TEST_RESTORE_DIR = ~/dar-backup/restore/
+# Optional parameter
+# If you want to store the catalog database away from the BACKUP_DIR,  use the MANAGER_DB_DIR variable.
+#MANAGER_DB_DIR = /some/where/else/
 
 [AGE]
+# DIFF and INCR backups are kept for a configured number of days, then deleted by the `cleanuo` 
 # age settings are in days
 DIFF_AGE = 100
 INCR_AGE = 40

dar_backup/dar_backup.py

@@ -37,8 +37,10 @@ from sys import stderr
 from sys import argv
 from sys import version_info
 from time import time
+from rich.console import Console
+from rich.text import Text
 from threading import Event
-from typing import List
+from typing import List, Tuple
 
 from . import __about__ as about
 from dar_backup.config_settings import ConfigSettings
@@ -48,7 +50,9 @@ 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 show_version
 from dar_backup.util import get_binary_info
+from dar_backup.util import print_aligned_settings
 from dar_backup.util import backup_definition_completer, list_archive_completer
 
 from dar_backup.command_runner import CommandRunner   
@@ -647,14 +651,6 @@ def filter_darrc_file(darrc_path):
 
 
 
-def show_version():
-    script_name = os.path.basename(argv[0])
-    print(f"{script_name} {about.__version__}") 
-    print(f"dar-backup.py source code is here: https://github.com/per2jensen/dar-backup")
-    print('''Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
-THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW, not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-See section 15 and section 16 in the supplied "LICENSE" file.''')
-
 
 def show_examples():
     examples = """
@@ -846,35 +842,40 @@ def main():
             args.darrc = filter_darrc_file(args.darrc)
             logger.debug(f"Filtered .darrc file: {args.darrc}")
 
+        start_msgs: List[Tuple[str, str]] = []
+
         start_time=int(time())
-        logger.info(f"=====================================")
-        logger.info(f"dar-backup.py started, version: {about.__version__}")
+        start_msgs.append(('dar-backup.py:', 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')
-        logger.debug(f"dar path: {dar_manager_properties['path']}")
-        logger.debug(f"dar version: {dar_manager_properties['version']}")
+        logger.debug(f"{'`Args`:\n'}{args}")
+        logger.debug(f"{'`Config_settings`:\n'}{config_settings}")
+        dar_properties = get_binary_info(command='dar')
+        start_msgs.append(('dar path:', dar_properties['path']))
+        start_msgs.append(('dar version:', dar_properties['version']))
 
         file_dir =  os.path.normpath(os.path.dirname(__file__))
-        args.verbose and (print(f"Script directory:  {file_dir}"))
-        args.verbose and (print(f"Config file:       {args.config_file}"))
-        args.verbose and args.full_backup         and (print(f"Type of backup:    FULL"))
-        args.verbose and args.differential_backup and (print(f"Type of backup:    DIFF"))
-        args.verbose and args.incremental_backup  and (print(f"Type of backup:    INCR"))
-        args.verbose and args.backup_definition   and (print(f"Backup definition: '{args.backup_definition}'"))
+        start_msgs.append(('Script directory:', os.path.abspath(file_dir)))
+        start_msgs.append(('Config file:', os.path.abspath(args.config_file)))
+        start_msgs.append((".darrc location:", args.darrc))
+
+        args.verbose and args.full_backup         and start_msgs.append(("Type of backup:", "FULL"))
+        args.verbose and args.differential_backup and start_msgs.append(("Type of backup:", "DIFF"))
+        args.verbose and args.incremental_backup  and start_msgs.append(("Type of backup:", "INCR"))
+        args.verbose and args.backup_definition   and start_msgs.append(("Backup definition:", args.backup_definition))
         if args.alternate_reference_archive:
-            args.verbose and (print(f"Alternate ref archive: {args.alternate_reference_archive}"))
-        args.verbose and (print(f"Backup.d dir:      {config_settings.backup_d_dir}"))
-        args.verbose and (print(f"Backup dir:        {config_settings.backup_dir}"))
+            args.verbose and start_msgs.append(("Alternate ref archive:", args.alternate_reference_archive))
+        args.verbose and start_msgs.append(("Backup.d dir:", config_settings.backup_d_dir))
+        args.verbose and start_msgs.append(("Backup dir:", config_settings.backup_dir))
 
         restore_dir = args.restore_dir if args.restore_dir else config_settings.test_restore_dir
-        args.verbose and (print(f"Restore dir:       {restore_dir}"))
+        args.verbose and start_msgs.append(("Restore dir:", restore_dir))
 
-        args.verbose and (print(f"Logfile location:  {config_settings.logfile_location}"))
-        args.verbose and (print(f".darrc location:   {args.darrc}"))
-        args.verbose and (print(f"PAR2 enabled:      {config_settings.par2_enabled}"))
-        args.verbose and (print(f"--do-not-compare:  {args.do_not_compare}"))
+        args.verbose and start_msgs.append(("Logfile location:", config_settings.logfile_location))
+        args.verbose and start_msgs.append(("PAR2 enabled:", config_settings.par2_enabled))
+        args.verbose and start_msgs.append(("--do-not-compare:", args.do_not_compare))
+
+        dangerous_keywords = ["--do-not", "alternate"] # TODO: add more dangerous keywords
+        print_aligned_settings(start_msgs)
 
         # sanity check
         if args.backup_definition and not os.path.exists(os.path.join(config_settings.backup_d_dir, args.backup_definition)):
@@ -936,12 +937,17 @@ def main():
             else:
                 logger.error(f"not correct result type: {result}, which must be a tuple (<msg>, <exit_code>)")
             i=i+1
+            
+    console = Console()
     if error:
-        args.verbose and print("\033[1m\033[31mErrors\033[0m encountered")
+        if args.verbose:
+            console.print(Text("Errors encountered", style="bold red"))
         exit(1)
     else:
-        args.verbose and print("\033[1m\033[32mSuccess\033[0m all backups completed") 
+        if args.verbose:
+            console.print(Text("Success: all backups completed", style="bold green"))
         exit(0)
+
     
 if __name__ == "__main__":
     main()

dar_backup/demo.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+installer.py source code is here: https://github.com/per2jensen/dar-backup/tree/main/v2/src/dar_backup/installer.py
+This script is part of dar-backup, a backup solution for Linux using dar and systemd.
+
+Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW, 
+not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See section 15 and section 16 in the supplied "LICENSE" file
+
+This script can be used to configure dar-backup on your system.
+It is non-destructive and will not overwrite any existing files or directories.
+"""
+
+import argparse
+import os
+import shutil
+import sys 
+
+from . import __about__ as about
+from pathlib import Path
+
+LICENSE = '''Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW, not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See section 15 and section 16 in the supplied "LICENSE" file.'''
+
+CONFIG_DIR = os.path.expanduser("~/.config/dar-backup")
+DAR_BACKUP_DIR = os.path.expanduser("~/dar-backup/")
+
+BACKUP_DEFINITION = '''
+# Demo of a `dar-backup` definition file
+# This back definition file configures a backup of ~/.config/dar-backup
+# `dar-backup` puts the backups in ~/dar-backup/backups
+# ------------------------------------------------------------------------
+
+# Switch to ordered selection mode, which means that the following options
+# will be considered top to bottom
+-am
+
+# Backup Root dir
+-R @@HOME_DIR@@
+
+# Directories to backup below the Root dir
+-g .config/dar-backup
+
+# Examples of directories to exclude below the Root dir
+ -P mnt
+ -P .private
+ -P .cache   
+
+# compression level
+ -z5
+
+ # no overwrite, if you rerun a backup, 'dar' halts and asks what to do
+ -n
+ 
+ # size of each slice in the archive
+ --slice 10G
+
+# bypass directores marked as cache directories
+# http://dar.linux.free.fr/doc/Features.html
+--cache-directory-tagging
+'''
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Set up `dar-backup` on your system.",
+    )
+    parser.add_argument(
+        "-i", "--install",
+        action="store_true",
+        help="Deploy a simple config file, use ~/dar-backup/ for log file, archives and restore tests."
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"%(prog)s version {about.__version__}, {LICENSE}"
+    )
+
+    args = parser.parse_args()
+
+    if args.install:
+        errors = []
+        if os.path.exists(CONFIG_DIR):
+            errors.append(f"Config directory '{CONFIG_DIR}' already exists.")
+        if os.path.exists(DAR_BACKUP_DIR):
+            errors.append(f"Directory '{DAR_BACKUP_DIR}' already exists.")
+
+        if errors:
+            for error in errors:
+                print(f"Error: {error}")
+            sys.exit(1)
+
+        try:
+            os.makedirs(DAR_BACKUP_DIR, exist_ok=False)
+            os.makedirs(os.path.join(DAR_BACKUP_DIR, "backups"), exist_ok=False)
+            os.makedirs(os.path.join(DAR_BACKUP_DIR, "restore"), exist_ok=False)
+            os.makedirs(CONFIG_DIR, exist_ok=False)
+            os.makedirs(os.path.join(CONFIG_DIR, "backup.d"), exist_ok=False)
+            print(f"Directories created: `{DAR_BACKUP_DIR}` and `{CONFIG_DIR}`")
+
+            script_dir = Path(__file__).parent
+            source_file = script_dir / "dar-backup.conf"
+            destination_file = Path(CONFIG_DIR) / "dar-backup.conf"
+
+            try:
+                shutil.copy2(source_file, destination_file)
+                print(f"Config file deployed to {destination_file}")
+            except Exception as e:
+                print(f"Error: Could not copy config file: {e}")
+                sys.exit(1)
+
+
+            backup_definition = BACKUP_DEFINITION.replace("@@HOME_DIR@@", os.path.expanduser("~"))
+
+            try:
+                with open(os.path.join(CONFIG_DIR, "backup.d", "default"), "w") as f:
+                    f.write(backup_definition)
+                print(f"Default backup definition file deployed to {os.path.join(CONFIG_DIR, 'backup.d', 'default')}")
+            except Exception as e:
+                print(f"Error: Could not write default backup definition: {e}")
+                sys.exit(1)
+        except Exception as e:
+            print(f"Installation failed: {e}")
+            sys.exit(1)
+
+        print("1. Now run `manager --create` to create the catalog database.")
+        print("2. Then you can run `dar-backup --full-backup` to create a backup.")
+        print("3. List backups with `dar-backup --list`")
+        print("4. List contents of a backup with `dar-backup --list-contents <backup-name>`")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

dar_backup/exceptions.py

@@ -0,0 +1,3 @@
+class ConfigSettingsError(Exception):
+    """Raised when ConfigSettings encounters a critical error."""
+    pass

dar_backup/installer.py

@@ -1,138 +1,58 @@
-#!/usr/bin/env python3
-"""
-installer.py source code is here: https://github.com/per2jensen/dar-backup/tree/main/v2/src/dar_backup/installer.py
-This script is part of dar-backup, a backup solution for Linux using dar and systemd.
-
-Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
-
-THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW, 
-not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-See section 15 and section 16 in the supplied "LICENSE" file
-
-This script can be used to configure dar-backup on your system.
-It is non-destructive and will not overwrite any existing files or directories.
-"""
-
 import argparse
 import os
-import shutil
-import sys 
-
-from . import __about__ as about
 from pathlib import Path
-
-LICENSE = '''Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
-THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW, not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-See section 15 and section 16 in the supplied "LICENSE" file.'''
-
-CONFIG_DIR = os.path.expanduser("~/.config/dar-backup")
-DAR_BACKUP_DIR = os.path.expanduser("~/dar-backup/")
-
-BACKUP_DEFINITION = '''
-# Demo of a `dar-backup` definition file
-# This back definition file configures a backup of ~/.config/dar-backup
-# `dar-backup` puts the backups in ~/dar-backup/backups
-# ------------------------------------------------------------------------
-
-# Switch to ordered selection mode, which means that the following options
-# will be considered top to bottom
--am
-
-# Backup Root dir
--R @@HOME_DIR@@
-
-# Directories to backup below the Root dir
--g .config/dar-backup
-
-# Examples of directories to exclude below the Root dir
- -P mnt
- -P .private
- -P .cache   
-
-# compression level
- -z5
-
- # no overwrite, if you rerun a backup, 'dar' halts and asks what to do
- -n
- 
- # size of each slice in the archive
- --slice 10G
-
-# bypass directores marked as cache directories
-# http://dar.linux.free.fr/doc/Features.html
---cache-directory-tagging
-'''
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Set up `dar-backup` on your system.",
-    )
-    parser.add_argument(
-        "-i", "--install",
-        action="store_true",
-        help="Deploy a simple config file, use ~/dar-backup/ for log file, archives and restore tests."
-    )
-    parser.add_argument(
-        "-v", "--version",
-        action="version",
-        version=f"%(prog)s version {about.__version__}, {LICENSE}"
+from dar_backup.config_settings import ConfigSettings
+from dar_backup.util import setup_logging, get_logger
+from dar_backup.command_runner import CommandRunner
+from dar_backup.manager import create_db
+
+
+def run_installer(config_file: str, create_db_flag: bool):
+    config_file = os.path.expanduser(os.path.expandvars(config_file))
+    config_settings = ConfigSettings(config_file)
+
+    # Set up logging based on the config's specified log file
+    command_log = config_settings.logfile_location.replace("dar-backup.log", "dar-backup-commands.log")
+    logger = setup_logging(
+        config_settings.logfile_location,
+        command_log,
+        log_level="info",
+        log_stdout=True,
     )
-
+    command_logger = get_logger(command_output_logger=True)
+    runner = CommandRunner(logger=logger, command_logger=command_logger)
+
+    # Create directories listed in config
+    for attr in ["backup_dir", "test_restore_dir", "backup_d_dir", "manager_db_dir"]:
+        path = getattr(config_settings, attr, None)
+        if path:
+            dir_path = Path(path).expanduser()
+            if not dir_path.exists():
+                dir_path.mkdir(parents=True, exist_ok=True)
+                print(f"Created directory: {dir_path}")
+            else:
+                print(f"Directory already exists: {dir_path}")
+
+    # Optionally create databases
+    if create_db_flag:
+        for file in os.listdir(config_settings.backup_d_dir):
+            backup_def = os.path.basename(file)
+            print(f"Creating catalog for: {backup_def}")
+            result = create_db(backup_def, config_settings, logger)
+            if result == 0:
+                print(f"✔️  Catalog created (or already existed): {backup_def}")
+            else:
+                print(f"❌ Failed to create catalog: {backup_def}")
+
+
+def installer_main():
+    parser = argparse.ArgumentParser(description="dar-backup installer")
+    parser.add_argument("--config", required=True, help="Path to config file")
+    parser.add_argument("--create-db", action="store_true", help="Create catalog databases")
     args = parser.parse_args()
 
-    if args.install:
-        errors = []
-        if os.path.exists(CONFIG_DIR):
-            errors.append(f"Config directory '{CONFIG_DIR}' already exists.")
-        if os.path.exists(DAR_BACKUP_DIR):
-            errors.append(f"Directory '{DAR_BACKUP_DIR}' already exists.")
-
-        if errors:
-            for error in errors:
-                print(f"Error: {error}")
-            sys.exit(1)
-
-        try:
-            os.makedirs(DAR_BACKUP_DIR, exist_ok=False)
-            os.makedirs(os.path.join(DAR_BACKUP_DIR, "backups"), exist_ok=False)
-            os.makedirs(os.path.join(DAR_BACKUP_DIR, "restore"), exist_ok=False)
-            os.makedirs(CONFIG_DIR, exist_ok=False)
-            os.makedirs(os.path.join(CONFIG_DIR, "backup.d"), exist_ok=False)
-            print(f"Directories created: `{DAR_BACKUP_DIR}` and `{CONFIG_DIR}`")
-
-            script_dir = Path(__file__).parent
-            source_file = script_dir / "dar-backup.conf"
-            destination_file = Path(CONFIG_DIR) / "dar-backup.conf"
-
-            try:
-                shutil.copy2(source_file, destination_file)
-                print(f"Config file deployed to {destination_file}")
-            except Exception as e:
-                print(f"Error: Could not copy config file: {e}")
-                sys.exit(1)
-
-
-            backup_definition = BACKUP_DEFINITION.replace("@@HOME_DIR@@", os.path.expanduser("~"))
-
-            try:
-                with open(os.path.join(CONFIG_DIR, "backup.d", "default"), "w") as f:
-                    f.write(backup_definition)
-                print(f"Default backup definition file deployed to {os.path.join(CONFIG_DIR, 'backup.d', 'default')}")
-            except Exception as e:
-                print(f"Error: Could not write default backup definition: {e}")
-                sys.exit(1)
-        except Exception as e:
-            print(f"Installation failed: {e}")
-            sys.exit(1)
-
-        print("1. Now run `manager --create` to create the catalog database.")
-        print("2. Then you can run `dar-backup --full-backup` to create a backup.")
-        print("3. List backups with `dar-backup --list`")
-        print("4. List contents of a backup with `dar-backup --list-contents <backup-name>`")
-
-    sys.exit(0)
+    run_installer(args.config, args.create_db)
 
 
 if __name__ == "__main__":
-    main()
+    installer_main()

dar_backup/manager.py

@@ -36,6 +36,8 @@ 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.util import show_version
+from dar_backup.util import print_aligned_settings
 
 from dar_backup.command_runner import CommandRunner   
 from dar_backup.command_runner import CommandResult
@@ -43,7 +45,7 @@ from dar_backup.util import backup_definition_completer, list_archive_completer,
 
 from datetime import datetime
 from time import time
-from typing import Dict, List, NamedTuple
+from typing import Dict, List, NamedTuple, Tuple
 
 # Constants
 SCRIPTNAME = os.path.basename(__file__)
@@ -54,6 +56,15 @@ DB_SUFFIX = ".db"
 logger = None
 runner = None
 
+
+def get_db_dir(config_settings: ConfigSettings) -> str:
+    """
+    Return the correct directory for storing catalog databases.
+    Uses manager_db_dir if set, otherwise falls back to backup_dir.
+    """
+    return getattr(config_settings, "manager_db_dir", None) or config_settings.backup_dir
+
+
 def show_more_help():
     help_text = f"""
 NAME
@@ -62,31 +73,43 @@ NAME
     print(help_text)
 
 
-def create_db(backup_def: str, config_settings: ConfigSettings):
+def create_db(backup_def: str, config_settings: ConfigSettings, logger, runner) -> int:
+    db_dir = get_db_dir(config_settings)
+
+    if not os.path.exists(db_dir):
+        logger.error(f"DB dir does not exist: {db_dir}")
+        return 1
+    if not os.path.isdir(db_dir):
+        logger.error(f"DB path exists but is not a directory: {db_dir}")
+        return 1
+    if not os.access(db_dir, os.W_OK):
+        logger.error(f"DB dir is not writable: {db_dir}")
+        return 1
+
     database = f"{backup_def}{DB_SUFFIX}"
-    
-    database_path = os.path.join(config_settings.backup_dir, database)
-    
-    logger.debug(f"BACKUP_DIR: {config_settings.backup_dir}")
+    database_path = os.path.join(db_dir, database)
+
+    logger.debug(f"DB directory: {db_dir}")
 
     if os.path.exists(database_path):
-        logger.warning(f'"{database_path}" already exists, skipping creation')
+        logger.info(f'"{database_path}" already exists, skipping creation')
         return 0
     else:
         logger.info(f'Create catalog database: "{database_path}"')
-        command = ['dar_manager', '--create' , database_path]
+        command = ['dar_manager', '--create', database_path]
         process = runner.run(command)
         logger.debug(f"return code from 'db created': {process.returncode}")
         if process.returncode == 0:
             logger.info(f'Database created: "{database_path}"')
         else:
             logger.error(f'Something went wrong creating the database: "{database_path}"')
-            stdout, stderr = process.stdout, process.stderr 
+            stdout, stderr = process.stdout, process.stderr
             logger.error(f"stderr: {stderr}")
             logger.error(f"stdout: {stdout}")
 
     return process.returncode
 
+
 def list_catalogs(backup_def: str, config_settings: ConfigSettings, suppress_output=False) -> CommandResult:
     """
     List catalogs from the database for the given backup definition.
@@ -95,7 +118,7 @@ def list_catalogs(backup_def: str, config_settings: ConfigSettings, suppress_out
         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)
+    database_path = os.path.join(get_db_dir(config_settings), database)
 
     if not os.path.exists(database_path):
         error_msg = f'Database not found: "{database_path}"'
@@ -174,7 +197,7 @@ def list_archive_contents(archive: str, config_settings: ConfigSettings) -> int:
     """
     backup_def = backup_def_from_archive(archive)
     database = f"{backup_def}{DB_SUFFIX}"
-    database_path = os.path.join(config_settings.backup_dir, database)
+    database_path = os.path.join(get_db_dir(config_settings), database)
 
     if not os.path.exists(database_path):
         logger.error(f'Database not found: "{database_path}"')
@@ -217,8 +240,9 @@ def list_catalog_contents(catalog_number: int, backup_def: str, config_settings:
     """
     List the contents of catalog # in catalog database for given backup definition
     """
+    logger = get_logger()
     database = f"{backup_def}{DB_SUFFIX}"
-    database_path = os.path.join(config_settings.backup_dir, database)
+    database_path = os.path.join(get_db_dir(config_settings), database)
     if not os.path.exists(database_path):
         logger.error(f'Catalog database not found: "{database_path}"')
         return 1
@@ -239,7 +263,7 @@ def find_file(file, backup_def, config_settings):
     Find a specific file
     """
     database = f"{backup_def}{DB_SUFFIX}"
-    database_path = os.path.join(config_settings.backup_dir, database)
+    database_path = os.path.join(get_db_dir(config_settings), database)
     if not os.path.exists(database_path):
         logger.error(f'Database not found: "{database_path}"')
         return 1
@@ -283,7 +307,7 @@ def add_specific_archive(archive: str, config_settings: ConfigSettings, director
 
     # Determine catalog DB path
     database = f"{backup_definition}{DB_SUFFIX}"
-    database_path = os.path.realpath(os.path.join(config_settings.backup_dir, database))
+    database_path = os.path.realpath(os.path.join(get_db_dir(config_settings), database))
 
     # Safety check: is archive older than latest in catalog?
     try:
@@ -444,7 +468,7 @@ def remove_specific_archive(archive: str, config_settings: ConfigSettings) -> in
 
     """
     backup_def = backup_def_from_archive(archive)
-    database_path = os.path.join(config_settings.backup_dir, f"{backup_def}{DB_SUFFIX}")
+    database_path = os.path.join(get_db_dir(config_settings), f"{backup_def}{DB_SUFFIX}")
     cat_no:int = cat_no_for_name(archive, config_settings)
     if cat_no >= 0:
         command = ['dar_manager', '--base', database_path, "--delete", str(cat_no)]
@@ -484,8 +508,6 @@ def build_arg_parser():
     return parser
 
 
-
-
 def main():
     global logger, runner 
 
@@ -508,16 +530,12 @@ def main():
         return
 
     if args.version:
-        print(f"{SCRIPTNAME} {about.__version__}")
-        print(f"Source code is here: https://github.com/per2jensen/dar-backup")
-        print('''Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
-THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW, not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-See section 15 and section 16 in the supplied "LICENSE" file.''')
+        show_version()
         sys.exit(0)
-        return
 
     args.config_file = os.path.expanduser(os.path.expandvars(args.config_file))
     config_settings = ConfigSettings(args.config_file)
+
     if not os.path.dirname(config_settings.logfile_location):
         print(f"Directory for log file '{config_settings.logfile_location}' does not exist, exiting")
         sys.exit(1)
@@ -528,15 +546,23 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
     command_logger = get_logger(command_output_logger=True)
     runner = CommandRunner(logger=logger, command_logger=command_logger)
 
+    start_msgs: List[Tuple[str, str]] = []
+
     start_time = int(time())
-    logger.info(f"{SCRIPTNAME} started, version: {about.__version__}")
+    start_msgs.append((f"{SCRIPTNAME}:", about.__version__))
     logger.info(f"START TIME: {start_time}")
     logger.debug(f"`args`:\n{args}")
     logger.debug(f"`config_settings`:\n{config_settings}")
+    start_msgs.append(("Config file:", args.config_file))
+    args.verbose and start_msgs.append(("Backup dir:", config_settings.backup_dir))
+    start_msgs.append(("Logfile:", config_settings.logfile_location))
+    args.verbose and start_msgs.append(("--alternate-archive-dir:", args.alternate_archive_dir))
+    args.verbose and start_msgs.append(("--cleanup-specific-archives:", args.cleanup_specific_archives)) 
     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']}")
+    start_msgs.append(("dar_manager:", dar_manager_properties['path']))
+    start_msgs.append(("dar_manager v.:", dar_manager_properties['version']))
     
+    print_aligned_settings(start_msgs)
 
     # --- Sanity checks ---
     if args.add_dir and not args.add_dir.strip():
@@ -597,14 +623,14 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
     # --- Functional logic ---
     if args.create_db:
         if args.backup_def:
-            sys.exit(create_db(args.backup_def, config_settings))
+            sys.exit(create_db(args.backup_def, config_settings, logger, runner))
             return
         else:
             for root, dirs, files in os.walk(config_settings.backup_d_dir):
                 for file in files:
                     current_backupdef = os.path.basename(file)
                     logger.debug(f"Create catalog db for backup definition: '{current_backupdef}'")
-                    result = create_db(current_backupdef, config_settings)
+                    result = create_db(current_backupdef, config_settings, logger, runner)
                     if result != 0:
                         sys.exit(result)
                         return

dar_backup/util.py

@@ -24,8 +24,11 @@ from datetime import datetime
 from dar_backup.config_settings import ConfigSettings
 import dar_backup.__about__ as about
 
-from typing import NamedTuple, List
+from rich.console import Console
+from rich.text import Text
 
+from typing import NamedTuple, List
+from typing import Tuple
 
 
 logger=None
@@ -100,6 +103,30 @@ def get_logger(command_output_logger: bool = False) -> logging.Logger:
     return secondary_logger if command_output_logger else logger
 
 
+# Setup completer logger only once
+def _setup_completer_logger(logfile="/tmp/dar_backup_completer.log"):
+    logger = logging.getLogger("completer")
+    if not logger.handlers:
+        handler = logging.FileHandler(logfile)
+        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        logger.setLevel(logging.DEBUG)
+    return logger
+
+# Singleton logger for completer debugging
+completer_logger = _setup_completer_logger()
+completer_logger.debug("Completer logger initialized.")
+
+
+
+def show_version():
+    script_name = os.path.basename(sys.argv[0])
+    print(f"{script_name} {about.__version__}")
+    print(f"{script_name} source code is here: https://github.com/per2jensen/dar-backup")
+    print('''Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW, not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See section 15 and section 16 in the supplied "LICENSE" file.''')
 
 def extract_version(output):
     match = re.search(r'(\d+\.\d+(\.\d+)?)', output)
@@ -218,7 +245,6 @@ class RestoreError(Exception):
     pass
 
 
-
 class CommandResult(NamedTuple):
     """
     The reult of the run_command() function.
@@ -338,6 +364,7 @@ def extract_backup_definition_fallback() -> str:
 
 
 
+
 def list_archive_completer(prefix, parsed_args, **kwargs):
     import os
     import configparser
@@ -361,12 +388,39 @@ def list_archive_completer(prefix, parsed_args, **kwargs):
     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 [
+    completions = [
         f.rsplit(".1.dar", 1)[0]
         for f in files
         if archive_re.match(f)
     ]
 
+    completions = sorted(set(completions), key=sort_key)
+    return completions or ["[no matching archives]"]
+
+
+
+def sort_key(archive_name: str):
+    """
+    Sort by backup definition and then by date extracted from the archive name.
+    Handles formats like: <def>_<TYPE>_<YYYY-MM-DD>.<N>.dar
+    """
+    try:
+        base = archive_name.split('.')[0]  # remove .1.dar
+        parts = base.split('_')
+        if len(parts) < 3:
+            return (archive_name, datetime.min)  # fallback for non-matching formats
+
+        # Correct assumption: last two parts are TYPE and DATE
+        def_name = '_'.join(parts[:-2])  # everything before _TYPE_DATE
+        date_str = parts[-1]
+        date = datetime.strptime(date_str, "%Y-%m-%d")
+        completer_logger.debug(f"Archive: {archive_name}, Def: {def_name}, Date: {date}")
+        return (def_name, date)
+    except Exception:
+        return (archive_name, datetime.min)
+
+
+
 
 def archive_content_completer(prefix, parsed_args, **kwargs):
     """
@@ -384,14 +438,15 @@ def archive_content_completer(prefix, parsed_args, **kwargs):
     # 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
+    #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
+    db_dir = expand_path(getattr(config, 'manager_db_dir', None) or 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")]
+        [os.path.join( db_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")]
+        else [os.path.join( db_dir, f) for f in os.listdir( db_dir) if f.endswith(".db")]
     )
 
     completions = []
@@ -418,13 +473,6 @@ def archive_content_completer(prefix, parsed_args, **kwargs):
                 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]"]
 
@@ -444,6 +492,8 @@ def add_specific_archive_completer(prefix, parsed_args, **kwargs):
 
     config_file = expand_path(getattr(parsed_args, "config_file", "~/.config/dar-backup/dar-backup.conf"))
     config = ConfigSettings(config_file=config_file)
+    #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
+    db_dir = expand_path(getattr(config, 'manager_db_dir') or config.backup_dir)
     backup_dir = config.backup_dir
     backup_def = getattr(parsed_args, "backup_def", None)
 
@@ -461,7 +511,7 @@ def add_specific_archive_completer(prefix, parsed_args, **kwargs):
                     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
+    db_path = os.path.join(db_dir, f"{backup_def}.db") if backup_def else None
     existing = set()
 
     if db_path and os.path.exists(db_path):
@@ -484,3 +534,92 @@ def add_specific_archive_completer(prefix, parsed_args, **kwargs):
     candidates = sorted(archive for archive in all_archives if archive not in existing)
     return candidates or ["[no new archives]"]
 
+
+
+
+def patch_config_file(path: str, replacements: dict) -> None:
+    """
+    Replace specific key values in a config file in-place.
+
+    Args:
+        path: Path to the config file.
+        replacements: Dictionary of keys to new values, e.g., {"LOGFILE_LOCATION": "/tmp/logfile.log"}.
+    """
+    with open(path, 'r') as f:
+        lines = f.readlines()
+
+    with open(path, 'w') as f:
+        for line in lines:
+            key = line.split('=')[0].strip()
+            if key in replacements:
+                f.write(f"{key} = {replacements[key]}\n")
+            else:
+                f.write(line)
+
+
+
+
+console = Console()
+
+def print_aligned_settings(
+    settings: List[Tuple[str, str]],
+    log: bool = True,
+    header: str = "Startup Settings",
+    highlight_keywords: List[str] = None
+) -> None:
+    """
+    Print and optionally log settings nicely, using rich for color.
+    Highlights settings if dangerous keywords are found inside label or text,
+    but only if text is not None or empty.
+    """
+    if not settings:
+        return
+
+    settings = [(str(label), "" if text is None else str(text)) for label, text in settings]
+    logger = get_logger()
+
+    max_label_length = max(len(label) for label, _ in settings)
+
+    header_line = f"========== {header} =========="
+    footer_line = "=" * len(header_line)
+
+    console.print(f"[bold cyan]{header_line}[/bold cyan]")
+    if log and logger:
+        logger.info(header_line)
+
+    for label, text in settings:
+        padded_label = f"{label:<{max_label_length}}"
+
+        label_clean = label.rstrip(":").lower()
+        text_clean = text.lower()
+
+        # Skip highlighting if text is empty
+        if not text_clean.strip():
+            danger = False
+        else:
+            danger = False
+            if highlight_keywords:
+                combined_text = f"{label_clean} {text_clean}"
+                danger = any(keyword.lower() in combined_text for keyword in highlight_keywords)
+
+        # Build the line
+        line_text = Text()
+        line_text.append(padded_label, style="bold")
+        line_text.append(" ", style="none")
+
+        if danger:
+            line_text.append("[!]", style="bold red")
+            line_text.append(" ", style="none")
+
+        line_text.append(text, style="white")
+
+        console.print(line_text)
+
+        # Always log clean text (no [!] in log)
+        final_line_for_log = f"{padded_label} {text}"
+        if log and logger:
+            logger.info(final_line_for_log)
+
+    console.print(f"[bold cyan]{footer_line}[/bold cyan]")
+    if log and logger:
+        logger.info(footer_line)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dar-backup
-Version: 0.6.19
+Version: 0.6.20.1
 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

dar_backup-0.6.20.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+dar_backup/.darrc,sha256=-aerqivZmOsW_XBCh9IfbYTUvw0GkzDSr3Vx4GcNB1g,2113
+dar_backup/Changelog.md,sha256=D993XIep6ECnK42XdH6ayE8RlXDJVCbpr-SeCqEFRH8,9448
+dar_backup/README.md,sha256=PcZQRaBw9i_GbRoA786OFKI0PwY87E7D30UzovWqEQQ,44902
+dar_backup/__about__.py,sha256=rQMac36Uw_nIjFumz9vuaDITRsJHLv1bbxAZYx-Ka4E,24
+dar_backup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dar_backup/clean_log.py,sha256=uQ_9HomK7RRkskXrgMPbAC84RgNlCFJ8RHL9KHeAMvc,5447
+dar_backup/cleanup.py,sha256=4IG736gdmvjurcQQ_DC-B5CoA3Ix9u5C3WfwmMmFIpc,12500
+dar_backup/command_runner.py,sha256=PQA968EXssSGjSs_16psFkdxRZi9-YK4TrBKFz0ss3k,4455
+dar_backup/config_settings.py,sha256=8HhIDVtFk7D3VqJlYcveOlAaSEJwIaO3MICz-rN3tVY,5260
+dar_backup/dar-backup.conf,sha256=WWNrysjQ1ii2jpab8jxgWCw3IkNxLBYVOW8fxWbO_9g,1155
+dar_backup/dar_backup.py,sha256=x0at94NeQzu8tv2ohg3YKAt6j76gQUS2387wh5Z4B78,41856
+dar_backup/dar_backup_systemd.py,sha256=oehD_t9CFu0CsMgDWRH-Gt74Ynl1m29yqQEh5Kxv7aw,3807
+dar_backup/demo.py,sha256=fl2LHHWxuXRT814M_zuZh_YqqLk6nuNg9BI9HpLzdUU,4841
+dar_backup/exceptions.py,sha256=6fpHpnhkbtFcFZVDMqCsdESg-kQNCjF40EROGKeq8yU,113
+dar_backup/installer.py,sha256=gISJ3inz1uTjM5235gNtwjDUG-Fq6b3OZzMQuJl5eRg,2252
+dar_backup/manager.py,sha256=JL-JX2C6RiDIj64Gw9pxNLUpxFqij1OBPp1BaUvV5sM,26573
+dar_backup/rich_progress.py,sha256=jTwM-4VlqHHzKqIfyXjL1pWEriobSJwCdN3YXzXzRdo,3105
+dar_backup/util.py,sha256=u_l6Hti6ZAHxaOqTZlSWBDspoKmkdoyzfZjhQgJqyOQ,21643
+dar_backup-0.6.20.1.dist-info/METADATA,sha256=bD9ou-yK2zva5xz8vPVd57xqkEsjN9OaNAWZeoxDajE,86626
+dar_backup-0.6.20.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dar_backup-0.6.20.1.dist-info/entry_points.txt,sha256=jFMqGdvGO8NeHrmcB0pxY7__PCSQAWRCFzsschMXsec,248
+dar_backup-0.6.20.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+dar_backup-0.6.20.1.dist-info/RECORD,,

{dar_backup-0.6.19.dist-info → dar_backup-0.6.20.1.dist-info}/entry_points.txt

@@ -3,5 +3,5 @@ clean-log = dar_backup.clean_log:main
 cleanup = dar_backup.cleanup:main
 dar-backup = dar_backup.dar_backup:main
 dar-backup-systemd = dar_backup.dar_backup_systemd:main
-installer = dar_backup.installer:main
+demo = dar_backup.demo:main
 manager = dar_backup.manager:main

dar_backup-0.6.19.dist-info/RECORD

@@ -1,21 +0,0 @@
-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,,