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

dar_backup/__about__.py

@@ -1 +1 @@
-__version__ = "0.6.17"
+__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
@@ -27,10 +28,11 @@ from typing import Dict, List, NamedTuple
 
 from . import __about__ as about
 from dar_backup.config_settings import ConfigSettings
-from dar_backup.util import extract_error_lines
 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
@@ -158,20 +160,47 @@ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW,
 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}")
+        else:
+            confirmation = inputimeout(
+                prompt=f"Are you sure you want to delete the FULL archive '{archive_name}'? (yes/no): ",
+                timeout=30)
+        if confirmation is None:
+            logger.info(f"No confirmation received for FULL archive: {archive_name}. Skipping deletion.")
+            return False
+        return confirmation.strip().lower() == "yes"
+    except TimeoutOccurred:
+        logger.info(f"Timeout waiting for confirmation for FULL archive: {archive_name}. Skipping deletion.")
+        return False
+    except KeyboardInterrupt:
+        logger.info(f"User interrupted confirmation for FULL archive: {archive_name}. Skipping deletion.")
+        return False
+    
+
+
 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))
@@ -206,21 +235,9 @@ def main():
     args.verbose and (print(f"--alternate-archive-dir:    {args.alternate_archive_dir}"))
     args.verbose and (print(f"--cleanup-specific-archives:{args.cleanup_specific_archives}")) 
 
-    # run PREREQ scripts
-    if 'PREREQ' in config_settings.config:
-        for key in sorted(config_settings.config['PREREQ'].keys()):
-            script = config_settings.config['PREREQ'][key]
-            try:
-                result = subprocess.run(script, shell=True, check=True)
-                logger.info(f"PREREQ {key}: '{script}' run, return code: {result.returncode}")
-                logger.info(f"PREREQ stdout:\n{result.stdout}")
-            except subprocess.CalledProcessError as e:
-                logger.error(f"Error executing {key}: '{script}': {e}")
-                if result:
-                    logger.error(f"PREREQ stderr:\n{result.stderr}")
-                print(f"Error executing {script}: {e}") 
-                sys.exit(1)
 
+    # run PREREQ scripts
+    requirements('PREREQ', config_settings)
 
     if args.alternate_archive_dir:
         if not os.path.exists(args.alternate_archive_dir):
@@ -231,37 +248,15 @@ def main():
             sys.exit(1) 
         config_settings.backup_dir = args.alternate_archive_dir
 
+    if args.cleanup_specific_archives is None and args.test_mode:
+        logger.info("No --cleanup-specific-archives provided; skipping specific archive deletion in test mode.")
 
     if args.cleanup_specific_archives:
         logger.info(f"Cleaning up specific archives: {args.cleanup_specific_archives}")
         archive_names = args.cleanup_specific_archives.split(',')
         for archive_name in archive_names:
             if "_FULL_" in archive_name:
-                try:
-                    try:
-                        # used for pytest cases
-                        if args.test_mode:
-                            confirmation = os.environ.get("CLEANUP_TEST_DELETE_FULL")
-                            if confirmation == None:
-                                raise RuntimeError("envvar 'CLEANUP_TEST_DELETE_FULL' not set")
-                            
-                        else:
-                            confirmation = inputimeout(
-                                prompt=f"Are you sure you want to delete the FULL archive '{archive_name}'? (yes/no): ",
-                                timeout=30)
-                        if confirmation == None:
-                            continue
-                        else:
-                            confirmation = confirmation.strip().lower()
-                    except TimeoutOccurred:
-                        logger.info(f"Timeout waiting for confirmation for FULL archive: {archive_name}. Skipping deletion.")
-                        continue
-                except KeyboardInterrupt:
-                    logger.info(f"User interrupted confirmation for FULL archive: {archive_name}. Skipping deletion.")
-                    continue
-
-                if confirmation != 'yes':
-                    logger.info(f"User did not answer 'yes' to confirm deletion of FULL archive: {archive_name}. Skipping deletion.")
+                if not confirm_full_archive_deletion(archive_name, args.test_mode):
                     continue
             logger.info(f"Deleting archive: {archive_name}")
             delete_archive(config_settings.backup_dir, archive_name.strip(), args)
@@ -280,10 +275,13 @@ def main():
             delete_old_backups(config_settings.backup_dir, config_settings.diff_age, 'DIFF', args, definition)
             delete_old_backups(config_settings.backup_dir, config_settings.incr_age, 'INCR', args, definition)
 
+    # run POST scripts
+    requirements('POSTREQ', config_settings)
+
 
     end_time=int(time())
     logger.info(f"END TIME: {end_time}")
-
+    sys.exit(0)
 
 if __name__ == "__main__":
     main()

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

@@ -1,5 +1,21 @@
 #!/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 control `dar` to backup parts of or the whole system.
+"""
+
+
+
+import argcomplete
 import argparse
 import filecmp
 
@@ -11,6 +27,7 @@ import shutil
 import subprocess
 import xml.etree.ElementTree as ET
 import tempfile
+import threading
 
 from argparse import ArgumentParser
 from datetime import datetime
@@ -20,6 +37,7 @@ from sys import stderr
 from sys import argv
 from sys import version_info
 from time import time
+from threading import Event
 from typing import List
 
 from . import __about__ as about
@@ -29,10 +47,16 @@ from dar_backup.util import setup_logging
 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
@@ -67,7 +91,31 @@ def generic_backup(type: str, command: List[str], backup_file: str, backup_defin
 
     logger.info(f"===> Starting {type} backup for {backup_definition}")
     try:
-        process = runner.run(command, timeout = config_settings.command_timeout_secs)
+        log_basename = os.path. dirname(config_settings.logfile_location)
+        logfile = os.path.basename(config_settings.logfile_location)[:-4] + "-commands.log"
+        log_path = os.path.join( log_basename, logfile)
+        logger.debug(f"Commands log file: {log_path}")
+
+        # wrap a progress bar around the dar command
+        stop_event = Event()
+        session_marker = f"=== START BACKUP SESSION: {int(time())} ==="
+        get_logger(command_output_logger=True).info(session_marker)
+
+        progress_thread = threading.Thread(
+            target=show_log_driven_bar,
+            args=(log_path, stop_event, session_marker),
+            daemon=True
+        )
+        progress_thread.start()
+        try:
+            process = runner.run(command, timeout = config_settings.command_timeout_secs)
+        except Exception as e:
+            print(f"[!] Backup failed: {e}")
+            raise
+        finally:
+            stop_event.set()
+            progress_thread.join()
+
         if process.returncode == 0:
             logger.info(f"{type} backup completed successfully.")
         elif process.returncode == 5:
@@ -194,7 +242,33 @@ def verify(args: argparse.Namespace, backup_file: str, backup_definition: str, c
     """
     result = True
     command = ['dar', '-t', backup_file, '-Q']
-    process = runner.run(command, timeout = config_settings.command_timeout_secs)
+ 
+ 
+    log_basename = os.path. dirname(config_settings.logfile_location)
+    logfile = os.path.basename(config_settings.logfile_location)[:-4] + "-commands.log"
+    log_path = os.path.join( log_basename, logfile)
+
+    # wrap a progress bar around the dar command
+    stop_event = Event()
+    session_marker = f"=== START BACKUP SESSION: {int(time())} ==="
+    get_logger(command_output_logger=True).info(session_marker)
+
+    progress_thread = threading.Thread(
+        target=show_log_driven_bar,
+        args=(log_path, stop_event, session_marker),
+        daemon=True
+    )
+    progress_thread.start()
+    try:
+        process = runner.run(command, timeout = config_settings.command_timeout_secs)
+    except Exception as e:
+        print(f"[!] Backup failed: {e}")
+        raise
+    finally:
+        stop_event.set()
+        progress_thread.join()
+
+
     if process.returncode == 0:
         logger.info("Archive integrity test passed.")
     else:
@@ -243,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....")
@@ -402,7 +477,8 @@ def perform_backup(args: argparse.Namespace, config_settings: ConfigSettings, ba
         if '_' in args.backup_definition:
             msg = f"Skipping backup definition: '{args.backup_definition}' due to '_' in name"
             logger.error(msg)
-            return results.append((msg, 1))
+            results.append((msg, 1))
+            return results
         backup_definitions.append((os.path.basename(args.backup_definition).split('.')[0], os.path.join(config_settings.backup_d_dir, args.backup_definition)))
     else:
         for root, _, files in os.walk(config_settings.backup_d_dir):
@@ -453,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...")
@@ -620,41 +700,53 @@ INCR back of a single backup definition in backup.d
 
 
 
-def requirements(type: str, config_setting: ConfigSettings):
+def print_markdown(source: str, from_string: bool = False, pretty: bool = True):
     """
-    Perform PREREQ or POSTREQ requirements.
-
+    Print Markdown content either from a file or directly from a string.
+    
     Args:
-        type (str): The type of prereq (PREREQ, POSTREQ).
-        config_settings (ConfigSettings): An instance of the ConfigSettings class.
+        source: Path to the file or Markdown string itself.
+        from_string: If True, treat `source` as Markdown string instead of file path.
+        pretty: If True, render with rich formatting if available.
+    """
+    import os
+    import sys
 
-    Raises:
-        RuntimeError: If a subprocess returns anything but zero.
+    content = ""
+    if from_string:
+        content = source
+    else:
+        if not os.path.exists(source):
+            print(f"❌ File not found: {source}")
+            sys.exit(1)
+        with open(source, "r", encoding="utf-8") as f:
+            content = f.read()
+
+    if pretty:
+        try:
+            from rich.console import Console
+            from rich.markdown import Markdown
+            console = Console()
+            console.print(Markdown(content))
+        except ImportError:
+            print("⚠️ 'rich' not installed. Falling back to plain text.\n")
+            print(content)
+    else:
+        print(content)
+
+
+
+def print_changelog(path: str = None, pretty: bool = True):
+    if path is None:
+        path = Path(__file__).parent / "Changelog.md"
+    print_markdown(str(path), pretty=pretty)
+
+
+def print_readme(path: str = None, pretty: bool = True):
+    if path is None:
+        path = Path(__file__).parent / "README.md"
+    print_markdown(str(path), pretty=pretty)
 
-        subprocess.CalledProcessError: if CalledProcessError is raised in subprocess.run(), let it bobble up.
-    """
-    if type is None or config_setting is None:
-        raise RuntimeError(f"requirements: 'type' or config_setting is None")
-
-    allowed_types = ['PREREQ', 'POSTREQ'] 
-    if type not in allowed_types:
-        raise RuntimeError(f"requirements: {type} not in: {allowed_types}")
-
-
-    logger.debug(f"Performing  {type}")
-    if type in config_setting.config:
-        for key in sorted(config_setting.config[type].keys()):
-            script = config_setting.config[type][key]
-            try:
-                result = subprocess.run(script, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True, check=True)
-                logger.debug(f"{type} {key}: '{script}' run, return code: {result.returncode}")
-                logger.debug(f"{type} stdout:\n{result.stdout}")
-                if result.returncode != 0:
-                    logger.error(f"{type} stderr:\n{result.stderr}")
-                    raise RuntimeError(f"{type} {key}: '{script}' failed, return code: {result.returncode}")    
-            except subprocess.CalledProcessError as e:
-                logger.error(f"Error executing {key}: '{script}': {e}")
-                raise e
 
 
 def main():
@@ -670,23 +762,29 @@ 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('--examples', action="store_true", help="Examples of using dar-backup.py.")
-    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")
     parser.add_argument('--log-level', type=str, help="`debug` or `trace`", default="info")
     parser.add_argument('--log-stdout', action='store_true', help='also print log messages to stdout')
     parser.add_argument('--do-not-compare', action='store_true', help="do not compare restores to file system")
+    parser.add_argument('--examples', action="store_true", help="Examples of using dar-backup.py.")
+    parser.add_argument("--readme", action="store_true", help="Print README.md to stdout and exit.")
+    parser.add_argument("--readme-pretty", action="store_true", help="Print README.md to stdout with Markdown styling and exit.")
+    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:
@@ -695,6 +793,20 @@ def main():
     elif args.examples:
         show_examples()
         exit(0)
+    elif args.readme:
+        print_readme(None, pretty=False)
+        exit(0)
+    elif args.readme_pretty:
+        print_readme(None, pretty=True)
+        exit(0)
+    elif args.changelog:
+        print_changelog(None, pretty=False)
+        exit(0)
+    elif args.changelog_pretty:
+        print_changelog(None, pretty=True)
+        exit(0)
+
+
 
     if not args.config_file:
         print(f"Config file not specified, exiting", file=stderr)
@@ -740,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}"))