dar-backup 0.6.20__py3-none-any.whl → 0.6.21__py3-none-any.whl

dar_backup/__about__.py

@@ -1 +1,6 @@
-__version__ = "0.6.20"
+__version__ = "0.6.21"
+
+__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.'''
+

dar_backup/cleanup.py

@@ -37,6 +37,7 @@ 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 get_invocation_command_line
 from dar_backup.util import print_aligned_settings
 from dar_backup.util import backup_definition_completer, list_archive_completer
 
@@ -222,6 +223,7 @@ def main():
     start_msgs.append(("cleanup.py:", 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}")
 

dar_backup/dar_backup.py

@@ -51,6 +51,7 @@ 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_invocation_command_line
 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
@@ -683,12 +684,29 @@ INCR back of a single backup definition in backup.d
 
 
 --selection
-    --selection takes dar selection parameters between a pair of `"`. 
 
-    Example: select file names with this date in file names "2024-07-01" in the
-    directory "path/to/a/dir" where the path is relative to root of the backup.
+    --selection takes dar file selection options inside a quoted string.
+    
+    💡 Shell quoting matters! Always wrap the entire selection string in double quotes to avoid shell splitting. 
+
+    ✅ Use:   --selection="-I '*.NEF'"
+    ❌ Avoid: --selection "-I '*.NEF'" → may break due to how your shell parses it.
+
+    Examples:
+    1)
+    select file names with "Z50_" in file names:
+        python3 dar-backup.py --restore <name of dar archive>  --selection="-I '*Z50_*'"
+    2)
+    Filter out *.xmp files:
+        python3 dar-backup.py --restore <name of dar archive>  --selection="-X '*.xmp'"
+    
+    3)
+    Include all files in a directory:
+        python3 dar-backup.py --restore <name of dar archive>  --selection="-g 'path/to/a/dir'"
 
-    python3 dar-backup.py --restore <name of dar archive>  --selection "-I '*2024-07-01*' -g path/to/a/dir"
+    4)
+    Exclude a directory:
+        python3 dar-backup.py --restore <name of dar archive>  --selection="-P 'path/to/a/dir'"
 
     See dar documentation on file selection: http://dar.linux.free.fr/doc/man/dar.html#COMMANDS%20AND%20OPTIONS
 """
@@ -764,7 +782,7 @@ def main():
     parser.add_argument('--darrc', type=str, help='Optional path to .darrc')
     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('--selection', type=str, help="Selection string to pass to 'dar', e.g. --selection=\"-I '*.NEF'\"")
 #    parser.add_argument('-r', '--restore', nargs=1, 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.")
@@ -847,6 +865,7 @@ def main():
         start_time=int(time())
         start_msgs.append(('dar-backup.py:', 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}")
         dar_properties = get_binary_info(command='dar')

dar_backup/demo.py

@@ -19,11 +19,8 @@ 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.'''
+from pathlib import Path
 
 CONFIG_DIR = os.path.expanduser("~/.config/dar-backup")
 DAR_BACKUP_DIR = os.path.expanduser("~/dar-backup/")
@@ -76,7 +73,7 @@ def main():
     parser.add_argument(
         "-v", "--version",
         action="version",
-        version=f"%(prog)s version {about.__version__}, {LICENSE}"
+        version=f"%(prog)s version {about.__version__}, {about.__license__}"
     )
 
     args = parser.parse_args()

dar_backup/installer.py

@@ -1,58 +1,83 @@
 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 run_installer(config_file: str, create_db_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("--create-db", action="store_true", help="Create catalog databases")
+    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 __name__ == "__main__":
-    installer_main()
+    main()

dar_backup/manager.py

@@ -37,6 +37,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 +504,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
 
@@ -535,7 +536,6 @@ def main():
 
     args.config_file = os.path.expanduser(os.path.expandvars(args.config_file))
     config_settings = ConfigSettings(args.config_file)
-    print(f"Config settings: {config_settings}")
 
     if not os.path.dirname(config_settings.logfile_location):
         print(f"Directory for log file '{config_settings.logfile_location}' does not exist, exiting")
@@ -552,6 +552,7 @@ 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))

dar_backup/util.py

@@ -102,13 +102,50 @@ 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 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)
@@ -245,6 +282,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
@@ -346,6 +405,7 @@ def extract_backup_definition_fallback() -> str:
 
 
 
+
 def list_archive_completer(prefix, parsed_args, **kwargs):
     import os
     import configparser
@@ -369,12 +429,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):
     """
@@ -392,14 +479,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 = []
@@ -426,13 +514,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]"]
 
@@ -452,6 +533,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)
 
@@ -469,7 +552,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):