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

dar_backup/installer.py

@@ -1,58 +1,188 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 import argparse
 import os
+from . import __about__ as about
 from pathlib import Path
 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
+# Always expand manager DB dir correctly, using helper function
+from dar_backup.manager import get_db_dir
+from dar_backup.util import expand_path
+
+def install_autocompletion():
+    """Detect user shell, choose RC file, and idempotently append autocompletion."""
+    shell = Path(os.environ.get("SHELL", "")).name
+    home = Path.home()
+
+    # pick RC file based on shell
+    if shell == "zsh":
+        rc_file = home / ".zshrc"
+    elif shell == "bash":
+        # prefer ~/.bash_profile on macOS if present
+        rc_file = home / ".bash_profile" if (home / ".bash_profile").exists() else home / ".bashrc"
+    else:
+        rc_file = home / ".bashrc"
+
+    marker = "# >>> dar-backup autocompletion >>>"
+    end_marker = "# <<< dar-backup autocompletion <<<"
+
+    block = "\n".join([
+        marker,
+        'eval "$(register-python-argcomplete dar-backup)"',
+        'eval "$(register-python-argcomplete cleanup)"',
+        'eval "$(register-python-argcomplete manager)"',
+        "#complete -o nosort -C 'python -m argcomplete cleanup' cleanup",
+        "#complete -o nosort -C 'python -m argcomplete manager' manager",
+        end_marker,
+    ]) + "\n"
+
+    # ensure RC file and parent directory exist
+    rc_file.parent.mkdir(parents=True, exist_ok=True)
+    if not rc_file.exists():
+        rc_file.touch()
+
+    content = rc_file.read_text()
+    if marker in content:
+        print(f"Autocompletion already installed in {rc_file}")
+        return
+
+    # append the autocompletion block
+    rc_file.open("a").write("\n" + block)
+    print(f"✔️ Appended autocompletion block to {rc_file}")
+
+
+
+def uninstall_autocompletion() -> str:
+    """Remove previously installed autocompletion block from shell RC file."""
+    shell = Path(os.environ.get("SHELL", "")).name
+    home = Path.home()
+
+    # pick RC file based on shell
+    if shell == "zsh":
+        rc_file = home / ".zshrc"
+    elif shell == "bash":
+        rc_file = home / ".bash_profile" if (home / ".bash_profile").exists() else home / ".bashrc"
+    else:
+        rc_file = home / ".bashrc"
+
+    marker = "# >>> dar-backup autocompletion >>>"
+    end_marker = "# <<< dar-backup autocompletion <<<"
+
+    if not rc_file.exists():
+        print(f"❌ RC file not found: {rc_file}")
+        return
+
+    content = rc_file.read_text()
+    if marker not in content:
+        print(f"No autocompletion block found in {rc_file}")
+        return f"No autocompletion block found in {rc_file}"  # for unit test
 
+    lines = content.splitlines(keepends=True)
+    new_lines = []
+    skipping = False
+    for line in lines:
+        if marker in line:
+            skipping = True
+            continue
+        if end_marker in line and skipping:
+            skipping = False
+            continue
+        if not skipping:
+            new_lines.append(line)
 
-def run_installer(config_file: str, create_db_flag: bool):
+    rc_file.write_text(''.join(new_lines))
+    print(f"✔️ Removed autocompletion block from {rc_file}")
+
+
+
+def run_installer(config_file: str, create_db_flag: bool, install_ac_flag: bool):
+    """
+    Run the installation process for dar-backup using the given config file.
+
+    This includes:
+    - Expanding and parsing the config file
+    - Setting up logging
+    - Creating required backup directories
+    - Optionally initializing catalog databases for all backup definitions
+
+    Args:
+        config_file (str): Path to the configuration file (may include ~ or env vars).
+        create_db_flag (bool): If True, databases are initialized for each backup definition.
+    """
     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
+    # Set up logging
     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,
+        log_to_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
+    # Create required directories
+    required_dirs = {
+        "backup_dir": config_settings.backup_dir,
+        "test_restore_dir": config_settings.test_restore_dir,
+        "backup_d_dir": config_settings.backup_d_dir,
+        "manager_db_dir": get_db_dir(config_settings),
+    }
+
+    for name, dir_path in required_dirs.items():
+        expanded = Path(expand_path(dir_path))
+        if not expanded.exists():
+            logger.info(f"Creating directory: {expanded} ({name})")
+            expanded.mkdir(parents=True, exist_ok=True)
+
+    # Optionally create databases for all backup definitions
     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)
+            result = create_db(backup_def, config_settings, logger, runner)
             if result == 0:
                 print(f"✔️  Catalog created (or already existed): {backup_def}")
             else:
                 print(f"❌ Failed to create catalog: {backup_def}")
 
 
-def installer_main():
+
+def main():
     parser = argparse.ArgumentParser(description="dar-backup installer")
-    parser.add_argument("--config", required=True, help="Path to config file")
+    parser.add_argument("--config", required=False, help="Path to config file")
     parser.add_argument("--create-db", action="store_true", help="Create catalog databases")
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "--install-autocompletion", action="store_true",
+        help="Append shell-completion setup to your shell RC"
+    )
+    group.add_argument(
+        "--remove-autocompletion", action="store_true",
+        help="Remove shell-completion setup from your shell RC"
+    )
+    parser.add_argument(
+        "-v", "--version", action="version",
+        version=f"%(prog)s version {about.__version__}, {about.__license__}"
+    )
+
     args = parser.parse_args()
 
-    run_installer(args.config, args.create_db)
+
+    if args.config:
+        run_installer(args.config, args.create_db)
+    elif args.install_autocompletion:
+        install_autocompletion()
+    elif args.remove_autocompletion:
+        uninstall_autocompletion()  
 
 
 if __name__ == "__main__":
-    installer_main()
+    main()

dar_backup/manager.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-3.0-or-later
 
 """
    Copyright (C) 2024  Per Jensen
@@ -37,6 +38,7 @@ 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 get_invocation_command_line
 from dar_backup.util import print_aligned_settings
 
 from dar_backup.command_runner import CommandRunner   
@@ -503,7 +505,7 @@ def build_arg_parser():
     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('--more-help', action='store_true', help='Show extended help message')
-    parser.add_argument('--version', action='store_true', help='Show version & license')
+    parser.add_argument('-v', '--version', action='store_true', help='Show version & license')
 
     return parser
 
@@ -551,18 +553,19 @@ def main():
     start_time = int(time())
     start_msgs.append((f"{SCRIPTNAME}:", about.__version__))
     logger.info(f"START TIME: {start_time}")
+    logger.debug(f"Command line: {get_invocation_command_line()}")
     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)) 
+    args.verbose and start_msgs.append(("--remove-specific-archive:", args.remove_specific_archive)) 
     dar_manager_properties = get_binary_info(command='dar_manager')
     start_msgs.append(("dar_manager:", dar_manager_properties['path']))
     start_msgs.append(("dar_manager v.:", dar_manager_properties['version']))
     
-    print_aligned_settings(start_msgs)
+    print_aligned_settings(start_msgs, quiet=not args.verbose)
 
     # --- Sanity checks ---
     if args.add_dir and not args.add_dir.strip():

dar_backup/rich_progress.py

@@ -1,3 +1,6 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 import os
 import time
 from threading import Event

dar_backup/util.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 """
 util.py source code is here: https://github.com/per2jensen/dar-backup
 
@@ -19,11 +21,14 @@ import shutil
 import sys
 import threading
 import traceback
+
+import dar_backup.__about__ as about
+
+
 from argcomplete.completers import ChoicesCompleter
 from datetime import datetime
 from dar_backup.config_settings import ConfigSettings
-import dar_backup.__about__ as about
-
+from pathlib import Path
 from rich.console import Console
 from rich.text import Text
 
@@ -119,14 +124,33 @@ completer_logger = _setup_completer_logger()
 completer_logger.debug("Completer logger initialized.")
 
 
+def get_invocation_command_line() -> str:
+    """
+    Safely retrieves the exact command line used to invoke the current Python process.
+
+    On Unix-like systems, this reads from /proc/[pid]/cmdline to reconstruct the
+    command with interpreter and arguments. If any error occurs (e.g., file not found,
+    permission denied, non-Unix platform), it returns a descriptive error message.
+
+    Returns:
+        str: The full command line string, or an error description if it cannot be retrieved.
+    """
+    try:
+        cmdline_path = f"/proc/{os.getpid()}/cmdline"
+        with open(cmdline_path, "rb") as f:
+            content = f.read()
+            if not content:
+                return "[error: /proc/cmdline is empty]"
+            return content.replace(b'\x00', b' ').decode().strip()
+    except Exception as e:
+        return f"[error: could not read /proc/[pid]/cmdline: {e}]"
+
 
 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.''')
+    print(about.__license__)
 
 def extract_version(output):
     match = re.search(r'(\d+\.\d+(\.\d+)?)', output)
@@ -263,6 +287,28 @@ class CommandResult(NamedTuple):
 
 def list_backups(backup_dir, backup_definition=None):
     """
+    Lists the available backup files in the specified directory along with their total sizes in megabytes. 
+    The function filters and processes `.dar` files, grouping them by their base names and ensuring proper 
+    alignment of the displayed sizes.
+    Args:
+        backup_dir (str): The directory containing the backup files.
+        backup_definition (str, optional): A prefix to filter backups by their base name. Only backups 
+                                           starting with this prefix will be included. Defaults to None.
+    Raises:
+        locale.Error: If setting the locale fails and the fallback to the 'C' locale is unsuccessful.
+    Behavior:
+        - Attempts to set the locale based on the environment for proper formatting of numbers.
+        - Filters `.dar` files in the specified directory based on the following criteria:
+            - The file name must contain one of the substrings: "_FULL_", "_DIFF_", or "_INCR_".
+            - The file name must include a date in the format "_YYYY-MM-DD".
+        - Groups files by their base name (excluding slice numbers and extensions) and calculates 
+          the total size for each group in megabytes.
+        - Sorts the backups by their base name and date (if included in the name).
+        - Prints the backup names and their sizes in a formatted and aligned manner.
+    Returns:
+        None: The function prints the results directly to the console. If no backups are found, 
+              it prints "No backups available.".
+
     List the available backups in the specified directory and their sizes in megabytes, with aligned sizes.
     """
     # Attempt to set locale from the environment or fall back to the default locale
@@ -565,6 +611,7 @@ def print_aligned_settings(
     settings: List[Tuple[str, str]],
     log: bool = True,
     header: str = "Startup Settings",
+    quiet: bool = True,
     highlight_keywords: List[str] = None
 ) -> None:
     """
@@ -583,7 +630,7 @@ def print_aligned_settings(
     header_line = f"========== {header} =========="
     footer_line = "=" * len(header_line)
 
-    console.print(f"[bold cyan]{header_line}[/bold cyan]")
+    not quiet and console.print(f"[bold cyan]{header_line}[/bold cyan]")
     if log and logger:
         logger.info(header_line)
 
@@ -613,13 +660,26 @@ def print_aligned_settings(
 
         line_text.append(text, style="white")
 
-        console.print(line_text)
+        not quiet and 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]")
+    not quiet and console.print(f"[bold cyan]{footer_line}[/bold cyan]")
     if log and logger:
         logger.info(footer_line)
+
+
+
+
+def normalize_dir(path: str) -> str:
+    """
+    Strip any trailing slash/backslash but leave root (“/” or “C:\\”) intact.
+    """
+    p = Path(path)
+    # Path(__str__) drops any trailing separators
+    normalized = str(p)
+    return normalized
+