dar-backup 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

dar_backup/.darrc

@@ -14,13 +14,13 @@ verbose:
 # -vs
 
 # shows diretory currently being processed
-# -vd 
+ -vd 
 
 # shows detailed messages, not related to files and directories
 # -vm
 
 # shows summary of each treated directory, including average compression
-# -vf
+ -vf
 
 # equivalent to "-vm -vs -vt"
 # -va

dar_backup/__about__.py

@@ -1 +1 @@
-__version__ = "0.6.2"
+__version__ = "0.6.4"

dar_backup/manager.py

@@ -21,8 +21,9 @@
 """
 
 
-import os
 import argparse
+import os
+import re
 import sys
 
 
@@ -30,7 +31,9 @@ from . import __about__ as about
 from dar_backup.config_settings import ConfigSettings
 from dar_backup.util import run_command
 from dar_backup.util import setup_logging
+from datetime import datetime
 from time import time
+from typing import Dict, List, NamedTuple
 
 # Constants
 SCRIPTNAME = os.path.basename(__file__)
@@ -70,9 +73,20 @@ def create_db(backup_def: str, config_settings: ConfigSettings):
             logger.error(f"stderr: {stderr}")
             logger.error(f"stdout: {stdout}")
 
+    return process.returncode
 
 
-def list_db(backup_def: str, config_settings: ConfigSettings):
+def list_catalogs(backup_def: str, config_settings: ConfigSettings) -> NamedTuple:
+    """
+    Returns:
+       a typing.NamedTuple of class dar-backup.util.CommandResult with the following properties:
+        - process: of type subprocess.CompletedProcess: The result of the command execution.
+        - stdout: of type str: The standard output of the command.
+        - stderr: of type str: The standard error of the command.
+        - returncode: of type int: The return code of the command.
+        - timeout: of type int: The timeout value in seconds used to run the command.
+        - command: of type list[str): The command executed.
+    """
     database = f"{backup_def}{DB_SUFFIX}"
     database_path = os.path.join(config_settings.backup_dir, database)
     if not os.path.exists(database_path):
@@ -87,27 +101,101 @@ def list_db(backup_def: str, config_settings: ConfigSettings):
         logger.error(f"stdout: {stdout}")
     else:
         print(stdout)
-    sys.exit(process.returncode)
+    return process
+
+
+def cat_no_for_name(archive: str, config_settings: ConfigSettings) -> int:
+    """
+    Find the catalog number for the given archive name
+
+    Returns:
+      - the found number, if the archive catalog is present in the database
+      - "-1" if the archive is not found
+    """
+    backup_def = backup_def_from_archive(archive)
+    process = list_catalogs(backup_def, config_settings)
+    if process.returncode != 0:
+        logger.error(f"Error listing catalogs for backup def: '{backup_def}'")
+        return -1
+    line_no = 1
+    for line in process.stdout.splitlines():
+        #print(f"{line_no}: '{line}'")
+        line_no += 1
+        search = re.search(f".*?(\d+)\s+.*?({archive}).*", line)
+        if search:
+            #print(f"FOUND: archive: {search.group(2)}, catalog #: '{search.group(1)}'")
+            logger.info(f"Found archive: '{archive}', catalog #: '{search.group(1)}'")
+            return int(search.group(1))
+    return -1
+
+
+
+
+
+def list_catalog_contents(catalog_number: int, backup_def: str, config_settings: ConfigSettings):
+    """
+    List the contents of catalog # in catalog database for given backup definition
+    """
+    database = f"{backup_def}{DB_SUFFIX}"
+    database_path = os.path.join(config_settings.backup_dir, database)
+    if not os.path.exists(database_path):
+        logger.error(f'Database not found: "{database_path}"')
+        return 1
+    command = ['dar_manager', '--base', database_path, '-u', f"{catalog_number}"]
+    process = run_command(command)
+    stdout, stderr = process.stdout, process.stderr 
+    if process.returncode != 0:
+        logger.error(f'Error listing catalogs for: "{database_path}"')
+        logger.error(f"stderr: {stderr}")  
+        logger.error(f"stdout: {stdout}")
+    else:
+        print(stdout)
+    return process.returncode
+
+
+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)
+    if not os.path.exists(database_path):
+        logger.error(f'Database not found: "{database_path}"')
+        return 1
+    command = ['dar_manager', '--base', database_path, '-f', f"{file}"]
+    process = run_command(command)
+    stdout, stderr = process.stdout, process.stderr 
+    if process.returncode != 0:
+        logger.error(f'Error finding file: {file} in: "{database_path}"')
+        logger.error(f"stderr: {stderr}")  
+        logger.error(f"stdout: {stdout}")
+    else:
+        print(stdout)
+    return process.returncode
 
 
-def add_specific_archive(archive: str, config_settings: ConfigSettings):    
+def add_specific_archive(archive: str, config_settings: ConfigSettings, directory: str =None) -> int:    
     # sanity check - does dar backup exist?
+    if not directory:
+        directory = config_settings.backup_dir
     archive = os.path.basename(archive)  # remove path if it was given
-    archive_path = os.path.join(config_settings.backup_dir, f'{archive}.1.dar')
-    if not os.path.exists(archive_path):
-        logger.error(f'dar backup: "{archive_path}" not found, exiting')
-        sys.exit(1)
+    archive_path = os.path.join(directory, f'{archive}')
+
+    archive_test_path =  os.path.join(directory, f'{archive}.1.dar')
+    if not os.path.exists(archive_test_path):
+        logger.error(f'dar backup: "{archive_test_path}" not found, exiting')
+        return 1
         
     # sanity check - does backup definition exist?
     backup_definition = archive.split('_')[0]
     backup_def_path = os.path.join(config_settings.backup_d_dir, backup_definition)
     if not os.path.exists(backup_def_path):
         logger.error(f'backup definition "{backup_definition}" not found (--add-specific-archive option probably not correct), exiting')
-        sys.exit(1)
+        return 1
     
     database = f"{backup_definition}{DB_SUFFIX}"
     database_path = os.path.realpath(os.path.join(config_settings.backup_dir, database))
-    logger.info(f'Add "{archive_path}" to catalog "{database}"')
+    logger.info(f'Add "{archive_path}" to catalog: "{database}"')
     
     command = ['dar_manager', '--base', database_path, "--add", archive_path, "-ai", "-Q"]
     process = run_command(command)
@@ -122,7 +210,99 @@ def add_specific_archive(archive: str, config_settings: ConfigSettings):
         logger.error(f"stderr: {stderr}")
         logger.error(f"stdout: {stdout}")
      
-    sys.exit(process.returncode)
+    return process.returncode
+
+
+
+def add_directory(args: argparse.ArgumentParser, config_settings: ConfigSettings) -> None:
+    """
+    Loop over the DAR archives in the given directory args.add_dir in increasing order by date and add them to their catalog database.
+
+    Args:
+        args (argparse.ArgumentParser): The command-line arguments object containing the add_dir attribute.
+        config_settings (ConfigSettings): The configuration settings object.
+
+    This function performs the following steps:
+    1. Checks if the specified directory exists. If not, raises a RuntimeError.
+    2. Uses a regular expression to match DAR archive files with base names in the format <string>_{FULL, DIFF, INCR}_YYYY-MM-DD.
+    3. Lists the DAR archives in the specified directory and extracts their base names and dates.
+    4. Sorts the DAR archives by date.
+    5. Loops over the sorted DAR archives and adds each archive to its catalog database using the add_specific_archive function.
+
+    Example:
+        args = argparse.ArgumentParser()
+        args.add_dir = '/path/to/dar/archives'
+        config_settings = ConfigSettings()
+        add_directory(args, config_settings)
+    """
+    if not os.path.exists(args.add_dir):
+        raise RuntimeError(f"Directory {args.add_dir} does not exist")
+
+    # Regular expression to match DAR archive files with base name and date in the format <string>_{FULL, DIFF, INCR}_YYYY-MM-DD
+    #dar_pattern = re.compile(r'^(.*?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2}))\.\d+\.dar$')
+    dar_pattern = re.compile(r'^(.*?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2}))\.1.dar$') # just read slice #1 of an archive
+    # List of DAR archives with their dates and base names
+    dar_archives = []
+
+    for filename in os.listdir(args.add_dir):
+        logger.debug(f"check if '{filename}' is a dar archive slice #1?")
+        match = dar_pattern.match(filename)
+        if match:
+            base_name = match.group(1)
+            date_str = match.group(3)
+            date_obj = datetime.strptime(date_str, '%Y-%m-%d')
+            dar_archives.append((date_obj, base_name))
+            logger.debug(f" -> yes: base name: {base_name}, date: {date_str}")
+
+    if not dar_archives or len(dar_archives) == 0:
+        logger.info(f"No 'dar' archives found in directory {args.add_dir}")
+        return
+
+    # Sort the DAR archives by date
+    dar_archives.sort()
+
+    # Loop over the sorted DAR archives and process them
+    result: List[Dict] = []
+    for date_obj, base_name in dar_archives:
+        logger.info(f"Adding dar archive: '{base_name}' to it's catalog database")
+        result_archive = add_specific_archive(base_name, config_settings, args.add_dir)
+        result.append({ f"{base_name}" : result_archive})
+        if result_archive != 0:
+            logger.error(f"Something went wrong added {base_name} to it's catalog")
+    
+    logger.debug(f"Results adding archives found in: '{args.add_dir}': result")
+
+
+def backup_def_from_archive(archive: str) -> str:
+    """
+    return the backup definition from archive name
+    """
+    search = re.search("(.*?)_", archive)
+    backup_def = search.group(1)
+    logger.debug(f"backup definition: '{backup_def}' from given archive '{archive}'")
+    return backup_def
+
+
+
+def remove_specific_archive(archive: str, config_settings: ConfigSettings) -> int:
+    backup_def = backup_def_from_archive(archive)
+    database_path = os.path.join(config_settings.backup_dir, f"{backup_def}{DB_SUFFIX}")
+    cat_no = cat_no_for_name(archive, config_settings)
+    if cat_no >= 0:
+        command = ['dar_manager', '--base', database_path, "--delete", str(cat_no)]
+        process = run_command(command)
+    else:
+        logger.error(f"archive: '{archive}' not found in in't catalog database: {database_path}")
+        return cat_no
+
+    if process.returncode == 0:
+        logger.info(f"'{archive}' removed from it's catalog")
+    else:
+        logger.error(process.stdout)
+        logger.error(process.sterr)
+
+    return process.returncode
+
 
 
 
@@ -142,7 +322,9 @@ def main():
     parser.add_argument('-d', '--backup-def', type=str, help='Restrict to work only on this backup definition')
     parser.add_argument('--add-specific-archive', type=str, help='Add this archive to catalog database')
     parser.add_argument('--remove-specific-archive', type=str, help='Remove this archive from catalog database')
-    parser.add_argument('--list-db', action='store_true', help='List catalogs in databases')
+    parser.add_argument('--list-catalog', action='store_true', help='List catalogs in databases for all backup definitions')
+    parser.add_argument('--list-catalog-contents', type=int, help="List contents of a catalog. Argument is the 'archive #', '-d <definition>' argument is also required")
+    parser.add_argument('--find-file', type=str, help="List catalogs containing <path>/file. '-d <definition>' argument is also required")
     parser.add_argument('--verbose', action='store_true', help='Be more verbose')
     parser.add_argument('--log-level', type=str, help="`debug` or `trace`, default is `info`", default="info")
     parser.add_argument('--log-stdout', action='store_true', help='also print log messages to stdout')
@@ -196,6 +378,13 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
         logger.error("you can't add and remove archives in the same operation, exiting")
         sys.exit(1)
 
+    if args.add_dir and args.add_specific_archive:
+        logger.error("you cannot add both a directory and an archive")
+        sys.exit(1)
+
+    if args.backup_def and not args.backup_def.strip():
+        logger.error(f"No backup definition given to --backup-def")
+
     if args.backup_def:
         backup_def_path = os.path.join(config_settings.backup_d_dir, args.backup_def)
         if not os.path.exists(backup_def_path):
@@ -203,6 +392,16 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
             sys.exit(1)
 
 
+    if args.list_catalog_contents and not args.backup_def:
+        logger.error(f"--list-catalog-contents requires the --backup-def, exiting")
+        sys.exit(1)
+
+    if args.find_file and not args.backup_def:
+        logger.error(f"--find-file requires the --backup-def, exiting")
+        sys.exit(1)
+    
+
+
     # Modify config settings based on the arguments
     if args.alternate_archive_dir:
         if not os.path.exists(args.alternate_archive_dir):
@@ -213,35 +412,53 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
 
     if args.create_db:
         if args.backup_def:
-            create_db(args.backup_def, config_settings)
+            sys.exit(create_db(args.backup_def, config_settings))
         else:
             for root, dirs, files in os.walk(config_settings.backup_d_dir):
                 for file in files:
                     current_backupdef = os.path.basename(file)
-                    create_db(current_backupdef, config_settings)
-        sys.exit(0)
+                    logger.debug(f"Create catalog db for backup definition: '{current_backupdef}'")
+                    result = create_db(current_backupdef, config_settings)
+                    if result != 0:
+                        sys.exit(result)
 
     if args.add_specific_archive:
-        add_specific_archive(args.add_specific_archive, config_settings)
+        sys.exit(add_specific_archive(args.add_specific_archive, config_settings))
 
     if args.add_dir:
-        # Implement add directory logic
-        pass
+        sys.exit(add_directory(args, config_settings))
+
 
     if args.remove_specific_archive:
-        # Implement remove specific archive logic
-        pass
+        
+        if remove_specific_archive(args.remove_specific_archive, config_settings) == 0:
+            sys.exit(0)
+        else:  
+            sys.exit(1)
+
 
 
-    if args.list_db:
+    if args.list_catalog:
         if args.backup_def:
-            list_db(args.backup_def, config_settings)
+            process = list_catalogs(args.backup_def, config_settings)
+            result = process.returncode
         else:
+            result = 0
             for root, dirs, files in os.walk(config_settings.backup_d_dir):
                 for file in files:
                     current_backupdef = os.path.basename(file)
-                    list_db(current_backupdef, config_settings)
-        sys.exit(0)
+                    if list_catalogs(current_backupdef, config_settings).returncode != 0:
+                        result = 1
+        sys.exit(result)
+
+    if args.list_catalog_contents:
+        result = list_catalog_contents(args.list_catalog_contents, args.backup_def, config_settings)
+        sys.exit(result)
+
+    if args.find_file:
+        result = find_file(args.find_file, args.backup_def, config_settings)
+        sys.exit(result)
+
 
 if __name__ == "__main__":
     main()

dar_backup/util.py

@@ -15,10 +15,11 @@ import re
 import subprocess
 import shlex
 import sys
+import threading
 import traceback
 from datetime import datetime
 
-from typing import NamedTuple
+from typing import NamedTuple, List
 
 logger=None
 
@@ -101,45 +102,110 @@ class CommandResult(NamedTuple):
     command: list[str]
 
     def __str__(self):
-        return f"CommandResult: [Return Code: '{self.returncode}', Stdout: '{self.stdout}', Stderr: '{self.stderr}', Timeout: '{self.timeout}', Command: '{self.command}']"
+        #return f"CommandResult: [Return Code: '{self.returncode}', \nCommand: '{' '.join(map(shlex.quote, self.command))}', \nStdout:\n'{self.stdout}', \nStderr:\n'{self.stderr}', \nTimeout: '{self.timeout}']"
+        return f"CommandResult: [Return Code: '{self.returncode}', \nCommand: '{' '.join(map(shlex.quote, self.command))}']"
 
 
-def run_command(command: list[str], timeout: int=30) -> typing.NamedTuple:
+
+def  _stream_reader(pipe, log_func, output_accumulator: List[str]):
+    """
+    Reads lines from the subprocess pipe, logs them, and accumulates them.
+
+    Args:
+        pipe: The pipe to read from (stdout or stderr).
+        log_func: The logging function to use (e.g., logger.info, logger.error).
+        output_accumulator: A list to store the lines read from the pipe.
+    """
+    with pipe:
+        for line in iter(pipe.readline, ''):
+            stripped_line = line.strip()
+            output_accumulator.append(stripped_line)  # Accumulate the output
+            log_func(stripped_line)  # Log the output in real time
+
+
+def run_command(command: List[str], timeout: int = 30) -> CommandResult:
     """
-    Executes a given command via subprocess and captures its output.
+    Executes a given command via subprocess, logs its output in real time, and returns the result.
 
     Args:
         command (list): The command to be executed, represented as a list of strings.
-        timeout (int): The maximum time in seconds to wait for the command to complete.Defaults to 30 seconds.
+        timeout (int): The maximum time in seconds to wait for the command to complete. Defaults to 30 seconds.
 
     Returns:
-        a typing.NamedTuple of class dar-backup.util.CommandResult with the following properties:
-        - process: of type subprocess.CompletedProcess: The result of the command execution.
-        - stdout: of type str: The standard output of the command.
-        - stderr: of type str: The standard error of the command.
-        - returncode: of type int: The return code of the command.
-        - timeout: of type int: The timeout value in seconds used to run the command.
-        - command: of type list[str): The command executed.
-    
+        A CommandResult NamedTuple with the following properties:
+        - process: subprocess.CompletedProcess
+        - stdout: str: The full standard output of the command.
+        - stderr: str: The full standard error of the command.
+        - returncode: int: The return code of the command.
+        - timeout: int: The timeout value in seconds used to run the command.
+        - command: list[str]: The command executed.
+
+    Logs:
+        - Logs standard output (`stdout`) in real-time at the INFO log level.
+        - Logs standard error (`stderr`) in real-time at the ERROR log level.
+
     Raises:
-        subprocess.TimeoutExpired: if the command execution times out (see `timeout` parameter).
-        Exception: raise exceptions during command runs.
+        subprocess.TimeoutExpired: If the command execution times out (see `timeout` parameter).
+        Exception: If other exceptions occur during command execution.
+
+    Notes:
+        - While the command runs, its `stdout` and `stderr` streams are logged in real-time.
+        - The returned `stdout` and `stderr` capture the complete output, even though the output is also logged.
+        - The command is forcibly terminated if it exceeds the specified timeout.
     """
-    stdout = None
-    stderr = None
+    stdout_lines = []  # To accumulate stdout
+    stderr_lines = []  # To accumulate stderr
+    process = None  # Track the process for cleanup
+
     try:
         logger.debug(f"Running command: {command}")
         process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        stdout, stderr = process.communicate(timeout)  # Wait with timeout
-        result = CommandResult(process=process, stdout=stdout, stderr=stderr, returncode=process.returncode, timeout=timeout, command=command)
-        logger.debug(f"Command result: {str(result)}")
+
+        # Start threads to read and log stdout and stderr
+        stdout_thread = threading.Thread(target=_stream_reader, args=(process.stdout, logger.info, stdout_lines))
+        stderr_thread = threading.Thread(target=_stream_reader, args=(process.stderr, logger.error, stderr_lines))
+        
+        stdout_thread.start()
+        stderr_thread.start()
+
+        # Wait for process to complete or timeout
+        process.wait(timeout=timeout)
+
     except subprocess.TimeoutExpired:
-        process.terminate()
+        if process:
+            process.terminate()
         logger.error(f"Command: '{command}' timed out and was terminated.")
         raise
     except Exception as e:
         logger.error(f"Error running command: {command}", exc_info=True)
         raise
+    finally:
+        # Ensure threads are joined to clean up
+        if stdout_thread.is_alive():
+            stdout_thread.join()
+        if stderr_thread.is_alive():
+            stderr_thread.join()
+
+        # Ensure process streams are closed
+        if process and process.stdout:
+            process.stdout.close()
+        if process and process.stderr:
+            process.stderr.close()
+
+    # Combine captured stdout and stderr lines into single strings
+    stdout = "\n".join(stdout_lines)
+    stderr = "\n".join(stderr_lines)
+
+    # Build the result object
+    result = CommandResult(
+        process=process,
+        stdout=stdout,
+        stderr=stderr,
+        returncode=process.returncode,
+        timeout=timeout,
+        command=command
+    )
+    logger.debug(f"Command result: {result}")
     return result
 
 

{dar_backup-0.6.2.dist-info → dar_backup-0.6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dar-backup
-Version: 0.6.2
+Version: 0.6.4
 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: Homepage, https://github.com/per2jensen/dar-backup
 Project-URL: Issues, https://github.com/per2jensen/dar-backup/issues

dar_backup-0.6.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+dar_backup/.darrc,sha256=3d9opAnnZGU9XLyQpTDsLtgo6hqsvZ3JU-yMLz-7_f0,2110
+dar_backup/__about__.py,sha256=ZbrGjsYU2ekVSe1-DcOOl7YsjrwB1bbJTUQlEi8pMjU,21
+dar_backup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dar_backup/cleanup.py,sha256=DgmxSUwKrLLIQuYSIY_yTRhIuOMgI6ivjlQuH4u3wX4,9057
+dar_backup/config_settings.py,sha256=CBMUhLOOZ-x7CRdS3vBDk4TYaGqC4N1Ot8IMH-qPaI0,3617
+dar_backup/dar_backup.py,sha256=YZoVu9NJX3_WIkQIG8EMLSK3-VWdslI0c2XKrM2Un38,32214
+dar_backup/manager.py,sha256=2qTcn1HiDrejc6S7dLpkylURGzMQ0QqTaSl2KQQ58Uw,19198
+dar_backup/util.py,sha256=SSSJYM9lQZfubhTUBlX1xDGWmCpYEF3ePARmlY544xM,11283
+dar_backup-0.6.4.dist-info/METADATA,sha256=9AKTUu-uyxNQqKoxtYdAWbAyMgHsmLCblvchEvT_B94,22496
+dar_backup-0.6.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dar_backup-0.6.4.dist-info/entry_points.txt,sha256=x9vnW-JEl8mpDJC69f_XBcn0mBSkV1U0cyvFV-NAP1g,126
+dar_backup-0.6.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+dar_backup-0.6.4.dist-info/RECORD,,

dar_backup-0.6.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-dar_backup/.darrc,sha256=ggex9N6eETOS6u003_QRRJMeWbveQfkT1lDBt0XpU-I,2112
-dar_backup/__about__.py,sha256=d7NGuoje3vHyudKIFR_PmfKozIOKDFvAhGx0QXiyuMw,21
-dar_backup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dar_backup/cleanup.py,sha256=DgmxSUwKrLLIQuYSIY_yTRhIuOMgI6ivjlQuH4u3wX4,9057
-dar_backup/config_settings.py,sha256=CBMUhLOOZ-x7CRdS3vBDk4TYaGqC4N1Ot8IMH-qPaI0,3617
-dar_backup/dar_backup.py,sha256=YZoVu9NJX3_WIkQIG8EMLSK3-VWdslI0c2XKrM2Un38,32214
-dar_backup/manager.py,sha256=lkw1ZAIdxY7WedLPKZMnHpuq_QbjkUdcG61ooiwUYpo,10197
-dar_backup/util.py,sha256=6lPCFHr3MDdaLWAW9EDMZ4jdL7pt8rki-5dOXcesmP8,8955
-dar_backup-0.6.2.dist-info/METADATA,sha256=PMfP8NhPwzhHRbjJt6_7Unqxbqqj13PW19QdYac6pcc,22496
-dar_backup-0.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dar_backup-0.6.2.dist-info/entry_points.txt,sha256=x9vnW-JEl8mpDJC69f_XBcn0mBSkV1U0cyvFV-NAP1g,126
-dar_backup-0.6.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-dar_backup-0.6.2.dist-info/RECORD,,